Grcov report - tests.rs

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

// Moonbeam 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

// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

16

17

use crate::mock::*;

18

use crate::*;

19

use cumulus_primitives_core::relay_chain::HrmpChannelId;

20

use frame_support::weights::Weight;

21

use frame_support::{assert_noop, assert_ok};

22

use sp_runtime::traits::Convert;

23

use sp_runtime::DispatchError;

24

use sp_std::boxed::Box;

25

use xcm::latest::prelude::*;

26

use xcm_primitives::{UtilityAvailableCalls, UtilityEncodeCall, XcmFeeTrader};

27

28

const TEST_RELATIVE_PRICE: u128 = 1_000_000_000_000_000_000u128; // 1e18

29

30

#[test]

31

1

fn test_register_address() {

32

1

	ExtBuilder::default()

33

1

		.with_balances(vec![])

34

1

		.build()

35

1

		.execute_with(|| {

36

			// Only root can do this, as specified in runtime

37

1

			assert_noop!(

38

1

				XcmTransactor::register(RuntimeOrigin::signed(1u64), 1u64, 1),

39

1

				DispatchError::BadOrigin

40

);

41

42

			// Root can register

43

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

44

45

1

			assert_eq!(XcmTransactor::index_to_account(&1).unwrap(), 1u64);

46

47

1

			let expected = vec![crate::Event::RegisteredDerivative {

48

1

				account_id: 1u64,

49

1

				index: 1,

50

1

}];

51

1

			assert_eq!(events(), expected);

52

1

})

53

1

54

55

#[test]

56

1

fn test_transact_through_derivative_errors() {

57

1

	ExtBuilder::default()

58

1

		.with_balances(vec![])

59

1

		.build()

60

1

		.execute_with(|| {

61

			// Non-claimed index so cannot transfer

62

1

			assert_noop!(

63

1

				XcmTransactor::transact_through_derivative(

64

1

					RuntimeOrigin::signed(1u64),

65

1

					Transactors::Relay,

66

1,

67

1

					CurrencyPayment {

68

1

						currency: Currency::AsMultiLocation(Box::new(

69

1

							xcm::VersionedLocation::from(Location::parent())

70

1

)),

71

1

						fee_amount: None

72

1

},

73

1

					vec![0u8],

74

1

					TransactWeights {

75

1

						transact_required_weight_at_most: 100u64.into(),

76

1

						overall_weight: None

77

1

},

78

					false

79

),

80

1

				Error::<Test>::UnclaimedIndex

81

);

82

83

			// Root can register

84

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

85

86

			// TransactInfo not yet set

87

1

			assert_noop!(

88

1

				XcmTransactor::transact_through_derivative(

89

1

					RuntimeOrigin::signed(1u64),

90

1

					Transactors::Relay,

91

1,

92

1

					CurrencyPayment {

93

1

						currency: Currency::AsMultiLocation(Box::new(

94

1

							xcm::VersionedLocation::from(Location::parent())

95

1

)),

96

1

						fee_amount: None

97

1

},

98

1

					vec![0u8],

99

1

					TransactWeights {

100

1

						transact_required_weight_at_most: 100u64.into(),

101

1

						overall_weight: None

102

1

},

103

					false

104

),

105

1

				Error::<Test>::TransactorInfoNotSet

106

);

107

108

			// Root can set transact info

109

1

			assert_ok!(XcmTransactor::set_transact_info(

110

1

				RuntimeOrigin::root(),

111

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

112

1

				0.into(),

113

1

				10000.into(),

114

1

				None

115

));

116

117

			// TransactInfo present, but FeePerSecond not set

118

1

			assert_noop!(

119

1

				XcmTransactor::transact_through_derivative(

120

1

					RuntimeOrigin::signed(1u64),

121

1

					Transactors::Relay,

122

1,

123

1

					CurrencyPayment {

124

1

						currency: Currency::AsMultiLocation(Box::new(

125

1

							xcm::VersionedLocation::from(Location::parent())

126

1

)),

127

1

						fee_amount: None

128

1

},

129

1

					vec![0u8],

130

1

					TransactWeights {

131

1

						transact_required_weight_at_most: 100u64.into(),

132

1

						overall_weight: None

133

1

},

134

					false

135

),

136

1

				DispatchError::Other("Asset relative price not set")

137

);

138

139

			// Set relative price using FeeTrader

140

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

141

1

				Location::new(1, [Junction::Parachain(1000)]),

142

				TEST_RELATIVE_PRICE

143

));

144

145

			// TransactInfo present, but the asset is not a reserve of dest

146

1

			assert_noop!(

147

1

				XcmTransactor::transact_through_derivative(

148

1

					RuntimeOrigin::signed(1u64),

149

1

					Transactors::Relay,

150

1,

151

1

					CurrencyPayment {

152

1

						currency: Currency::AsMultiLocation(Box::new(

153

1

							xcm::VersionedLocation::from(Location::new(

154

1

1,

155

1

								[Junction::Parachain(1000)]

156

1

))

157

1

)),

158

1

						fee_amount: None

159

1

},

160

1

					vec![0u8],

161

1

					TransactWeights {

162

1

						transact_required_weight_at_most: 100u64.into(),

163

1

						overall_weight: None

164

1

},

165

					false

166

),

167

1

				Error::<Test>::AssetIsNotReserveInDestination

168

);

169

170

			// Set relative price using FeeTrader

171

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

172

1

				Location::parent(),

173

				TEST_RELATIVE_PRICE

174

));

175

176

			// Cannot exceed the max weight

177

1

			assert_noop!(

178

1

				XcmTransactor::transact_through_derivative(

179

1

					RuntimeOrigin::signed(1u64),

180

1

					Transactors::Relay,

181

1,

182

1

					CurrencyPayment {

183

1

						currency: Currency::AsMultiLocation(Box::new(

184

1

							xcm::VersionedLocation::from(Location::parent())

185

1

)),

186

1

						fee_amount: None

187

1

},

188

1

					vec![0u8],

189

1

					TransactWeights {

190

1

						transact_required_weight_at_most: 10001u64.into(),

191

1

						overall_weight: None

192

1

},

193

					false

194

),

195

1

				Error::<Test>::MaxWeightTransactReached

196

);

197

1

})

198

1

199

200

#[test]

201

1

