git.delta.rocks / unique-network / refs/commits / 0f67e15c3f4a

--- a/tests/src/xcm/lowLevelXcmQuartz.test.ts
+++ b/tests/src/xcm/lowLevelXcmQuartz.test.ts
@@ -15,7 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds,  usingMoonriverPlaygrounds, usingShidenPlaygrounds} from '../util';
+import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds,  usingMoonriverPlaygrounds, usingShidenPlaygrounds, usingRelayPlaygrounds} from '../util';
 import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';
 import {STATEMINE_CHAIN, QUARTZ_CHAIN, KARURA_CHAIN, MOONRIVER_CHAIN, SHIDEN_CHAIN, STATEMINE_DECIMALS, KARURA_DECIMALS, QTZ_DECIMALS, RELAY_DECIMALS, SHIDEN_DECIMALS, karuraUrl, moonriverUrl, relayUrl, shidenUrl, statemineUrl, SAFE_XCM_VERSION, XcmTestHelper, TRANSFER_AMOUNT} from './xcm.types';
 
@@ -379,3 +379,67 @@
     await testHelper.reserveTransferUNQfrom('shiden', alice);
   });
 });
+
+describeXCM('[XCMLL] Integration test: The relay can do some root ops', () => {
+  let sudoer: IKeyringPair;
+
+  before(async function () {
+    await usingRelayPlaygrounds(relayUrl, async (_, privateKey) => {
+      sudoer = await privateKey('//Alice');
+    });
+  });
+
+  // At the moment there is no reliable way
+  // to establish the correspondence between the `ExecutedDownward` event
+  // and the relay's sent message due to `SetTopic` instruction
+  // containing an unpredictable topic silently added by the relay on the router level.
+  // This changes the message hash on arrival to our chain.
+  //
+  // See:
+  // * The relay's router: https://github.com/paritytech/polkadot-sdk/blob/f60318f68687e601c47de5ad5ca88e2c3f8139a7/polkadot/runtime/westend/src/xcm_config.rs#L83
+  // * The `WithUniqueTopic` helper: https://github.com/paritytech/polkadot-sdk/blob/945ebbbcf66646be13d5b1d1bc26c8b0d3296d9e/polkadot/xcm/xcm-builder/src/routing.rs#L36
+  //
+  // Because of this, we insert time gaps between tests so
+  // different `ExecutedDownward` events won't interfere with each other.
+  afterEach(async () => {
+    await usingPlaygrounds(async (helper) => {
+      await helper.wait.newBlocks(3);
+    });
+  });
+
+  itSub('The relay can set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'plain');
+  });
+
+  itSub('The relay can batch set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'batch');
+  });
+
+  itSub('The relay can batchAll set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'batchAll');
+  });
+
+  itSub('The relay can forceBatch set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'forceBatch');
+  });
+
+  itSub('[negative] The relay cannot set balance', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'plain');
+  });
+
+  itSub('[negative] The relay cannot set balance via batch', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batch');
+  });
+
+  itSub('[negative] The relay cannot set balance via batchAll', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batchAll');
+  });
+
+  itSub('[negative] The relay cannot set balance via forceBatch', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'forceBatch');
+  });
+
+  itSub('[negative] The relay cannot set balance via dispatchAs', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'dispatchAs');
+  });
+});

--- a/tests/src/xcm/lowLevelXcmUnique.test.ts
+++ b/tests/src/xcm/lowLevelXcmUnique.test.ts
@@ -16,11 +16,11 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import config from '../config';
-import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';
+import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds, requirePalletsOrSkip, Pallets} from '../util';
 import {Event} from '../util/playgrounds/unique.dev';
 import {nToBigInt} from '@polkadot/util';
 import {hexToString} from '@polkadot/util';
-import {ASTAR_DECIMALS, NETWORKS, SAFE_XCM_VERSION, UNIQUE_CHAIN, UNQ_DECIMALS, XcmTestHelper, acalaUrl, astarUrl, expectFailedToTransact, expectUntrustedReserveLocationFail, getDevPlayground, mapToChainId, mapToChainUrl, maxWaitBlocks, moonbeamUrl, polkadexUrl, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types';
+import {ASTAR_DECIMALS, NETWORKS, SAFE_XCM_VERSION, UNIQUE_CHAIN, UNQ_DECIMALS, XcmTestHelper, acalaUrl, astarUrl, expectFailedToTransact, expectUntrustedReserveLocationFail, getDevPlayground, mapToChainId, mapToChainUrl, maxWaitBlocks, moonbeamUrl, polkadexUrl, relayUrl, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types';
 
 
 const TRANSFER_AMOUNT = 2000000_000_000_000_000_000_000n;
@@ -672,3 +672,67 @@
     await genericReserveTransferUNQfrom('astar', alice);
   });
 });
