Grcov report - claims.rs

1

// Copyright (C) Parity Technologies (UK) Ltd.

2

// This file is part of Polkadot.

3

4

// Substrate is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Substrate is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.

16

17

//! Pallet to process claims from Ethereum addresses.

18

19

#[cfg(not(feature = "std"))]

20

use alloc::{format, string::String};

21

use alloc::{vec, vec::Vec};

22

use codec::{Decode, Encode};

23

use core::fmt::Debug;

24

use frame_support::{

25

	ensure,

26

	traits::{Currency, Get, IsSubType, VestingSchedule},

27

	weights::Weight,

28

	DefaultNoBound,

29

};

30

pub use pallet::*;

31

use polkadot_primitives::ValidityError;

32

use scale_info::TypeInfo;

33

use serde::{self, Deserialize, Deserializer, Serialize, Serializer};

34

use sp_io::{crypto::secp256k1_ecdsa_recover, hashing::keccak_256};

35

use sp_runtime::{

36

	traits::{CheckedSub, DispatchInfoOf, SignedExtension, Zero},

37

	transaction_validity::{

38

		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,

39

},

40

	RuntimeDebug,

41

};

42

43

type CurrencyOf<T> = <<T as Config>::VestingSchedule as VestingSchedule<

44

	<T as frame_system::Config>::AccountId,

45

>>::Currency;

46

type BalanceOf<T> = <CurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::Balance;

47

48

pub trait WeightInfo {

49

	fn claim() -> Weight;

50

	fn mint_claim() -> Weight;

51

	fn claim_attest() -> Weight;

52

	fn attest() -> Weight;

53

	fn move_claim() -> Weight;

54

55

56

pub struct TestWeightInfo;

57

impl WeightInfo for TestWeightInfo {

58