fn test_transact_through_signed_errors() {

202

1

	ExtBuilder::default()

203

1

		.with_balances(vec![])

204

1

		.build()

205

1

		.execute_with(|| {

206

			// TransactInfo not yet set

207

1

			assert_noop!(

208

1

				XcmTransactor::transact_through_signed(

209

1

					RuntimeOrigin::signed(1u64),

210

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

211

1

					CurrencyPayment {

212

1

						currency: Currency::AsMultiLocation(Box::new(

213

1

							xcm::VersionedLocation::from(Location::parent())

214

1

)),

215

1

						fee_amount: None

216

1

},

217

1

					vec![0u8],

218

1

					TransactWeights {

219

1

						transact_required_weight_at_most: 100u64.into(),

220

1

						overall_weight: None

221

1

},

222

					false

223

),

224

1

				Error::<Test>::TransactorInfoNotSet

225

);

226

227

			// Root can set transact info without extra_signed being None

228

1

			assert_ok!(XcmTransactor::set_transact_info(

229

1

				RuntimeOrigin::root(),

230

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

231

1

				0.into(),

232

1

				10000.into(),

233

1

				None

234

));

235

236

			// TransactInfo present, but FeePerSecond not set

237

1

			assert_noop!(

238

1

				XcmTransactor::transact_through_signed(

239

1

					RuntimeOrigin::signed(1u64),

240

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

241

1

					CurrencyPayment {

242

1

						currency: Currency::AsMultiLocation(Box::new(

243

1

							xcm::VersionedLocation::from(Location::parent())

244

1

)),

245

1

						fee_amount: None

246

1

},

247

1

					vec![0u8],

248

1

					TransactWeights {

249

1

						transact_required_weight_at_most: 100u64.into(),

250

1

						overall_weight: None

251

1

},

252

					false

253

),

254

1

				Error::<Test>::SignedTransactNotAllowedForDestination

255

);

256

257

			// Root can set transact info, with extra signed

258

1

			assert_ok!(XcmTransactor::set_transact_info(

259

1

				RuntimeOrigin::root(),

260

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

261

1

				0.into(),

262

1

				15000.into(),

263

1

				Some(12000.into())

264

));

265

266

			// TransactInfo present, but FeePerSecond not set

267

1

			assert_noop!(

268

1

				XcmTransactor::transact_through_signed(

269

1

					RuntimeOrigin::signed(1u64),

270

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

271

1

					CurrencyPayment {

272

1

						currency: Currency::AsMultiLocation(Box::new(

273

1

							xcm::VersionedLocation::from(Location::parent())

274

1

)),

275

1

						fee_amount: None

276

1

},

277

1

					vec![0u8],

278

1

					TransactWeights {

279

1

						transact_required_weight_at_most: 100u64.into(),

280

1

						overall_weight: None

281

1

},

282

					false

283

),

284

1

				DispatchError::Other("Asset relative price not set")

285

);

286

287

			// Set relative price using FeeTrader

288

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

289

1

				Location::new(1, [Junction::Parachain(1000)]),

290

				TEST_RELATIVE_PRICE

291

));

292

293

			// TransactInfo present, but the asset is not a reserve of dest

294

1

			assert_noop!(

295

1

				XcmTransactor::transact_through_signed(

296

1

					RuntimeOrigin::signed(1u64),

297

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

298

1

					CurrencyPayment {

299

1

						currency: Currency::AsMultiLocation(Box::new(

300

1

							xcm::VersionedLocation::from(Location::new(

301

1

1,

302

1

								[Junction::Parachain(1000)]

303

1

))

304

1

)),

305

1

						fee_amount: None

306

1

},

307

1

					vec![0u8],

308

1

					TransactWeights {

309

1

						transact_required_weight_at_most: 100u64.into(),

310

1

						overall_weight: None

311

1

},

312

					false

313

),

314

1

				Error::<Test>::AssetIsNotReserveInDestination

315

);

316

1

})

317

1

318

319

#[test]

320

1

fn test_transact_through_derivative_multilocation_success() {

321

1

	ExtBuilder::default()

322

1

		.with_balances(vec![])

323

1

		.build()

324

1

		.execute_with(|| {

325

			// Root can register

326

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

327

328

			// Root can set transact info

329

1

			assert_ok!(XcmTransactor::set_transact_info(

330

1

				RuntimeOrigin::root(),

331

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

332

1

				0.into(),

333

1

				10000.into(),

334

1

				None

335

));

336

337

			// Set fee per second using FeeTrader

338

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

339

1

				Location::parent(),

340

341

));

342

343

			// fee as destination are the same, this time it should work

344

1

			assert_ok!(XcmTransactor::transact_through_derivative(

345

1

				RuntimeOrigin::signed(1u64),

346

1

				Transactors::Relay,

347

1,

348

1

				CurrencyPayment {

349

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

350

1

						Location::parent()

351

1

					))),

352

1

					fee_amount: None

353

1

},

354

1

				vec![1u8],

355

1

				TransactWeights {

356

1

					transact_required_weight_at_most: 100u64.into(),

357

1

					overall_weight: None

358

1

},

359

				false

360

));

361

1

			let expected = vec![

362

1

				crate::Event::RegisteredDerivative {

363

1

					account_id: 1u64,

364

1

					index: 1,

365

1

},

366

1

				crate::Event::TransactInfoChanged {

367

1

					location: Location::parent(),

368

1

					remote_info: RemoteTransactInfoWithMaxWeight {

369

1

						transact_extra_weight: 0.into(),

370

1

						max_weight: 10000.into(),

371

1

						transact_extra_weight_signed: None,

372

1

},

373

1

},

374

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

375

1

				crate::Event::TransactedDerivative {

376

1

					account_id: 1u64,

377

1

					dest: Location::parent(),

378

1

					call: <XcmTransactor as UtilityEncodeCall>::encode_call(

379

1

						Transactors::Relay,

380

1

						UtilityAvailableCalls::AsDerivative(1, vec![1u8]),

381

1

),

382

1

					index: 1,

383

1

},

384

];

385

1

			assert_eq!(events(), expected);

386

1

})

387

1

388

389

#[test]

390

1

fn test_transact_through_derivative_success() {

391

1

	ExtBuilder::default()

392

1

		.with_balances(vec![])

393

1

		.build()

394

1

		.execute_with(|| {

395

			// Root can register

396

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

397

398

			// Root can set transact info

399

1

			assert_ok!(XcmTransactor::set_transact_info(

400

1

				RuntimeOrigin::root(),

401

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

402

1

				0.into(),

403

1

				10000.into(),

404

1

				None

405

));

406

407

			// Set fee per second using FeeTrader

408

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

409

1

				Location::parent(),

410

411

));

412

413

			// fee as destination are the same, this time it should work

414

1

			assert_ok!(XcmTransactor::transact_through_derivative(

415

1

				RuntimeOrigin::signed(1u64),

416

1

				Transactors::Relay,

417

1,

418

1

				CurrencyPayment {

419

1

					currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

420

1

					fee_amount: None

421

1

},

422

1

				vec![1u8],

423

1

				TransactWeights {

424

1

					transact_required_weight_at_most: 100u64.into(),

425

1

					overall_weight: None

426

1

},

427

				false

428

));

429

1

			let expected = vec![

430

1

				crate::Event::RegisteredDerivative {

431

1

					account_id: 1u64,

432

1

					index: 1,

433

1

},

434

1

				crate::Event::TransactInfoChanged {

435

1

					location: Location::parent(),

436

1

					remote_info: RemoteTransactInfoWithMaxWeight {

437

1

						transact_extra_weight: 0.into(),

438

1

						max_weight: 10000.into(),

439

1

						transact_extra_weight_signed: None,

440

1

},

441

1

},

442

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

443

1

				crate::Event::TransactedDerivative {

444

1

					account_id: 1u64,

445

1

					dest: Location::parent(),

446

1

					call: <XcmTransactor as UtilityEncodeCall>::encode_call(

447

1

						Transactors::Relay,

448

1

						UtilityAvailableCalls::AsDerivative(1, vec![1u8]),

449

1

),

450

1

					index: 1,

451

1

},

452

];

453

1

			assert_eq!(events(), expected);

454

1

			let sent_messages = mock::sent_xcm();

455

1

			let (_, sent_message) = sent_messages.first().unwrap();

456

457

			// Check message doesn't contain the appendix

458

1

			assert!(!sent_message.0.contains(&SetAppendix(Xcm(vec![

459

1

				RefundSurplus,

460

1

				DepositAsset {

461

1

					assets: Wild(AllCounted(1u32)),

462

1

					beneficiary: Location {

463

1

						parents: 0,

464

1

						interior: [Junction::Parachain(100)].into()

465

1

466

1

467

1

			]))));

468

1

})

469

1

470

471

#[test]

472

1

fn test_root_can_transact_through_sovereign() {

473

1

	ExtBuilder::default()

474

1

		.with_balances(vec![])

475

1

		.build()

476

1

		.execute_with(|| {

477

			// Only root can do this

478

1

			assert_noop!(

479

1

				XcmTransactor::transact_through_sovereign(

480

1

					RuntimeOrigin::signed(1),

481

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

482

1

					Some(1u64),

483

1

					CurrencyPayment {

484

1

						currency: Currency::AsMultiLocation(Box::new(

485

1

							xcm::VersionedLocation::from(Location::parent())

486

1

)),

487

1

						fee_amount: None

488

1

},

489

1

					vec![1u8],

490

1

					OriginKind::SovereignAccount,

491

1

					TransactWeights {

492

1

						transact_required_weight_at_most: 100u64.into(),

493

1

						overall_weight: None

494

1

},

495

					false

496

),

497

1

				DispatchError::BadOrigin

498

);

499

500

			// Root can set transact info

501

1

			assert_ok!(XcmTransactor::set_transact_info(

502

1

				RuntimeOrigin::root(),

503

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

504

1

				0.into(),

505

1

				10000.into(),

506

1

				None

507

));

508

509

			// Set fee per second using FeeTrader

510

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

511

1

				Location::parent(),

512

513

));

514

515

			// fee as destination are the same, this time it should work

516

1

			assert_ok!(XcmTransactor::transact_through_sovereign(

517

1

				RuntimeOrigin::root(),

518

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

519

1

				Some(1u64),

520

1

				CurrencyPayment {

521

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

522

1

						Location::parent()

523

1

					))),

524

1

					fee_amount: None

525

1

},

526

1

				vec![1u8],

527

1

				OriginKind::SovereignAccount,

528

1

				TransactWeights {

529

1

					transact_required_weight_at_most: 100u64.into(),

530

1

					overall_weight: None

531

1

},

532

				false

533

));