+
+describeXCM('[XCMLL] Integration test: The relay can do some root ops', () => {
+  let sudoer: IKeyringPair;
+
+  before(async function () {
+    await usingRelayPlaygrounds(relayUrl, async (_, privateKey) => {
+      sudoer = await privateKey('//Alice');
+    });
+  });
+
+  // At the moment there is no reliable way
+  // to establish the correspondence between the `ExecutedDownward` event
+  // and the relay's sent message due to `SetTopic` instruction
+  // containing an unpredictable topic silently added by the relay on the router level.
+  // This changes the message hash on arrival to our chain.
+  //
+  // See:
+  // * The relay's router: https://github.com/paritytech/polkadot-sdk/blob/f60318f68687e601c47de5ad5ca88e2c3f8139a7/polkadot/runtime/westend/src/xcm_config.rs#L83
+  // * The `WithUniqueTopic` helper: https://github.com/paritytech/polkadot-sdk/blob/945ebbbcf66646be13d5b1d1bc26c8b0d3296d9e/polkadot/xcm/xcm-builder/src/routing.rs#L36
+  //
+  // Because of this, we insert time gaps between tests so
+  // different `ExecutedDownward` events won't interfere with each other.
+  afterEach(async () => {
+    await usingPlaygrounds(async (helper) => {
+      await helper.wait.newBlocks(3);
+    });
+  });
+
+  itSub('The relay can set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'plain');
+  });
+
+  itSub('The relay can batch set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'batch');
+  });
+
+  itSub('The relay can batchAll set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'batchAll');
+  });
+
+  itSub('The relay can forceBatch set storage', async () => {
+    await testHelper.relayIsPermittedToSetStorage(sudoer, 'forceBatch');
+  });
+
+  itSub('[negative] The relay cannot set balance', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'plain');
+  });
+
+  itSub('[negative] The relay cannot set balance via batch', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batch');
+  });
+
+  itSub('[negative] The relay cannot set balance via batchAll', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'batchAll');
+  });
+
+  itSub('[negative] The relay cannot set balance via forceBatch', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'forceBatch');
+  });
+
+  itSub('[negative] The relay cannot set balance via dispatchAs', async () => {
+    await testHelper.relayIsNotPermittedToSetBalance(sudoer, 'dispatchAs');
+  });
+});

