git.delta.rocks / unique-network / refs/commits / 683a1283827b

--- a/tests/.vscode/settings.json
+++ b/tests/.vscode/settings.json
@@ -1,6 +1,10 @@
 {
-	"mocha.enabled": true,
-	"mochaExplorer.files": "**/*.test.ts",
+	"mochaExplorer.env": {
+		"RUN_GOV_TESTS": "1",
+		"RUN_XCM_TESTS": "1"
+	},
+	"mochaExplorer.files": "src/**/*.test.ts",
+	"mochaExplorer.envPath": ".mocha.env",
 	"mochaExplorer.require": "ts-node/register",
 	"eslint.format.enable": true,
 	"[javascript]": {

--- a/tests/src/config.ts
+++ b/tests/src/config.ts
@@ -28,6 +28,7 @@
   westmintUrl: process.env.RELAY_WESTMINT_URL || 'ws://127.0.0.1:9948',
   statemineUrl: process.env.RELAY_STATEMINE_URL || 'ws://127.0.0.1:9948',
   statemintUrl: process.env.RELAY_STATEMINT_URL || 'ws://127.0.0.1:9948',
+  polkadexUrl: process.env.RELAY_POLKADEX_URL || 'ws://127.0.0.1:9950',
 };
 
 export default config;

--- a/tests/src/util/index.ts
+++ b/tests/src/util/index.ts
@@ -11,7 +11,7 @@
 import config from '../config';
 import {ChainHelperBase} from './playgrounds/unique';
 import {ILogger} from './playgrounds/types';
-import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper} from './playgrounds/unique.dev';
+import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper, DevPolkadexHelper} from './playgrounds/unique.dev';
 import {dirname} from 'path';
 import {fileURLToPath} from 'url';
 
@@ -89,6 +89,8 @@
 
 export const usingShidenPlaygrounds = (url: string, code: (helper: DevShidenHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevShidenHelper>(DevShidenHelper, url, code);
 
+export const usingPolkadexPlaygrounds = (url: string, code: (helper: DevPolkadexHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevPolkadexHelper>(DevPolkadexHelper, url, code);
+
 export const MINIMUM_DONOR_FUND = 4_000_000n;
 export const DONOR_FUNDING = 4_000_000n;
 

--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -3,7 +3,7 @@
 
 import {stringToU8a} from '@polkadot/util';
 import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
-import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper} from './unique';
+import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper, PolkadexHelper} from './unique';
 import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
 import * as defs from '../../interfaces/definitions';
 import {IKeyringPair} from '@polkadot/types/types';
@@ -249,6 +249,10 @@
       messageHash: eventJsonData(data, 0),
     }));
 
+    static Success = this.Method('Success', data => ({
+      messageHash: eventJsonData(data, 0),
+    }));
+
     static Fail = this.Method('Fail', data => ({
       messageHash: eventJsonData(data, 0),
       outcome: eventData<XcmV2TraitsError>(data, 1),
@@ -406,6 +410,16 @@
   }
 }
 
+export class DevPolkadexHelper extends PolkadexHelper {
+  wait: WaitGroup;
+  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
+    options.helperBase = options.helperBase ?? PolkadexHelper;
+
+    super(logger, options);
+    this.wait = new WaitGroup(this);
+  }
+}
+
 export class DevKaruraHelper extends DevAcalaHelper {}
 
 export class ArrangeGroup {

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -3694,6 +3694,12 @@
   }
 }
 
+class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {
+  async whitelistToken(signer: TSigner, assetId: any) {
+    await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);
+  }
+}
+
 class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {
   async accounts(address: string, currencyId: any) {
     const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;
@@ -3977,6 +3983,30 @@
   }
 }
 