534

535

1

			let expected = vec![

536

1

				crate::Event::TransactInfoChanged {

537

1

					location: Location::parent(),

538

1

					remote_info: RemoteTransactInfoWithMaxWeight {

539

1

						transact_extra_weight: 0.into(),

540

1

						max_weight: 10000.into(),

541

1

						transact_extra_weight_signed: None,

542

1

},

543

1

},

544

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

545

1

				crate::Event::TransactedSovereign {

546

1

					fee_payer: Some(1u64),

547

1

					dest: Location::parent(),

548

1

					call: vec![1u8],

549

1

},

550

];

551

1

			assert_eq!(events(), expected);

552

1

})

553

1

554

555

// Removed: test_fee_calculation_works

556

// The calculate_fee_per_second function was removed. Fee calculation is now handled by pallet-xcm-weight-trader.

557

558

// Removed: test_fee_calculation_works_kusama_0_9_20_case

559

// The calculate_fee_per_second function was removed. Fee calculation is now handled by pallet-xcm-weight-trader.

560

561

#[test]

562

1

fn de_registering_works() {

563

1

	ExtBuilder::default()

564

1

		.with_balances(vec![])

565

1

		.build()

566

1

		.execute_with(|| {

567

			// Root can register

568

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

569

570

1

			assert_eq!(XcmTransactor::index_to_account(&1).unwrap(), 1u64);

571

572

1

			assert_ok!(XcmTransactor::deregister(RuntimeOrigin::root(), 1));

573

574

1

			assert!(XcmTransactor::index_to_account(&1).is_none());

575

576

1

			let expected = vec![

577

1

				crate::Event::RegisteredDerivative {

578

1

					account_id: 1u64,

579

1

					index: 1,

580

1

},

581

1

				crate::Event::DeRegisteredDerivative { index: 1 },

582

];

583

1

			assert_eq!(events(), expected);

584

1

})

585

1

586

587

#[test]

588

1

fn removing_transact_info_works() {

589

1

	ExtBuilder::default()

590

1

		.with_balances(vec![])

591

1

		.build()

592

1

		.execute_with(|| {

593

			// Root can set transact info

594

1

			assert_ok!(XcmTransactor::set_transact_info(

595

1

				RuntimeOrigin::root(),

596

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

597

1

				0.into(),

598

1

				10000.into(),

599

1

				None

600

));

601

602

			// Root can remove transact info

603

1

			assert_ok!(XcmTransactor::remove_transact_info(

604

1

				RuntimeOrigin::root(),

605

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

606

));

607

608

1

			assert!(XcmTransactor::transact_info(Location::parent()).is_none());

609

610

1

			let expected = vec![

611

1

				crate::Event::TransactInfoChanged {

612

1

					location: Location::parent(),

613

1

					remote_info: RemoteTransactInfoWithMaxWeight {

614

1

						transact_extra_weight: 0.into(),

615

1

						max_weight: 10000.into(),

616

1

						transact_extra_weight_signed: None,

617

1

},

618

1

},

619

1

				crate::Event::TransactInfoRemoved {

620

1

					location: Location::parent(),

621

1

},

622

];

623

1

			assert_eq!(events(), expected);

624

1

})

625

1

626

627

#[test]

628

1

fn test_transact_through_signed_fails_if_transact_info_not_set_at_all() {

629

1

	ExtBuilder::default()

630

1

		.with_balances(vec![])

631

1

		.build()

632

1

		.execute_with(|| {

633

			// fee as destination are the same, this time it should work

634

1

			assert_noop!(

635

1

				XcmTransactor::transact_through_signed(

636

1

					RuntimeOrigin::signed(1u64),

637

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

638

1

					CurrencyPayment {

639

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

640

1

						fee_amount: None

641

1

},

642

1

					vec![1u8],

643

1

					TransactWeights {

644

1

						transact_required_weight_at_most: 100u64.into(),

645

1

						overall_weight: None

646

1

},

647

					false

648

),

649

1

				Error::<Test>::TransactorInfoNotSet

650

);

651

1

})

652

1

653

654

#[test]

655

1

fn test_transact_through_signed_fails_if_weight_is_not_set() {

656

1

	ExtBuilder::default()

657

1

		.with_balances(vec![])

658

1

		.build()

659

1

		.execute_with(|| {

660

			// Root can set transact info

661

1

			assert_ok!(XcmTransactor::set_transact_info(

662

1

				RuntimeOrigin::root(),

663

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

664

1

				0.into(),

665

1

				10000.into(),

666

1

				None

667

));

668

669

			// weight value not set for signed transact, fails

670

1

			assert_noop!(

671

1

				XcmTransactor::transact_through_signed(

672

1

					RuntimeOrigin::signed(1u64),

673

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

674

1

					CurrencyPayment {

675

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

676

1

						fee_amount: None

677

1

},

678

1

					vec![1u8],

679

1

					TransactWeights {

680

1

						transact_required_weight_at_most: 100u64.into(),

681

1

						overall_weight: None

682

1

},

683

					false

684

),

685

1

				Error::<Test>::SignedTransactNotAllowedForDestination

686

);

687

1

})

688

1

689

690

#[test]

691

1

fn test_transact_through_signed_fails_if_weight_overflows() {

692

1

	ExtBuilder::default()

693

1

		.with_balances(vec![])

694

1

		.build()

695

1

		.execute_with(|| {

696

			// Root can set transact info

697

1

			assert_ok!(XcmTransactor::set_transact_info(

698

1

				RuntimeOrigin::root(),

699

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

700

1

				0.into(),

701

1

				10000.into(),

702

1

				Some(Weight::MAX)

703

));

704

705

			// weight should overflow

706

1

			assert_noop!(

707

1

				XcmTransactor::transact_through_signed(

708

1

					RuntimeOrigin::signed(1u64),

709

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

710

1

					CurrencyPayment {

711

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

712

1

						fee_amount: None

713

1

},

714

1

					vec![1u8],

715

1

					TransactWeights {

716

1

						transact_required_weight_at_most: 10064u64.into(),

717

1

						overall_weight: None

718

1

},

719

					false

720

),

721

1

				Error::<Test>::WeightOverflow

722

);

723

1

})

724

1

725

726

#[test]

727

1

fn test_transact_through_signed_fails_if_weight_is_bigger_than_max_weight() {

728

1

	ExtBuilder::default()

729

1

		.with_balances(vec![])

730

1

		.build()

731

1

		.execute_with(|| {

732

			// Root can set transact info

733

1

			assert_ok!(XcmTransactor::set_transact_info(

734

1

				RuntimeOrigin::root(),

735

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

736

1

				0.into(),

737

1

				10000.into(),

738

1

				Some(1.into())

739

));

740

741

			// 10000 + 1 > 10000 (max weight permitted by dest chain)

742

1

			assert_noop!(

743

1

				XcmTransactor::transact_through_signed(

744

1

					RuntimeOrigin::signed(1u64),

745

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

746

1

					CurrencyPayment {

747

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

748

1

						fee_amount: None

749

1

},

750

1

					vec![1u8],

751

1

					TransactWeights {

752

1

						transact_required_weight_at_most: 100000u64.into(),

753

1

						overall_weight: None

754

1

},

755

					false

756

),

757

1

				Error::<Test>::MaxWeightTransactReached

758

);

759

1

})

760

1

761

762

#[test]

763

1

fn test_transact_through_signed_fails_if_fee_per_second_not_set() {

764

1

	ExtBuilder::default()

765

1

		.with_balances(vec![])

766

1

		.build()

767

1

		.execute_with(|| {

768

			// Root can set transact info

769

1

			assert_ok!(XcmTransactor::set_transact_info(

770

1

				RuntimeOrigin::root(),

771

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

772

1

				0.into(),

773

1

				10000.into(),

774

1

				Some(1.into())

775

));

776

777

			// fee per second not set, fails

778

1

			assert_noop!(

779

1

				XcmTransactor::transact_through_signed(

780

1

					RuntimeOrigin::signed(1u64),

781

1

					Box::new(xcm::VersionedLocation::from(Location::parent())),

782

1

					CurrencyPayment {

783

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

784

1

						fee_amount: None

785

1

},

786

1

					vec![1u8],

787

1

					TransactWeights {

788

1

						transact_required_weight_at_most: 100u64.into(),

789

1

						overall_weight: None

790

1

},

791

					false

792

),

793

1

				DispatchError::Other("Asset relative price not set")

794

);

795

1

})

796

1

797

798

#[test]

799

1

fn test_transact_through_signed_works() {

800

1

	ExtBuilder::default()

801

1

		.with_balances(vec![])

802

1

		.build()

803

1

		.execute_with(|| {

804

			// Root can set transact info

805

1

			assert_ok!(XcmTransactor::set_transact_info(

806

1

				RuntimeOrigin::root(),

807

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

808

1

				0.into(),

809

1

				10000.into(),

810

1

				Some(1.into())

811

));

812

813

			// Set relative price using FeeTrader

814

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

815

1

				Location::parent(),

816

				TEST_RELATIVE_PRICE

817

));

818

819

			// transact info and fee per second set

820

			// this time it should work

821

1

			assert_ok!(XcmTransactor::transact_through_signed(

822

1

				RuntimeOrigin::signed(1u64),

823

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

824

1

				CurrencyPayment {

825

1

					currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

826

1

					fee_amount: None

827

1

},

828

1

				vec![1u8],

829

1

				TransactWeights {

830

1

					transact_required_weight_at_most: 100u64.into(),

831

1

					overall_weight: None

832

1

},

833

				false

834

));

835

836

1

			let expected = vec![

837

1

				crate::Event::TransactInfoChanged {

838

1

					location: Location::parent(),

839

1

					remote_info: RemoteTransactInfoWithMaxWeight {

840

1

						transact_extra_weight: 0.into(),

841

1

						max_weight: 10000.into(),

842

1

						transact_extra_weight_signed: Some(1.into()),

843

1

},

844

1

},

845

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

846

1

				crate::Event::TransactedSigned {

847

1

					fee_payer: 1u64,

848

1

					dest: Location::parent(),

849

1

					call: vec![1u8],

850

1

},

851

];

852

1

			assert_eq!(events(), expected);

853

1

})

854

1

855

856

#[test]

857

1

fn test_send_through_derivative_with_custom_weight_and_fee() {

858

1

	ExtBuilder::default()

859

1

		.with_balances(vec![])

860

1

		.build()

861

1

		.execute_with(|| {

862

			// Root can register

863

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

864

865

			// We are gonna use a total weight of 10_100, a tx weight of 100,

866

			// and a total fee of 100

867

1

			let total_weight: Weight = 10_100u64.into();

868

1

			let tx_weight: Weight = 100_u64.into();

869

1

			let total_fee = 100u128;

870

871

			// By specifying total fee and total weight, we ensure

872

			// that even if the transact_info is not populated,

873

			// the message is forged with our parameters

874

1

			assert_ok!(XcmTransactor::transact_through_derivative(

875

1

				RuntimeOrigin::signed(1u64),

876

1

				Transactors::Relay,

877

1,

878

1

				CurrencyPayment {

879

1

					currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

880

1

					fee_amount: Some(total_fee)

881

1

},

882

1

				vec![1u8],

883

1

				TransactWeights {

884

1

					transact_required_weight_at_most: tx_weight,

885

1

					overall_weight: Some(Limited(total_weight))

886

1

},

887

				false

888

));

889

1

			let expected = vec![

890

1

				crate::Event::RegisteredDerivative {

891

1

					account_id: 1u64,

892

1

					index: 1,

893

1

},

894

1

				crate::Event::TransactedDerivative {

895

1

					account_id: 1u64,

896

1

					dest: Location::parent(),

897

1

					call: <XcmTransactor as UtilityEncodeCall>::encode_call(

898

1

						Transactors::Relay,

899

1

						UtilityAvailableCalls::AsDerivative(1, vec![1u8]),

900

1

),

901

1

					index: 1,

902

1

},

903

];

904

1

			assert_eq!(events(), expected);

905

1

			let sent_messages = mock::sent_xcm();

906

1

			let (_, sent_message) = sent_messages.first().unwrap();

907

			// Lets make sure the message is as expected

908

1

			assert!(sent_message

909

1

.0

910

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

911

1

			assert!(sent_message.0.contains(&BuyExecution {

912

1

				fees: (Location::here(), total_fee).into(),

913

1

				weight_limit: Limited(total_weight),

914

1

			}));

915

1

			assert!(sent_message.0.contains(&Transact {

916

1

				origin_kind: OriginKind::SovereignAccount,

917

1

				fallback_max_weight: Some(tx_weight),

918

1

				call: <XcmTransactor as UtilityEncodeCall>::encode_call(

919

1

					Transactors::Relay,

920

1

					UtilityAvailableCalls::AsDerivative(1, vec![1u8])

921

1

922

1

				.into(),

923

1

			}));

924

1

})

925

1

926

927

#[test]

928

1

fn test_send_through_sovereign_with_custom_weight_and_fee() {

929

1

	ExtBuilder::default()

930

1

		.with_balances(vec![])

931

1

		.build()

932

1

		.execute_with(|| {

933

			// Root can register

934

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

935

936

			// We are gonna use a total weight of 10_100, a tx weight of 100,

937

			// and a total fee of 100

938

1

			let total_weight: Weight = 10_100u64.into();

939

1

			let tx_weight: Weight = 100_u64.into();

940

1

			let total_fee = 100u128;

941

942

			// By specifying total fee and total weight, we ensure

943

			// that even if the transact_info is not populated,

944

			// the message is forged with our parameters

945

946

			// fee as destination are the same, this time it should work

947

1

			assert_ok!(XcmTransactor::transact_through_sovereign(

948

1

				RuntimeOrigin::root(),

949

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

950

1

				Some(1u64),

951

1

				CurrencyPayment {

952

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

953

1

						Location::parent()

954

1

					))),

955

1

					fee_amount: Some(total_fee)

956

1

},

957

1

				vec![1u8],

958

1

				OriginKind::SovereignAccount,

959

1

				TransactWeights {

960

1

					transact_required_weight_at_most: tx_weight,

961

1

					overall_weight: Some(Limited(total_weight))

962

1

},

963

				false

964

));

965

966

1

			let expected = vec![

967

1

				crate::Event::RegisteredDerivative {

968

1

					account_id: 1u64,

969

1

					index: 1,

970

1

},

971

1

				crate::Event::TransactedSovereign {

972

1

					fee_payer: Some(1u64),

973

1

					dest: Location::parent(),

974

1

					call: vec![1u8],

975

1

},

976

];

977

1

			assert_eq!(events(), expected);

978

1

			let sent_messages = mock::sent_xcm();

979

1

			let (_, sent_message) = sent_messages.first().unwrap();

980

			// Lets make sure the message is as expected

981

1

			assert!(sent_message

982

1

.0

983

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

984

1

			assert!(sent_message.0.contains(&BuyExecution {

985

1

				fees: (Location::here(), total_fee).into(),

986

1

				weight_limit: Limited(total_weight),

987

1

			}));

988

1

			assert!(sent_message.0.contains(&Transact {

989

1

				origin_kind: OriginKind::SovereignAccount,

990

1

				fallback_max_weight: Some(tx_weight),

991

1

				call: vec![1u8].into(),

992

1

			}));

993

1

})

994

1

995

996

#[test]

997

1

fn test_transact_through_sovereign_with_fee_payer_none() {

998

1

	ExtBuilder::default()

999

1

		.with_balances(vec![])

1000

1

		.build()

1001

1

		.execute_with(|| {

1002

			// Root can register

1003

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

1004

1005

1

			let total_weight: Weight = 10_100u64.into();

1006

1

			let tx_weight: Weight = 100_u64.into();

1007

1

			let total_fee = 100u128;

1008

1009

1

			assert_ok!(XcmTransactor::transact_through_sovereign(

1010

1

				RuntimeOrigin::root(),

1011

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

1012

				// We don't specify any fee_payer, instead we pay fees with the

1013

				// sovereign account funds directly on the destination.

1014

1

				None,

1015

1

				CurrencyPayment {

1016

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1017

1

						Location::parent()

1018

1

					))),

1019

1

					fee_amount: Some(total_fee)

1020

1

},

1021

1

				vec![1u8],

1022

1

				OriginKind::SovereignAccount,

1023

1

				TransactWeights {

1024

1

					transact_required_weight_at_most: tx_weight,

1025

1

					overall_weight: Some(Limited(total_weight))

1026

1

},

1027

				false

1028

));

1029

1030

1

			let expected = vec![

1031

1

				crate::Event::RegisteredDerivative {

1032

1

					account_id: 1u64,

1033

1

					index: 1,

1034

1

},

1035

1

				crate::Event::TransactedSovereign {

1036

1

					fee_payer: None,

1037

1

					dest: Location::parent(),

1038

1

					call: vec![1u8],

1039

1

},

1040

];

1041

1

			assert_eq!(events(), expected);

1042

1

			let sent_messages = mock::sent_xcm();

1043

1

			let (_, sent_message) = sent_messages.first().unwrap();

1044

			// Lets make sure the message is as expected even if we haven't indicated a

1045

			// fee_payer.

1046

1

			assert!(sent_message

1047

1

.0

1048

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1049

1

			assert!(sent_message.0.contains(&BuyExecution {

1050

1

				fees: (Location::here(), total_fee).into(),

1051

1

				weight_limit: Limited(total_weight),

1052

1

			}));

1053

1

			assert!(sent_message.0.contains(&Transact {

1054

1

				origin_kind: OriginKind::SovereignAccount,

1055

1

				fallback_max_weight: Some(tx_weight),

1056

1

				call: vec![1u8].into(),

1057

1

			}));

1058

1

})

1059

1

1060

1061

#[test]

1062

1

fn test_send_through_signed_with_custom_weight_and_fee() {

1063

1

	ExtBuilder::default()

1064

1

		.with_balances(vec![])

1065

1

		.build()

1066

1

		.execute_with(|| {

1067

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1068

			// and a total fee of 100

1069

1

			let total_weight: Weight = 10_100u64.into();

1070

1

			let tx_weight: Weight = 100_u64.into();

1071

1

			let total_fee = 100u128;

1072

1073

			// By specifying total fee and total weight, we ensure

1074

			// that even if the transact_info is not populated,

1075

			// the message is forged with our parameters

1076

1077

			// fee as destination are the same, this time it should work

1078

1

			assert_ok!(XcmTransactor::transact_through_signed(

1079

1

				RuntimeOrigin::signed(1u64),

1080

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

1081

1

				CurrencyPayment {

1082

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1083

1

						Location::parent()

1084

1

					))),

1085

1

					fee_amount: Some(total_fee)

1086

1

},

1087

1

				vec![1u8],

1088

1

				TransactWeights {

1089

1

					transact_required_weight_at_most: tx_weight,

1090

1

					overall_weight: Some(Limited(total_weight))

1091

1

},

1092

				false

1093

));

1094

1095

1

			let expected = vec![crate::Event::TransactedSigned {

1096

1

				fee_payer: 1u64,

1097

1

				dest: Location::parent(),

1098

1

				call: vec![1u8],

1099

1

}];

1100

1

			assert_eq!(events(), expected);

1101

1

			let sent_messages = mock::sent_xcm();

1102

1

			let (_, sent_message) = sent_messages.first().unwrap();

1103

			// Lets make sure the message is as expected

1104

1

			assert!(sent_message

1105

1

.0

1106

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1107

1

			assert!(sent_message.0.contains(&BuyExecution {

1108

1

				fees: (Location::here(), total_fee).into(),

1109

1

				weight_limit: Limited(total_weight),

1110

1

			}));

1111

1

			assert!(sent_message.0.contains(&Transact {

1112

1

				origin_kind: OriginKind::SovereignAccount,

1113

1

				fallback_max_weight: Some(tx_weight),

1114

1

				call: vec![1u8].into(),

1115

1

			}));

1116

1

})

1117

1

1118

1119

#[test]

1120

1

fn test_hrmp_manipulator_init() {

1121

1

	ExtBuilder::default()

1122

1

		.with_balances(vec![])

1123

1

		.build()

1124

1

		.execute_with(|| {

1125

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1126

			// and a total fee of 100

1127

1

			let total_weight: Weight = 10_100u64.into();

1128

1

			let tx_weight: Weight = 100_u64.into();

1129

1

			let total_fee = 100u128;

1130

1131

1

			assert_ok!(XcmTransactor::hrmp_manage(

1132

1

				RuntimeOrigin::root(),

1133

1

				HrmpOperation::InitOpen(HrmpInitParams {

1134

1

					para_id: 1u32.into(),

1135

1

					proposed_max_capacity: 1,

1136

1

					proposed_max_message_size: 1

1137

1

}),

1138

1

				CurrencyPayment {

1139

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1140

1

						Location::parent()

1141

1

					))),

1142

1

					fee_amount: Some(total_fee)

1143

1

},

1144

1

				TransactWeights {

1145

1

					transact_required_weight_at_most: tx_weight,

1146

1

					overall_weight: Some(Limited(total_weight))

1147

1

1148

));

1149

1150

1

			let sent_messages = mock::sent_xcm();

1151

1

			let (_, sent_message) = sent_messages.first().unwrap();

1152

			// Lets make sure the message is as expected

1153

1

			assert!(sent_message

1154

1

.0

1155

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1156

1

			assert!(sent_message.0.contains(&BuyExecution {

1157

1

				fees: (Location::here(), total_fee).into(),

1158

1

				weight_limit: Limited(total_weight),

1159

1

			}));

1160

1

			assert!(sent_message.0.contains(&Transact {

1161

1

				origin_kind: OriginKind::Native,

1162

1

				fallback_max_weight: Some(tx_weight),

1163

1

				call: vec![0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0].into(),

1164

1

			}));

1165

1

})

1166

1

1167

1168

#[test]

1169

1

fn test_hrmp_manipulator_init_v3_convert_works() {

1170

1

	ExtBuilder::default()

1171

1

		.with_balances(vec![])

1172

1

		.build()

1173

1

		.execute_with(|| {

1174

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1175

			// and a total fee of 100

1176

1

			let total_weight: Weight = 10_100u64.into();

1177

1

			let tx_weight: Weight = 100_u64.into();

1178

1

			let total_fee = 100u128;

1179

1180

			// Change xcm version

1181

1

			CustomVersionWrapper::set_version(3);

1182

1183

1

			assert_ok!(XcmTransactor::hrmp_manage(

1184

1

				RuntimeOrigin::root(),

1185

1

				HrmpOperation::InitOpen(HrmpInitParams {

1186

1

					para_id: 1u32.into(),

1187

1

					proposed_max_capacity: 1,

1188

1

					proposed_max_message_size: 1

1189

1

}),

1190

1

				CurrencyPayment {

1191

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1192

1

						Location::parent()

1193

1

					))),

1194

1

					fee_amount: Some(total_fee)

1195

1

},

1196

1

				TransactWeights {

1197

1

					transact_required_weight_at_most: tx_weight,

1198

1

					overall_weight: Some(Limited(total_weight))

1199

1

1200

));

1201

1202

1

			let sent_messages = mock::sent_xcm();

1203

1

			let (_, sent_message) = sent_messages.first().unwrap();

1204

			// Lets make sure the message is as expected

1205

1

			assert!(sent_message

1206

1

.0

1207

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1208

1

			assert!(sent_message.0.contains(&BuyExecution {

1209

1

				fees: (Location::here(), total_fee).into(),

1210

1

				weight_limit: Limited(total_weight),

1211

1

			}));

1212

1

			assert!(sent_message.0.contains(&Transact {

1213

1

				origin_kind: OriginKind::Native,

1214

1

				fallback_max_weight: Some(tx_weight),

1215

1

				call: vec![0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0].into(),

1216

1

			}));

1217

1218

			// Check message contains the new appendix

1219

1

			assert!(sent_message.0.contains(&SetAppendix(Xcm(vec![

1220

1

				RefundSurplus,

1221

1

				DepositAsset {

1222

1

					assets: Wild(AllCounted(1)),

1223

1

					beneficiary: Location {

1224

1

						parents: 0,

1225

1

						interior: [Junction::Parachain(100)].into()

1226

1

1227

1

1228

1

			]))));

1229

1

})

1230

1

1231

1232

#[test]

1233

1

fn test_hrmp_manipulator_init_v5_convert_works() {

1234

1

	ExtBuilder::default()

1235

1

		.with_balances(vec![])

1236

1

		.build()

1237

1

		.execute_with(|| {

1238

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1239

			// and a total fee of 100

1240

1

			let total_weight: Weight = 10_100u64.into();

1241

1

			let tx_weight: Weight = 100_u64.into();

1242

1

			let total_fee = 100u128;

1243

1244

			// Change xcm version

1245

1

			CustomVersionWrapper::set_version(5);

1246

1247

1

			assert_ok!(XcmTransactor::hrmp_manage(

1248

1

				RuntimeOrigin::root(),

1249

1

				HrmpOperation::InitOpen(HrmpInitParams {

1250

1

					para_id: 1u32.into(),

1251

1

					proposed_max_capacity: 1,

1252

1

					proposed_max_message_size: 1

1253

1

}),

1254

1

				CurrencyPayment {

1255

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1256

1

						Location::parent()

1257

1

					))),

1258

1

					fee_amount: Some(total_fee)

1259

1

},

1260

1

				TransactWeights {

1261

1

					transact_required_weight_at_most: tx_weight,

1262

1

					overall_weight: Some(Limited(total_weight))

1263

1

1264

));

1265

1266

1

			let sent_messages = mock::sent_xcm();

1267

1

			let (_, sent_message) = sent_messages.first().unwrap();

1268

			// Lets make sure the message is as expected

1269

1

			assert!(sent_message

1270

1

.0

1271

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1272

1

			assert!(sent_message.0.contains(&BuyExecution {

1273

1

				fees: (Location::here(), total_fee).into(),

1274

1

				weight_limit: Limited(total_weight),

1275

1

			}));

1276

1

			assert!(sent_message.0.contains(&Transact {

1277

1

				origin_kind: OriginKind::Native,

1278

1

				fallback_max_weight: Some(tx_weight),

1279

1

				call: vec![0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0].into(),

1280

1

			}));

1281

1282

			// Check message contains the new appendix

1283

1

			assert!(sent_message.0.contains(&SetAppendix(Xcm(vec![

1284

1

				RefundSurplus,

1285

1

				DepositAsset {

1286

1

					assets: Wild(AllCounted(1)),

1287

1

					beneficiary: Location {

1288

1

						parents: 0,

1289

1

						interior: [Junction::Parachain(100)].into()

1290

1

1291

1

1292

1

			]))));

1293

1

})

1294

1

1295

1296

#[test]

1297

1

fn test_hrmp_manipulator_init_v6_convert_fails() {

1298

1

	ExtBuilder::default()

1299

1

		.with_balances(vec![])

1300

1

		.build()

1301

1

		.execute_with(|| {

1302

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1303

			// and a total fee of 100

1304

1

			let total_weight: Weight = 10_100u64.into();

1305

1

			let tx_weight: Weight = 100_u64.into();

1306

1

			let total_fee = 100u128;

1307

1308

			// Change xcm version

1309

1

			CustomVersionWrapper::set_version(6);

1310

1311

1

			assert_noop!(

1312

1

				XcmTransactor::hrmp_manage(

1313

1

					RuntimeOrigin::root(),

1314

1

					HrmpOperation::InitOpen(HrmpInitParams {

1315

1

						para_id: 1u32.into(),

1316

1

						proposed_max_capacity: 1,

1317

1

						proposed_max_message_size: 1

1318

1

}),

1319

1

					CurrencyPayment {

1320

1

						currency: Currency::AsMultiLocation(Box::new(

1321

1

							xcm::VersionedLocation::from(Location::parent())

1322

1

)),

1323

1

						fee_amount: Some(total_fee)

1324

1

},

1325

1

					TransactWeights {

1326

1

						transact_required_weight_at_most: tx_weight,

1327

1

						overall_weight: Some(Limited(total_weight))

1328

1

1329

),

1330

1

				Error::<Test>::ErrorValidating

1331

);

1332

1

})

1333

1

1334

1335

#[test]

1336

1

fn test_hrmp_max_fee_errors() {

1337

1

	ExtBuilder::default()

1338

1

		.with_balances(vec![])

1339

1

		.build()

1340

1

		.execute_with(|| {

1341

1

			let total_weight: Weight = 10_100u64.into();

1342

1

			let tx_weight: Weight = 100_u64.into();

1343

1

			let total_fee = 10_000_000_000_000u128;

1344

1345

1

			assert_noop!(

1346

1

				XcmTransactor::hrmp_manage(

1347

1

					RuntimeOrigin::root(),

1348

1

					HrmpOperation::InitOpen(HrmpInitParams {

1349

1

						para_id: 1u32.into(),

1350

1

						proposed_max_capacity: 1,

1351

1

						proposed_max_message_size: 1

1352

1

}),

1353

1

					CurrencyPayment {

1354

1

						currency: Currency::AsMultiLocation(Box::new(

1355

1

							xcm::VersionedLocation::from(Location::parent())

1356

1

)),

1357

1

						fee_amount: Some(total_fee)

1358

1

},

1359

1

					TransactWeights {

1360

1

						transact_required_weight_at_most: tx_weight,

1361

1

						overall_weight: Some(Limited(total_weight))

1362

1

1363

),

1364

1

				Error::<Test>::TooMuchFeeUsed

1365

);

1366

1

})

1367

1

1368

1369

#[test]

1370

1

fn test_hrmp_manipulator_accept() {

1371

1

	ExtBuilder::default()

1372

1

		.with_balances(vec![])

1373

1

		.build()

1374

1

		.execute_with(|| {

1375

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1376

			// and a total fee of 100

1377

1

			let total_weight: Weight = 10_100u64.into();

1378

1

			let tx_weight: Weight = 100_u64.into();

1379

1

			let total_fee = 100u128;

1380

1381

1

			assert_ok!(XcmTransactor::hrmp_manage(

1382

1

				RuntimeOrigin::root(),

1383

1

				HrmpOperation::Accept {

1384

1

					para_id: 1u32.into()

1385

1

},

1386

1

				CurrencyPayment {

1387

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1388

1

						Location::parent()

1389

1

					))),

1390

1

					fee_amount: Some(total_fee)

1391

1

},

1392

1

				TransactWeights {

1393

1

					transact_required_weight_at_most: tx_weight,

1394

1

					overall_weight: Some(Limited(total_weight))

1395

1

1396

));

1397

1398

1

			let sent_messages = mock::sent_xcm();

1399

1

			let (_, sent_message) = sent_messages.first().unwrap();

1400

			// Lets make sure the message is as expected

1401

1

			assert!(sent_message

1402

1

.0

1403

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1404

1

			assert!(sent_message.0.contains(&BuyExecution {

1405

1

				fees: (Location::here(), total_fee).into(),

1406

1

				weight_limit: Limited(total_weight),

1407

1

			}));

1408

1

			assert!(sent_message.0.contains(&Transact {

1409

1

				origin_kind: OriginKind::Native,

1410

1

				fallback_max_weight: Some(tx_weight),

1411

1

				call: vec![0, 0, 1, 0, 0, 0].into(),

1412

1

			}));

1413

1

})

1414

1

1415

1416

#[test]

1417

1

fn test_hrmp_manipulator_cancel() {

1418

1

	ExtBuilder::default()

1419

1

		.with_balances(vec![])

1420

1

		.build()

1421

1

		.execute_with(|| {

1422

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1423

			// and a total fee of 100

1424

1

			let total_weight: Weight = 10_100u64.into();

1425

1

			let tx_weight: Weight = 100_u64.into();

1426

1

			let total_fee = 100u128;

1427

1

			let channel_id = HrmpChannelId {

1428

1

				sender: 1u32.into(),

1429

1

				recipient: 1u32.into(),

1430

1

};

1431

1

			let open_requests: u32 = 1;

1432

1433

1

			assert_ok!(XcmTransactor::hrmp_manage(

1434

1

				RuntimeOrigin::root(),

1435

1

				HrmpOperation::Cancel {

1436

1

					channel_id,

1437

1

					open_requests

1438

1

},

1439

1

				CurrencyPayment {

1440

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1441

1

						Location::parent()

1442

1

					))),

1443

1

					fee_amount: Some(total_fee)

1444

1

},

1445

1

				TransactWeights {

1446

1

					transact_required_weight_at_most: tx_weight,

1447

1

					overall_weight: Some(Limited(total_weight))

1448

1

1449

));

1450

1451

1

			let sent_messages = mock::sent_xcm();

1452

1

			let (_, sent_message) = sent_messages.first().unwrap();

1453

			// Lets make sure the message is as expected

1454

1

			assert!(sent_message

1455

1

.0

1456

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1457

1

			assert!(sent_message.0.contains(&BuyExecution {

1458

1

				fees: (Location::here(), total_fee).into(),

1459

1

				weight_limit: Limited(total_weight),

1460

1

			}));

1461

1

			assert!(sent_message.0.contains(&Transact {

1462

1

				origin_kind: OriginKind::Native,

1463

1

				fallback_max_weight: Some(tx_weight),

1464

1

				call: vec![0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0].into(),

1465

1

			}));

1466

1

})

1467

1

1468

1469

#[test]

1470

1

fn test_hrmp_manipulator_close() {

1471

1

	ExtBuilder::default()

1472

1

		.with_balances(vec![])

1473

1

		.build()

1474

1

		.execute_with(|| {

1475

			// We are gonna use a total weight of 10_100, a tx weight of 100,

1476

			// and a total fee of 100

1477

1

			let total_weight: Weight = 10_100u64.into();

1478

1

			let tx_weight: Weight = 100_u64.into();

1479

1

			let total_fee = 100u128;

1480

1481

1

			assert_ok!(XcmTransactor::hrmp_manage(

1482

1

				RuntimeOrigin::root(),

1483

1

				HrmpOperation::Close(HrmpChannelId {

1484

1

					sender: 1u32.into(),

1485

1

					recipient: 1u32.into()

1486

1

}),

1487

1

				CurrencyPayment {

1488

1

					currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1489

1

						Location::parent()

1490

1

					))),

1491

1

					fee_amount: Some(total_fee)

1492

1

},

1493

1

				TransactWeights {

1494

1

					transact_required_weight_at_most: tx_weight,

1495

1

					overall_weight: Some(Limited(total_weight))

1496

1

1497

));

1498

1499

1

			let sent_messages = mock::sent_xcm();

1500

1

			let (_, sent_message) = sent_messages.first().unwrap();

1501

			// Lets make sure the message is as expected

1502

1

			assert!(sent_message

1503

1

.0

1504

1

				.contains(&WithdrawAsset((Location::here(), total_fee).into())));

1505

1

			assert!(sent_message.0.contains(&BuyExecution {

1506

1

				fees: (Location::here(), total_fee).into(),

1507

1

				weight_limit: Limited(total_weight),

1508

1

			}));

1509

1

			assert!(sent_message.0.contains(&Transact {

1510

1

				origin_kind: OriginKind::Native,

1511

1

				fallback_max_weight: Some(tx_weight),

1512

1

				call: vec![0, 0, 1, 0, 0, 0, 1, 0, 0, 0].into(),

1513

1

			}));

1514

1

})

1515

1

1516

1517

#[test]

1518

1

fn test_transact_through_derivative_with_refund_works() {

1519

1

	ExtBuilder::default()

1520

1

		.with_balances(vec![])

1521

1

		.build()

1522

1

		.execute_with(|| {

1523

			// Root can register

1524

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

1525

1526

			// Root can set transact info

1527

1

			assert_ok!(XcmTransactor::set_transact_info(

1528

1

				RuntimeOrigin::root(),

1529

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

1530

1

				0.into(),

1531

1

				10000.into(),

1532

1

				None

1533

));

1534

1535

			// Set fee per second using FeeTrader

1536

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

1537

1

				Location::parent(),

1538

1539

));

1540

1541

			// fee as destination are the same, this time it should work

1542

1

			assert_ok!(XcmTransactor::transact_through_derivative(

1543

1

				RuntimeOrigin::signed(1u64),

1544

1

				Transactors::Relay,

1545

1,

1546

1

				CurrencyPayment {

1547

1

					currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

1548

1

					fee_amount: None

1549

1

},

1550

1

				vec![1u8],

1551

1

				TransactWeights {

1552

1

					transact_required_weight_at_most: 100u64.into(),

1553

1

					overall_weight: Some(Limited(1000.into()))

1554

1

},

1555

				true

1556

));

1557

1

			let expected = vec![

1558

1

				crate::Event::RegisteredDerivative {

1559

1

					account_id: 1u64,

1560

1

					index: 1,

1561

1

},

1562

1

				crate::Event::TransactInfoChanged {

1563

1

					location: Location::parent(),

1564

1

					remote_info: RemoteTransactInfoWithMaxWeight {

1565

1

						transact_extra_weight: 0.into(),

1566

1

						max_weight: 10000.into(),

1567

1

						transact_extra_weight_signed: None,

1568

1

},

1569

1

},

1570

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

1571

1

				crate::Event::TransactedDerivative {

1572

1

					account_id: 1u64,

1573

1

					dest: Location::parent(),

1574

1

					call: <XcmTransactor as UtilityEncodeCall>::encode_call(

1575

1

						Transactors::Relay,

1576

1

						UtilityAvailableCalls::AsDerivative(1, vec![1u8]),

1577

1

),

1578

1

					index: 1,

1579

1

},

1580

];

1581

1

			assert_eq!(events(), expected);

1582

1

			let sent_messages = mock::sent_xcm();

1583

1

			let (_, sent_message) = sent_messages.first().unwrap();

1584

1585

			// Check message contains the new appendix

1586

1

			assert!(sent_message.0.contains(&SetAppendix(Xcm(vec![

1587

1

				RefundSurplus,

1588

1

				DepositAsset {

1589

1

					assets: Wild(AllCounted(1u32)),

1590

1

					beneficiary: Location {

1591

1

						parents: 0,

1592

1

						interior: [Junction::Parachain(100)].into()

1593

1

1594

1

1595

1

			]))));

1596

1

})

1597

1

1598

1599

#[test]

1600

1

fn test_transact_through_derivative_with_refund_fails_overall_weight_not_set() {

1601

1

	ExtBuilder::default()

1602

1

		.with_balances(vec![])

1603

1

		.build()

1604

1

		.execute_with(|| {

1605

			// Root can register

1606

1

			assert_ok!(XcmTransactor::register(RuntimeOrigin::root(), 1u64, 1));

1607

1608

			// Root can set transact info

1609

1

			assert_ok!(XcmTransactor::set_transact_info(

1610

1

				RuntimeOrigin::root(),

1611

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

1612

1

				0.into(),

1613

1

				10000.into(),

1614

1

				None

1615

));

1616

1617

			// Set fee per second using FeeTrader

1618

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

1619

1

				Location::parent(),

1620

1621

));

1622

1623

			// fee as destination are the same, this time it should work

1624

1

			assert_noop!(

1625

1

				XcmTransactor::transact_through_derivative(

1626

1

					RuntimeOrigin::signed(1u64),

1627

1

					Transactors::Relay,

1628

1,

1629

1

					CurrencyPayment {

1630

1

						currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

1631

1

						fee_amount: None

1632

1

},

1633

1

					vec![1u8],

1634

1

					TransactWeights {

1635

1

						transact_required_weight_at_most: 100u64.into(),

1636

1

						overall_weight: None

1637

1

},

1638

					true

1639

),

1640

1

				Error::<Test>::RefundNotSupportedWithTransactInfo

1641

);

1642

1

})

1643

1

1644

1645

#[test]

1646

1

fn test_transact_through_signed_with_refund_works() {

1647

1

	ExtBuilder::default()

1648

1

		.with_balances(vec![])

1649

1

		.build()

1650

1

		.execute_with(|| {

1651

			// Set fee per second using FeeTrader

1652

1

			assert_ok!(<Test as Config>::FeeTrader::set_asset_price(

1653

1

				Location::parent(),

1654

1655

));

1656

1657

			// Overall weight to use

1658

1

			let total_weight: Weight = 10_100u64.into();

1659

1

			assert_ok!(XcmTransactor::transact_through_signed(

1660

1

				RuntimeOrigin::signed(1u64),

1661

1

				Box::new(xcm::VersionedLocation::from(Location::parent())),

1662

1

				CurrencyPayment {

1663

1

					currency: Currency::AsCurrencyId(CurrencyId::OtherReserve(0)),

1664

1

					fee_amount: None

1665

1

},

1666

1

				vec![1u8],

1667

1

				TransactWeights {

1668

1

					transact_required_weight_at_most: 100u64.into(),

1669

1

					overall_weight: Some(Limited(total_weight))

1670

1

},

1671

				true

1672

));

1673

1674

1

			let expected = vec![

1675

				// DestFeePerSecondChanged event removed - fee configuration now handled by pallet-xcm-weight-trader

1676

1

				crate::Event::TransactedSigned {

1677

1

					fee_payer: 1u64,

1678

1

					dest: Location::parent(),

1679

1

					call: vec![1u8],

1680

1

},

1681

];

1682

1

			assert_eq!(events(), expected);

1683

1

			let sent_messages = mock::sent_xcm();

1684

1

			let (_, sent_message) = sent_messages.first().unwrap();

1685

1686

			// Check message contains the new appendix

1687

1

			assert!(sent_message.0.contains(&SetAppendix(Xcm(vec![

1688

1

				RefundSurplus,

1689

1

				DepositAsset {

1690

1

					assets: Wild(AllCounted(1u32)),

1691

1

					beneficiary: Location {

1692

1

						parents: 0,

1693

1

						interior: [

1694

1

							Junction::Parachain(100),

1695

1

							AccountIdToLocation::convert(1)

1696

1

								.interior

1697

1

								.take_first()

1698

1

								.unwrap()

1699

1

1700

1

						.into()

1701

1

1702

1

1703

1

			]))));

1704

1

})

1705

1