1import {IKeyringPair} from '@polkadot/types/types';1import {IKeyringPair} from '@polkadot/types/types';
2import {hexToString} from '@polkadot/util';
2import {expect, usingAcalaPlaygrounds, usingAstarPlaygrounds, usingKaruraPlaygrounds, usingMoonbeamPlaygrounds, usingMoonriverPlaygrounds, usingPlaygrounds, usingPolkadexPlaygrounds, usingShidenPlaygrounds} from '../util';3import {expect, usingAcalaPlaygrounds, usingAstarPlaygrounds, usingKaruraPlaygrounds, usingMoonbeamPlaygrounds, usingMoonriverPlaygrounds, usingPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds, usingShidenPlaygrounds} from '../util';
3import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';4import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';
4import config from '../config';5import config from '../config';
6import {blake2AsHex} from '@polkadot/util-crypto';
57
6export const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);8export const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);
7export const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);9export const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);
68         && event.outcome.isUntrustedReserveLocation);70         && event.outcome.isUntrustedReserveLocation);
69};71};
72
73export const expectDownwardXcmNoPermission = async (helper: DevUniqueHelper) => {
74  // The correct messageHash for downward messages can't be reliably obtained
75  await helper.wait.expectEvent(maxWaitBlocks, Event.DmpQueue.ExecutedDownward, event => event.outcome.asIncomplete[1].isNoPermission);
76};
77
78export const expectDownwardXcmComplete = async (helper: DevUniqueHelper) => {
79  // The correct messageHash for downward messages can't be reliably obtained
80  await helper.wait.expectEvent(maxWaitBlocks, Event.DmpQueue.ExecutedDownward, event => event.outcome.isComplete);
81};
7082
71export const NETWORKS = {83export const NETWORKS = {
72  acala: usingAcalaPlaygrounds,84  acala: usingAcalaPlaygrounds,
161    }173    }
162  }174  }
175
176  uniqueChainMultilocationForRelay() {
177    return {
178      V3: {
179        parents: 0,
180        interior: {
181          X1: {Parachain: this._getNativeId()},
182        },
183      },
184    };
185  }
163186
164  async sendUnqTo(187  async sendUnqTo(
165    networkName: keyof typeof NETWORKS,188    networkName: keyof typeof NETWORKS,
470    });493    });
471  }494  }
472495
496  private async _relayXcmTransactSetStorage(variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch') {
497    // eslint-disable-next-line require-await
498    return await usingPlaygrounds(async (helper) => {
499      const relayForceKV = () => {
500        const random = Math.random();
501        const key = `relay-forced-key (instance: ${random})`;
502        const val = `relay-forced-value (instance: ${random})`;
503        const call = helper.constructApiCall('api.tx.system.setStorage', [[[key, val]]]).method.toHex();
504
505        return {
506          call,
507          key,
508          val,
509        };
510      };
511
512      if(variant == 'plain') {
513        const kv = relayForceKV();
514        return {
515          program: helper.arrange.makeTransactProgram({
516            weightMultiplier: 1,
517            call: kv.call,
518          }),
519          kvs: [kv],
520        };
521      } else {
522        const kv0 = relayForceKV();
523        const kv1 = relayForceKV();
524
525        const batchCall = helper.constructApiCall(`api.tx.utility.${variant}`, [[kv0.call, kv1.call]]).method.toHex();
526        return {
527          program: helper.arrange.makeTransactProgram({
528            weightMultiplier: 2,
529            call: batchCall,
530          }),
531          kvs: [kv0, kv1],
532        };
533      }
534    });
535  }
536
537  async relayIsPermittedToSetStorage(relaySudoer: IKeyringPair, variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch') {
538    const {program, kvs} = await this._relayXcmTransactSetStorage(variant);
539
540    await usingRelayPlaygrounds(relayUrl, async (helper) => {
541      await helper.getSudo().executeExtrinsic(relaySudoer, 'api.tx.xcmPallet.send', [
542        this.uniqueChainMultilocationForRelay(),
543        program,
544      ]);
545    });
546
547    await usingPlaygrounds(async (helper) => {
548      await expectDownwardXcmComplete(helper);
549
550      for(const kv of kvs) {
551        const forcedValue = await helper.callRpc('api.rpc.state.getStorage', [kv.key]);
552        expect(hexToString(forcedValue.toHex())).to.be.equal(kv.val);
553      }
554    });
555  }
556
557  private async _relayXcmTransactSetBalance(variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch' | 'dispatchAs') {
558    // eslint-disable-next-line require-await
559    return await usingPlaygrounds(async (helper) => {
560      const emptyAccount = helper.arrange.createEmptyAccount().address;
561
562      const forceSetBalanceCall = helper.constructApiCall('api.tx.balances.forceSetBalance', [emptyAccount, 10_000n]).method.toHex();
563
564      let call;
565
566      if(variant == 'plain') {
567        call = forceSetBalanceCall;
568
569      } else if(variant == 'dispatchAs') {
570        call = helper.constructApiCall('api.tx.utility.dispatchAs', [
571          {
572            system: 'Root',
573          },
574          forceSetBalanceCall,
575        ]).method.toHex();
576      } else {
577        call = helper.constructApiCall(`api.tx.utility.${variant}`, [[forceSetBalanceCall]]).method.toHex();
578      }
579
580      return {
581        program: helper.arrange.makeTransactProgram({
582          weightMultiplier: 1,
583          call,
584        }),
585        emptyAccount,
586      };
587    });
588  }
589
590  async relayIsNotPermittedToSetBalance(
591    relaySudoer: IKeyringPair,
592    variant: 'plain' | 'batch' | 'batchAll' | 'forceBatch' | 'dispatchAs',
593  ) {
594    const {program, emptyAccount} = await this._relayXcmTransactSetBalance(variant);
595
596    await usingRelayPlaygrounds(relayUrl, async (helper) => {
597      await helper.getSudo().executeExtrinsic(relaySudoer, 'api.tx.xcmPallet.send', [
598        this.uniqueChainMultilocationForRelay(),
599        program,
600      ]);
601    });
602
603    await usingPlaygrounds(async (helper) => {
604      await expectDownwardXcmNoPermission(helper);
605      expect(await helper.balance.getSubstrate(emptyAccount)).to.be.equal(0n);
606    });
607  }
473}608}
609