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

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 {blake2AsHex} from '@polkadot/util-crypto';19import config from '../config';20import {XcmV2TraitsError} from '../interfaces';21import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util';2223const QUARTZ_CHAIN = 2095;24const STATEMINE_CHAIN = 1000;25const KARURA_CHAIN = 2000;26const MOONRIVER_CHAIN = 2023;27const SHIDEN_CHAIN = 2007;2829const STATEMINE_PALLET_INSTANCE = 50;3031const relayUrl = config.relayUrl;32const statemineUrl = config.statemineUrl;33const karuraUrl = config.karuraUrl;34const moonriverUrl = config.moonriverUrl;35const shidenUrl = config.shidenUrl;3637const RELAY_DECIMALS = 12;38const STATEMINE_DECIMALS = 12;39const KARURA_DECIMALS = 12;40const SHIDEN_DECIMALS = 18n;41const QTZ_DECIMALS = 18n;4243const TRANSFER_AMOUNT = 2000000000000000000000000n;4445const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4647const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4849const USDT_ASSET_ID = 100;50const USDT_ASSET_METADATA_DECIMALS = 18;51const USDT_ASSET_METADATA_NAME = 'USDT';52const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';53const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;54const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5556const SAFE_XCM_VERSION = 2;5758describeXCM('[XCM] Integration test: Exchanging USDT with Statemine', () => {59  let alice: IKeyringPair;60  let bob: IKeyringPair;6162  let balanceStmnBefore: bigint;63  let balanceStmnAfter: bigint;6465  let balanceQuartzBefore: bigint;66  let balanceQuartzAfter: bigint;67  let balanceQuartzFinal: bigint;6869  let balanceBobBefore: bigint;70  let balanceBobAfter: bigint;71  let balanceBobFinal: bigint;7273  let balanceBobRelayTokenBefore: bigint;74  let balanceBobRelayTokenAfter: bigint;757677  before(async () => {78    await usingPlaygrounds(async (helper, privateKey) => {79      alice = await privateKey('//Alice');80      bob = await privateKey('//Bob'); // sovereign account on Statemine(t) funds donor8182      // Set the default version to wrap the first message to other chains.83      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);84    });8586    await usingRelayPlaygrounds(relayUrl, async (helper) => {87      // Fund accounts on Statemine(t)88      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, alice.addressRaw, FUNDING_AMOUNT);89      await helper.xcm.teleportNativeAsset(alice, STATEMINE_CHAIN, bob.addressRaw, FUNDING_AMOUNT);90    });9192    await usingStateminePlaygrounds(statemineUrl, async (helper) => {93      const sovereignFundingAmount = 3_500_000_000n;9495      await helper.assets.create(96        alice,97        USDT_ASSET_ID,98        alice.address,99        USDT_ASSET_METADATA_MINIMAL_BALANCE,100      );101      await helper.assets.setMetadata(102        alice,103        USDT_ASSET_ID,104        USDT_ASSET_METADATA_NAME,105        USDT_ASSET_METADATA_DESCRIPTION,106        USDT_ASSET_METADATA_DECIMALS,107      );108      await helper.assets.mint(109        alice,110        USDT_ASSET_ID,111        alice.address,112        USDT_ASSET_AMOUNT,113      );114115      // funding parachain sovereing account on Statemine(t).116      // The sovereign account should be created before any action117      // (the assets pallet on Statemine(t) check if the sovereign account exists)118      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(QUARTZ_CHAIN);119      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);120    });121122123    await usingPlaygrounds(async (helper) => {124      const location = {125        V2: {126          parents: 1,127          interior: {X3: [128            {129              Parachain: STATEMINE_CHAIN,130            },131            {132              PalletInstance: STATEMINE_PALLET_INSTANCE,133            },134            {135              GeneralIndex: USDT_ASSET_ID,136            },137          ]},138        },139      };140141      const metadata =142      {143        name: USDT_ASSET_ID,144        symbol: USDT_ASSET_METADATA_NAME,145        decimals: USDT_ASSET_METADATA_DECIMALS,146        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,147      };148      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);149      balanceQuartzBefore = await helper.balance.getSubstrate(alice.address);150    });151152153    // Providing the relay currency to the quartz sender account154    // (fee for USDT XCM are paid in relay tokens)155    await usingRelayPlaygrounds(relayUrl, async (helper) => {156      const destination = {157        V1: {158          parents: 0,159          interior: {X1: {160            Parachain: QUARTZ_CHAIN,161          },162          },163        }};164165      const beneficiary = {166        V1: {167          parents: 0,168          interior: {X1: {169            AccountId32: {170              network: 'Any',171              id: alice.addressRaw,172            },173          }},174        },175      };176177      const assets = {178        V1: [179          {180            id: {181              Concrete: {182                parents: 0,183                interior: 'Here',184              },185            },186            fun: {187              Fungible: TRANSFER_AMOUNT_RELAY,188            },189          },190        ],191      };192193      const feeAssetItem = 0;194195      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');196    });197198  });199200  itSub('Should connect and send USDT from Statemine to Quartz', async ({helper}) => {201    await usingStateminePlaygrounds(statemineUrl, async (helper) => {202      const dest = {203        V1: {204          parents: 1,205          interior: {X1: {206            Parachain: QUARTZ_CHAIN,207          },208          },209        }};210211      const beneficiary = {212        V1: {213          parents: 0,214          interior: {X1: {215            AccountId32: {216              network: 'Any',217              id: alice.addressRaw,218            },219          }},220        },221      };222223      const assets = {224        V1: [225          {226            id: {227              Concrete: {228                parents: 0,229                interior: {230                  X2: [231                    {232                      PalletInstance: STATEMINE_PALLET_INSTANCE,233                    },234                    {235                      GeneralIndex: USDT_ASSET_ID,236                    },237                  ]},238              },239            },240            fun: {241              Fungible: TRANSFER_AMOUNT,242            },243          },244        ],245      };246247      const feeAssetItem = 0;248249      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);250      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');251252      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);253254      // common good parachain take commission in it native token255      console.log(256        '[Statemine -> Quartz] transaction fees on Statemine: %s WND',257        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINE_DECIMALS),258      );259      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;260261    });262263264    // ensure that asset has been delivered265    await helper.wait.newBlocks(3);266267    // expext collection id will be with id 1268    const free = await helper.ft.getBalance(1, {Substrate: alice.address});269270    balanceQuartzAfter = await helper.balance.getSubstrate(alice.address);271272    console.log(273      '[Statemine -> Quartz] transaction fees on Quartz: %s USDT',274      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),275    );276    console.log(277      '[Statemine -> Quartz] transaction fees on Quartz: %s QTZ',278      helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzBefore),279    );280    // commission has not paid in USDT token281    expect(free).to.be.equal(TRANSFER_AMOUNT);282    // ... and parachain native token283    expect(balanceQuartzAfter == balanceQuartzBefore).to.be.true;284  });285286  itSub('Should connect and send USDT from Quartz to Statemine back', async ({helper}) => {287    const destination = {288      V2: {289        parents: 1,290        interior: {X2: [291          {292            Parachain: STATEMINE_CHAIN,293          },294          {295            AccountId32: {296              network: 'Any',297              id: alice.addressRaw,298            },299          },300        ]},301      },302    };303304    const relayFee = 400_000_000_000_000n;305    const currencies: [any, bigint][] = [306      [307        {308          ForeignAssetId: 0,309        },310        TRANSFER_AMOUNT,311      ],312      [313        {314          NativeAssetId: 'Parent',315        },316        relayFee,317      ],318    ];319320    const feeItem = 1;321322    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');323324    // the commission has been paid in parachain native token325    balanceQuartzFinal = await helper.balance.getSubstrate(alice.address);326    console.log('[Quartz -> Statemine] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(balanceQuartzAfter - balanceQuartzFinal));327    expect(balanceQuartzAfter > balanceQuartzFinal).to.be.true;328329    await usingStateminePlaygrounds(statemineUrl, async (helper) => {330      await helper.wait.newBlocks(3);331332      // The USDT token never paid fees. Its amount not changed from begin value.333      // Also check that xcm transfer has been succeeded334      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;335    });336  });337338  itSub('Should connect and send Relay token to Quartz', async ({helper}) => {339    balanceBobBefore = await helper.balance.getSubstrate(bob.address);340    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});341342    await usingRelayPlaygrounds(relayUrl, async (helper) => {343      const destination = {344        V1: {345          parents: 0,346          interior: {X1: {347            Parachain: QUARTZ_CHAIN,348          },349          },350        }};351352      const beneficiary = {353        V1: {354          parents: 0,355          interior: {X1: {356            AccountId32: {357              network: 'Any',358              id: bob.addressRaw,359            },360          }},361        },362      };363364      const assets = {365        V1: [366          {367            id: {368              Concrete: {369                parents: 0,370                interior: 'Here',371              },372            },373            fun: {374              Fungible: TRANSFER_AMOUNT_RELAY,375            },376          },377        ],378      };379380      const feeAssetItem = 0;381382      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');383    });384385    await helper.wait.newBlocks(3);386387    balanceBobAfter = await helper.balance.getSubstrate(bob.address);388    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});389390    const wndFeeOnQuartz = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;391    const wndDiffOnQuartz = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;392    console.log(393      '[Relay (Westend) -> Quartz] transaction fees: %s QTZ',394      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),395    );396    console.log(397      '[Relay (Westend) -> Quartz] transaction fees: %s WND',398      helper.util.bigIntToDecimals(wndFeeOnQuartz, STATEMINE_DECIMALS),399    );400    console.log('[Relay (Westend) -> Quartz] actually delivered: %s WND', wndDiffOnQuartz);401    expect(wndFeeOnQuartz == 0n, 'No incoming WND fees should be taken').to.be.true;402    expect(balanceBobBefore == balanceBobAfter, 'No incoming QTZ fees should be taken').to.be.true;403  });404405  itSub('Should connect and send Relay token back', async ({helper}) => {406    let relayTokenBalanceBefore: bigint;407    let relayTokenBalanceAfter: bigint;408    await usingRelayPlaygrounds(relayUrl, async (helper) => {409      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);410    });411412    const destination = {413      V2: {414        parents: 1,415        interior: {416          X1:{417            AccountId32: {418              network: 'Any',419              id: bob.addressRaw,420            },421          },422        },423      },424    };425426    const currencies: any = [427      [428        {429          NativeAssetId: 'Parent',430        },431        TRANSFER_AMOUNT_RELAY,432      ],433    ];434435    const feeItem = 0;436437    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');438439    balanceBobFinal = await helper.balance.getSubstrate(bob.address);440    console.log('[Quartz -> Relay (Westend)] transaction fees: %s QTZ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));441442    await usingRelayPlaygrounds(relayUrl, async (helper) => {443      await helper.wait.newBlocks(10);444      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);445446      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;447      console.log('[Quartz -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));448      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;449    });450  });451});452453describeXCM('[XCM] Integration test: Exchanging tokens with Karura', () => {454  let alice: IKeyringPair;455  let randomAccount: IKeyringPair;456457  let balanceQuartzTokenInit: bigint;458  let balanceQuartzTokenMiddle: bigint;459  let balanceQuartzTokenFinal: bigint;460  let balanceKaruraTokenInit: bigint;461  let balanceKaruraTokenMiddle: bigint;462  let balanceKaruraTokenFinal: bigint;463  let balanceQuartzForeignTokenInit: bigint;464  let balanceQuartzForeignTokenMiddle: bigint;465  let balanceQuartzForeignTokenFinal: bigint;466467  // computed by a test transfer from prod Quartz to prod Karura.468  // 2 QTZ sent https://quartz.subscan.io/xcm_message/kusama-f60d821b049f8835a3005ce7102285006f5b61e9469  // 1.919176000000000000 QTZ received (you can check Karura's chain state in the corresponding block)470  const expectedKaruraIncomeFee = 2000000000000000000n - 1919176000000000000n;471472  const KARURA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedKaruraIncomeFee;473474  before(async () => {475    await usingPlaygrounds(async (helper, privateKey) => {476      alice = await privateKey('//Alice');477      [randomAccount] = await helper.arrange.createAccounts([0n], alice);478479      // Set the default version to wrap the first message to other chains.480      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);481    });482483    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {484      const destination = {485        V1: {486          parents: 1,487          interior: {488            X1: {489              Parachain: QUARTZ_CHAIN,490            },491          },492        },493      };494495      const metadata = {496        name: 'Quartz',497        symbol: 'QTZ',498        decimals: 18,499        minimalBalance: 1000000000000000000n,500      };501502      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);503      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);504      balanceKaruraTokenInit = await helper.balance.getSubstrate(randomAccount.address);505      balanceQuartzForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});506    });507508    await usingPlaygrounds(async (helper) => {509      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);510      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccount.address);511    });512  });513514  itSub('Should connect and send QTZ to Karura', async ({helper}) => {515    const destination = {516      V2: {517        parents: 1,518        interior: {519          X1: {520            Parachain: KARURA_CHAIN,521          },522        },523      },524    };525526    const beneficiary = {527      V2: {528        parents: 0,529        interior: {530          X1: {531            AccountId32: {532              network: 'Any',533              id: randomAccount.addressRaw,534            },535          },536        },537      },538    };539540    const assets = {541      V2: [542        {543          id: {544            Concrete: {545              parents: 0,546              interior: 'Here',547            },548          },549          fun: {550            Fungible: TRANSFER_AMOUNT,551          },552        },553      ],554    };555556    const feeAssetItem = 0;557558    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');559    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);560561    const qtzFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;562    expect(qtzFees > 0n, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;563    console.log('[Quartz -> Karura] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));564565    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {566      await helper.wait.newBlocks(3);567568      balanceQuartzForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});569      balanceKaruraTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);570571      const karFees = balanceKaruraTokenInit - balanceKaruraTokenMiddle;572      const qtzIncomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenInit;573      const karUnqFees = TRANSFER_AMOUNT - qtzIncomeTransfer;574575      console.log(576        '[Quartz -> Karura] transaction fees on Karura: %s KAR',577        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),578      );579      console.log(580        '[Quartz -> Karura] transaction fees on Karura: %s QTZ',581        helper.util.bigIntToDecimals(karUnqFees),582      );583      console.log('[Quartz -> Karura] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));584      expect(karFees == 0n).to.be.true;585      expect(586        karUnqFees == expectedKaruraIncomeFee,587        'Karura took different income fee, check the Karura foreign asset config',588      ).to.be.true;589    });590  });591592  itSub('Should connect to Karura and send QTZ back', async ({helper}) => {593    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {594      const destination = {595        V1: {596          parents: 1,597          interior: {598            X2: [599              {Parachain: QUARTZ_CHAIN},600              {601                AccountId32: {602                  network: 'Any',603                  id: randomAccount.addressRaw,604                },605              },606            ],607          },608        },609      };610611      const id = {612        ForeignAsset: 0,613      };614615      await helper.xTokens.transfer(randomAccount, id, KARURA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');616      balanceKaruraTokenFinal = await helper.balance.getSubstrate(randomAccount.address);617      balanceQuartzForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);618619      const karFees = balanceKaruraTokenMiddle - balanceKaruraTokenFinal;620      const qtzOutcomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenFinal;621622      console.log(623        '[Karura -> Quartz] transaction fees on Karura: %s KAR',624        helper.util.bigIntToDecimals(karFees, KARURA_DECIMALS),625      );626      console.log('[Karura -> Quartz] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));627628      expect(karFees > 0, 'Negative fees KAR, looks like nothing was transferred').to.be.true;629      expect(qtzOutcomeTransfer == KARURA_BACKWARD_TRANSFER_AMOUNT).to.be.true;630    });631632    await helper.wait.newBlocks(3);633634    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccount.address);635    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;636    expect(actuallyDelivered > 0).to.be.true;637638    console.log('[Karura -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));639640    const qtzFees = KARURA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;641    console.log('[Karura -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));642    expect(qtzFees == 0n).to.be.true;643  });644});645646// These tests are relevant only when the foreign asset pallet is disabled647describeXCM('[XCM] Integration test: Quartz rejects non-native tokens', () => {648  let alice: IKeyringPair;649650  before(async () => {651    await usingPlaygrounds(async (helper, privateKey) => {652      alice = await privateKey('//Alice');653654      // Set the default version to wrap the first message to other chains.655      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);656    });657  });658659  itSub('Quartz rejects KAR tokens from Karura', async ({helper}) => {660    await usingKaruraPlaygrounds(karuraUrl, async (helper) => {661      const destination = {662        V1: {663          parents: 1,664          interior: {665            X2: [666              {Parachain: QUARTZ_CHAIN},667              {668                AccountId32: {669                  network: 'Any',670                  id: alice.addressRaw,671                },672              },673            ],674          },675        },676      };677678      const id = {679        Token: 'KAR',680      };681682      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');683    });684685    const maxWaitBlocks = 3;686687    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');688689    expect(690      xcmpQueueFailEvent != null,691      '[Karura] xcmpQueue.FailEvent event is expected',692    ).to.be.true;693694    const event = xcmpQueueFailEvent!.event;695    const outcome = event.data[1] as XcmV2TraitsError;696697    expect(698      outcome.isFailedToTransactAsset,699      '[Karura] The XCM error should be `FailedToTransactAsset`',700    ).to.be.true;701  });702});703704describeXCM('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {705  // Quartz constants706  let quartzDonor: IKeyringPair;707  let quartzAssetLocation;708709  let randomAccountQuartz: IKeyringPair;710  let randomAccountMoonriver: IKeyringPair;711712  // Moonriver constants713  let assetId: string;714715  const councilVotingThreshold = 2;716  const technicalCommitteeThreshold = 2;717  const votingPeriod = 3;718  const delayPeriod = 0;719720  const quartzAssetMetadata = {721    name: 'xcQuartz',722    symbol: 'xcQTZ',723    decimals: 18,724    isFrozen: false,725    minimalBalance: 1n,726  };727728  let balanceQuartzTokenInit: bigint;729  let balanceQuartzTokenMiddle: bigint;730  let balanceQuartzTokenFinal: bigint;731  let balanceForeignQtzTokenInit: bigint;732  let balanceForeignQtzTokenMiddle: bigint;733  let balanceForeignQtzTokenFinal: bigint;734  let balanceMovrTokenInit: bigint;735  let balanceMovrTokenMiddle: bigint;736  let balanceMovrTokenFinal: bigint;737738  before(async () => {739    await usingPlaygrounds(async (helper, privateKey) => {740      quartzDonor = await privateKey('//Alice');741      [randomAccountQuartz] = await helper.arrange.createAccounts([0n], quartzDonor);742743      balanceForeignQtzTokenInit = 0n;744      745      // Set the default version to wrap the first message to other chains.746      const alice = quartzDonor;747      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);748    });749750    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {751      const alithAccount = helper.account.alithAccount();752      const baltatharAccount = helper.account.baltatharAccount();753      const dorothyAccount = helper.account.dorothyAccount();754755      randomAccountMoonriver = helper.account.create();756757      // >>> Sponsoring Dorothy >>>758      console.log('Sponsoring Dorothy.......');759      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);760      console.log('Sponsoring Dorothy.......DONE');761      // <<< Sponsoring Dorothy <<<762763      quartzAssetLocation = {764        XCM: {765          parents: 1,766          interior: {X1: {Parachain: QUARTZ_CHAIN}},767        },768      };769      const existentialDeposit = 1n;770      const isSufficient = true;771      const unitsPerSecond = 1n;772      const numAssetsWeightHint = 0;773774      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({775        location: quartzAssetLocation,776        metadata: quartzAssetMetadata,777        existentialDeposit,778        isSufficient,779        unitsPerSecond,780        numAssetsWeightHint,781      });782      const proposalHash = blake2AsHex(encodedProposal);783784      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);785      console.log('Encoded length %d', encodedProposal.length);786      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);787788      // >>> Note motion preimage >>>789      console.log('Note motion preimage.......');790      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);791      console.log('Note motion preimage.......DONE');792      // <<< Note motion preimage <<<793794      // >>> Propose external motion through council >>>795      console.log('Propose external motion through council.......');796      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});797      const encodedMotion = externalMotion?.method.toHex() || '';798      const motionHash = blake2AsHex(encodedMotion);799      console.log('Motion hash is %s', motionHash);800801      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);802803      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;804      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);805      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);806807      await helper.collective.council.close(808        dorothyAccount,809        motionHash,810        councilProposalIdx,811        {812          refTime: 1_000_000_000,813          proofSize: 1_000_000,814        },815        externalMotion.encodedLength,816      );817      console.log('Propose external motion through council.......DONE');818      // <<< Propose external motion through council <<<819820      // >>> Fast track proposal through technical committee >>>821      console.log('Fast track proposal through technical committee.......');822      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);823      const encodedFastTrack = fastTrack?.method.toHex() || '';824      const fastTrackHash = blake2AsHex(encodedFastTrack);825      console.log('FastTrack hash is %s', fastTrackHash);826827      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);828829      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;830      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);831      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);832833      await helper.collective.techCommittee.close(834        baltatharAccount,835        fastTrackHash,836        techProposalIdx,837        {838          refTime: 1_000_000_000,839          proofSize: 1_000_000,840        },841        fastTrack.encodedLength,842      );843      console.log('Fast track proposal through technical committee.......DONE');844      // <<< Fast track proposal through technical committee <<<845846      // >>> Referendum voting >>>847      console.log('Referendum voting.......');848      await helper.democracy.referendumVote(dorothyAccount, 0, {849        balance: 10_000_000_000_000_000_000n,850        vote: {aye: true, conviction: 1},851      });852      console.log('Referendum voting.......DONE');853      // <<< Referendum voting <<<854855      // >>> Acquire Quartz AssetId Info on Moonriver >>>856      console.log('Acquire Quartz AssetId Info on Moonriver.......');857858      // Wait for the democracy execute859      await helper.wait.newBlocks(5);860861      assetId = (await helper.assetManager.assetTypeId(quartzAssetLocation)).toString();862863      console.log('QTZ asset ID is %s', assetId);864      console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');865      // >>> Acquire Quartz AssetId Info on Moonriver >>>866867      // >>> Sponsoring random Account >>>868      console.log('Sponsoring random Account.......');869      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonriver.address, 11_000_000_000_000_000_000n);870      console.log('Sponsoring random Account.......DONE');871      // <<< Sponsoring random Account <<<872873      balanceMovrTokenInit = await helper.balance.getEthereum(randomAccountMoonriver.address);874    });875876    await usingPlaygrounds(async (helper) => {877      await helper.balance.transferToSubstrate(quartzDonor, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);878      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccountQuartz.address);879    });880  });881882  itSub('Should connect and send QTZ to Moonriver', async ({helper}) => {883    const currencyId = {884      NativeAssetId: 'Here',885    };886    const dest = {887      V2: {888        parents: 1,889        interior: {890          X2: [891            {Parachain: MOONRIVER_CHAIN},892            {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},893          ],894        },895      },896    };897    const amount = TRANSFER_AMOUNT;898899    await helper.xTokens.transfer(randomAccountQuartz, currencyId, amount, dest, 'Unlimited');900901    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccountQuartz.address);902    expect(balanceQuartzTokenMiddle < balanceQuartzTokenInit).to.be.true;903904    const transactionFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;905    console.log('[Quartz -> Moonriver] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(transactionFees));906    expect(transactionFees > 0, 'Negative fees QTZ, looks like nothing was transferred').to.be.true;907908    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {909      await helper.wait.newBlocks(3);910911      balanceMovrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonriver.address);912913      const movrFees = balanceMovrTokenInit - balanceMovrTokenMiddle;914      console.log('[Quartz -> Moonriver] transaction fees on Moonriver: %s MOVR',helper.util.bigIntToDecimals(movrFees));915      expect(movrFees == 0n).to.be.true;916917      balanceForeignQtzTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonriver.address))!; // BigInt(qtzRandomAccountAsset['balance']);918      const qtzIncomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenInit;919      console.log('[Quartz -> Moonriver] income %s QTZ', helper.util.bigIntToDecimals(qtzIncomeTransfer));920      expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;921    });922  });923924  itSub('Should connect to Moonriver and send QTZ back', async ({helper}) => {925    await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {926      const asset = {927        V1: {928          id: {929            Concrete: {930              parents: 1,931              interior: {932                X1: {Parachain: QUARTZ_CHAIN},933              },934            },935          },936          fun: {937            Fungible: TRANSFER_AMOUNT,938          },939        },940      };941      const destination = {942        V1: {943          parents: 1,944          interior: {945            X2: [946              {Parachain: QUARTZ_CHAIN},947              {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},948            ],949          },950        },951      };952953      await helper.xTokens.transferMultiasset(randomAccountMoonriver, asset, destination, 'Unlimited');954955      balanceMovrTokenFinal = await helper.balance.getEthereum(randomAccountMoonriver.address);956957      const movrFees = balanceMovrTokenMiddle - balanceMovrTokenFinal;958      console.log('[Moonriver -> Quartz] transaction fees on Moonriver: %s MOVR', helper.util.bigIntToDecimals(movrFees));959      expect(movrFees > 0, 'Negative fees MOVR, looks like nothing was transferred').to.be.true;960961      const qtzRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonriver.address);962963      expect(qtzRandomAccountAsset).to.be.null;964965      balanceForeignQtzTokenFinal = 0n;966967      const qtzOutcomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenFinal;968      console.log('[Quartz -> Moonriver] outcome %s QTZ', helper.util.bigIntToDecimals(qtzOutcomeTransfer));969      expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;970    });971972    await helper.wait.newBlocks(3);973974    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccountQuartz.address);975    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;976    expect(actuallyDelivered > 0).to.be.true;977978    console.log('[Moonriver -> Quartz] actually delivered %s QTZ', helper.util.bigIntToDecimals(actuallyDelivered));979980    const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;981    console.log('[Moonriver -> Quartz] transaction fees on Quartz: %s QTZ', helper.util.bigIntToDecimals(qtzFees));982    expect(qtzFees == 0n).to.be.true;983  });984});985986describeXCM('[XCM] Integration test: Exchanging tokens with Shiden', () => {987  let alice: IKeyringPair;988  let sender: IKeyringPair;989990  const QTZ_ASSET_ID_ON_SHIDEN = 1;991  const QTZ_MINIMAL_BALANCE_ON_SHIDEN = 1n;992993  // Quartz -> Shiden994  const shidenInitialBalance = 1n * (10n ** SHIDEN_DECIMALS); // 1 SHD, existential deposit required to actually create the account on Shiden995  const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?996  const qtzToShidenTransferred = 10n * (10n ** QTZ_DECIMALS); // 10 QTZ997  const qtzToShidenArrived = 9_999_999_999_088_000_000n; // 9.999 ... QTZ, Shiden takes a commision in foreign tokens998  const senderIinitialBalanceQTZ = 100n * (10n ** QTZ_DECIMALS); // How many QTZ sender has initially999  const senderBalanceAfterXCM = 89_941967662676666465n; // 89.94... QTZ after XCM call10001001  // Shiden -> Quartz1002  const qtzFromShidenTransfered = 5n * (10n ** QTZ_DECIMALS); // 5 QTZ1003  const qtzOnShidenLeft = qtzToShidenArrived - qtzFromShidenTransfered; // 4.999_999_999_088_000_000n QTZ10041005  before(async () => {1006    await usingPlaygrounds(async (helper, privateKey) => {1007      alice = await privateKey('//Alice');1008      [sender] = await helper.arrange.createAccounts([100n], alice);1009      console.log('sender', sender.address);1010    });10111012    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1013      console.log('1. Create foreign asset and metadata');1014      // TODO update metadata with values from production1015      await helper.assets.create(1016        alice,1017        QTZ_ASSET_ID_ON_SHIDEN,1018        alice.address,1019        QTZ_MINIMAL_BALANCE_ON_SHIDEN,1020      );10211022      await helper.assets.setMetadata(1023        alice,1024        QTZ_ASSET_ID_ON_SHIDEN,1025        'Cross chain QTZ',1026        'xcQTZ',1027        Number(QTZ_DECIMALS),1028      );10291030      console.log('2. Register asset location on Shiden');1031      const assetLocation = {1032        V1: {1033          parents: 1,1034          interior: {1035            X1: {1036              Parachain: QUARTZ_CHAIN,1037            },1038          },1039        },1040      };10411042      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, QTZ_ASSET_ID_ON_SHIDEN]);10431044      console.log('3. Set QTZ payment for XCM execution on Shiden');1045      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);10461047      console.log('4. Transfer 1 SDN to recipient to create the account (needed due to existential balance)');1048      await helper.balance.transferToSubstrate(alice, sender.address, shidenInitialBalance);1049    });1050  });10511052  itSub('Should connect and send QTZ to Shiden', async ({helper}) => {1053    const destination = {1054      V1: {1055        parents: 1,1056        interior: {1057          X1: {1058            Parachain: SHIDEN_CHAIN,1059          },1060        },1061      },1062    };10631064    const beneficiary = {1065      V1: {1066        parents: 0,1067        interior: {1068          X1: {1069            AccountId32: {1070              network: 'Any',1071              id: sender.addressRaw,1072            },1073          },1074        },1075      },1076    };10771078    const assets = {1079      V1: [1080        {1081          id: {1082            Concrete: {1083              parents: 0,1084              interior: 'Here',1085            },1086          },1087          fun: {1088            Fungible: qtzToShidenTransferred,1089          },1090        },1091      ],1092    };10931094    // Initial balance is 100 QTZ1095    const balanceBefore = await helper.balance.getSubstrate(sender.address);1096    console.log(`Initial balance is: ${balanceBefore}`);1097    expect(balanceBefore).to.eq(senderIinitialBalanceQTZ);10981099    const feeAssetItem = 0;1100    await helper.xcm.limitedReserveTransferAssets(sender, destination, beneficiary, assets, feeAssetItem, 'Unlimited');11011102    // Balance after reserve transfer is less than 901103    const balanceAfter = await helper.balance.getSubstrate(sender.address);1104    console.log(`QTZ Balance on Quartz after XCM is: ${balanceAfter}`);1105    console.log(`Quartz's QTZ commission is: ${balanceBefore - balanceAfter}`);1106    expect(balanceAfter).to.eq(senderBalanceAfterXCM);11071108    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1109      await helper.wait.newBlocks(3);1110      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1111      const shidenBalance = await helper.balance.getSubstrate(sender.address);11121113      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);1114      console.log(`Shiden's QTZ commission is: ${qtzToShidenTransferred - xcQTZbalance!}`);11151116      expect(xcQTZbalance).to.eq(qtzToShidenArrived);1117      // SHD balance does not changed:1118      expect(shidenBalance).to.eq(shidenInitialBalance);1119    });1120  });11211122  itSub('Should connect to Shiden and send QTZ back', async ({helper}) => {1123    await usingShidenPlaygrounds(shidenUrl, async (helper) => {1124      const destination = {1125        V1: {1126          parents: 1,1127          interior: {1128            X1: {1129              Parachain: QUARTZ_CHAIN,1130            },1131          },1132        },1133      };11341135      const beneficiary = {1136        V1: {1137          parents: 0,1138          interior: {1139            X1: {1140              AccountId32: {1141                network: 'Any',1142                id: sender.addressRaw,1143              },1144            },1145          },1146        },1147      };11481149      const assets = {1150        V1: [1151          {1152            id: {1153              Concrete: {1154                parents: 1,1155                interior: {1156                  X1: {1157                    Parachain: QUARTZ_CHAIN,1158                  },1159                },1160              },1161            },1162            fun: {1163              Fungible: qtzFromShidenTransfered,1164            },1165          },1166        ],1167      };11681169      // Initial balance is 1 SDN1170      const balanceSDNbefore = await helper.balance.getSubstrate(sender.address);1171      console.log(`SDN balance is: ${balanceSDNbefore}, it does not changed`);1172      expect(balanceSDNbefore).to.eq(shidenInitialBalance);11731174      const feeAssetItem = 0;1175      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1176      await helper.executeExtrinsic(sender, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);11771178      // Balance after reserve transfer is less than 1 SDN1179      const xcQTZbalance = await helper.assets.account(QTZ_ASSET_ID_ON_SHIDEN, sender.address);1180      const balanceSDN = await helper.balance.getSubstrate(sender.address);1181      console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);11821183      // Assert: xcQTZ balance correctly decreased1184      expect(xcQTZbalance).to.eq(qtzOnShidenLeft);1185      // Assert: SDN balance is 0.996...1186      expect(balanceSDN / (10n ** (SHIDEN_DECIMALS - 3n))).to.eq(996n);1187    });11881189    await helper.wait.newBlocks(3);1190    const balanceQTZ = await helper.balance.getSubstrate(sender.address);1191    console.log(`QTZ Balance on Quartz after XCM is: ${balanceQTZ}`);1192    expect(balanceQTZ).to.eq(senderBalanceAfterXCM + qtzFromShidenTransfered);1193  });1194});