git.delta.rocks / unique-network / refs/commits / ccee89d02173

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import type {IKeyringPair} from '@polkadot/types/types';18import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util/index.js';19import {DevUniqueHelper, Event} from '@unique/playgrounds/unique.dev.js';20import {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} from './xcm.types.js';21import {hexToString} from '@polkadot/util';22import {XcmTestHelper} from './xcm.types';2324const STATEMINE_PALLET_INSTANCE = 50;2526const TRANSFER_AMOUNT = 2000000000000000000000000n;2728const FUNDING_AMOUNT = 3_500_000_0000_000_000n;2930const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;3132const USDT_ASSET_ID = 100;33const USDT_ASSET_METADATA_DECIMALS = 18;34const USDT_ASSET_METADATA_NAME = 'USDT';35const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';36const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;37const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;3839const SAFE_XCM_VERSION = 2;4041const testHelper = new XcmTestHelper('quartz');4243describeXCM('[XCM] Integration test: Exchanging USDT with Statemine', () => {44  let alice: IKeyringPair;45  let bob: IKeyringPair;4647  let balanceStmnBefore: bigint;48  let balanceStmnAfter: bigint;4950  let balanceQuartzBefore: bigint;51  let balanceQuartzAfter: bigint;52  let balanceQuartzFinal: bigint;5354  let balanceBobBefore: bigint;55  let balanceBobAfter: bigint;56  let balanceBobFinal: bigint;5758  let balanceBobRelayTokenBefore: bigint;59  let balanceBobRelayTokenAfter: bigint;6061  let usdtCollectionId: number;62  let relayCollectionId: number;6364  before(async () => {65    await usingPlaygrounds(async (helper, privateKey) => {66      alice = await privateKey('//Alice');67      bob = await privateKey('//Bob'); // sovereign account on Statemine(t) funds donor6869      // Set the default version to wrap the first message to other chains.70      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);7172      relayCollectionId = await testHelper.registerRelayNativeTokenOnUnique(alice);73    });7475    await usingRelayPlaygrounds(relayUrl, async (helper) => {76      // Fund accounts on Statemine(t)77      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, alice.addressRaw, FUNDING_AMOUNT);78      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, bob.addressRaw, FUNDING_AMOUNT);79    });8081    await usingStateminePlaygrounds(statemineUrl, async (helper) => {82      const assetInfo = await helper.assets.assetInfo(USDT_ASSET_ID);83      if(assetInfo == null) {84        await helper.assets.create(85          alice,86          USDT_ASSET_ID,87          alice.address,88          USDT_ASSET_METADATA_MINIMAL_BALANCE,89        );90        await helper.assets.setMetadata(91          alice,92          USDT_ASSET_ID,93          USDT_ASSET_METADATA_NAME,94          USDT_ASSET_METADATA_DESCRIPTION,95          USDT_ASSET_METADATA_DECIMALS,96        );97      } else {98        console.log('The USDT asset is already registered on AssetHub');99      }100101      await helper.assets.mint(102        alice,103        USDT_ASSET_ID,104        alice.address,105        USDT_ASSET_AMOUNT,106      );107108      const sovereignFundingAmount = 3_500_000_000n;109110      // funding parachain sovereing account on Statemine(t).111      // The sovereign account should be created before any action112      // (the assets pallet on Statemine(t) check if the sovereign account exists)113      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(QUARTZ_CHAIN);114      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);115    });116117118    await usingPlaygrounds(async (helper) => {119      const location = {120        parents: 1,121        interior: {X3: [122          {123            Parachain: STATEMINE_CHAIN,124          },125          {126            PalletInstance: STATEMINE_PALLET_INSTANCE,127          },128          {129            GeneralIndex: USDT_ASSET_ID,130          },131        ]},132      };133134      if(await helper.foreignAssets.foreignCollectionId(location) == null) {135        const tokenPrefix = USDT_ASSET_METADATA_NAME;136        await helper.getSudo().foreignAssets.register(alice, location, USDT_ASSET_METADATA_NAME, tokenPrefix, {Fungible: USDT_ASSET_METADATA_DECIMALS});137      } else {138        console.log('Foreign collection is already registered on Quartz');139      }140141      balanceQuartzBefore = await helper.balance.getSubstrate(alice.address);142      usdtCollectionId = await helper.foreignAssets.foreignCollectionId(location);143    });144145146    // Providing the relay currency to the quartz sender account147    // (fee for USDT XCM are paid in relay tokens)148    await usingRelayPlaygrounds(relayUrl, async (helper) => {149      const destination = {150        V2: {151          parents: 0,152          interior: {X1: {153            Parachain: QUARTZ_CHAIN,154          },155          },156        }};157158      const beneficiary = {159        V2: {160          parents: 0,161          interior: {X1: {162            AccountId32: {163              network: 'Any',164              id: alice.addressRaw,165            },166          }},167        },168      };169170      const assets = {171        V2: [172          {173            id: {174              Concrete: {175                parents: 0,176                interior: 'Here',177              },178            },179            fun: {180              Fungible: TRANSFER_AMOUNT_RELAY,181            },182          },183        ],184      };185186      const feeAssetItem = 0;187188      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');189    });190191  });192193  itSub('Should connect and send USDT from Statemine to Quartz', async ({helper}) => {194    await usingStateminePlaygrounds(statemineUrl, async (helper) => {195      const dest = {196        V2: {197          parents: 1,198          interior: {X1: {199            Parachain: QUARTZ_CHAIN,200          },201          },202        }};203204      const beneficiary = {205        V2: {206          parents: 0,207          interior: {X1: {208            AccountId32: {209              network: 'Any',210              id: alice.addressRaw,211            },212          }},213        },214      };215216      const assets = {217        V2: [218          {219            id: {220              Concrete: {221                parents: 0,222                interior: {223                  X2: [224                    {225                      PalletInstance: STATEMINE_PALLET_INSTANCE,226                    },227                    {228                      GeneralIndex: USDT_ASSET_ID,229                    },230                  ]},231              },232            },233            fun: {234              Fungible: TRANSFER_AMOUNT,235            },236          },237        ],238      };239240      const feeAssetItem = 0;241242      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);243      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');244245      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);246247      // common good parachain take commission in it native token248      console.log(249        '[Statemine -> Quartz] transaction fees on Statemine: %s WND',250        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINE_DECIMALS),251      );252      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;253254    });255256257    // ensure that asset has been delivered258    await helper.wait.newBlocks(3);259260    const free = await helper.ft.getBalance(usdtCollectionId, {Substrate: alice.address});261262    balanceQuartzAfter = await helper.balance.getSubstrate(alice.address);263264    console.log(265      '[Statemine -> Quartz] transaction fees on Quartz: %s USDT',266      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),267    );268    console.log(269      '[Statemine -> Quartz] transaction fees on Quartz: %s QTZ',270      helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzBefore),271    );272    // commission has not paid in USDT token273    expect(free).to.be.equal(TRANSFER_AMOUNT);274    // ... and parachain native token275    expect(balanceQuartzAfter == balanceQuartzBefore).to.be.true;276  });277278  itSub('Should connect and send USDT from Quartz to Statemine back', async ({helper}) => {279    const destination = {280      V2: {281        parents: 1,282        interior: {X2: [283          {284            Parachain: STATEMINE_CHAIN,285          },286          {287            AccountId32: {288              network: 'Any',289              id: alice.addressRaw,290            },291          },292        ]},293      },294    };295296    const relayFee = 400_000_000_000_000n;297    const currencies: [any, bigint][] = [298      [299        usdtCollectionId,300        TRANSFER_AMOUNT,301      ],302      [303        relayCollectionId,304        relayFee,305      ],306    ];307308    const feeItem = 1;309310    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');311312    // the commission has been paid in parachain native token313    balanceQuartzFinal = await helper.balance.getSubstrate(alice.address);314    console.log('[Quartz -> Statemine] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzFinal));315    expect(balanceQuartzAfter > balanceQuartzFinal).to.be.true;316317    await usingStateminePlaygrounds(statemineUrl, async (helper) => {318      await helper.wait.newBlocks(3);319320      // The USDT token never paid fees. Its amount not changed from begin value.321      // Also check that xcm transfer has been succeeded322      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;323    });324  });325326  itSub('Should connect and send Relay token to Quartz', async ({helper}) => {327    balanceBobBefore = await helper.balance.getSubstrate(bob.address);328    balanceBobRelayTokenBefore = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});329330    await usingRelayPlaygrounds(relayUrl, async (helper) => {331      const destination = {332        V2: {333          parents: 0,334          interior: {X1: {335            Parachain: QUARTZ_CHAIN,336          },337          },338        }};339340      const beneficiary = {341        V2: {342          parents: 0,343          interior: {X1: {344            AccountId32: {345              network: 'Any',346              id: bob.addressRaw,347            },348          }},349        },350      };351352      const assets = {353        V2: [354          {355            id: {356              Concrete: {357                parents: 0,358                interior: 'Here',359              },360            },361            fun: {362              Fungible: TRANSFER_AMOUNT_RELAY,363            },364          },365        ],366      };367368      const feeAssetItem = 0;369370      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');371    });372373    await helper.wait.newBlocks(3);374375    balanceBobAfter = await helper.balance.getSubstrate(bob.address);376    balanceBobRelayTokenAfter = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});377378    const wndFeeOnQuartz = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;379    const wndDiffOnQuartz = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;380    console.log(381      '[Relay (Westend) -> Quartz] transaction fees: %s QTZ',382      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),383    );384    console.log(385      '[Relay (Westend) -> Quartz] transaction fees: %s WND',386      helper.util.bigIntToDecimals(wndFeeOnQuartz, STATEMINE_DECIMALS),387    );388    console.log('[Relay (Westend) -> Quartz] actually delivered: %s WND', wndDiffOnQuartz);389    expect(wndFeeOnQuartz == 0n, 'No incoming WND fees should be taken').to.be.true;390    expect(balanceBobBefore == balanceBobAfter, 'No incoming QTZ fees should be taken').to.be.true;391  });392393  itSub('Should connect and send Relay token back', async ({helper}) => {394    let relayTokenBalanceBefore: bigint;395    let relayTokenBalanceAfter: bigint;396    await usingRelayPlaygrounds(relayUrl, async (helper) => {397      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);398    });399400    const destination = {401      V2: {402        parents: 1,403        interior: {404          X1:{405            AccountId32: {406              network: 'Any',407              id: bob.addressRaw,408            },409          },410        },411      },412    };413414    const currencies: any = [415      [416        relayCollectionId,417        TRANSFER_AMOUNT_RELAY,418      ],419    ];420421    const feeItem = 0;422423    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');424425    balanceBobFinal = await helper.balance.getSubstrate(bob.address);426    console.log('[Quartz -> Relay (Westend)] transaction fees: %s QTZ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));427428    await usingRelayPlaygrounds(relayUrl, async (helper) => {429      await helper.wait.newBlocks(10);430      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);431432      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;433      console.log('[Quartz -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));434      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;435    });436  });437});438439describeXCM('[XCM] Integration test: Exchanging tokens with Karura', () => {440  let alice: IKeyringPair;441  let randomAccount: IKeyringPair;442443  let balanceQuartzTokenInit: bigint;444  let balanceQuartzTokenMiddle: bigint;445  let balanceQuartzTokenFinal: bigint;446  let balanceKaruraTokenInit: bigint;447  let balanceKaruraTokenMiddle: bigint;448  let balanceKaruraTokenFinal: bigint;449  let balanceQuartzForeignTokenInit: bigint;450  let balanceQuartzForeignTokenMiddle: bigint;451  let balanceQuartzForeignTokenFinal: bigint;452453  // computed by a test transfer from prod Quartz to prod Karura.454  // 2 QTZ sent https://quartz.subscan.io/xcm_message/kusama-f60d821b049f8835a3005ce7102285006f5b61e9455  // 1.919176000000000000 QTZ received (you can check Karura's chain state in the corresponding block)456  const expectedKaruraIncomeFee = 2000000000000000000n - 1919176000000000000n;457  const karuraEps = 8n * 10n ** 16n;458459  let karuraBackwardTransferAmount: bigint;460461  before(async () => {462    await usingPlaygrounds(async (helper, privateKey) => {463      alice = await privateKey('//Alice');464      [randomAccount] = await helper.arrange.createAccounts([0n], alice);465466      // Set the default version to wrap the first message to other chains.467      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);468    });469470    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {471      const destination = {472        V2: {473          parents: 1,474          interior: {475            X1: {476              Parachain: QUARTZ_CHAIN,477            },478          },479        },480      };481482      const metadata = {483        name: 'Quartz',484        symbol: 'QTZ',485        decimals: 18,486        minimalBalance: 1000000000000000000n,487      };488489      const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v]: [any, any]) =>490        hexToString(v.toJSON()['symbol'])) as string[];491492      if(!assets.includes('QTZ')) {493        await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);494      } else {495        console.log('QTZ token already registered on Karura assetRegistry pallet');496      }497      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);498      balanceKaruraTokenInit = await helper.balance.getSubstrate(randomAccount.address);499      balanceQuartzForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});500    });501502    await usingPlaygrounds(async (helper) => {503      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);504      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccount.address);505    });506  });507508  itSub('Should connect and send QTZ to Karura', async ({helper}) => {509    const destination = {510      V2: {511        parents: 1,512        interior: {513          X1: {514            Parachain: KARURA_CHAIN,515          },516        },517      },518    };519520    const beneficiary = {521      V2: {522        parents: 0,523        interior: {524          X1: {525            AccountId32: {526              network: 'Any',527              id: randomAccount.addressRaw,528            },529          },530        },531      },532    };533534    const assets = {535      V2: [536        {537          id: {538            Concrete: {539              parents: 0,540              interior: 'Here',541            },542          },543          fun: {544            Fungible: TRANSFER_AMOUNT,545          },546        },547      ],548    };549550    const feeAssetItem = 0;551552    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');553    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);554555    const qtzFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;556    expect(qtzFees > 0n, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;557    console.log('[Quartz -> Karura] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));558559    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {560      await helper.wait.newBlocks(3);561562      balanceQuartzForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});563      balanceKaruraTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);564565      const karFees = balanceKaruraTokenInit - balanceKaruraTokenMiddle;566      const qtzIncomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenInit;567      karuraBackwardTransferAmount = qtzIncomeTransfer;568569      const karUnqFees = TRANSFER_AMOUNT - qtzIncomeTransfer;570571      console.log(572        '[Quartz -> Karura] transaction fees on Karura: %s KAR',573        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),574      );575      console.log(576        '[Quartz -> Karura] transaction fees on Karura: %s QTZ',577        helper.util.bigIntToDecimals(karUnqFees),578      );579      console.log('[Quartz -> Karura] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));580      expect(karFees == 0n).to.be.true;581582      const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;583584      expect(585        bigintAbs(karUnqFees - expectedKaruraIncomeFee) < karuraEps,586        'Karura took different income fee, check the Karura foreign asset config',587      ).to.be.true;588    });589  });590591  itSub('Should connect to Karura and send QTZ back', async ({helper}) => {592    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {593      const destination = {594        V2: {595          parents: 1,596          interior: {597            X2: [598              {Parachain: QUARTZ_CHAIN},599              {600                AccountId32: {601                  network: 'Any',602                  id: randomAccount.addressRaw,603                },604              },605            ],606          },607        },608      };609610      const id = {611        ForeignAsset: 0,612      };613614      await helper.xTokens.transfer(randomAccount, id, karuraBackwardTransferAmount, destination, 'Unlimited');615      balanceKaruraTokenFinal = await helper.balance.getSubstrate(randomAccount.address);616      balanceQuartzForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);617618      const karFees = balanceKaruraTokenMiddle - balanceKaruraTokenFinal;619      const qtzOutcomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenFinal;620621      console.log(622        '[Karura -> Quartz] transaction fees on Karura: %s KAR',623        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),624      );625      console.log('[Karura -> Quartz] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));626627      expect(karFees > 0, 'Negative fees KAR, looks like nothing was transferred').to.be.true;628      expect(qtzOutcomeTransfer == karuraBackwardTransferAmount).to.be.true;629    });630631    await helper.wait.newBlocks(3);632633    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccount.address);634    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;635    expect(actuallyDelivered > 0).to.be.true;636637    console.log('[Karura -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));638639    const qtzFees = karuraBackwardTransferAmount - actuallyDelivered;640    console.log('[Karura -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));641    expect(qtzFees == 0n).to.be.true;642  });643644  itSub('Karura can send only up to its balance', async ({helper}) => {645    // set Karura's sovereign account's balance646    const karuraBalance = 10000n * (10n ** QTZ_DECIMALS);647    const karuraSovereignAccount = helper.address.paraSiblingSovereignAccount(KARURA_CHAIN);648    await helper.getSudo().balance.setBalanceSubstrate(alice, karuraSovereignAccount, karuraBalance);649650    const moreThanKaruraHas = karuraBalance * 2n;651652    let targetAccountBalance = 0n;653    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);654655    const quartzMultilocation = {656      V2: {657        parents: 1,658        interior: {659          X1: {Parachain: QUARTZ_CHAIN},660        },661      },662    };663664    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(665      targetAccount.addressRaw,666      {667        Concrete: {668          parents: 0,669          interior: 'Here',670        },671      },672      moreThanKaruraHas,673    );674675    let maliciousXcmProgramSent: any;676    const maxWaitBlocks = 5;677678    // Try to trick Quartz679    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {680      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);681682      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);683    });684685    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash686        && event.outcome.isFailedToTransactAsset);687688    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);689    expect(targetAccountBalance).to.be.equal(0n);690691    // But Karura still can send the correct amount692    const validTransferAmount = karuraBalance / 2n;693    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(694      targetAccount.addressRaw,695      {696        Concrete: {697          parents: 0,698          interior: 'Here',699        },700      },701      validTransferAmount,702    );703704    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {705      await helper.getSudo().xcm.send(alice, quartzMultilocation, validXcmProgram);706    });707708    await helper.wait.newBlocks(maxWaitBlocks);709710    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);711    expect(targetAccountBalance).to.be.equal(validTransferAmount);712  });713714  itSub('Should not accept reserve transfer of QTZ from Karura', async ({helper}) => {715    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);716    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);717718    const quartzMultilocation = {719      V2: {720        parents: 1,721        interior: {722          X1: {723            Parachain: QUARTZ_CHAIN,724          },725        },726      },727    };728729    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(730      targetAccount.addressRaw,731      {732        Concrete: {733          parents: 1,734          interior: {735            X1: {736              Parachain: QUARTZ_CHAIN,737            },738          },739        },740      },741      testAmount,742    );743744    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(745      targetAccount.addressRaw,746      {747        Concrete: {748          parents: 0,749          interior: 'Here',750        },751      },752      testAmount,753    );754755    let maliciousXcmProgramFullIdSent: any;756    let maliciousXcmProgramHereIdSent: any;757    const maxWaitBlocks = 3;758759    // Try to trick Quartz using full QTZ identification760    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {761      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);762763      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);764    });765766    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash767        && event.outcome.isUntrustedReserveLocation);768769    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);770    expect(accountBalance).to.be.equal(0n);771772    // Try to trick Quartz using shortened QTZ identification773    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {774      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);775776      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);777    });778779    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash780        && event.outcome.isUntrustedReserveLocation);781782    accountBalance = await helper.balance.getSubstrate(targetAccount.address);783    expect(accountBalance).to.be.equal(0n);784  });785786  itSub.skip('Transfer NFT from Quartz to Karura', async ({helper}) => {787    const collection = await helper.nft.mintCollection(alice, {788      tokenPrefix: 'xNFT',789    });790791    const collectionId = collection.collectionId;792793    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {794      const uniqueCollectionLocation = {795        parents: 1,796        interior: {797          X2: [798            {799              Parachain: QUARTZ_CHAIN,800            },801            {802              GeneralIndex: collectionId,803            },804          ],805        },806      };807808      await helper.executeExtrinsic(809        alice,810        'api.tx.xnft.registerAsset',811        [{812          Concrete: uniqueCollectionLocation,813        }],814      );815    });816817    const token = await collection.mintToken(alice, {Substrate: alice.address});818    const tokenId = token.tokenId;819820    const destination = {821      V3: {822        parents: 1,823        interior: {824          X1: {825            Parachain: KARURA_CHAIN,826          },827        },828      },829    };830831    const beneficiary = {832      V3: {833        parents: 0,834        interior: {835          X1: {836            AccountId32: {837              network: null,838              id: randomAccount.addressRaw,839            },840          },841        },842      },843    };844845    const buyExecutionFee = 10n * 10n ** QTZ_DECIMALS;846847    const assets = {848      V3: [849        {850          id: {851            Concrete: {852              parents: 0,853              interior: 'Here',854            },855          },856          fun: {857            Fungible: buyExecutionFee,858          },859        },860        {861          id: {862            Concrete: {863              parents: 1,864              interior: {865                X2: [866                  {867                    Parachain: QUARTZ_CHAIN,868                  },869                  {870                    GeneralIndex: collectionId,871                  },872                ],873              },874            },875          },876          fun: {877            NonFungible: {878              Index: tokenId,879            },880          },881        },882      ],883    };884885    const feeAssetItem = 0;886887    await helper.xcm.limitedReserveTransferAssets(888      alice,889      destination,890      beneficiary,891      assets,892      feeAssetItem,893      'Unlimited',894    );895896    const maxWaitBlocks = 3;897    const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);898899    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {900      const xcmpSuccess = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success);901      expect(xcmpSuccess.messageHash).to.be.equal(messageSent.messageHash);902    });903  });904});905906// These tests are relevant only when907// the the corresponding foreign assets are not registered908describeXCM('[XCM] Integration test: Quartz rejects non-native tokens', () => {909  let alice: IKeyringPair;910  let alith: IKeyringPair;911912  const testAmount = 100_000_000_000n;913  let quartzParachainJunction;914  let quartzAccountJunction;915916  let quartzParachainMultilocation: any;917  let quartzAccountMultilocation: any;918  let quartzCombinedMultilocation: any;919920  let messageSent: any;921922  const maxWaitBlocks = 3;923924  before(async () => {925    await usingPlaygrounds(async (helper, privateKey) => {926      alice = await privateKey('//Alice');927928      quartzParachainJunction = {Parachain: QUARTZ_CHAIN};929      quartzAccountJunction = {930        AccountId32: {931          network: 'Any',932          id: alice.addressRaw,933        },934      };935936      quartzParachainMultilocation = {937        V2: {938          parents: 1,939          interior: {940            X1: quartzParachainJunction,941          },942        },943      };944945      quartzAccountMultilocation = {946        V2: {947          parents: 0,948          interior: {949            X1: quartzAccountJunction,950          },951        },952      };953954      quartzCombinedMultilocation = {955        V2: {956          parents: 1,957          interior: {958            X2: [quartzParachainJunction, quartzAccountJunction],959          },960        },961      };962963      // Set the default version to wrap the first message to other chains.964      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);965    });966967    // eslint-disable-next-line require-await968    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {969      alith = helper.account.alithAccount();970    });971  });972973  const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {974    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash975        && event.outcome.isFailedToTransactAsset);976  };977978  itSub('Quartz rejects KAR tokens from Karura', async ({helper}) => {979    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {980      const id = {981        Token: 'KAR',982      };983      const destination = quartzCombinedMultilocation;984      await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');985986      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);987    });988989    await expectFailedToTransact(helper, messageSent);990  });991992  itSub('Quartz rejects MOVR tokens from Moonriver', async ({helper}) => {993    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {994      const id = 'SelfReserve';995      const destination = quartzCombinedMultilocation;996      await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');997998      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);999    });10001001    await expectFailedToTransact(helper, messageSent);1002  });10031004  itSub('Quartz rejects SDN tokens from Shiden', async ({helper}) => {1005    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1006      const destinationParachain = quartzParachainMultilocation;1007      const beneficiary = quartzAccountMultilocation;1008      const assets = {1009        V2: [{1010          id: {1011            Concrete: {1012              parents: 0,1013              interior: 'Here',1014            },1015          },1016          fun: {1017            Fungible: testAmount,1018          },1019        }],1020      };1021      const feeAssetItem = 0;10221023      await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1024        destinationParachain,1025        beneficiary,1026        assets,1027        feeAssetItem,1028      ]);10291030      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1031    });10321033    await expectFailedToTransact(helper, messageSent);1034  });1035});10361037describeXCM('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {1038  // Quartz constants1039  let alice: IKeyringPair;1040  let quartzAssetLocation;10411042  let randomAccountQuartz: IKeyringPair;1043  let randomAccountMoonriver: IKeyringPair;10441045  // Moonriver constants1046  let assetId: string;10471048  const quartzAssetMetadata = {1049    name: 'xcQuartz',1050    symbol: 'xcQTZ',1051    decimals: 18,1052    isFrozen: false,1053    minimalBalance: 1n,1054  };10551056  let balanceQuartzTokenInit: bigint;1057  let balanceQuartzTokenMiddle: bigint;1058  let balanceQuartzTokenFinal: bigint;1059  let balanceForeignQtzTokenInit: bigint;1060  let balanceForeignQtzTokenMiddle: bigint;1061  let balanceForeignQtzTokenFinal: bigint;1062  let balanceMovrTokenInit: bigint;1063  let balanceMovrTokenMiddle: bigint;1064  let balanceMovrTokenFinal: bigint;10651066  before(async () => {1067    await usingPlaygrounds(async (helper, privateKey) => {1068      alice = await privateKey('//Alice');1069      [randomAccountQuartz] = await helper.arrange.createAccounts([0n], alice);10701071      balanceForeignQtzTokenInit = 0n;10721073      // Set the default version to wrap the first message to other chains.1074      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1075    });10761077    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1078      const alithAccount = helper.account.alithAccount();1079      const baltatharAccount = helper.account.baltatharAccount();1080      const dorothyAccount = helper.account.dorothyAccount();10811082      randomAccountMoonriver = helper.account.create();10831084      // >>> Sponsoring Dorothy >>>1085      console.log('Sponsoring Dorothy.......');1086      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1087      console.log('Sponsoring Dorothy.......DONE');1088      // <<< Sponsoring Dorothy <<<10891090      quartzAssetLocation = {1091        XCM: {1092          parents: 1,1093          interior: {X1: {Parachain: QUARTZ_CHAIN}},1094        },1095      };1096      const existentialDeposit = 1n;1097      const isSufficient = true;1098      const unitsPerSecond = 1n;1099      const numAssetsWeightHint = 0;11001101      if((await helper.assetManager.assetTypeId(quartzAssetLocation)).toJSON()) {1102        console.log('Quartz asset already registered on Moonriver');1103      } else {1104        const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1105          location: quartzAssetLocation,1106          metadata: quartzAssetMetadata,1107          existentialDeposit,1108          isSufficient,1109          unitsPerSecond,1110          numAssetsWeightHint,1111        });11121113        console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);11141115        await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);1116      }1117      // >>> Acquire Quartz AssetId Info on Moonriver >>>1118      console.log('Acquire Quartz AssetId Info on Moonriver.......');11191120      assetId = (await helper.assetManager.assetTypeId(quartzAssetLocation)).toString();11211122      console.log('QTZ asset ID is %s', assetId);1123      console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');1124      // >>> Acquire Quartz AssetId Info on Moonriver >>>11251126      // >>> Sponsoring random Account >>>1127      console.log('Sponsoring random Account.......');1128      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonriver.address, 11_000_000_000_000_000_000n);1129      console.log('Sponsoring random Account.......DONE');1130      // <<< Sponsoring random Account <<<11311132      balanceMovrTokenInit = await helper.balance.getEthereum(randomAccountMoonriver.address);1133    });11341135    await usingPlaygrounds(async (helper) => {1136      await helper.balance.transferToSubstrate(alice, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);1137      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccountQuartz.address);1138    });1139  });11401141  itSub('Should connect and send QTZ to Moonriver', async ({helper}) => {1142    const currencyId = 0;1143    const dest = {1144      V2: {1145        parents: 1,1146        interior: {1147          X2: [1148            {Parachain: MOONRIVER_CHAIN},1149            {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},1150          ],1151        },1152      },1153    };1154    const amount = TRANSFER_AMOUNT;11551156    await helper.xTokens.transfer(randomAccountQuartz, currencyId, amount, dest, 'Unlimited');11571158    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccountQuartz.address);1159    expect(balanceQuartzTokenMiddle < balanceQuartzTokenInit).to.be.true;11601161    const transactionFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;1162    console.log('[Quartz -> Moonriver] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(transactionFees));1163    expect(transactionFees > 0, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;11641165    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1166      await helper.wait.newBlocks(3);11671168      balanceMovrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonriver.address);11691170      const movrFees = balanceMovrTokenInit - balanceMovrTokenMiddle;1171      console.log('[Quartz -> Moonriver] transaction fees on Moonriver: %s MOVR',helper.util.bigIntToDecimals(movrFees));1172      expect(movrFees == 0n).to.be.true;11731174      balanceForeignQtzTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonriver.address))!; // BigInt(qtzRandomAccountAsset['balance']);1175      const qtzIncomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenInit;1176      console.log('[Quartz -> Moonriver] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));1177      expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1178    });1179  });11801181  itSub('Should connect to Moonriver and send QTZ back', async ({helper}) => {1182    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1183      const asset = {1184        V2: {1185          id: {1186            Concrete: {1187              parents: 1,1188              interior: {1189                X1: {Parachain: QUARTZ_CHAIN},1190              },1191            },1192          },1193          fun: {1194            Fungible: TRANSFER_AMOUNT,1195          },1196        },1197      };1198      const destination = {1199        V2: {1200          parents: 1,1201          interior: {1202            X2: [1203              {Parachain: QUARTZ_CHAIN},1204              {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},1205            ],1206          },1207        },1208      };12091210      await helper.xTokens.transferMultiasset(randomAccountMoonriver, asset, destination, 'Unlimited');12111212      balanceMovrTokenFinal = await helper.balance.getEthereum(randomAccountMoonriver.address);12131214      const movrFees = balanceMovrTokenMiddle - balanceMovrTokenFinal;1215      console.log('[Moonriver -> Quartz] transaction fees on Moonriver: %s MOVR', helper.util.bigIntToDecimals(movrFees));1216      expect(movrFees > 0, 'Negative fees MOVR, looks like nothing was transferred').to.be.true;12171218      const qtzRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonriver.address);12191220      expect(qtzRandomAccountAsset).to.be.null;12211222      balanceForeignQtzTokenFinal = 0n;12231224      const qtzOutcomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenFinal;1225      console.log('[Quartz -> Moonriver] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));1226      expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1227    });12281229    await helper.wait.newBlocks(3);12301231    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccountQuartz.address);1232    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;1233    expect(actuallyDelivered > 0).to.be.true;12341235    console.log('[Moonriver -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));12361237    const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;1238    console.log('[Moonriver -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));1239    expect(qtzFees == 0n).to.be.true;1240  });12411242  itSub('Moonriver can send only up to its balance', async ({helper}) => {1243    // set Moonriver's sovereign account's balance1244    const moonriverBalance = 10000n * (10n ** QTZ_DECIMALS);1245    const moonriverSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONRIVER_CHAIN);1246    await helper.getSudo().balance.setBalanceSubstrate(alice, moonriverSovereignAccount, moonriverBalance);12471248    const moreThanMoonriverHas = moonriverBalance * 2n;12491250    let targetAccountBalance = 0n;1251    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);12521253    const quartzMultilocation = {1254      V2: {1255        parents: 1,1256        interior: {1257          X1: {Parachain: QUARTZ_CHAIN},1258        },1259      },1260    };12611262    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1263      targetAccount.addressRaw,1264      {1265        Concrete: {1266          parents: 0,1267          interior: 'Here',1268        },1269      },1270      moreThanMoonriverHas,1271    );12721273    let maliciousXcmProgramSent: any;1274    const maxWaitBlocks = 3;12751276    // Try to trick Quartz1277    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1278      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgram]);12791280      // Needed to bypass the call filter.1281      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1282      await helper.fastDemocracy.executeProposal('try to spend more QTZ than Moonriver has', batchCall);12831284      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1285    });12861287    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1288        && event.outcome.isFailedToTransactAsset);12891290    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1291    expect(targetAccountBalance).to.be.equal(0n);12921293    // But Moonriver still can send the correct amount1294    const validTransferAmount = moonriverBalance / 2n;1295    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1296      targetAccount.addressRaw,1297      {1298        Concrete: {1299          parents: 0,1300          interior: 'Here',1301        },1302      },1303      validTransferAmount,1304    );13051306    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1307      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, validXcmProgram]);13081309      // Needed to bypass the call filter.1310      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1311      await helper.fastDemocracy.executeProposal('Spend the correct amount of QTZ', batchCall);1312    });13131314    await helper.wait.newBlocks(maxWaitBlocks);13151316    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1317    expect(targetAccountBalance).to.be.equal(validTransferAmount);1318  });13191320  itSub('Should not accept reserve transfer of QTZ from Moonriver', async ({helper}) => {1321    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);1322    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);13231324    const quartzMultilocation = {1325      V2: {1326        parents: 1,1327        interior: {1328          X1: {1329            Parachain: QUARTZ_CHAIN,1330          },1331        },1332      },1333    };13341335    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1336      targetAccount.addressRaw,1337      {1338        Concrete: {1339          parents: 0,1340          interior: {1341            X1: {1342              Parachain: QUARTZ_CHAIN,1343            },1344          },1345        },1346      },1347      testAmount,1348    );13491350    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1351      targetAccount.addressRaw,1352      {1353        Concrete: {1354          parents: 0,1355          interior: 'Here',1356        },1357      },1358      testAmount,1359    );13601361    let maliciousXcmProgramFullIdSent: any;1362    let maliciousXcmProgramHereIdSent: any;1363    const maxWaitBlocks = 3;13641365    // Try to trick Quartz using full QTZ identification1366    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1367      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramFullId]);13681369      // Needed to bypass the call filter.1370      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1371      await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using path asset identification', batchCall);13721373      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1374    });13751376    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1377        && event.outcome.isUntrustedReserveLocation);13781379    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1380    expect(accountBalance).to.be.equal(0n);13811382    // Try to trick Quartz using shortened QTZ identification1383    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1384      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramHereId]);13851386      // Needed to bypass the call filter.1387      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1388      await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using "here" asset identification', batchCall);13891390      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1391    });13921393    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1394        && event.outcome.isUntrustedReserveLocation);13951396    accountBalance = await helper.balance.getSubstrate(targetAccount.address);1397    expect(accountBalance).to.be.equal(0n);1398  });1399});14001401describeXCM('[XCM] Integration test: Exchanging tokens with Shiden', () => {1402  let alice: IKeyringPair;1403  let sender: IKeyringPair;14041405  const QTZ_ASSET_ID_ON_SHIDEN = 18_446_744_073_709_551_633n; // The value is taken from the live Shiden1406  const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n; // The value is taken from the live Shiden14071408  // Quartz -> Shiden1409  const shidenInitialBalance = 1n * (10n ** SHIDEN_DECIMALS); // 1 SHD, existential deposit required to actually create the account on Shiden1410  const unitsPerSecond = 500_451_000_000_000_000_000n; // The value is taken from the live Shiden1411  const qtzToShidenTransferred = 10n * (10n ** QTZ_DECIMALS); // 10 QTZ1412  const qtzToShidenArrived = 7_998_196_000_000_000_000n; // 7.99 ... QTZ, Shiden takes a commision in foreign tokens14131414  // Shiden -> Quartz1415  const qtzFromShidenTransfered = 5n * (10n ** QTZ_DECIMALS); // 5 QTZ1416  const qtzOnShidenLeft = qtzToShidenArrived - qtzFromShidenTransfered; // 2.99 ... QTZ14171418  let balanceAfterQuartzToShidenXCM: bigint;14191420  before(async () => {1421    await usingPlaygrounds(async (helper, privateKey) => {1422      alice = await privateKey('//Alice');1423      [sender] = await helper.arrange.createAccounts([100n], alice);1424      console.log('sender', sender.address);14251426      // Set the default version to wrap the first message to other chains.1427      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1428    });14291430    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1431      if(!(await helper.callRpc('api.query.assets.asset', [QTZ_ASSET_ID_ON_SHIDEN])).toJSON()) {1432        console.log('1. Create foreign asset and metadata');1433        await helper.getSudo().assets.forceCreate(1434          alice,1435          QTZ_ASSET_ID_ON_SHIDEN,1436          alice.address,1437          QTZ_MINIMAL_BALANCE_ON_SHIDEN,1438        );14391440        await helper.assets.setMetadata(1441          alice,1442          QTZ_ASSET_ID_ON_SHIDEN,1443          'Quartz',1444          'QTZ',1445          Number(QTZ_DECIMALS),1446        );14471448        console.log('2. Register asset location on Shiden');1449        const assetLocation = {1450          V2: {1451            parents: 1,1452            interior: {1453              X1: {1454                Parachain: QUARTZ_CHAIN,1455              },1456            },1457          },1458        };14591460        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);14611462        console.log('3. Set QTZ payment for XCM execution on Shiden');1463        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1464      } else {1465        console.log('QTZ is already registered on Shiden');1466      }1467      console.log('4. Transfer 1 SDN to recipient to create the account (needed due to existential balance)');1468      await helper.balance.transferToSubstrate(alice, sender.address, shidenInitialBalance);1469    });1470  });14711472  itSub('Should connect and send QTZ to Shiden', async ({helper}) => {1473    const destination = {1474      V2: {1475        parents: 1,1476        interior: {1477          X1: {1478            Parachain: SHIDEN_CHAIN,1479          },1480        },1481      },1482    };14831484    const beneficiary = {1485      V2: {1486        parents: 0,1487        interior: {1488          X1: {1489            AccountId32: {1490              network: 'Any',1491              id: sender.addressRaw,1492            },1493          },1494        },1495      },1496    };14971498    const assets = {1499      V2: [1500        {1501          id: {1502            Concrete: {1503              parents: 0,1504              interior: 'Here',1505            },1506          },1507          fun: {1508            Fungible: qtzToShidenTransferred,1509          },1510        },1511      ],1512    };15131514    // Initial balance is 100 QTZ1515    const balanceBefore = await helper.balance.getSubstrate(sender.address);1516    console.log(`Initial balance is: ${balanceBefore}`);15171518    const feeAssetItem = 0;1519    await helper.xcm.limitedReserveTransferAssets(sender, destination, beneficiary, assets, feeAssetItem, 'Unlimited');15201521    // Balance after reserve transfer is less than 901522    balanceAfterQuartzToShidenXCM = await helper.balance.getSubstrate(sender.address);1523    console.log(`QTZ Balance on Quartz after XCM is: ${balanceAfterQuartzToShidenXCM}`);1524    console.log(`Quartz's QTZ commission is: ${balanceBefore - balanceAfterQuartzToShidenXCM}`);1525    expect(balanceBefore - balanceAfterQuartzToShidenXCM > 0).to.be.true;15261527    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1528      await helper.wait.newBlocks(3);1529      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1530      const shidenBalance = await helper.balance.getSubstrate(sender.address);15311532      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);1533      console.log(`Shiden's QTZ commission is: ${qtzToShidenTransferred - xcQTZbalance!}`);15341535      expect(xcQTZbalance).to.eq(qtzToShidenArrived);1536      // SHD balance does not changed:1537      expect(shidenBalance).to.eq(shidenInitialBalance);1538    });1539  });15401541  itSub('Should connect to Shiden and send QTZ back', async ({helper}) => {1542    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1543      const destination = {1544        V2: {1545          parents: 1,1546          interior: {1547            X1: {1548              Parachain: QUARTZ_CHAIN,1549            },1550          },1551        },1552      };15531554      const beneficiary = {1555        V2: {1556          parents: 0,1557          interior: {1558            X1: {1559              AccountId32: {1560                network: 'Any',1561                id: sender.addressRaw,1562              },1563            },1564          },1565        },1566      };15671568      const assets = {1569        V2: [1570          {1571            id: {1572              Concrete: {1573                parents: 1,1574                interior: {1575                  X1: {1576                    Parachain: QUARTZ_CHAIN,1577                  },1578                },1579              },1580            },1581            fun: {1582              Fungible: qtzFromShidenTransfered,1583            },1584          },1585        ],1586      };15871588      // Initial balance is 1 SDN1589      const balanceSDNbefore = await helper.balance.getSubstrate(sender.address);1590      console.log(`SDN balance is: ${balanceSDNbefore}, it does not changed`);1591      expect(balanceSDNbefore).to.eq(shidenInitialBalance);15921593      const feeAssetItem = 0;1594      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1595      await helper.executeExtrinsic(sender, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);15961597      // Balance after reserve transfer is less than 1 SDN1598      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1599      const balanceSDN = await helper.balance.getSubstrate(sender.address);1600      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);16011602      // Assert: xcQTZ balance correctly decreased1603      expect(xcQTZbalance).to.eq(qtzOnShidenLeft);1604      // Assert: SDN balance is 0.996...1605      expect(balanceSDN / (10n ** (SHIDEN_DECIMALS - 3n))).to.eq(996n);1606    });16071608    await helper.wait.newBlocks(3);1609    const balanceQTZ = await helper.balance.getSubstrate(sender.address);1610    console.log(`QTZ Balance on Quartz after XCM is: ${balanceQTZ}`);1611    expect(balanceQTZ).to.eq(balanceAfterQuartzToShidenXCM + qtzFromShidenTransfered);1612  });16131614  itSub('Shiden can send only up to its balance', async ({helper}) => {1615    // set Shiden's sovereign account's balance1616    const shidenBalance = 10000n * (10n ** QTZ_DECIMALS);1617    const shidenSovereignAccount = helper.address.paraSiblingSovereignAccount(SHIDEN_CHAIN);1618    await helper.getSudo().balance.setBalanceSubstrate(alice, shidenSovereignAccount, shidenBalance);16191620    const moreThanShidenHas = shidenBalance * 2n;16211622    let targetAccountBalance = 0n;1623    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);16241625    const quartzMultilocation = {1626      V2: {1627        parents: 1,1628        interior: {1629          X1: {Parachain: QUARTZ_CHAIN},1630        },1631      },1632    };16331634    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1635      targetAccount.addressRaw,1636      {1637        Concrete: {1638          parents: 0,1639          interior: 'Here',1640        },1641      },1642      moreThanShidenHas,1643    );16441645    let maliciousXcmProgramSent: any;1646    const maxWaitBlocks = 3;16471648    // Try to trick Quartz1649    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1650      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);16511652      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1653    });16541655    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1656        && event.outcome.isFailedToTransactAsset);16571658    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1659    expect(targetAccountBalance).to.be.equal(0n);16601661    // But Shiden still can send the correct amount1662    const validTransferAmount = shidenBalance / 2n;1663    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1664      targetAccount.addressRaw,1665      {1666        Concrete: {1667          parents: 0,1668          interior: 'Here',1669        },1670      },1671      validTransferAmount,1672    );16731674    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1675      await helper.getSudo().xcm.send(alice, quartzMultilocation, validXcmProgram);1676    });16771678    await helper.wait.newBlocks(maxWaitBlocks);16791680    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1681    expect(targetAccountBalance).to.be.equal(validTransferAmount);1682  });16831684  itSub('Should not accept reserve transfer of QTZ from Shiden', async ({helper}) => {1685    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);1686    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);16871688    const quartzMultilocation = {1689      V2: {1690        parents: 1,1691        interior: {1692          X1: {1693            Parachain: QUARTZ_CHAIN,1694          },1695        },1696      },1697    };16981699    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1700      targetAccount.addressRaw,1701      {1702        Concrete: {1703          parents: 1,1704          interior: {1705            X1: {1706              Parachain: QUARTZ_CHAIN,1707            },1708          },1709        },1710      },1711      testAmount,1712    );17131714    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1715      targetAccount.addressRaw,1716      {1717        Concrete: {1718          parents: 0,1719          interior: 'Here',1720        },1721      },1722      testAmount,1723    );17241725    let maliciousXcmProgramFullIdSent: any;1726    let maliciousXcmProgramHereIdSent: any;1727    const maxWaitBlocks = 3;17281729    // Try to trick Quartz using full QTZ identification1730    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1731      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);17321733      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1734    });17351736    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1737        && event.outcome.isUntrustedReserveLocation);17381739    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1740    expect(accountBalance).to.be.equal(0n);17411742    // Try to trick Quartz using shortened QTZ identification1743    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1744      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);17451746      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1747    });17481749    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1750        && event.outcome.isUntrustedReserveLocation);17511752    accountBalance = await helper.balance.getSubstrate(targetAccount.address);1753    expect(accountBalance).to.be.equal(0n);1754  });1755});