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

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 {IKeyringPair} from '@polkadot/types/types';18import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util';19import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';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';21import {hexToString} from '@polkadot/util';22232425const STATEMINE_PALLET_INSTANCE = 50;2627const TRANSFER_AMOUNT = 2000000000000000000000000n;2829const FUNDING_AMOUNT = 3_500_000_0000_000_000n;3031const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;3233const USDT_ASSET_ID = 100;34const USDT_ASSET_METADATA_DECIMALS = 18;35const USDT_ASSET_METADATA_NAME = 'USDT';36const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';37const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;38const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;3940const SAFE_XCM_VERSION = 2;4142describeXCM('[XCM] Integration test: Exchanging USDT with Statemine', () => {43  let alice: IKeyringPair;44  let bob: IKeyringPair;4546  let balanceStmnBefore: bigint;47  let balanceStmnAfter: bigint;4849  let balanceQuartzBefore: bigint;50  let balanceQuartzAfter: bigint;51  let balanceQuartzFinal: bigint;5253  let balanceBobBefore: bigint;54  let balanceBobAfter: bigint;55  let balanceBobFinal: bigint;5657  let balanceBobRelayTokenBefore: bigint;58  let balanceBobRelayTokenAfter: bigint;596061  before(async () => {62    await usingPlaygrounds(async (helper, privateKey) => {63      alice = await privateKey('//Alice');64      bob = await privateKey('//Bob'); // sovereign account on Statemine(t) funds donor6566      // Set the default version to wrap the first message to other chains.67      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);68    });6970    await usingRelayPlaygrounds(relayUrl, async (helper) => {71      // Fund accounts on Statemine(t)72      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, alice.addressRaw, FUNDING_AMOUNT);73      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, bob.addressRaw, FUNDING_AMOUNT);74    });7576    await usingStateminePlaygrounds(statemineUrl, async (helper) => {77      const sovereignFundingAmount = 3_500_000_000n;7879      await helper.assets.create(80        alice,81        USDT_ASSET_ID,82        alice.address,83        USDT_ASSET_METADATA_MINIMAL_BALANCE,84      );85      await helper.assets.setMetadata(86        alice,87        USDT_ASSET_ID,88        USDT_ASSET_METADATA_NAME,89        USDT_ASSET_METADATA_DESCRIPTION,90        USDT_ASSET_METADATA_DECIMALS,91      );92      await helper.assets.mint(93        alice,94        USDT_ASSET_ID,95        alice.address,96        USDT_ASSET_AMOUNT,97      );9899      // funding parachain sovereing account on Statemine(t).100      // The sovereign account should be created before any action101      // (the assets pallet on Statemine(t) check if the sovereign account exists)102      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(QUARTZ_CHAIN);103      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);104    });105106107    await usingPlaygrounds(async (helper) => {108      const location = {109        V2: {110          parents: 1,111          interior: {X3: [112            {113              Parachain: STATEMINE_CHAIN,114            },115            {116              PalletInstance: STATEMINE_PALLET_INSTANCE,117            },118            {119              GeneralIndex: USDT_ASSET_ID,120            },121          ]},122        },123      };124125      const metadata =126      {127        name: USDT_ASSET_ID,128        symbol: USDT_ASSET_METADATA_NAME,129        decimals: USDT_ASSET_METADATA_DECIMALS,130        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,131      };132      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);133      balanceQuartzBefore = await helper.balance.getSubstrate(alice.address);134    });135136137    // Providing the relay currency to the quartz sender account138    // (fee for USDT XCM are paid in relay tokens)139    await usingRelayPlaygrounds(relayUrl, async (helper) => {140      const destination = {141        V2: {142          parents: 0,143          interior: {X1: {144            Parachain: QUARTZ_CHAIN,145          },146          },147        }};148149      const beneficiary = {150        V2: {151          parents: 0,152          interior: {X1: {153            AccountId32: {154              network: 'Any',155              id: alice.addressRaw,156            },157          }},158        },159      };160161      const assets = {162        V2: [163          {164            id: {165              Concrete: {166                parents: 0,167                interior: 'Here',168              },169            },170            fun: {171              Fungible: TRANSFER_AMOUNT_RELAY,172            },173          },174        ],175      };176177      const feeAssetItem = 0;178179      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');180    });181182  });183184  itSub('Should connect and send USDT from Statemine to Quartz', async ({helper}) => {185    await usingStateminePlaygrounds(statemineUrl, async (helper) => {186      const dest = {187        V2: {188          parents: 1,189          interior: {X1: {190            Parachain: QUARTZ_CHAIN,191          },192          },193        }};194195      const beneficiary = {196        V2: {197          parents: 0,198          interior: {X1: {199            AccountId32: {200              network: 'Any',201              id: alice.addressRaw,202            },203          }},204        },205      };206207      const assets = {208        V2: [209          {210            id: {211              Concrete: {212                parents: 0,213                interior: {214                  X2: [215                    {216                      PalletInstance: STATEMINE_PALLET_INSTANCE,217                    },218                    {219                      GeneralIndex: USDT_ASSET_ID,220                    },221                  ]},222              },223            },224            fun: {225              Fungible: TRANSFER_AMOUNT,226            },227          },228        ],229      };230231      const feeAssetItem = 0;232233      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);234      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');235236      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);237238      // common good parachain take commission in it native token239      console.log(240        '[Statemine -> Quartz] transaction fees on Statemine: %s WND',241        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINE_DECIMALS),242      );243      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;244245    });246247248    // ensure that asset has been delivered249    await helper.wait.newBlocks(3);250251    // expext collection id will be with id 1252    const free = await helper.ft.getBalance(1, {Substrate: alice.address});253254    balanceQuartzAfter = await helper.balance.getSubstrate(alice.address);255256    console.log(257      '[Statemine -> Quartz] transaction fees on Quartz: %s USDT',258      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),259    );260    console.log(261      '[Statemine -> Quartz] transaction fees on Quartz: %s QTZ',262      helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzBefore),263    );264    // commission has not paid in USDT token265    expect(free).to.be.equal(TRANSFER_AMOUNT);266    // ... and parachain native token267    expect(balanceQuartzAfter == balanceQuartzBefore).to.be.true;268  });269270  itSub('Should connect and send USDT from Quartz to Statemine back', async ({helper}) => {271    const destination = {272      V2: {273        parents: 1,274        interior: {X2: [275          {276            Parachain: STATEMINE_CHAIN,277          },278          {279            AccountId32: {280              network: 'Any',281              id: alice.addressRaw,282            },283          },284        ]},285      },286    };287288    const relayFee = 400_000_000_000_000n;289    const currencies: [any, bigint][] = [290      [291        {292          ForeignAssetId: 0,293        },294        TRANSFER_AMOUNT,295      ],296      [297        {298          NativeAssetId: 'Parent',299        },300        relayFee,301      ],302    ];303304    const feeItem = 1;305306    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');307308    // the commission has been paid in parachain native token309    balanceQuartzFinal = await helper.balance.getSubstrate(alice.address);310    console.log('[Quartz -> Statemine] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzFinal));311    expect(balanceQuartzAfter > balanceQuartzFinal).to.be.true;312313    await usingStateminePlaygrounds(statemineUrl, async (helper) => {314      await helper.wait.newBlocks(3);315316      // The USDT token never paid fees. Its amount not changed from begin value.317      // Also check that xcm transfer has been succeeded318      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;319    });320  });321322  itSub('Should connect and send Relay token to Quartz', async ({helper}) => {323    balanceBobBefore = await helper.balance.getSubstrate(bob.address);324    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});325326    await usingRelayPlaygrounds(relayUrl, async (helper) => {327      const destination = {328        V2: {329          parents: 0,330          interior: {X1: {331            Parachain: QUARTZ_CHAIN,332          },333          },334        }};335336      const beneficiary = {337        V2: {338          parents: 0,339          interior: {X1: {340            AccountId32: {341              network: 'Any',342              id: bob.addressRaw,343            },344          }},345        },346      };347348      const assets = {349        V2: [350          {351            id: {352              Concrete: {353                parents: 0,354                interior: 'Here',355              },356            },357            fun: {358              Fungible: TRANSFER_AMOUNT_RELAY,359            },360          },361        ],362      };363364      const feeAssetItem = 0;365366      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');367    });368369    await helper.wait.newBlocks(3);370371    balanceBobAfter = await helper.balance.getSubstrate(bob.address);372    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});373374    const wndFeeOnQuartz = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;375    const wndDiffOnQuartz = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;376    console.log(377      '[Relay (Westend) -> Quartz] transaction fees: %s QTZ',378      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),379    );380    console.log(381      '[Relay (Westend) -> Quartz] transaction fees: %s WND',382      helper.util.bigIntToDecimals(wndFeeOnQuartz, STATEMINE_DECIMALS),383    );384    console.log('[Relay (Westend) -> Quartz] actually delivered: %s WND', wndDiffOnQuartz);385    expect(wndFeeOnQuartz == 0n, 'No incoming WND fees should be taken').to.be.true;386    expect(balanceBobBefore == balanceBobAfter, 'No incoming QTZ fees should be taken').to.be.true;387  });388389  itSub('Should connect and send Relay token back', async ({helper}) => {390    let relayTokenBalanceBefore: bigint;391    let relayTokenBalanceAfter: bigint;392    await usingRelayPlaygrounds(relayUrl, async (helper) => {393      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);394    });395396    const destination = {397      V2: {398        parents: 1,399        interior: {400          X1:{401            AccountId32: {402              network: 'Any',403              id: bob.addressRaw,404            },405          },406        },407      },408    };409410    const currencies: any = [411      [412        {413          NativeAssetId: 'Parent',414        },415        TRANSFER_AMOUNT_RELAY,416      ],417    ];418419    const feeItem = 0;420421    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');422423    balanceBobFinal = await helper.balance.getSubstrate(bob.address);424    console.log('[Quartz -> Relay (Westend)] transaction fees: %s QTZ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));425426    await usingRelayPlaygrounds(relayUrl, async (helper) => {427      await helper.wait.newBlocks(10);428      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);429430      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;431      console.log('[Quartz -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));432      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;433    });434  });435});436437describeXCM('[XCM] Integration test: Exchanging tokens with Karura', () => {438  let alice: IKeyringPair;439  let randomAccount: IKeyringPair;440441  let balanceQuartzTokenInit: bigint;442  let balanceQuartzTokenMiddle: bigint;443  let balanceQuartzTokenFinal: bigint;444  let balanceKaruraTokenInit: bigint;445  let balanceKaruraTokenMiddle: bigint;446  let balanceKaruraTokenFinal: bigint;447  let balanceQuartzForeignTokenInit: bigint;448  let balanceQuartzForeignTokenMiddle: bigint;449  let balanceQuartzForeignTokenFinal: bigint;450451  // computed by a test transfer from prod Quartz to prod Karura.452  // 2 QTZ sent https://quartz.subscan.io/xcm_message/kusama-f60d821b049f8835a3005ce7102285006f5b61e9453  // 1.919176000000000000 QTZ received (you can check Karura's chain state in the corresponding block)454  const expectedKaruraIncomeFee = 2000000000000000000n - 1919176000000000000n;455  const karuraEps = 8n * 10n ** 16n;456457  let karuraBackwardTransferAmount: bigint;458459  before(async () => {460    await usingPlaygrounds(async (helper, privateKey) => {461      alice = await privateKey('//Alice');462      [randomAccount] = await helper.arrange.createAccounts([0n], alice);463464      // Set the default version to wrap the first message to other chains.465      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);466    });467468    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {469      const destination = {470        V2: {471          parents: 1,472          interior: {473            X1: {474              Parachain: QUARTZ_CHAIN,475            },476          },477        },478      };479480      const metadata = {481        name: 'Quartz',482        symbol: 'QTZ',483        decimals: 18,484        minimalBalance: 1000000000000000000n,485      };486487      const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v]: [any, any]) =>488        hexToString(v.toJSON()['symbol'])) as string[];489490      if(!assets.includes('QTZ')) {491        await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);492      } else {493        console.log('QTZ token already registered on Karura assetRegistry pallet');494      }495      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);496      balanceKaruraTokenInit = await helper.balance.getSubstrate(randomAccount.address);497      balanceQuartzForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});498    });499500    await usingPlaygrounds(async (helper) => {501      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);502      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccount.address);503    });504  });505506  itSub('Should connect and send QTZ to Karura', async ({helper}) => {507    const destination = {508      V2: {509        parents: 1,510        interior: {511          X1: {512            Parachain: KARURA_CHAIN,513          },514        },515      },516    };517518    const beneficiary = {519      V2: {520        parents: 0,521        interior: {522          X1: {523            AccountId32: {524              network: 'Any',525              id: randomAccount.addressRaw,526            },527          },528        },529      },530    };531532    const assets = {533      V2: [534        {535          id: {536            Concrete: {537              parents: 0,538              interior: 'Here',539            },540          },541          fun: {542            Fungible: TRANSFER_AMOUNT,543          },544        },545      ],546    };547548    const feeAssetItem = 0;549550    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');551    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);552553    const qtzFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;554    expect(qtzFees > 0n, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;555    console.log('[Quartz -> Karura] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));556557    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {558      await helper.wait.newBlocks(3);559560      balanceQuartzForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});561      balanceKaruraTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);562563      const karFees = balanceKaruraTokenInit - balanceKaruraTokenMiddle;564      const qtzIncomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenInit;565      karuraBackwardTransferAmount = qtzIncomeTransfer;566567      const karUnqFees = TRANSFER_AMOUNT - qtzIncomeTransfer;568569      console.log(570        '[Quartz -> Karura] transaction fees on Karura: %s KAR',571        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),572      );573      console.log(574        '[Quartz -> Karura] transaction fees on Karura: %s QTZ',575        helper.util.bigIntToDecimals(karUnqFees),576      );577      console.log('[Quartz -> Karura] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));578      expect(karFees == 0n).to.be.true;579580      const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;581582      expect(583        bigintAbs(karUnqFees - expectedKaruraIncomeFee) < karuraEps,584        'Karura took different income fee, check the Karura foreign asset config',585      ).to.be.true;586    });587  });588589  itSub('Should connect to Karura and send QTZ back', async ({helper}) => {590    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {591      const destination = {592        V2: {593          parents: 1,594          interior: {595            X2: [596              {Parachain: QUARTZ_CHAIN},597              {598                AccountId32: {599                  network: 'Any',600                  id: randomAccount.addressRaw,601                },602              },603            ],604          },605        },606      };607608      const id = {609        ForeignAsset: 0,610      };611612      await helper.xTokens.transfer(randomAccount, id, karuraBackwardTransferAmount, destination, 'Unlimited');613      balanceKaruraTokenFinal = await helper.balance.getSubstrate(randomAccount.address);614      balanceQuartzForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);615616      const karFees = balanceKaruraTokenMiddle - balanceKaruraTokenFinal;617      const qtzOutcomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenFinal;618619      console.log(620        '[Karura -> Quartz] transaction fees on Karura: %s KAR',621        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),622      );623      console.log('[Karura -> Quartz] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));624625      expect(karFees > 0, 'Negative fees KAR, looks like nothing was transferred').to.be.true;626      expect(qtzOutcomeTransfer == karuraBackwardTransferAmount).to.be.true;627    });628629    await helper.wait.newBlocks(3);630631    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccount.address);632    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;633    expect(actuallyDelivered > 0).to.be.true;634635    console.log('[Karura -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));636637    const qtzFees = karuraBackwardTransferAmount - actuallyDelivered;638    console.log('[Karura -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));639    expect(qtzFees == 0n).to.be.true;640  });641642  itSub('Karura can send only up to its balance', async ({helper}) => {643    // set Karura's sovereign account's balance644    const karuraBalance = 10000n * (10n ** QTZ_DECIMALS);645    const karuraSovereignAccount = helper.address.paraSiblingSovereignAccount(KARURA_CHAIN);646    await helper.getSudo().balance.setBalanceSubstrate(alice, karuraSovereignAccount, karuraBalance);647648    const moreThanKaruraHas = karuraBalance * 2n;649650    let targetAccountBalance = 0n;651    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);652653    const quartzMultilocation = {654      V2: {655        parents: 1,656        interior: {657          X1: {Parachain: QUARTZ_CHAIN},658        },659      },660    };661662    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(663      targetAccount.addressRaw,664      {665        Concrete: {666          parents: 0,667          interior: 'Here',668        },669      },670      moreThanKaruraHas,671    );672673    let maliciousXcmProgramSent: any;674    const maxWaitBlocks = 5;675676    // Try to trick Quartz677    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {678      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);679680      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);681    });682683    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash684        && event.outcome.isFailedToTransactAsset);685686    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);687    expect(targetAccountBalance).to.be.equal(0n);688689    // But Karura still can send the correct amount690    const validTransferAmount = karuraBalance / 2n;691    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(692      targetAccount.addressRaw,693      {694        Concrete: {695          parents: 0,696          interior: 'Here',697        },698      },699      validTransferAmount,700    );701702    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {703      await helper.getSudo().xcm.send(alice, quartzMultilocation, validXcmProgram);704    });705706    await helper.wait.newBlocks(maxWaitBlocks);707708    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);709    expect(targetAccountBalance).to.be.equal(validTransferAmount);710  });711712  itSub('Should not accept reserve transfer of QTZ from Karura', async ({helper}) => {713    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);714    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);715716    const quartzMultilocation = {717      V2: {718        parents: 1,719        interior: {720          X1: {721            Parachain: QUARTZ_CHAIN,722          },723        },724      },725    };726727    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(728      targetAccount.addressRaw,729      {730        Concrete: {731          parents: 1,732          interior: {733            X1: {734              Parachain: QUARTZ_CHAIN,735            },736          },737        },738      },739      testAmount,740    );741742    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(743      targetAccount.addressRaw,744      {745        Concrete: {746          parents: 0,747          interior: 'Here',748        },749      },750      testAmount,751    );752753    let maliciousXcmProgramFullIdSent: any;754    let maliciousXcmProgramHereIdSent: any;755    const maxWaitBlocks = 3;756757    // Try to trick Quartz using full QTZ identification758    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {759      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);760761      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);762    });763764    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash765        && event.outcome.isUntrustedReserveLocation);766767    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);768    expect(accountBalance).to.be.equal(0n);769770    // Try to trick Quartz using shortened QTZ identification771    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {772      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);773774      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);775    });776777    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash778        && event.outcome.isUntrustedReserveLocation);779780    accountBalance = await helper.balance.getSubstrate(targetAccount.address);781    expect(accountBalance).to.be.equal(0n);782  });783});784785// These tests are relevant only when786// the the corresponding foreign assets are not registered787describeXCM('[XCM] Integration test: Quartz rejects non-native tokens', () => {788  let alice: IKeyringPair;789  let alith: IKeyringPair;790791  const testAmount = 100_000_000_000n;792  let quartzParachainJunction;793  let quartzAccountJunction;794795  let quartzParachainMultilocation: any;796  let quartzAccountMultilocation: any;797  let quartzCombinedMultilocation: any;798799  let messageSent: any;800801  const maxWaitBlocks = 3;802803  before(async () => {804    await usingPlaygrounds(async (helper, privateKey) => {805      alice = await privateKey('//Alice');806807      quartzParachainJunction = {Parachain: QUARTZ_CHAIN};808      quartzAccountJunction = {809        AccountId32: {810          network: 'Any',811          id: alice.addressRaw,812        },813      };814815      quartzParachainMultilocation = {816        V2: {817          parents: 1,818          interior: {819            X1: quartzParachainJunction,820          },821        },822      };823824      quartzAccountMultilocation = {825        V2: {826          parents: 0,827          interior: {828            X1: quartzAccountJunction,829          },830        },831      };832833      quartzCombinedMultilocation = {834        V2: {835          parents: 1,836          interior: {837            X2: [quartzParachainJunction, quartzAccountJunction],838          },839        },840      };841842      // Set the default version to wrap the first message to other chains.843      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);844    });845846    // eslint-disable-next-line require-await847    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {848      alith = helper.account.alithAccount();849    });850  });851852  const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {853    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash854        && event.outcome.isFailedToTransactAsset);855  };856857  itSub('Quartz rejects KAR tokens from Karura', async ({helper}) => {858    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {859      const id = {860        Token: 'KAR',861      };862      const destination = quartzCombinedMultilocation;863      await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');864865      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);866    });867868    await expectFailedToTransact(helper, messageSent);869  });870871  itSub('Quartz rejects MOVR tokens from Moonriver', async ({helper}) => {872    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {873      const id = 'SelfReserve';874      const destination = quartzCombinedMultilocation;875      await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');876877      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);878    });879880    await expectFailedToTransact(helper, messageSent);881  });882883  itSub('Quartz rejects SDN tokens from Shiden', async ({helper}) => {884    await usingShidenPlaygrounds(shidenUrl, async (helper) => {885      const destinationParachain = quartzParachainMultilocation;886      const beneficiary = quartzAccountMultilocation;887      const assets = {888        V2: [{889          id: {890            Concrete: {891              parents: 0,892              interior: 'Here',893            },894          },895          fun: {896            Fungible: testAmount,897          },898        }],899      };900      const feeAssetItem = 0;901902      await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [903        destinationParachain,904        beneficiary,905        assets,906        feeAssetItem,907      ]);908909      messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);910    });911912    await expectFailedToTransact(helper, messageSent);913  });914});915916describeXCM('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {917  // Quartz constants918  let alice: IKeyringPair;919  let quartzAssetLocation;920921  let randomAccountQuartz: IKeyringPair;922  let randomAccountMoonriver: IKeyringPair;923924  // Moonriver constants925  let assetId: string;926927  const quartzAssetMetadata = {928    name: 'xcQuartz',929    symbol: 'xcQTZ',930    decimals: 18,931    isFrozen: false,932    minimalBalance: 1n,933  };934935  let balanceQuartzTokenInit: bigint;936  let balanceQuartzTokenMiddle: bigint;937  let balanceQuartzTokenFinal: bigint;938  let balanceForeignQtzTokenInit: bigint;939  let balanceForeignQtzTokenMiddle: bigint;940  let balanceForeignQtzTokenFinal: bigint;941  let balanceMovrTokenInit: bigint;942  let balanceMovrTokenMiddle: bigint;943  let balanceMovrTokenFinal: bigint;944945  before(async () => {946    await usingPlaygrounds(async (helper, privateKey) => {947      alice = await privateKey('//Alice');948      [randomAccountQuartz] = await helper.arrange.createAccounts([0n], alice);949950      balanceForeignQtzTokenInit = 0n;951952      // Set the default version to wrap the first message to other chains.953      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);954    });955956    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {957      const alithAccount = helper.account.alithAccount();958      const baltatharAccount = helper.account.baltatharAccount();959      const dorothyAccount = helper.account.dorothyAccount();960961      randomAccountMoonriver = helper.account.create();962963      // >>> Sponsoring Dorothy >>>964      console.log('Sponsoring Dorothy.......');965      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);966      console.log('Sponsoring Dorothy.......DONE');967      // <<< Sponsoring Dorothy <<<968969      quartzAssetLocation = {970        XCM: {971          parents: 1,972          interior: {X1: {Parachain: QUARTZ_CHAIN}},973        },974      };975      const existentialDeposit = 1n;976      const isSufficient = true;977      const unitsPerSecond = 1n;978      const numAssetsWeightHint = 0;979980      if((await helper.assetManager.assetTypeId(quartzAssetLocation)).toJSON()) {981        console.log('Quartz asset already registered on Moonriver');982      } else {983        const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({984          location: quartzAssetLocation,985          metadata: quartzAssetMetadata,986          existentialDeposit,987          isSufficient,988          unitsPerSecond,989          numAssetsWeightHint,990        });991992        console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);993994        await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);995      }996      // >>> Acquire Quartz AssetId Info on Moonriver >>>997      console.log('Acquire Quartz AssetId Info on Moonriver.......');998999      assetId = (await helper.assetManager.assetTypeId(quartzAssetLocation)).toString();10001001      console.log('QTZ asset ID is %s', assetId);1002      console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');1003      // >>> Acquire Quartz AssetId Info on Moonriver >>>10041005      // >>> Sponsoring random Account >>>1006      console.log('Sponsoring random Account.......');1007      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonriver.address, 11_000_000_000_000_000_000n);1008      console.log('Sponsoring random Account.......DONE');1009      // <<< Sponsoring random Account <<<10101011      balanceMovrTokenInit = await helper.balance.getEthereum(randomAccountMoonriver.address);1012    });10131014    await usingPlaygrounds(async (helper) => {1015      await helper.balance.transferToSubstrate(alice, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);1016      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccountQuartz.address);1017    });1018  });10191020  itSub('Should connect and send QTZ to Moonriver', async ({helper}) => {1021    const currencyId = {1022      NativeAssetId: 'Here',1023    };1024    const dest = {1025      V2: {1026        parents: 1,1027        interior: {1028          X2: [1029            {Parachain: MOONRIVER_CHAIN},1030            {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},1031          ],1032        },1033      },1034    };1035    const amount = TRANSFER_AMOUNT;10361037    await helper.xTokens.transfer(randomAccountQuartz, currencyId, amount, dest, 'Unlimited');10381039    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccountQuartz.address);1040    expect(balanceQuartzTokenMiddle < balanceQuartzTokenInit).to.be.true;10411042    const transactionFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;1043    console.log('[Quartz -> Moonriver] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(transactionFees));1044    expect(transactionFees > 0, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;10451046    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1047      await helper.wait.newBlocks(3);10481049      balanceMovrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonriver.address);10501051      const movrFees = balanceMovrTokenInit - balanceMovrTokenMiddle;1052      console.log('[Quartz -> Moonriver] transaction fees on Moonriver: %s MOVR',helper.util.bigIntToDecimals(movrFees));1053      expect(movrFees == 0n).to.be.true;10541055      balanceForeignQtzTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonriver.address))!; // BigInt(qtzRandomAccountAsset['balance']);1056      const qtzIncomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenInit;1057      console.log('[Quartz -> Moonriver] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));1058      expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1059    });1060  });10611062  itSub('Should connect to Moonriver and send QTZ back', async ({helper}) => {1063    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1064      const asset = {1065        V2: {1066          id: {1067            Concrete: {1068              parents: 1,1069              interior: {1070                X1: {Parachain: QUARTZ_CHAIN},1071              },1072            },1073          },1074          fun: {1075            Fungible: TRANSFER_AMOUNT,1076          },1077        },1078      };1079      const destination = {1080        V2: {1081          parents: 1,1082          interior: {1083            X2: [1084              {Parachain: QUARTZ_CHAIN},1085              {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},1086            ],1087          },1088        },1089      };10901091      await helper.xTokens.transferMultiasset(randomAccountMoonriver, asset, destination, 'Unlimited');10921093      balanceMovrTokenFinal = await helper.balance.getEthereum(randomAccountMoonriver.address);10941095      const movrFees = balanceMovrTokenMiddle - balanceMovrTokenFinal;1096      console.log('[Moonriver -> Quartz] transaction fees on Moonriver: %s MOVR', helper.util.bigIntToDecimals(movrFees));1097      expect(movrFees > 0, 'Negative fees MOVR, looks like nothing was transferred').to.be.true;10981099      const qtzRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonriver.address);11001101      expect(qtzRandomAccountAsset).to.be.null;11021103      balanceForeignQtzTokenFinal = 0n;11041105      const qtzOutcomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenFinal;1106      console.log('[Quartz -> Moonriver] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));1107      expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1108    });11091110    await helper.wait.newBlocks(3);11111112    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccountQuartz.address);1113    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;1114    expect(actuallyDelivered > 0).to.be.true;11151116    console.log('[Moonriver -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));11171118    const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;1119    console.log('[Moonriver -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));1120    expect(qtzFees == 0n).to.be.true;1121  });11221123  itSub('Moonriver can send only up to its balance', async ({helper}) => {1124    // set Moonriver's sovereign account's balance1125    const moonriverBalance = 10000n * (10n ** QTZ_DECIMALS);1126    const moonriverSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONRIVER_CHAIN);1127    await helper.getSudo().balance.setBalanceSubstrate(alice, moonriverSovereignAccount, moonriverBalance);11281129    const moreThanMoonriverHas = moonriverBalance * 2n;11301131    let targetAccountBalance = 0n;1132    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);11331134    const quartzMultilocation = {1135      V2: {1136        parents: 1,1137        interior: {1138          X1: {Parachain: QUARTZ_CHAIN},1139        },1140      },1141    };11421143    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1144      targetAccount.addressRaw,1145      {1146        Concrete: {1147          parents: 0,1148          interior: 'Here',1149        },1150      },1151      moreThanMoonriverHas,1152    );11531154    let maliciousXcmProgramSent: any;1155    const maxWaitBlocks = 3;11561157    // Try to trick Quartz1158    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1159      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgram]);11601161      // Needed to bypass the call filter.1162      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1163      await helper.fastDemocracy.executeProposal('try to spend more QTZ than Moonriver has', batchCall);11641165      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1166    });11671168    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1169        && event.outcome.isFailedToTransactAsset);11701171    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1172    expect(targetAccountBalance).to.be.equal(0n);11731174    // But Moonriver still can send the correct amount1175    const validTransferAmount = moonriverBalance / 2n;1176    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1177      targetAccount.addressRaw,1178      {1179        Concrete: {1180          parents: 0,1181          interior: 'Here',1182        },1183      },1184      validTransferAmount,1185    );11861187    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1188      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, validXcmProgram]);11891190      // Needed to bypass the call filter.1191      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1192      await helper.fastDemocracy.executeProposal('Spend the correct amount of QTZ', batchCall);1193    });11941195    await helper.wait.newBlocks(maxWaitBlocks);11961197    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1198    expect(targetAccountBalance).to.be.equal(validTransferAmount);1199  });12001201  itSub('Should not accept reserve transfer of QTZ from Moonriver', async ({helper}) => {1202    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);1203    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);12041205    const quartzMultilocation = {1206      V2: {1207        parents: 1,1208        interior: {1209          X1: {1210            Parachain: QUARTZ_CHAIN,1211          },1212        },1213      },1214    };12151216    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1217      targetAccount.addressRaw,1218      {1219        Concrete: {1220          parents: 0,1221          interior: {1222            X1: {1223              Parachain: QUARTZ_CHAIN,1224            },1225          },1226        },1227      },1228      testAmount,1229    );12301231    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1232      targetAccount.addressRaw,1233      {1234        Concrete: {1235          parents: 0,1236          interior: 'Here',1237        },1238      },1239      testAmount,1240    );12411242    let maliciousXcmProgramFullIdSent: any;1243    let maliciousXcmProgramHereIdSent: any;1244    const maxWaitBlocks = 3;12451246    // Try to trick Quartz using full QTZ identification1247    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1248      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramFullId]);12491250      // Needed to bypass the call filter.1251      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1252      await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using path asset identification', batchCall);12531254      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1255    });12561257    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1258        && event.outcome.isUntrustedReserveLocation);12591260    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1261    expect(accountBalance).to.be.equal(0n);12621263    // Try to trick Quartz using shortened QTZ identification1264    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {1265      const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramHereId]);12661267      // Needed to bypass the call filter.1268      const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1269      await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using "here" asset identification', batchCall);12701271      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1272    });12731274    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1275        && event.outcome.isUntrustedReserveLocation);12761277    accountBalance = await helper.balance.getSubstrate(targetAccount.address);1278    expect(accountBalance).to.be.equal(0n);1279  });1280});12811282describeXCM('[XCM] Integration test: Exchanging tokens with Shiden', () => {1283  let alice: IKeyringPair;1284  let sender: IKeyringPair;12851286  const QTZ_ASSET_ID_ON_SHIDEN = 1;1287  const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n;12881289  // Quartz -> Shiden1290  const shidenInitialBalance = 1n * (10n ** SHIDEN_DECIMALS); // 1 SHD, existential deposit required to actually create the account on Shiden1291  const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1292  const qtzToShidenTransferred = 10n * (10n ** QTZ_DECIMALS); // 10 QTZ1293  const qtzToShidenArrived = 9_999_999_999_088_000_000n; // 9.999 ... QTZ, Shiden takes a commision in foreign tokens12941295  // Shiden -> Quartz1296  const qtzFromShidenTransfered = 5n * (10n ** QTZ_DECIMALS); // 5 QTZ1297  const qtzOnShidenLeft = qtzToShidenArrived - qtzFromShidenTransfered; // 4.999_999_999_088_000_000n QTZ12981299  let balanceAfterQuartzToShidenXCM: bigint;13001301  before(async () => {1302    await usingPlaygrounds(async (helper, privateKey) => {1303      alice = await privateKey('//Alice');1304      [sender] = await helper.arrange.createAccounts([100n], alice);1305      console.log('sender', sender.address);13061307      // Set the default version to wrap the first message to other chains.1308      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1309    });13101311    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1312      if(!(await helper.callRpc('api.query.assets.asset', [QTZ_ASSET_ID_ON_SHIDEN])).toJSON()) {1313        console.log('1. Create foreign asset and metadata');1314        // TODO update metadata with values from production1315        await helper.assets.create(1316          alice,1317          QTZ_ASSET_ID_ON_SHIDEN,1318          alice.address,1319          QTZ_MINIMAL_BALANCE_ON_SHIDEN,1320        );13211322        await helper.assets.setMetadata(1323          alice,1324          QTZ_ASSET_ID_ON_SHIDEN,1325          'Cross chain QTZ',1326          'xcQTZ',1327          Number(QTZ_DECIMALS),1328        );13291330        console.log('2. Register asset location on Shiden');1331        const assetLocation = {1332          V2: {1333            parents: 1,1334            interior: {1335              X1: {1336                Parachain: QUARTZ_CHAIN,1337              },1338            },1339          },1340        };13411342        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);13431344        console.log('3. Set QTZ payment for XCM execution on Shiden');1345        await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1346      } else {1347        console.log('QTZ is already registered on Shiden');1348      }1349      console.log('4. Transfer 1 SDN to recipient to create the account (needed due to existential balance)');1350      await helper.balance.transferToSubstrate(alice, sender.address, shidenInitialBalance);1351    });1352  });13531354  itSub('Should connect and send QTZ to Shiden', async ({helper}) => {1355    const destination = {1356      V2: {1357        parents: 1,1358        interior: {1359          X1: {1360            Parachain: SHIDEN_CHAIN,1361          },1362        },1363      },1364    };13651366    const beneficiary = {1367      V2: {1368        parents: 0,1369        interior: {1370          X1: {1371            AccountId32: {1372              network: 'Any',1373              id: sender.addressRaw,1374            },1375          },1376        },1377      },1378    };13791380    const assets = {1381      V2: [1382        {1383          id: {1384            Concrete: {1385              parents: 0,1386              interior: 'Here',1387            },1388          },1389          fun: {1390            Fungible: qtzToShidenTransferred,1391          },1392        },1393      ],1394    };13951396    // Initial balance is 100 QTZ1397    const balanceBefore = await helper.balance.getSubstrate(sender.address);1398    console.log(`Initial balance is: ${balanceBefore}`);13991400    const feeAssetItem = 0;1401    await helper.xcm.limitedReserveTransferAssets(sender, destination, beneficiary, assets, feeAssetItem, 'Unlimited');14021403    // Balance after reserve transfer is less than 901404    balanceAfterQuartzToShidenXCM = await helper.balance.getSubstrate(sender.address);1405    console.log(`QTZ Balance on Quartz after XCM is: ${balanceAfterQuartzToShidenXCM}`);1406    console.log(`Quartz's QTZ commission is: ${balanceBefore - balanceAfterQuartzToShidenXCM}`);1407    expect(balanceBefore - balanceAfterQuartzToShidenXCM > 0).to.be.true;14081409    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1410      await helper.wait.newBlocks(3);1411      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1412      const shidenBalance = await helper.balance.getSubstrate(sender.address);14131414      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);1415      console.log(`Shiden's QTZ commission is: ${qtzToShidenTransferred - xcQTZbalance!}`);14161417      expect(xcQTZbalance).to.eq(qtzToShidenArrived);1418      // SHD balance does not changed:1419      expect(shidenBalance).to.eq(shidenInitialBalance);1420    });1421  });14221423  itSub('Should connect to Shiden and send QTZ back', async ({helper}) => {1424    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1425      const destination = {1426        V2: {1427          parents: 1,1428          interior: {1429            X1: {1430              Parachain: QUARTZ_CHAIN,1431            },1432          },1433        },1434      };14351436      const beneficiary = {1437        V2: {1438          parents: 0,1439          interior: {1440            X1: {1441              AccountId32: {1442                network: 'Any',1443                id: sender.addressRaw,1444              },1445            },1446          },1447        },1448      };14491450      const assets = {1451        V2: [1452          {1453            id: {1454              Concrete: {1455                parents: 1,1456                interior: {1457                  X1: {1458                    Parachain: QUARTZ_CHAIN,1459                  },1460                },1461              },1462            },1463            fun: {1464              Fungible: qtzFromShidenTransfered,1465            },1466          },1467        ],1468      };14691470      // Initial balance is 1 SDN1471      const balanceSDNbefore = await helper.balance.getSubstrate(sender.address);1472      console.log(`SDN balance is: ${balanceSDNbefore}, it does not changed`);1473      expect(balanceSDNbefore).to.eq(shidenInitialBalance);14741475      const feeAssetItem = 0;1476      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1477      await helper.executeExtrinsic(sender, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);14781479      // Balance after reserve transfer is less than 1 SDN1480      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1481      const balanceSDN = await helper.balance.getSubstrate(sender.address);1482      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);14831484      // Assert: xcQTZ balance correctly decreased1485      expect(xcQTZbalance).to.eq(qtzOnShidenLeft);1486      // Assert: SDN balance is 0.996...1487      expect(balanceSDN / (10n ** (SHIDEN_DECIMALS - 3n))).to.eq(996n);1488    });14891490    await helper.wait.newBlocks(3);1491    const balanceQTZ = await helper.balance.getSubstrate(sender.address);1492    console.log(`QTZ Balance on Quartz after XCM is: ${balanceQTZ}`);1493    expect(balanceQTZ).to.eq(balanceAfterQuartzToShidenXCM + qtzFromShidenTransfered);1494  });14951496  itSub('Shiden can send only up to its balance', async ({helper}) => {1497    // set Shiden's sovereign account's balance1498    const shidenBalance = 10000n * (10n ** QTZ_DECIMALS);1499    const shidenSovereignAccount = helper.address.paraSiblingSovereignAccount(SHIDEN_CHAIN);1500    await helper.getSudo().balance.setBalanceSubstrate(alice, shidenSovereignAccount, shidenBalance);15011502    const moreThanShidenHas = shidenBalance * 2n;15031504    let targetAccountBalance = 0n;1505    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);15061507    const quartzMultilocation = {1508      V2: {1509        parents: 1,1510        interior: {1511          X1: {Parachain: QUARTZ_CHAIN},1512        },1513      },1514    };15151516    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1517      targetAccount.addressRaw,1518      {1519        Concrete: {1520          parents: 0,1521          interior: 'Here',1522        },1523      },1524      moreThanShidenHas,1525    );15261527    let maliciousXcmProgramSent: any;1528    const maxWaitBlocks = 3;15291530    // Try to trick Quartz1531    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1532      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);15331534      maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1535    });15361537    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1538        && event.outcome.isFailedToTransactAsset);15391540    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1541    expect(targetAccountBalance).to.be.equal(0n);15421543    // But Shiden still can send the correct amount1544    const validTransferAmount = shidenBalance / 2n;1545    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1546      targetAccount.addressRaw,1547      {1548        Concrete: {1549          parents: 0,1550          interior: 'Here',1551        },1552      },1553      validTransferAmount,1554    );15551556    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1557      await helper.getSudo().xcm.send(alice, quartzMultilocation, validXcmProgram);1558    });15591560    await helper.wait.newBlocks(maxWaitBlocks);15611562    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1563    expect(targetAccountBalance).to.be.equal(validTransferAmount);1564  });15651566  itSub('Should not accept reserve transfer of QTZ from Shiden', async ({helper}) => {1567    const testAmount = 10_000n * (10n ** QTZ_DECIMALS);1568    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);15691570    const quartzMultilocation = {1571      V2: {1572        parents: 1,1573        interior: {1574          X1: {1575            Parachain: QUARTZ_CHAIN,1576          },1577        },1578      },1579    };15801581    const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1582      targetAccount.addressRaw,1583      {1584        Concrete: {1585          parents: 1,1586          interior: {1587            X1: {1588              Parachain: QUARTZ_CHAIN,1589            },1590          },1591        },1592      },1593      testAmount,1594    );15951596    const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1597      targetAccount.addressRaw,1598      {1599        Concrete: {1600          parents: 0,1601          interior: 'Here',1602        },1603      },1604      testAmount,1605    );16061607    let maliciousXcmProgramFullIdSent: any;1608    let maliciousXcmProgramHereIdSent: any;1609    const maxWaitBlocks = 3;16101611    // Try to trick Quartz using full QTZ identification1612    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1613      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);16141615      maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1616    });16171618    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1619        && event.outcome.isUntrustedReserveLocation);16201621    let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1622    expect(accountBalance).to.be.equal(0n);16231624    // Try to trick Quartz using shortened QTZ identification1625    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1626      await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);16271628      maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1629    });16301631    await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1632        && event.outcome.isUntrustedReserveLocation);16331634    accountBalance = await helper.balance.getSubstrate(targetAccount.address);1635    expect(accountBalance).to.be.equal(0n);1636  });1637});