	fn claim() -> Weight {

59

		Weight::zero()

60

61

	fn mint_claim() -> Weight {

62

		Weight::zero()

63

64

	fn claim_attest() -> Weight {

65

		Weight::zero()

66

67

	fn attest() -> Weight {

68

		Weight::zero()

69

70

	fn move_claim() -> Weight {

71

		Weight::zero()

72

73

74

75

/// The kind of statement an account needs to make for a claim to be valid.

76

#[derive(

77

	Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo, Serialize, Deserialize,

78

)]

79

pub enum StatementKind {

80

	/// Statement required to be made by non-SAFT holders.

81

	Regular,

82

	/// Statement required to be made by SAFT holders.

83

	Saft,

84

85

86

impl StatementKind {

87

	/// Convert this to the (English) statement it represents.

88

	fn to_text(self) -> &'static [u8] {

89

		match self {

90

			StatementKind::Regular =>

91

				&b"I hereby agree to the terms of the statement whose SHA-256 multihash is \

92

				Qmc1XYqT6S39WNp2UeiRUrZichUWUPpGEThDE6dAb3f6Ny. (This may be found at the URL: \

93

				https://statement.polkadot.network/regular.html)"[..],

94

			StatementKind::Saft =>

95

				&b"I hereby agree to the terms of the statement whose SHA-256 multihash is \

96

				QmXEkMahfhHJPzT3RjkXiZVFi77ZeVeuxtAjhojGRNYckz. (This may be found at the URL: \

97

				https://statement.polkadot.network/saft.html)"[..],

98

99

100

101

102

impl Default for StatementKind {

103

	fn default() -> Self {

104

		StatementKind::Regular

105

106

107

108

/// An Ethereum address (i.e. 20 bytes, used to represent an Ethereum account).

109

///

110

/// This gets serialized to the 0x-prefixed hex representation.

111

#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, Default, RuntimeDebug, TypeInfo)]

112

pub struct EthereumAddress([u8; 20]);

113

114

impl Serialize for EthereumAddress {

115

	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

116

	where

117

		S: Serializer,

118

119

		let hex: String = rustc_hex::ToHex::to_hex(&self.0[..]);

120

		serializer.serialize_str(&format!("0x{}", hex))

121

122

123

124

impl<'de> Deserialize<'de> for EthereumAddress {

125

	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

126

	where

127

		D: Deserializer<'de>,

128

129

		let base_string = String::deserialize(deserializer)?;

130

		let offset = if base_string.starts_with("0x") { 2 } else { 0 };

131

		let s = &base_string[offset..];

132

		if s.len() != 40 {

133

			Err(serde::de::Error::custom(

134

				"Bad length of Ethereum address (should be 42 including '0x')",

135

			))?;

136

137

		let raw: Vec<u8> = rustc_hex::FromHex::from_hex(s)

138

			.map_err(|e| serde::de::Error::custom(format!("{:?}", e)))?;

139

		let mut r = Self::default();

140

		r.0.copy_from_slice(&raw);

141

		Ok(r)

142

143

144

145

#[derive(Encode, Decode, Clone, TypeInfo)]

146

pub struct EcdsaSignature(pub [u8; 65]);

147

148

impl PartialEq for EcdsaSignature {

149

	fn eq(&self, other: &Self) -> bool {

150

		&self.0[..] == &other.0[..]

151

152

153

154

impl core::fmt::Debug for EcdsaSignature {

155

	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

156

		write!(f, "EcdsaSignature({:?})", &self.0[..])

157

158

159

160

#[frame_support::pallet]

161

pub mod pallet {

162

	use super::*;

163

	use frame_support::pallet_prelude::*;

164

	use frame_system::pallet_prelude::*;

165

166

	#[pallet::pallet]

167

	#[pallet::without_storage_info]

168

	pub struct Pallet<T>(_);

169

170

	/// Configuration trait.

171

	#[pallet::config]

172

	pub trait Config: frame_system::Config {

173

		/// The overarching event type.

174

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

175

		type VestingSchedule: VestingSchedule<Self::AccountId, Moment = BlockNumberFor<Self>>;

176

		#[pallet::constant]

177

		type Prefix: Get<&'static [u8]>;

178

		type MoveClaimOrigin: EnsureOrigin<Self::RuntimeOrigin>;

179

		type WeightInfo: WeightInfo;

180

181

182

	#[pallet::event]

183

	#[pallet::generate_deposit(pub(super) fn deposit_event)]

184

	pub enum Event<T: Config> {

185

		/// Someone claimed some DOTs.

186

		Claimed { who: T::AccountId, ethereum_address: EthereumAddress, amount: BalanceOf<T> },

187

188

189

	#[pallet::error]

190

	pub enum Error<T> {

191

		/// Invalid Ethereum signature.

192

		InvalidEthereumSignature,

193

		/// Ethereum address has no claim.

194

		SignerHasNoClaim,

195

		/// Account ID sending transaction has no claim.

196

		SenderHasNoClaim,

197

		/// There's not enough in the pot to pay out some unvested amount. Generally implies a

198

		/// logic error.

199

		PotUnderflow,

200

		/// A needed statement was not included.

201

		InvalidStatement,

202

		/// The account already has a vested balance.

203

		VestedBalanceExists,

204

205

206

	#[pallet::storage]

207

	pub type Claims<T: Config> = StorageMap<_, Identity, EthereumAddress, BalanceOf<T>>;

208

209

	#[pallet::storage]

210

	pub type Total<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;

211

212

	/// Vesting schedule for a claim.

213

	/// First balance is the total amount that should be held for vesting.

214

	/// Second balance is how much should be unlocked per block.

215

	/// The block number is when the vesting should start.

216

	#[pallet::storage]

217

	pub type Vesting<T: Config> =

218

		StorageMap<_, Identity, EthereumAddress, (BalanceOf<T>, BalanceOf<T>, BlockNumberFor<T>)>;

219

220

	/// The statement kind that must be signed, if any.

221

	#[pallet::storage]

222

	pub(super) type Signing<T> = StorageMap<_, Identity, EthereumAddress, StatementKind>;

223

224

	/// Pre-claimed Ethereum accounts, by the Account ID that they are claimed to.

225

	#[pallet::storage]

226

	pub(super) type Preclaims<T: Config> = StorageMap<_, Identity, T::AccountId, EthereumAddress>;

227

228

	#[pallet::genesis_config]

229

	#[derive(DefaultNoBound)]

230

	pub struct GenesisConfig<T: Config> {

231

		pub claims:

232

			Vec<(EthereumAddress, BalanceOf<T>, Option<T::AccountId>, Option<StatementKind>)>,

233

		pub vesting: Vec<(EthereumAddress, (BalanceOf<T>, BalanceOf<T>, BlockNumberFor<T>))>,

234

235

236

	#[pallet::genesis_build]

237

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

238

		fn build(&self) {

239

			// build `Claims`

240

			self.claims.iter().map(|(a, b, _, _)| (*a, *b)).for_each(|(a, b)| {

241

				Claims::<T>::insert(a, b);

242

});

243

			// build `Total`

244

			Total::<T>::put(

245

				self.claims

246

					.iter()

247

					.fold(Zero::zero(), |acc: BalanceOf<T>, &(_, b, _, _)| acc + b),

248

);

249

			// build `Vesting`

250

			self.vesting.iter().for_each(|(k, v)| {

251

				Vesting::<T>::insert(k, v);

252

});

253

			// build `Signing`

254

			self.claims

255

				.iter()

256

				.filter_map(|(a, _, _, s)| Some((*a, (*s)?)))

257

				.for_each(|(a, s)| {

258

					Signing::<T>::insert(a, s);

259

});

260

			// build `Preclaims`

261

			self.claims.iter().filter_map(|(a, _, i, _)| Some((i.clone()?, *a))).for_each(

262

				|(i, a)| {

263

					Preclaims::<T>::insert(i, a);

264

},

265

);

266

267

268

269

	#[pallet::hooks]

270

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}

271

272

	#[pallet::call]

273

	impl<T: Config> Pallet<T> {

274

		/// Make a claim to collect your DOTs.

275

///

276

		/// The dispatch origin for this call must be _None_.

277

///

278

		/// Unsigned Validation:

279

		/// A call to claim is deemed valid if the signature provided matches

280

		/// the expected signed message of:

281

///

282

		/// > Ethereum Signed Message:

283

		/// > (configured prefix string)(address)

284

///

285

		/// and `address` matches the `dest` account.

286

///

287

		/// Parameters:

288

		/// - `dest`: The destination account to payout the claim.

289

		/// - `ethereum_signature`: The signature of an ethereum signed message matching the format

290

		///   described above.

291

///

292

		/// <weight>

293

		/// The weight of this call is invariant over the input parameters.

294

		/// Weight includes logic to validate unsigned `claim` call.

295

///

296

		/// Total Complexity: O(1)

297

		/// </weight>

298

		#[pallet::call_index(0)]

299

		#[pallet::weight(T::WeightInfo::claim())]

300

		pub fn claim(

301

			origin: OriginFor<T>,

302

			dest: T::AccountId,

303

			ethereum_signature: EcdsaSignature,

304

		) -> DispatchResult {

305

			ensure_none(origin)?;

306

307

			let data = dest.using_encoded(to_ascii_hex);

308

			let signer = Self::eth_recover(&ethereum_signature, &data, &[][..])

309

				.ok_or(Error::<T>::InvalidEthereumSignature)?;

310

			ensure!(Signing::<T>::get(&signer).is_none(), Error::<T>::InvalidStatement);

311

312

			Self::process_claim(signer, dest)?;

313

			Ok(())

314

315

316

		/// Mint a new claim to collect DOTs.

317

///

318

		/// The dispatch origin for this call must be _Root_.

319

///

320

		/// Parameters:

321

		/// - `who`: The Ethereum address allowed to collect this claim.

322

		/// - `value`: The number of DOTs that will be claimed.

323

		/// - `vesting_schedule`: An optional vesting schedule for these DOTs.

324

///

325

		/// <weight>

326

		/// The weight of this call is invariant over the input parameters.

327

		/// We assume worst case that both vesting and statement is being inserted.

328

///

329

		/// Total Complexity: O(1)

330

		/// </weight>

331

		#[pallet::call_index(1)]

332

		#[pallet::weight(T::WeightInfo::mint_claim())]

333

		pub fn mint_claim(

334

			origin: OriginFor<T>,

335

			who: EthereumAddress,

336

			value: BalanceOf<T>,

337

			vesting_schedule: Option<(BalanceOf<T>, BalanceOf<T>, BlockNumberFor<T>)>,

338

			statement: Option<StatementKind>,

339

		) -> DispatchResult {

340

			ensure_root(origin)?;

341

342

			Total::<T>::mutate(|t| *t += value);

343

			Claims::<T>::insert(who, value);

344

			if let Some(vs) = vesting_schedule {

345

				Vesting::<T>::insert(who, vs);

346

347

			if let Some(s) = statement {

348

				Signing::<T>::insert(who, s);

349

350

			Ok(())

351

352

353

		/// Make a claim to collect your DOTs by signing a statement.

354

///

355

		/// The dispatch origin for this call must be _None_.

356

///

357

		/// Unsigned Validation:

358

		/// A call to `claim_attest` is deemed valid if the signature provided matches

359

		/// the expected signed message of:

360

///

361

		/// > Ethereum Signed Message:

362

		/// > (configured prefix string)(address)(statement)

363

///

364

		/// and `address` matches the `dest` account; the `statement` must match that which is

365

		/// expected according to your purchase arrangement.

366

///

367

		/// Parameters:

368

		/// - `dest`: The destination account to payout the claim.

369

		/// - `ethereum_signature`: The signature of an ethereum signed message matching the format

370

		///   described above.

371

		/// - `statement`: The identity of the statement which is being attested to in the

372

		///   signature.

373

///

374

		/// <weight>

375

		/// The weight of this call is invariant over the input parameters.

376

		/// Weight includes logic to validate unsigned `claim_attest` call.

377

///

378

		/// Total Complexity: O(1)

379

		/// </weight>

380

		#[pallet::call_index(2)]

381

		#[pallet::weight(T::WeightInfo::claim_attest())]

382

		pub fn claim_attest(

383

			origin: OriginFor<T>,

384

			dest: T::AccountId,

385

			ethereum_signature: EcdsaSignature,

386

			statement: Vec<u8>,

387

		) -> DispatchResult {

388

			ensure_none(origin)?;

389

390

			let data = dest.using_encoded(to_ascii_hex);

391

			let signer = Self::eth_recover(&ethereum_signature, &data, &statement)

392

				.ok_or(Error::<T>::InvalidEthereumSignature)?;

393

			if let Some(s) = Signing::<T>::get(signer) {

394

				ensure!(s.to_text() == &statement[..], Error::<T>::InvalidStatement);

395

396

			Self::process_claim(signer, dest)?;

397

			Ok(())

398

399

400

		/// Attest to a statement, needed to finalize the claims process.

401

///

402

		/// WARNING: Insecure unless your chain includes `PrevalidateAttests` as a

403

		/// `SignedExtension`.

404

///

405

		/// Unsigned Validation:

406

		/// A call to attest is deemed valid if the sender has a `Preclaim` registered

407

		/// and provides a `statement` which is expected for the account.

408

///

409

		/// Parameters:

410

		/// - `statement`: The identity of the statement which is being attested to in the

411

		///   signature.

412

///

413

		/// <weight>

414

		/// The weight of this call is invariant over the input parameters.

415

		/// Weight includes logic to do pre-validation on `attest` call.

416

///

417

		/// Total Complexity: O(1)

418

		/// </weight>

419

		#[pallet::call_index(3)]

420

		#[pallet::weight((

421

			T::WeightInfo::attest(),

422

			DispatchClass::Normal,

423

			Pays::No

424

))]

425

		pub fn attest(origin: OriginFor<T>, statement: Vec<u8>) -> DispatchResult {

426

			let who = ensure_signed(origin)?;

427

			let signer = Preclaims::<T>::get(&who).ok_or(Error::<T>::SenderHasNoClaim)?;

428

			if let Some(s) = Signing::<T>::get(signer) {

429

				ensure!(s.to_text() == &statement[..], Error::<T>::InvalidStatement);

430

431

			Self::process_claim(signer, who.clone())?;

432

			Preclaims::<T>::remove(&who);

433

			Ok(())

434

435

436

		#[pallet::call_index(4)]

437

		#[pallet::weight(T::WeightInfo::move_claim())]

438

		pub fn move_claim(

439

			origin: OriginFor<T>,

440

			old: EthereumAddress,

441

			new: EthereumAddress,

442

			maybe_preclaim: Option<T::AccountId>,

443

		) -> DispatchResultWithPostInfo {

444

			T::MoveClaimOrigin::try_origin(origin).map(|_| ()).or_else(ensure_root)?;

445

446

			Claims::<T>::take(&old).map(|c| Claims::<T>::insert(&new, c));

447

			Vesting::<T>::take(&old).map(|c| Vesting::<T>::insert(&new, c));

448

			Signing::<T>::take(&old).map(|c| Signing::<T>::insert(&new, c));

449

			maybe_preclaim.map(|preclaim| {

450

				Preclaims::<T>::mutate(&preclaim, |maybe_o| {

451

					if maybe_o.as_ref().map_or(false, |o| o == &old) {

452

						*maybe_o = Some(new)

453

454

})

455

});

456

			Ok(Pays::No.into())

457

458

459

460

	#[pallet::validate_unsigned]

461

	impl<T: Config> ValidateUnsigned for Pallet<T> {

462

		type Call = Call<T>;

463

464

		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {

465

			const PRIORITY: u64 = 100;

466

467

			let (maybe_signer, maybe_statement) = match call {

468

				// <weight>

469

				// The weight of this logic is included in the `claim` dispatchable.

470

				// </weight>

471

				Call::claim { dest: account, ethereum_signature } => {

472

					let data = account.using_encoded(to_ascii_hex);

473

					(Self::eth_recover(&ethereum_signature, &data, &[][..]), None)

474

},

475

				// <weight>

476

				// The weight of this logic is included in the `claim_attest` dispatchable.

477

				// </weight>

478

				Call::claim_attest { dest: account, ethereum_signature, statement } => {

479

					let data = account.using_encoded(to_ascii_hex);

480

481

						Self::eth_recover(&ethereum_signature, &data, &statement),

482

						Some(statement.as_slice()),

483

484

},

485

				_ => return Err(InvalidTransaction::Call.into()),

486

};

487

488

			let signer = maybe_signer.ok_or(InvalidTransaction::Custom(

489

				ValidityError::InvalidEthereumSignature.into(),

490

			))?;

491

492

			let e = InvalidTransaction::Custom(ValidityError::SignerHasNoClaim.into());

493

			ensure!(Claims::<T>::contains_key(&signer), e);

494

495

			let e = InvalidTransaction::Custom(ValidityError::InvalidStatement.into());

496

			match Signing::<T>::get(signer) {

497

				None => ensure!(maybe_statement.is_none(), e),

498

				Some(s) => ensure!(Some(s.to_text()) == maybe_statement, e),

499

500

501

			Ok(ValidTransaction {

502

				priority: PRIORITY,

503

				requires: vec![],

504

				provides: vec![("claims", signer).encode()],

505

				longevity: TransactionLongevity::max_value(),

506

				propagate: true,

507

})

508

509

510

511

512

/// Converts the given binary data into ASCII-encoded hex. It will be twice the length.

513

fn to_ascii_hex(data: &[u8]) -> Vec<u8> {

514

	let mut r = Vec::with_capacity(data.len() * 2);

515

	let mut push_nibble = |n| r.push(if n < 10 { b'0' + n } else { b'a' - 10 + n });

516

	for &b in data.iter() {

517

		push_nibble(b / 16);

518

		push_nibble(b % 16);

519

520

521

522

523

impl<T: Config> Pallet<T> {

524

	// Constructs the message that Ethereum RPC's `personal_sign` and `eth_sign` would sign.

525

	fn ethereum_signable_message(what: &[u8], extra: &[u8]) -> Vec<u8> {

526

		let prefix = T::Prefix::get();

527

		let mut l = prefix.len() + what.len() + extra.len();

528

		let mut rev = Vec::new();

529

		while l > 0 {

530

			rev.push(b'0' + (l % 10) as u8);

531

			l /= 10;

532

533

		let mut v = b"\x19Ethereum Signed Message:\n".to_vec();

534

		v.extend(rev.into_iter().rev());

535

		v.extend_from_slice(prefix);

536

		v.extend_from_slice(what);

537

		v.extend_from_slice(extra);

538

539

540

541

	// Attempts to recover the Ethereum address from a message signature signed by using

542

	// the Ethereum RPC's `personal_sign` and `eth_sign`.

543

	fn eth_recover(s: &EcdsaSignature, what: &[u8], extra: &[u8]) -> Option<EthereumAddress> {

544

		let msg = keccak_256(&Self::ethereum_signable_message(what, extra));

545

		let mut res = EthereumAddress::default();

546

		res.0

547

			.copy_from_slice(&keccak_256(&secp256k1_ecdsa_recover(&s.0, &msg).ok()?[..])[12..]);

548

		Some(res)

549

550

551

	fn process_claim(signer: EthereumAddress, dest: T::AccountId) -> sp_runtime::DispatchResult {

552

		let balance_due = Claims::<T>::get(&signer).ok_or(Error::<T>::SignerHasNoClaim)?;

553

554

		let new_total =

555

			Total::<T>::get().checked_sub(&balance_due).ok_or(Error::<T>::PotUnderflow)?;

556

557

		let vesting = Vesting::<T>::get(&signer);

558

		if vesting.is_some() && T::VestingSchedule::vesting_balance(&dest).is_some() {

559

			return Err(Error::<T>::VestedBalanceExists.into())

560

561

562

		// We first need to deposit the balance to ensure that the account exists.

563

		let _ = CurrencyOf::<T>::deposit_creating(&dest, balance_due);

564

565

		// Check if this claim should have a vesting schedule.

566

		if let Some(vs) = vesting {

567

			// This can only fail if the account already has a vesting schedule,

568

			// but this is checked above.

569

			T::VestingSchedule::add_vesting_schedule(&dest, vs.0, vs.1, vs.2)

570

				.expect("No other vesting schedule exists, as checked above; qed");

571

572

573

		Total::<T>::put(new_total);

574

		Claims::<T>::remove(&signer);

575

		Vesting::<T>::remove(&signer);

576

		Signing::<T>::remove(&signer);

577

578

		// Let's deposit an event to let the outside world know this happened.

579

		Self::deposit_event(Event::<T>::Claimed {

580

			who: dest,

581

			ethereum_address: signer,

582

			amount: balance_due,

583

});

584

585

		Ok(())

586

587

588

589

/// Validate `attest` calls prior to execution. Needed to avoid a DoS attack since they are

590

/// otherwise free to place on chain.

591

#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]

592

#[scale_info(skip_type_params(T))]

593

pub struct PrevalidateAttests<T>(core::marker::PhantomData<fn(T)>);

594

595

impl<T: Config> Debug for PrevalidateAttests<T>

596

where

597

	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,

598

599

	#[cfg(feature = "std")]

600

	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

601

		write!(f, "PrevalidateAttests")

602

603

604

	#[cfg(not(feature = "std"))]

605

	fn fmt(&self, _: &mut core::fmt::Formatter) -> core::fmt::Result {

606

		Ok(())

607

608

609

610

impl<T: Config> PrevalidateAttests<T>

611

where

612

	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,

613

614

	/// Create new `SignedExtension` to check runtime version.

615

	pub fn new() -> Self {

616

		Self(core::marker::PhantomData)

617

618

619

620

impl<T: Config> SignedExtension for PrevalidateAttests<T>

621

where

622

	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,

623

624

	type AccountId = T::AccountId;

625

	type Call = <T as frame_system::Config>::RuntimeCall;

626

	type AdditionalSigned = ();

627

	type Pre = ();

628

	const IDENTIFIER: &'static str = "PrevalidateAttests";

629

630

	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {

631

		Ok(())

632

633

634

	fn pre_dispatch(

635

		self,

636

		who: &Self::AccountId,

637

		call: &Self::Call,

638

		info: &DispatchInfoOf<Self::Call>,

639

		len: usize,

640

	) -> Result<Self::Pre, TransactionValidityError> {

641

		self.validate(who, call, info, len).map(|_| ())

642

643

644

	// <weight>

645

	// The weight of this logic is included in the `attest` dispatchable.

646

	// </weight>

647

	fn validate(

648

		&self,

649

		who: &Self::AccountId,

650

		call: &Self::Call,

651

		_info: &DispatchInfoOf<Self::Call>,

652

		_len: usize,

653

	) -> TransactionValidity {

654

		if let Some(local_call) = call.is_sub_type() {

655

			if let Call::attest { statement: attested_statement } = local_call {

656

				let signer = Preclaims::<T>::get(who)

657

					.ok_or(InvalidTransaction::Custom(ValidityError::SignerHasNoClaim.into()))?;

658

				if let Some(s) = Signing::<T>::get(signer) {

659

					let e = InvalidTransaction::Custom(ValidityError::InvalidStatement.into());

660

					ensure!(&attested_statement[..] == s.to_text(), e);

661

662

663

664

		Ok(ValidTransaction::default())

665

666

667

668

#[cfg(any(test, feature = "runtime-benchmarks"))]

669

mod secp_utils {

670

	use super::*;

671

672

	pub fn public(secret: &libsecp256k1::SecretKey) -> libsecp256k1::PublicKey {

673

		libsecp256k1::PublicKey::from_secret_key(secret)

674

675

	pub fn eth(secret: &libsecp256k1::SecretKey) -> EthereumAddress {

676

		let mut res = EthereumAddress::default();

677

		res.0.copy_from_slice(&keccak_256(&public(secret).serialize()[1..65])[12..]);

678

res

679

680

	pub fn sig<T: Config>(

681

		secret: &libsecp256k1::SecretKey,

682

		what: &[u8],

683

		extra: &[u8],

684

	) -> EcdsaSignature {

685

		let msg = keccak_256(&super::Pallet::<T>::ethereum_signable_message(

686

			&to_ascii_hex(what)[..],

687

			extra,

688

));

689

		let (sig, recovery_id) = libsecp256k1::sign(&libsecp256k1::Message::parse(&msg), secret);

690

		let mut r = [0u8; 65];

691

		r[0..64].copy_from_slice(&sig.serialize()[..]);

692

		r[64] = recovery_id.serialize();

693

		EcdsaSignature(r)

694

695

696

697

#[cfg(test)]

698

mod tests {

699

	use super::*;

700

	use hex_literal::hex;

701

	use secp_utils::*;

702

703

	use codec::Encode;

704

	// The testing primitives are very useful for avoiding having to work with signatures

705

	// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.

706

	use crate::claims;

707

	use claims::Call as ClaimsCall;

708

	use frame_support::{

709

		assert_err, assert_noop, assert_ok, derive_impl,

710

		dispatch::{GetDispatchInfo, Pays},

711

		ord_parameter_types, parameter_types,

712

		traits::{ExistenceRequirement, WithdrawReasons},

713

};

714

	use pallet_balances;

715

	use sp_runtime::{

716

		traits::Identity, transaction_validity::TransactionLongevity, BuildStorage,

717

		DispatchError::BadOrigin, TokenError,

718

};

719

720

	type Block = frame_system::mocking::MockBlock<Test>;

721

722

	frame_support::construct_runtime!(

723

		pub enum Test

724

725

			System: frame_system,

726

			Balances: pallet_balances,

727

			Vesting: pallet_vesting,

728

			Claims: claims,

729

730

);

731

732

	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]

733

	impl frame_system::Config for Test {

734

		type RuntimeOrigin = RuntimeOrigin;

735

		type RuntimeCall = RuntimeCall;

736

		type Block = Block;

737

		type RuntimeEvent = RuntimeEvent;

738

		type AccountData = pallet_balances::AccountData<u64>;

739

		type MaxConsumers = frame_support::traits::ConstU32<16>;

740

741

742

	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]

743

	impl pallet_balances::Config for Test {

744

		type AccountStore = System;

745

746

747

	parameter_types! {

748

		pub const MinVestedTransfer: u64 = 1;

749

		pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =

750

			WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);

751

752

753

	impl pallet_vesting::Config for Test {

754

		type RuntimeEvent = RuntimeEvent;

755

		type Currency = Balances;

756

		type BlockNumberToBalance = Identity;

757

		type MinVestedTransfer = MinVestedTransfer;

758

		type WeightInfo = ();

759

		type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;

760

		type BlockNumberProvider = System;

761

		const MAX_VESTING_SCHEDULES: u32 = 28;

762

763

764

	parameter_types! {

765

		pub Prefix: &'static [u8] = b"Pay RUSTs to the TEST account:";

766

767

	ord_parameter_types! {

768

		pub const Six: u64 = 6;

769

770

771

	impl Config for Test {

772

		type RuntimeEvent = RuntimeEvent;

773

		type VestingSchedule = Vesting;

774

		type Prefix = Prefix;

775

		type MoveClaimOrigin = frame_system::EnsureSignedBy<Six, u64>;

776

		type WeightInfo = TestWeightInfo;

777

778

779

	fn alice() -> libsecp256k1::SecretKey {

780

		libsecp256k1::SecretKey::parse(&keccak_256(b"Alice")).unwrap()

781

782

	fn bob() -> libsecp256k1::SecretKey {

783

		libsecp256k1::SecretKey::parse(&keccak_256(b"Bob")).unwrap()

784

785

	fn dave() -> libsecp256k1::SecretKey {

786

		libsecp256k1::SecretKey::parse(&keccak_256(b"Dave")).unwrap()

787

788

	fn eve() -> libsecp256k1::SecretKey {

789

		libsecp256k1::SecretKey::parse(&keccak_256(b"Eve")).unwrap()

790

791

	fn frank() -> libsecp256k1::SecretKey {

792

		libsecp256k1::SecretKey::parse(&keccak_256(b"Frank")).unwrap()

793

794

795

	// This function basically just builds a genesis storage key/value store according to

796

	// our desired mockup.

797

	pub fn new_test_ext() -> sp_io::TestExternalities {

798

		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();

799

		// We use default for brevity, but you can configure as desired if needed.

800

		pallet_balances::GenesisConfig::<Test>::default()

801

			.assimilate_storage(&mut t)

802

			.unwrap();

803

		claims::GenesisConfig::<Test> {

804

			claims: vec![

805

				(eth(&alice()), 100, None, None),

806

				(eth(&dave()), 200, None, Some(StatementKind::Regular)),

807

				(eth(&eve()), 300, Some(42), Some(StatementKind::Saft)),

808

				(eth(&frank()), 400, Some(43), None),

809

],

810

			vesting: vec![(eth(&alice()), (50, 10, 1))],

811

812

		.assimilate_storage(&mut t)

813

		.unwrap();

814

		t.into()

815

816

817

	fn total_claims() -> u64 {

818

		100 + 200 + 300 + 400

819

820

821

	#[test]

822

	fn basic_setup_works() {

823

		new_test_ext().execute_with(|| {

824

			assert_eq!(claims::Total::<Test>::get(), total_claims());

825

			assert_eq!(claims::Claims::<Test>::get(&eth(&alice())), Some(100));

826

			assert_eq!(claims::Claims::<Test>::get(&eth(&dave())), Some(200));

827

			assert_eq!(claims::Claims::<Test>::get(&eth(&eve())), Some(300));

828

			assert_eq!(claims::Claims::<Test>::get(&eth(&frank())), Some(400));

829

			assert_eq!(claims::Claims::<Test>::get(&EthereumAddress::default()), None);

830

			assert_eq!(claims::Vesting::<Test>::get(&eth(&alice())), Some((50, 10, 1)));

831

});

832

833

834

	#[test]

835

	fn serde_works() {

836

		let x = EthereumAddress(hex!["0123456789abcdef0123456789abcdef01234567"]);

837

		let y = serde_json::to_string(&x).unwrap();

838

		assert_eq!(y, "\"0x0123456789abcdef0123456789abcdef01234567\"");

839

		let z: EthereumAddress = serde_json::from_str(&y).unwrap();

840

		assert_eq!(x, z);

841

842

843

	#[test]

844

	fn claiming_works() {

845

		new_test_ext().execute_with(|| {

846

			assert_eq!(Balances::free_balance(42), 0);

847

			assert_ok!(Claims::claim(

848

				RuntimeOrigin::none(),

849

42,

850

				sig::<Test>(&alice(), &42u64.encode(), &[][..])

851

));

852

			assert_eq!(Balances::free_balance(&42), 100);

853

			assert_eq!(Vesting::vesting_balance(&42), Some(50));

854

			assert_eq!(claims::Total::<Test>::get(), total_claims() - 100);

855

});

856

857

858

	#[test]

859

	fn basic_claim_moving_works() {

860

		new_test_ext().execute_with(|| {

861

			assert_eq!(Balances::free_balance(42), 0);

862

			assert_noop!(

863

				Claims::move_claim(RuntimeOrigin::signed(1), eth(&alice()), eth(&bob()), None),

864

				BadOrigin

865

);

866

			assert_ok!(Claims::move_claim(

867

				RuntimeOrigin::signed(6),

868

				eth(&alice()),

869

				eth(&bob()),

870

				None

871

));

872

			assert_noop!(

873

				Claims::claim(

874

					RuntimeOrigin::none(),

875

42,

876

					sig::<Test>(&alice(), &42u64.encode(), &[][..])

877

),

878

				Error::<Test>::SignerHasNoClaim

879

);

880

			assert_ok!(Claims::claim(

881

				RuntimeOrigin::none(),

882

42,

883

				sig::<Test>(&bob(), &42u64.encode(), &[][..])

884

));

885

			assert_eq!(Balances::free_balance(&42), 100);

886

			assert_eq!(Vesting::vesting_balance(&42), Some(50));

887

			assert_eq!(claims::Total::<Test>::get(), total_claims() - 100);

888

});

889

890

891

	#[test]

892

	fn claim_attest_moving_works() {

893

		new_test_ext().execute_with(|| {

894

			assert_ok!(Claims::move_claim(

895

				RuntimeOrigin::signed(6),

896

				eth(&dave()),

897

				eth(&bob()),

898

				None

899

));

900

			let s = sig::<Test>(&bob(), &42u64.encode(), StatementKind::Regular.to_text());

901

			assert_ok!(Claims::claim_attest(

902

				RuntimeOrigin::none(),

903

42,

904

s,

905

				StatementKind::Regular.to_text().to_vec()

906

));

907

			assert_eq!(Balances::free_balance(&42), 200);

908

});

909

910

911

	#[test]

912

	fn attest_moving_works() {

913

		new_test_ext().execute_with(|| {

914

			assert_ok!(Claims::move_claim(

915

				RuntimeOrigin::signed(6),

916

				eth(&eve()),

917

				eth(&bob()),

918

				Some(42)

919

));

920

			assert_ok!(Claims::attest(

921

				RuntimeOrigin::signed(42),

922

				StatementKind::Saft.to_text().to_vec()

923

));

924

			assert_eq!(Balances::free_balance(&42), 300);

925

});

926

927

928

	#[test]

929

	fn claiming_does_not_bypass_signing() {

930

		new_test_ext().execute_with(|| {

931

			assert_ok!(Claims::claim(

932

				RuntimeOrigin::none(),

933

42,

934

				sig::<Test>(&alice(), &42u64.encode(), &[][..])

935

));

936

			assert_noop!(

937

				Claims::claim(

938

					RuntimeOrigin::none(),

939

42,

940

					sig::<Test>(&dave(), &42u64.encode(), &[][..])

941

),

942

				Error::<Test>::InvalidStatement,

943

);

944

			assert_noop!(

945

				Claims::claim(

946

					RuntimeOrigin::none(),

947

42,

948

					sig::<Test>(&eve(), &42u64.encode(), &[][..])

949

),

950

				Error::<Test>::InvalidStatement,

951

);

952

			assert_ok!(Claims::claim(

953

				RuntimeOrigin::none(),

954

42,

955

				sig::<Test>(&frank(), &42u64.encode(), &[][..])

956

));

957

});

958

959

960

	#[test]

961

	fn attest_claiming_works() {

962

		new_test_ext().execute_with(|| {

963

			assert_eq!(Balances::free_balance(42), 0);

964

			let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Saft.to_text());

965

			let r = Claims::claim_attest(

966

				RuntimeOrigin::none(),

967

42,

968

				s.clone(),

969

				StatementKind::Saft.to_text().to_vec(),

970

);

971

			assert_noop!(r, Error::<Test>::InvalidStatement);

972

973

			let r = Claims::claim_attest(

974

				RuntimeOrigin::none(),

975

42,

976

s,

977

				StatementKind::Regular.to_text().to_vec(),

978

);

979

			assert_noop!(r, Error::<Test>::SignerHasNoClaim);

980

			// ^^^ we use ecdsa_recover, so an invalid signature just results in a random signer id

981

			// being recovered, which realistically will never have a claim.

982

983

			let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Regular.to_text());

984

			assert_ok!(Claims::claim_attest(

985

				RuntimeOrigin::none(),

986

42,

987

s,

988

				StatementKind::Regular.to_text().to_vec()

989

));

990

			assert_eq!(Balances::free_balance(&42), 200);

991

			assert_eq!(claims::Total::<Test>::get(), total_claims() - 200);

992

993

			let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Regular.to_text());

994

			let r = Claims::claim_attest(

995

				RuntimeOrigin::none(),

996

42,

997

s,

998

				StatementKind::Regular.to_text().to_vec(),

999

);

1000

			assert_noop!(r, Error::<Test>::SignerHasNoClaim);

1001

});

1002

1003

1004

	#[test]

1005

	fn attesting_works() {

1006

		new_test_ext().execute_with(|| {

1007

			assert_eq!(Balances::free_balance(42), 0);

1008

			assert_noop!(

1009

				Claims::attest(RuntimeOrigin::signed(69), StatementKind::Saft.to_text().to_vec()),

1010

				Error::<Test>::SenderHasNoClaim

1011

);

1012

			assert_noop!(

1013

				Claims::attest(

1014

					RuntimeOrigin::signed(42),

1015

					StatementKind::Regular.to_text().to_vec()

1016

),

1017

				Error::<Test>::InvalidStatement

1018

);

1019

			assert_ok!(Claims::attest(

1020

				RuntimeOrigin::signed(42),

1021

				StatementKind::Saft.to_text().to_vec()

1022

));

1023

			assert_eq!(Balances::free_balance(&42), 300);

1024

			assert_eq!(claims::Total::<Test>::get(), total_claims() - 300);

1025

});

1026

1027

1028

	#[test]

1029

	fn claim_cannot_clobber_preclaim() {

1030

		new_test_ext().execute_with(|| {

1031

			assert_eq!(Balances::free_balance(42), 0);

1032

			// Alice's claim is 100

1033

			assert_ok!(Claims::claim(

1034

				RuntimeOrigin::none(),

1035

42,

1036

				sig::<Test>(&alice(), &42u64.encode(), &[][..])

1037

));

1038

			assert_eq!(Balances::free_balance(&42), 100);

1039

			// Eve's claim is 300 through Account 42

1040

			assert_ok!(Claims::attest(

1041

				RuntimeOrigin::signed(42),

1042

				StatementKind::Saft.to_text().to_vec()

1043

));

1044

			assert_eq!(Balances::free_balance(&42), 100 + 300);

1045

			assert_eq!(claims::Total::<Test>::get(), total_claims() - 400);

1046

});

1047

1048

1049

	#[test]

1050

	fn valid_attest_transactions_are_free() {

1051

		new_test_ext().execute_with(|| {

1052

			let p = PrevalidateAttests::<Test>::new();

1053

			let c = RuntimeCall::Claims(ClaimsCall::attest {

1054

				statement: StatementKind::Saft.to_text().to_vec(),

1055

});

1056

			let di = c.get_dispatch_info();

1057

			assert_eq!(di.pays_fee, Pays::No);

1058

			let r = p.validate(&42, &c, &di, 20);

1059

			assert_eq!(r, TransactionValidity::Ok(ValidTransaction::default()));

1060

});

1061

1062

1063

	#[test]

1064

	fn invalid_attest_transactions_are_recognized() {

1065

		new_test_ext().execute_with(|| {

1066

			let p = PrevalidateAttests::<Test>::new();

1067

			let c = RuntimeCall::Claims(ClaimsCall::attest {

1068

				statement: StatementKind::Regular.to_text().to_vec(),

1069

});

1070

			let di = c.get_dispatch_info();

1071

			let r = p.validate(&42, &c, &di, 20);

1072

			assert!(r.is_err());

1073

			let c = RuntimeCall::Claims(ClaimsCall::attest {

1074

				statement: StatementKind::Saft.to_text().to_vec(),

1075

});

1076

			let di = c.get_dispatch_info();

1077

			let r = p.validate(&69, &c, &di, 20);

1078

			assert!(r.is_err());

1079

});

1080

1081

1082

	#[test]

1083

	fn cannot_bypass_attest_claiming() {

1084

		new_test_ext().execute_with(|| {

1085

			assert_eq!(Balances::free_balance(42), 0);

1086

			let s = sig::<Test>(&dave(), &42u64.encode(), &[]);

1087

			let r = Claims::claim(RuntimeOrigin::none(), 42, s.clone());

1088

			assert_noop!(r, Error::<Test>::InvalidStatement);

1089

});

1090

1091

1092

	#[test]

1093

	fn add_claim_works() {

1094

		new_test_ext().execute_with(|| {

1095

			assert_noop!(

1096

				Claims::mint_claim(RuntimeOrigin::signed(42), eth(&bob()), 200, None, None),

1097

				sp_runtime::traits::BadOrigin,

1098

);

1099

			assert_eq!(Balances::free_balance(42), 0);

1100

			assert_noop!(

1101

				Claims::claim(

1102

					RuntimeOrigin::none(),

1103

69,

1104

					sig::<Test>(&bob(), &69u64.encode(), &[][..])

1105

),

1106

				Error::<Test>::SignerHasNoClaim,

1107

);

1108

			assert_ok!(Claims::mint_claim(RuntimeOrigin::root(), eth(&bob()), 200, None, None));

1109

			assert_eq!(claims::Total::<Test>::get(), total_claims() + 200);

1110

			assert_ok!(Claims::claim(

1111

				RuntimeOrigin::none(),

1112

69,

1113

				sig::<Test>(&bob(), &69u64.encode(), &[][..])

1114

));

1115

			assert_eq!(Balances::free_balance(&69), 200);

1116

			assert_eq!(Vesting::vesting_balance(&69), None);

1117

			assert_eq!(claims::Total::<Test>::get(), total_claims());

1118

});

1119

1120

1121

	#[test]

1122

	fn add_claim_with_vesting_works() {

1123

		new_test_ext().execute_with(|| {

1124

			assert_noop!(

1125

				Claims::mint_claim(

1126

					RuntimeOrigin::signed(42),

1127

					eth(&bob()),

1128

					200,

1129

					Some((50, 10, 1)),

1130

					None

1131

),

1132

				sp_runtime::traits::BadOrigin,

1133

);

1134

			assert_eq!(Balances::free_balance(42), 0);

1135

			assert_noop!(

1136

				Claims::claim(

1137

					RuntimeOrigin::none(),

1138

69,

1139

					sig::<Test>(&bob(), &69u64.encode(), &[][..])

1140

),

1141

				Error::<Test>::SignerHasNoClaim,

1142

);

1143

			assert_ok!(Claims::mint_claim(

1144

				RuntimeOrigin::root(),

1145

				eth(&bob()),

1146

				200,

1147

				Some((50, 10, 1)),

1148

				None

1149

));

1150

			assert_ok!(Claims::claim(

1151

				RuntimeOrigin::none(),

1152

69,

1153

				sig::<Test>(&bob(), &69u64.encode(), &[][..])

1154

));

1155

			assert_eq!(Balances::free_balance(&69), 200);

1156

			assert_eq!(Vesting::vesting_balance(&69), Some(50));

1157

1158

			// Make sure we can not transfer the vested balance.

1159

			assert_err!(

1160

				<Balances as Currency<_>>::transfer(

1161

					&69,

1162

					&80,

1163

					180,

1164

					ExistenceRequirement::AllowDeath

1165

),

1166

				TokenError::Frozen,

1167

);

1168

});

1169

1170

1171

	#[test]

1172

	fn add_claim_with_statement_works() {

1173

		new_test_ext().execute_with(|| {

1174

			assert_noop!(

1175

				Claims::mint_claim(

1176

					RuntimeOrigin::signed(42),

1177

					eth(&bob()),

1178

					200,

1179

					None,

1180

					Some(StatementKind::Regular)

1181

),

1182

				sp_runtime::traits::BadOrigin,

1183

);

1184

			assert_eq!(Balances::free_balance(42), 0);

1185

			let signature = sig::<Test>(&bob(), &69u64.encode(), StatementKind::Regular.to_text());

1186

			assert_noop!(

1187

				Claims::claim_attest(

1188

					RuntimeOrigin::none(),

1189

69,

1190

					signature.clone(),

1191

					StatementKind::Regular.to_text().to_vec()

1192

),

1193

				Error::<Test>::SignerHasNoClaim

1194

);

1195

			assert_ok!(Claims::mint_claim(

1196

				RuntimeOrigin::root(),

1197

				eth(&bob()),

1198

				200,

1199

				None,

1200

				Some(StatementKind::Regular)

1201

));

1202

			assert_noop!(

1203

				Claims::claim_attest(RuntimeOrigin::none(), 69, signature.clone(), vec![],),

1204

				Error::<Test>::SignerHasNoClaim

1205

);

1206

			assert_ok!(Claims::claim_attest(

1207

				RuntimeOrigin::none(),

1208

69,

1209

				signature.clone(),

1210

				StatementKind::Regular.to_text().to_vec()

1211

));

1212

			assert_eq!(Balances::free_balance(&69), 200);

1213

});

1214

1215

1216

	#[test]

1217

	fn origin_signed_claiming_fail() {

1218

		new_test_ext().execute_with(|| {

1219

			assert_eq!(Balances::free_balance(42), 0);

1220

			assert_err!(

1221

				Claims::claim(

1222

					RuntimeOrigin::signed(42),

1223

42,

1224

					sig::<Test>(&alice(), &42u64.encode(), &[][..])

1225

),

1226

				sp_runtime::traits::BadOrigin,

1227

);

1228

});

1229

1230

1231

	#[test]

1232

	fn double_claiming_doesnt_work() {

1233

		new_test_ext().execute_with(|| {

1234

			assert_eq!(Balances::free_balance(42), 0);

1235

			assert_ok!(Claims::claim(

1236

				RuntimeOrigin::none(),

1237

42,

1238

				sig::<Test>(&alice(), &42u64.encode(), &[][..])

1239

));

1240

			assert_noop!(

1241

				Claims::claim(

1242

					RuntimeOrigin::none(),

1243

42,

1244

					sig::<Test>(&alice(), &42u64.encode(), &[][..])

1245

),

1246

				Error::<Test>::SignerHasNoClaim

1247

);

1248

});

1249

1250

1251

	#[test]

1252

	fn claiming_while_vested_doesnt_work() {

1253

		new_test_ext().execute_with(|| {

1254

			CurrencyOf::<Test>::make_free_balance_be(&69, total_claims());

1255

			assert_eq!(Balances::free_balance(69), total_claims());

1256

			// A user is already vested

1257

			assert_ok!(<Test as Config>::VestingSchedule::add_vesting_schedule(

1258

				&69,

1259

				total_claims(),

1260

				100,

1261

1262

));

1263

			assert_ok!(Claims::mint_claim(

1264

				RuntimeOrigin::root(),

1265

				eth(&bob()),

1266

				200,

1267

				Some((50, 10, 1)),

1268

				None

1269

));

1270

			// New total

1271

			assert_eq!(claims::Total::<Test>::get(), total_claims() + 200);

1272

1273

			// They should not be able to claim

1274

			assert_noop!(

1275

				Claims::claim(

1276

					RuntimeOrigin::none(),

1277

69,

1278

					sig::<Test>(&bob(), &69u64.encode(), &[][..])

1279

),

1280

				Error::<Test>::VestedBalanceExists,

1281

);

1282

});

1283

1284

1285

	#[test]

1286

	fn non_sender_sig_doesnt_work() {

1287

		new_test_ext().execute_with(|| {

1288

			assert_eq!(Balances::free_balance(42), 0);

1289

			assert_noop!(

1290

				Claims::claim(

1291

					RuntimeOrigin::none(),

1292

42,

1293

					sig::<Test>(&alice(), &69u64.encode(), &[][..])

1294

),

1295

				Error::<Test>::SignerHasNoClaim

1296

);

1297

});

1298

1299

1300

	#[test]

1301

	fn non_claimant_doesnt_work() {

1302

		new_test_ext().execute_with(|| {

1303

			assert_eq!(Balances::free_balance(42), 0);

1304

			assert_noop!(

1305

				Claims::claim(

1306

					RuntimeOrigin::none(),

1307

42,

1308

					sig::<Test>(&bob(), &69u64.encode(), &[][..])

1309

),

1310

				Error::<Test>::SignerHasNoClaim

1311

);

1312

});

1313

1314

1315

	#[test]

1316

	fn real_eth_sig_works() {

1317

		new_test_ext().execute_with(|| {

1318

			// "Pay RUSTs to the TEST account:2a00000000000000"

1319

			let sig = hex!["444023e89b67e67c0562ed0305d252a5dd12b2af5ac51d6d3cb69a0b486bc4b3191401802dc29d26d586221f7256cd3329fe82174bdf659baea149a40e1c495d1c"];

1320

			let sig = EcdsaSignature(sig);

1321

			let who = 42u64.using_encoded(to_ascii_hex);

1322

			let signer = Claims::eth_recover(&sig, &who, &[][..]).unwrap();

1323

			assert_eq!(signer.0, hex!["6d31165d5d932d571f3b44695653b46dcc327e84"]);

1324

});

1325

1326

1327

	#[test]

1328

	fn validate_unsigned_works() {

1329

		use sp_runtime::traits::ValidateUnsigned;

1330

		let source = sp_runtime::transaction_validity::TransactionSource::External;

1331

1332

		new_test_ext().execute_with(|| {

1333

			assert_eq!(

1334

				Pallet::<Test>::validate_unsigned(

1335

					source,

1336

					&ClaimsCall::claim {

1337

						dest: 1,

1338

						ethereum_signature: sig::<Test>(&alice(), &1u64.encode(), &[][..])

1339

1340

),

1341

				Ok(ValidTransaction {

1342

					priority: 100,

1343

					requires: vec![],

1344

					provides: vec![("claims", eth(&alice())).encode()],

1345

					longevity: TransactionLongevity::max_value(),

1346

					propagate: true,

1347

})

1348

);

1349

			assert_eq!(

1350

				Pallet::<Test>::validate_unsigned(

1351

					source,

1352

					&ClaimsCall::claim { dest: 0, ethereum_signature: EcdsaSignature([0; 65]) }

1353

),

1354

				InvalidTransaction::Custom(ValidityError::InvalidEthereumSignature.into()).into(),

1355

);

1356

			assert_eq!(

1357

				Pallet::<Test>::validate_unsigned(

1358

					source,

1359

					&ClaimsCall::claim {

1360

						dest: 1,

1361

						ethereum_signature: sig::<Test>(&bob(), &1u64.encode(), &[][..])

1362

1363

),

1364

				InvalidTransaction::Custom(ValidityError::SignerHasNoClaim.into()).into(),

1365

);

1366

			let s = sig::<Test>(&dave(), &1u64.encode(), StatementKind::Regular.to_text());

1367

			let call = ClaimsCall::claim_attest {

1368

				dest: 1,

1369

				ethereum_signature: s,

1370

				statement: StatementKind::Regular.to_text().to_vec(),

1371

};

1372

			assert_eq!(

1373

				Pallet::<Test>::validate_unsigned(source, &call),

1374

				Ok(ValidTransaction {

1375

					priority: 100,

1376

					requires: vec![],

1377

					provides: vec![("claims", eth(&dave())).encode()],

1378

					longevity: TransactionLongevity::max_value(),

1379

					propagate: true,

1380

})

1381

);

1382

			assert_eq!(

1383

				Pallet::<Test>::validate_unsigned(

1384

					source,

1385

					&ClaimsCall::claim_attest {

1386

						dest: 1,

1387

						ethereum_signature: EcdsaSignature([0; 65]),

1388

						statement: StatementKind::Regular.to_text().to_vec()

1389

1390

),

1391

				InvalidTransaction::Custom(ValidityError::InvalidEthereumSignature.into()).into(),

1392

);

1393

1394

			let s = sig::<Test>(&bob(), &1u64.encode(), StatementKind::Regular.to_text());

1395

			let call = ClaimsCall::claim_attest {

1396

				dest: 1,

1397

				ethereum_signature: s,

1398

				statement: StatementKind::Regular.to_text().to_vec(),

1399

};

1400

			assert_eq!(

1401

				Pallet::<Test>::validate_unsigned(source, &call),

1402

				InvalidTransaction::Custom(ValidityError::SignerHasNoClaim.into()).into(),

1403

);

1404

1405

			let s = sig::<Test>(&dave(), &1u64.encode(), StatementKind::Saft.to_text());

1406

			let call = ClaimsCall::claim_attest {

1407

				dest: 1,

1408

				ethereum_signature: s,

1409

				statement: StatementKind::Regular.to_text().to_vec(),

1410

};

1411

			assert_eq!(

1412

				Pallet::<Test>::validate_unsigned(source, &call),

1413

				InvalidTransaction::Custom(ValidityError::SignerHasNoClaim.into()).into(),

1414

);

1415

1416

			let s = sig::<Test>(&dave(), &1u64.encode(), StatementKind::Saft.to_text());

1417

			let call = ClaimsCall::claim_attest {

1418

				dest: 1,

1419

				ethereum_signature: s,

1420

				statement: StatementKind::Saft.to_text().to_vec(),

1421

};

1422

			assert_eq!(

1423

				Pallet::<Test>::validate_unsigned(source, &call),

1424

				InvalidTransaction::Custom(ValidityError::InvalidStatement.into()).into(),

1425

);

1426

});

1427

1428

1429

1430

#[cfg(feature = "runtime-benchmarks")]

1431

mod benchmarking {

1432

	use super::*;

1433

	use crate::claims::Call;

1434

	use frame_benchmarking::{account, benchmarks};

1435

	use frame_support::traits::UnfilteredDispatchable;

1436

	use frame_system::RawOrigin;

1437

	use secp_utils::*;

1438

	use sp_runtime::{traits::ValidateUnsigned, DispatchResult};

1439

1440

	const SEED: u32 = 0;

1441

1442

	const MAX_CLAIMS: u32 = 10_000;

1443

	const VALUE: u32 = 1_000_000;

1444

1445

	fn create_claim<T: Config>(input: u32) -> DispatchResult {

1446

		let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&input.encode())).unwrap();

1447

		let eth_address = eth(&secret_key);

1448

		let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1449

		super::Pallet::<T>::mint_claim(

1450

			RawOrigin::Root.into(),

1451

			eth_address,

1452

			VALUE.into(),

1453

			vesting,

1454

			None,

1455

)?;

1456

		Ok(())

1457

1458

1459

	fn create_claim_attest<T: Config>(input: u32) -> DispatchResult {

1460

		let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&input.encode())).unwrap();

1461

		let eth_address = eth(&secret_key);

1462

		let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1463

		super::Pallet::<T>::mint_claim(

1464

			RawOrigin::Root.into(),

1465

			eth_address,

1466

			VALUE.into(),

1467

			vesting,

1468

			Some(Default::default()),

1469

)?;

1470

		Ok(())

1471

1472

1473

	benchmarks! {

1474

		// Benchmark `claim` including `validate_unsigned` logic.

1475

		claim {

1476

			let c = MAX_CLAIMS;

1477

1478

			for i in 0 .. c / 2 {

1479

				create_claim::<T>(c)?;

1480

				create_claim_attest::<T>(u32::MAX - c)?;

1481

1482

1483

			let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&c.encode())).unwrap();

1484

			let eth_address = eth(&secret_key);

1485

			let account: T::AccountId = account("user", c, SEED);

1486

			let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1487

			let signature = sig::<T>(&secret_key, &account.encode(), &[][..]);

1488

			super::Pallet::<T>::mint_claim(RawOrigin::Root.into(), eth_address, VALUE.into(), vesting, None)?;

1489

			assert_eq!(Claims::<T>::get(eth_address), Some(VALUE.into()));

1490

			let source = sp_runtime::transaction_validity::TransactionSource::External;

1491

			let call_enc = Call::<T>::claim {

1492

				dest: account.clone(),

1493

				ethereum_signature: signature.clone()

1494

			}.encode();

1495

		}: {

1496

			let call = <Call<T> as Decode>::decode(&mut &*call_enc)

1497

				.expect("call is encoded above, encoding must be correct");

1498

			super::Pallet::<T>::validate_unsigned(source, &call).map_err(|e| -> &'static str { e.into() })?;

1499

			call.dispatch_bypass_filter(RawOrigin::None.into())?;

1500

1501

		verify {

1502

			assert_eq!(Claims::<T>::get(eth_address), None);

1503

1504

1505

		// Benchmark `mint_claim` when there already exists `c` claims in storage.

1506

		mint_claim {

1507

			let c = MAX_CLAIMS;

1508

1509

			for i in 0 .. c / 2 {

1510

				create_claim::<T>(c)?;

1511

				create_claim_attest::<T>(u32::MAX - c)?;

1512

1513

1514

			let eth_address = account("eth_address", 0, SEED);

1515

			let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1516

			let statement = StatementKind::Regular;

1517

		}: _(RawOrigin::Root, eth_address, VALUE.into(), vesting, Some(statement))

1518

		verify {

1519

			assert_eq!(Claims::<T>::get(eth_address), Some(VALUE.into()));

1520

1521

1522

		// Benchmark `claim_attest` including `validate_unsigned` logic.

1523

		claim_attest {

1524

			let c = MAX_CLAIMS;

1525

1526

			for i in 0 .. c / 2 {

1527

				create_claim::<T>(c)?;

1528

				create_claim_attest::<T>(u32::MAX - c)?;

1529

1530

1531

			// Crate signature

1532

			let attest_c = u32::MAX - c;

1533

			let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&attest_c.encode())).unwrap();

1534

			let eth_address = eth(&secret_key);

1535

			let account: T::AccountId = account("user", c, SEED);

1536

			let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1537

			let statement = StatementKind::Regular;

1538

			let signature = sig::<T>(&secret_key, &account.encode(), statement.to_text());

1539

			super::Pallet::<T>::mint_claim(RawOrigin::Root.into(), eth_address, VALUE.into(), vesting, Some(statement))?;

1540

			assert_eq!(Claims::<T>::get(eth_address), Some(VALUE.into()));

1541

			let call_enc = Call::<T>::claim_attest {

1542

				dest: account.clone(),

1543

				ethereum_signature: signature.clone(),

1544

				statement: StatementKind::Regular.to_text().to_vec()

1545

			}.encode();

1546

			let source = sp_runtime::transaction_validity::TransactionSource::External;

1547

		}: {

1548

			let call = <Call<T> as Decode>::decode(&mut &*call_enc)

1549

				.expect("call is encoded above, encoding must be correct");

1550

			super::Pallet::<T>::validate_unsigned(source, &call).map_err(|e| -> &'static str { e.into() })?;

1551

			call.dispatch_bypass_filter(RawOrigin::None.into())?;

1552

1553

		verify {

1554

			assert_eq!(Claims::<T>::get(eth_address), None);

1555

1556

1557

		// Benchmark `attest` including prevalidate logic.

1558

		attest {

1559

			let c = MAX_CLAIMS;

1560

1561

			for i in 0 .. c / 2 {

1562

				create_claim::<T>(c)?;

1563

				create_claim_attest::<T>(u32::MAX - c)?;

1564

1565

1566

			let attest_c = u32::MAX - c;

1567

			let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&attest_c.encode())).unwrap();

1568

			let eth_address = eth(&secret_key);

1569

			let account: T::AccountId = account("user", c, SEED);

1570

			let vesting = Some((100_000u32.into(), 1_000u32.into(), 100u32.into()));

1571

			let statement = StatementKind::Regular;

1572

			let signature = sig::<T>(&secret_key, &account.encode(), statement.to_text());

1573

			super::Pallet::<T>::mint_claim(RawOrigin::Root.into(), eth_address, VALUE.into(), vesting, Some(statement))?;

1574

			Preclaims::<T>::insert(&account, eth_address);

1575

			assert_eq!(Claims::<T>::get(eth_address), Some(VALUE.into()));

1576

1577

			let call = super::Call::<T>::attest { statement: StatementKind::Regular.to_text().to_vec() };

1578

			// We have to copy the validate statement here because of trait issues... :(

1579

			let validate = |who: &T::AccountId, call: &super::Call<T>| -> DispatchResult {

1580

				if let Call::attest{ statement: attested_statement } = call {

1581

					let signer = Preclaims::<T>::get(who).ok_or("signer has no claim")?;

1582

					if let Some(s) = Signing::<T>::get(signer) {

1583

						ensure!(&attested_statement[..] == s.to_text(), "invalid statement");

1584

1585

1586

				Ok(())

1587

};

1588

			let call_enc = call.encode();

1589

		}: {

1590

			let call = <Call<T> as Decode>::decode(&mut &*call_enc)

1591

				.expect("call is encoded above, encoding must be correct");

1592

			validate(&account, &call)?;

1593

			call.dispatch_bypass_filter(RawOrigin::Signed(account).into())?;

1594

1595

		verify {

1596

			assert_eq!(Claims::<T>::get(eth_address), None);

1597

1598

1599

		move_claim {

1600

			let c = MAX_CLAIMS;

1601

1602

			for i in 0 .. c / 2 {

1603

				create_claim::<T>(c)?;

1604

				create_claim_attest::<T>(u32::MAX - c)?;

1605

1606

1607

			let attest_c = u32::MAX - c;

1608

			let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&attest_c.encode())).unwrap();

1609

			let eth_address = eth(&secret_key);

1610

1611

			let new_secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&(u32::MAX/2).encode())).unwrap();

1612

			let new_eth_address = eth(&new_secret_key);

1613

1614

			let account: T::AccountId = account("user", c, SEED);

1615

			Preclaims::<T>::insert(&account, eth_address);

1616

1617

			assert!(Claims::<T>::contains_key(eth_address));

1618

			assert!(!Claims::<T>::contains_key(new_eth_address));

1619

		}: _(RawOrigin::Root, eth_address, new_eth_address, Some(account))

1620

		verify {

1621

			assert!(!Claims::<T>::contains_key(eth_address));

1622

			assert!(Claims::<T>::contains_key(new_eth_address));

1623

1624

1625

		// Benchmark the time it takes to do `repeat` number of keccak256 hashes

1626

		#[extra]

1627

		keccak256 {

1628

			let i in 0 .. 10_000;

1629

			let bytes = (i).encode();

1630

		}: {

1631

			for index in 0 .. i {

1632

				let _hash = keccak_256(&bytes);

1633

1634

1635

1636

		// Benchmark the time it takes to do `repeat` number of `eth_recover`

1637

		#[extra]

1638

		eth_recover {

1639

			let i in 0 .. 1_000;

1640

			// Crate signature

1641

			let secret_key = libsecp256k1::SecretKey::parse(&keccak_256(&i.encode())).unwrap();

1642

			let account: T::AccountId = account("user", i, SEED);

1643

			let signature = sig::<T>(&secret_key, &account.encode(), &[][..]);

1644

			let data = account.using_encoded(to_ascii_hex);

1645

			let extra = StatementKind::default().to_text();

1646

		}: {

1647

			for _ in 0 .. i {

1648

				assert!(super::Pallet::<T>::eth_recover(&signature, &data, extra).is_some());

1649

1650

1651

1652

		impl_benchmark_test_suite!(

1653

			Pallet,

1654

			crate::claims::tests::new_test_ext(),

1655

			crate::claims::tests::Test,

1656

);

1657

1658