+export class PolkadexHelper extends XcmChainHelper {
+  assets: AssetsGroup<PolkadexHelper>;
+  balance: SubstrateBalanceGroup<PolkadexHelper>;
+  xTokens: XTokensGroup<PolkadexHelper>;
+  xcm: XcmGroup<PolkadexHelper>;
+  xcmHelper: PolkadexXcmHelperGroup<PolkadexHelper>;
+
+  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
+    super(logger, options.helperBase ?? PolkadexHelper);
+
+    this.assets = new AssetsGroup(this);
+    this.balance = new SubstrateBalanceGroup(this);
+    this.xTokens = new XTokensGroup(this);
+    this.xcm = new XcmGroup(this, 'polkadotXcm');
+    this.xcmHelper = new PolkadexXcmHelperGroup(this);
+  }
+
+  getSudo<T extends PolkadexHelper>() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const SudoHelperType = SudoHelper(this.helperBase);
+    return this.clone(SudoHelperType) as T;
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/naming-convention
 function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {
   return class extends Base {

1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import config from '../config';18import config from '../config';
19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds} from '../util';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';
20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';
21import {nToBigInt} from '@polkadot/util';
2122
22const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);23const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);
23const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);24const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);
24const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);25const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);
25const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);26const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);
26const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);27const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);
28const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);
2729
28const STATEMINT_PALLET_INSTANCE = 50;30const STATEMINT_PALLET_INSTANCE = 50;
2931
32const acalaUrl = config.acalaUrl;34const acalaUrl = config.acalaUrl;
33const moonbeamUrl = config.moonbeamUrl;35const moonbeamUrl = config.moonbeamUrl;
34const astarUrl = config.astarUrl;36const astarUrl = config.astarUrl;
37const polkadexUrl = config.polkadexUrl;
3538
36const RELAY_DECIMALS = 12;39const RELAY_DECIMALS = 12;
37const STATEMINT_DECIMALS = 12;40const STATEMINT_DECIMALS = 12;
791  });794  });
792});795});
796
797describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {
798  let alice: IKeyringPair;
799  let randomAccount: IKeyringPair;
800  let unqFees: bigint;
801  let balanceUniqueTokenInit: bigint;
802  let balanceUniqueTokenMiddle: bigint;
803  let balanceUniqueTokenFinal: bigint;
804  const maxWaitBlocks = 6;
805
806  const uniqueAssetId = {
807    Concrete: {
808      parents: 1,
809      interior: {
810        X1: {
811          Parachain: UNIQUE_CHAIN,
812        },
813      },
814    },
815  };
816
817  before(async () => {
818    await usingPlaygrounds(async (helper, privateKey) => {
819      alice = await privateKey('//Alice');
820      [randomAccount] = await helper.arrange.createAccounts([0n], alice);
821
822      // Set the default version to wrap the first message to other chains.
823      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
824    });
825
826    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
827      const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', [])).toJSON() as [])
828        .map(nToBigInt).length != 0;
829
830      if(!isWhitelisted) {
831        await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);
832      }
833
834      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);
835    });
836
837    await usingPlaygrounds(async (helper) => {
838      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);
839      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);
840    });
841  });
842
843  itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {
844
845    const destination = {
846      V2: {
847        parents: 1,
848        interior: {
849          X1: {
850            Parachain: POLKADEX_CHAIN,
851          },
852        },
853      },
854    };
855
856    const beneficiary = {
857      V2: {
858        parents: 0,
859        interior: {
860          X1: {
861            AccountId32: {
862              network: 'Any',
863              id: randomAccount.addressRaw,
864            },
865          },
866        },
867      },
868    };
869
870    const assets = {
871      V2: [
872        {
873          id: {
874            Concrete: {
875              parents: 0,
876              interior: 'Here',
877            },
878          },
879          fun: {
880            Fungible: TRANSFER_AMOUNT,
881          },
882        },
883      ],
884    };
885
886    const feeAssetItem = 0;
887
888    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');
889    const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
890    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);
891
892    unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;
893    console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));
894    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;
895
896    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
897      await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);
898    });
899  });
900
901
902  itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {
903
904    const uniqueMultilocation = {
905      V2: {
906        parents: 1,
907        interior: {
908          X1: {Parachain: UNIQUE_CHAIN},
909        },
910      },
911    };
912
913    const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
914      randomAccount.addressRaw,
915      {
916        Concrete: {
917          parents: 0,
918          interior: 'Here',
919        },
920      },
921      TRANSFER_AMOUNT,
922    );
923
924    let xcmProgramSent: any;
925
926
927    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
928      await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);
929
930      xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
931    });
932
933    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);
934
935    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);
936
937    expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);
938  });
939
940  itSub('Polkadex can send only up to its balance', async ({helper}) => {
941    const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);
942    const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);
943    await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);
944    const moreThanPolkadexHas = 2n * polkadexBalance;
945
946    const targetAccount = helper.arrange.createEmptyAccount();
947
948    const uniqueMultilocation = {
949      V2: {
950        parents: 1,
951        interior: {
952          X1: {Parachain: UNIQUE_CHAIN},
953        },
954      },
955    };
956
957    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
958      targetAccount.addressRaw,
959      {
960        Concrete: {
961          parents: 0,
962          interior: 'Here',
963        },
964      },
965      moreThanPolkadexHas,
966    );
967
968    let maliciousXcmProgramSent: any;
969
970
971    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
972      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);
973
974      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
975    });
976
977    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash);
978
979    const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
980    expect(targetAccountBalance).to.be.equal(0n);
981  });
982});
793983
794// These tests are relevant only when984// These tests are relevant only when
795// the the corresponding foreign assets are not registered985// the the corresponding foreign assets are not registered
931    await expectFailedToTransact(helper, messageSent);1121    await expectFailedToTransact(helper, messageSent);
932  });1122  });
1123
1124  itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {
1125
1126    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
1127      helper.arrange.createEmptyAccount().addressRaw,
1128      {
1129        Concrete: {
1130          parents: 1,
1131          interior: {
1132            X1: {
1133              Parachain: POLKADEX_CHAIN,
1134            },
1135          },
1136        },
1137      },
1138      testAmount,
1139    );
1140
1141    await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {
1142      await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);
1143      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);
1144    });
1145
1146    await expectFailedToTransact(helper, messageSent);
1147  });
933});1148});
9341149
935describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1150describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {