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, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds} from '../util';2223const UNIQUE_CHAIN = 2037;24const STATEMINT_CHAIN = 1000;25const ACALA_CHAIN = 2000;26const MOONBEAM_CHAIN = 2004;27const ASTAR_CHAIN = 2006;2829const STATEMINT_PALLET_INSTANCE = 50;3031const relayUrl = config.relayUrl;32const statemintUrl = config.statemintUrl;33const acalaUrl = config.acalaUrl;34const moonbeamUrl = config.moonbeamUrl;35const astarUrl = config.astarUrl;3637const RELAY_DECIMALS = 12;38const STATEMINT_DECIMALS = 12;39const ACALA_DECIMALS = 12;40const ASTAR_DECIMALS = 18n;41const UNQ_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 Statemint', () => {59  let alice: IKeyringPair;60  let bob: IKeyringPair;6162  let balanceStmnBefore: bigint;63  let balanceStmnAfter: bigint;6465  let balanceUniqueBefore: bigint;66  let balanceUniqueAfter: bigint;67  let balanceUniqueFinal: 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 Statemint 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 Statemint88      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);89      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);90    });9192    await usingStatemintPlaygrounds(statemintUrl, 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 Statemint.116      // The sovereign account should be created before any action117      // (the assets pallet on Statemint check if the sovereign account exists)118      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_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: STATEMINT_CHAIN,130            },131            {132              PalletInstance: STATEMINT_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      balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);150    });151152153    // Providing the relay currency to the unique 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: UNIQUE_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 Statemint to Unique', async ({helper}) => {201    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {202      const dest = {203        V1: {204          parents: 1,205          interior: {X1: {206            Parachain: UNIQUE_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: STATEMINT_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        '[Statemint -> Unique] transaction fees on Statemint: %s WND',257        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_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    balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);271272    console.log(273      '[Statemint -> Unique] transaction fees on Unique: %s USDT',274      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),275    );276    console.log(277      '[Statemint -> Unique] transaction fees on Unique: %s UNQ',278      helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),279    );280    // commission has not paid in USDT token281    expect(free).to.be.equal(TRANSFER_AMOUNT);282    // ... and parachain native token283    expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;284  });285286  itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {287    const destination = {288      V2: {289        parents: 1,290        interior: {X2: [291          {292            Parachain: STATEMINT_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    balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);326    console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));327    expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;328329    await usingStatemintPlaygrounds(statemintUrl, 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 Unique', 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: UNIQUE_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 wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;391    const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;392    console.log(393      '[Relay (Westend) -> Unique] transaction fees: %s UNQ',394      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),395    );396    console.log(397      '[Relay (Westend) -> Unique] transaction fees: %s WND',398      helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),399    );400    console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);401    expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;402    expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ 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('[Unique -> Relay (Westend)] transaction fees: %s UNQ',  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('[Unique -> 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 Acala', () => {454  let alice: IKeyringPair;455  let randomAccount: IKeyringPair;456457  let balanceUniqueTokenInit: bigint;458  let balanceUniqueTokenMiddle: bigint;459  let balanceUniqueTokenFinal: bigint;460  let balanceAcalaTokenInit: bigint;461  let balanceAcalaTokenMiddle: bigint;462  let balanceAcalaTokenFinal: bigint;463  let balanceUniqueForeignTokenInit: bigint;464  let balanceUniqueForeignTokenMiddle: bigint;465  let balanceUniqueForeignTokenFinal: bigint;466467  // computed by a test transfer from prod Unique to prod Acala.468  // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48469  // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)470  const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;471472  const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;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 usingAcalaPlaygrounds(acalaUrl, async (helper) => {484      const destination = {485        V1: {486          parents: 1,487          interior: {488            X1: {489              Parachain: UNIQUE_CHAIN,490            },491          },492        },493      };494495      const metadata = {496        name: 'Unique Network',497        symbol: 'UNQ',498        decimals: 18,499        minimalBalance: 1250000000000000000n,500      };501502      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);503      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);504      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);505      balanceUniqueForeignTokenInit = 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      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);511    });512  });513514  itSub('Should connect and send UNQ to Acala', async ({helper}) => {515516    const destination = {517      V2: {518        parents: 1,519        interior: {520          X1: {521            Parachain: ACALA_CHAIN,522          },523        },524      },525    };526527    const beneficiary = {528      V2: {529        parents: 0,530        interior: {531          X1: {532            AccountId32: {533              network: 'Any',534              id: randomAccount.addressRaw,535            },536          },537        },538      },539    };540541    const assets = {542      V2: [543        {544          id: {545            Concrete: {546              parents: 0,547              interior: 'Here',548            },549          },550          fun: {551            Fungible: TRANSFER_AMOUNT,552          },553        },554      ],555    };556557    const feeAssetItem = 0;558559    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');560    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);561562    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;563    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));564    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;565566    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {567      await helper.wait.newBlocks(3);568569      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});570      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);571572      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;573      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;574      const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;575576      console.log(577        '[Unique -> Acala] transaction fees on Acala: %s ACA',578        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),579      );580      console.log(581        '[Unique -> Acala] transaction fees on Acala: %s UNQ',582        helper.util.bigIntToDecimals(acaUnqFees),583      );584      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));585      expect(acaFees == 0n).to.be.true;586      expect(587        acaUnqFees == expectedAcalaIncomeFee,588        'Acala took different income fee, check the Acala foreign asset config',589      ).to.be.true;590    });591  });592593  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {594    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {595      const destination = {596        V1: {597          parents: 1,598          interior: {599            X2: [600              {Parachain: UNIQUE_CHAIN},601              {602                AccountId32: {603                  network: 'Any',604                  id: randomAccount.addressRaw,605                },606              },607            ],608          },609        },610      };611612      const id = {613        ForeignAsset: 0,614      };615616      await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');617      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);618      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);619620      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;621      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;622623      console.log(624        '[Acala -> Unique] transaction fees on Acala: %s ACA',625        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),626      );627      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));628629      expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;630      expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;631    });632633    await helper.wait.newBlocks(3);634635    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);636    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;637    expect(actuallyDelivered > 0).to.be.true;638639    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));640641    const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;642    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));643    expect(unqFees == 0n).to.be.true;644  });645});646647// These tests are relevant only when the foreign asset pallet is disabled648describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {649  let alice: IKeyringPair;650651  before(async () => {652    await usingPlaygrounds(async (helper, privateKey) => {653      alice = await privateKey('//Alice');654655      // Set the default version to wrap the first message to other chains.656      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);657    });658  });659660  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {661    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {662      const destination = {663        V1: {664          parents: 1,665          interior: {666            X2: [667              {Parachain: UNIQUE_CHAIN},668              {669                AccountId32: {670                  network: 'Any',671                  id: alice.addressRaw,672                },673              },674            ],675          },676        },677      };678679      const id = {680        Token: 'ACA',681      };682683      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');684    });685686    const maxWaitBlocks = 3;687688    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');689690    expect(691      xcmpQueueFailEvent != null,692      '[Acala] xcmpQueue.FailEvent event is expected',693    ).to.be.true;694695    const event = xcmpQueueFailEvent!.event;696    const outcome = event.data[1] as XcmV2TraitsError;697698    expect(699      outcome.isFailedToTransactAsset,700      '[Acala] The XCM error should be `FailedToTransactAsset`',701    ).to.be.true;702  });703});704705describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {706  // Unique constants707  let uniqueDonor: IKeyringPair;708  let uniqueAssetLocation;709710  let randomAccountUnique: IKeyringPair;711  let randomAccountMoonbeam: IKeyringPair;712713  // Moonbeam constants714  let assetId: string;715716  const councilVotingThreshold = 2;717  const technicalCommitteeThreshold = 2;718  const votingPeriod = 3;719  const delayPeriod = 0;720721  const uniqueAssetMetadata = {722    name: 'xcUnique',723    symbol: 'xcUNQ',724    decimals: 18,725    isFrozen: false,726    minimalBalance: 1n,727  };728729  let balanceUniqueTokenInit: bigint;730  let balanceUniqueTokenMiddle: bigint;731  let balanceUniqueTokenFinal: bigint;732  let balanceForeignUnqTokenInit: bigint;733  let balanceForeignUnqTokenMiddle: bigint;734  let balanceForeignUnqTokenFinal: bigint;735  let balanceGlmrTokenInit: bigint;736  let balanceGlmrTokenMiddle: bigint;737  let balanceGlmrTokenFinal: bigint;738739  before(async () => {740    await usingPlaygrounds(async (helper, privateKey) => {741      uniqueDonor = await privateKey('//Alice');742      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);743744      balanceForeignUnqTokenInit = 0n;745746      // Set the default version to wrap the first message to other chains.747      const alice = uniqueDonor;748      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);749    });750751    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {752      const alithAccount = helper.account.alithAccount();753      const baltatharAccount = helper.account.baltatharAccount();754      const dorothyAccount = helper.account.dorothyAccount();755756      randomAccountMoonbeam = helper.account.create();757758      // >>> Sponsoring Dorothy >>>759      console.log('Sponsoring Dorothy.......');760      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);761      console.log('Sponsoring Dorothy.......DONE');762      // <<< Sponsoring Dorothy <<<763764      uniqueAssetLocation = {765        XCM: {766          parents: 1,767          interior: {X1: {Parachain: UNIQUE_CHAIN}},768        },769      };770      const existentialDeposit = 1n;771      const isSufficient = true;772      const unitsPerSecond = 1n;773      const numAssetsWeightHint = 0;774775      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({776        location: uniqueAssetLocation,777        metadata: uniqueAssetMetadata,778        existentialDeposit,779        isSufficient,780        unitsPerSecond,781        numAssetsWeightHint,782      });783      const proposalHash = blake2AsHex(encodedProposal);784785      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);786      console.log('Encoded length %d', encodedProposal.length);787      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);788789      // >>> Note motion preimage >>>790      console.log('Note motion preimage.......');791      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);792      console.log('Note motion preimage.......DONE');793      // <<< Note motion preimage <<<794795      // >>> Propose external motion through council >>>796      console.log('Propose external motion through council.......');797      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});798      const encodedMotion = externalMotion?.method.toHex() || '';799      const motionHash = blake2AsHex(encodedMotion);800      console.log('Motion hash is %s', motionHash);801802      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);803804      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;805      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);806      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);807808      await helper.collective.council.close(809        dorothyAccount,810        motionHash,811        councilProposalIdx,812        {813          refTime: 1_000_000_000,814          proofSize: 1_000_000,815        },816        externalMotion.encodedLength,817      );818      console.log('Propose external motion through council.......DONE');819      // <<< Propose external motion through council <<<820821      // >>> Fast track proposal through technical committee >>>822      console.log('Fast track proposal through technical committee.......');823      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);824      const encodedFastTrack = fastTrack?.method.toHex() || '';825      const fastTrackHash = blake2AsHex(encodedFastTrack);826      console.log('FastTrack hash is %s', fastTrackHash);827828      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);829830      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;831      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);832      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);833834      await helper.collective.techCommittee.close(835        baltatharAccount,836        fastTrackHash,837        techProposalIdx,838        {839          refTime: 1_000_000_000,840          proofSize: 1_000_000,841        },842        fastTrack.encodedLength,843      );844      console.log('Fast track proposal through technical committee.......DONE');845      // <<< Fast track proposal through technical committee <<<846847      // >>> Referendum voting >>>848      console.log('Referendum voting.......');849      await helper.democracy.referendumVote(dorothyAccount, 0, {850        balance: 10_000_000_000_000_000_000n,851        vote: {aye: true, conviction: 1},852      });853      console.log('Referendum voting.......DONE');854      // <<< Referendum voting <<<855856      // >>> Acquire Unique AssetId Info on Moonbeam >>>857      console.log('Acquire Unique AssetId Info on Moonbeam.......');858859      // Wait for the democracy execute860      await helper.wait.newBlocks(5);861862      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();863864      console.log('UNQ asset ID is %s', assetId);865      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');866      // >>> Acquire Unique AssetId Info on Moonbeam >>>867868      // >>> Sponsoring random Account >>>869      console.log('Sponsoring random Account.......');870      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);871      console.log('Sponsoring random Account.......DONE');872      // <<< Sponsoring random Account <<<873874      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);875    });876877    await usingPlaygrounds(async (helper) => {878      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);879      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);880    });881  });882883  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {884    const currencyId = {885      NativeAssetId: 'Here',886    };887    const dest = {888      V2: {889        parents: 1,890        interior: {891          X2: [892            {Parachain: MOONBEAM_CHAIN},893            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},894          ],895        },896      },897    };898    const amount = TRANSFER_AMOUNT;899900    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');901902    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);903    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;904905    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;906    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));907    expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;908909    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {910      await helper.wait.newBlocks(3);911912      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);913914      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;915      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));916      expect(glmrFees == 0n).to.be.true;917918      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;919920      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;921      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));922      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;923    });924  });925926  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {927    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {928      const asset = {929        V1: {930          id: {931            Concrete: {932              parents: 1,933              interior: {934                X1: {Parachain: UNIQUE_CHAIN},935              },936            },937          },938          fun: {939            Fungible: TRANSFER_AMOUNT,940          },941        },942      };943      const destination = {944        V1: {945          parents: 1,946          interior: {947            X2: [948              {Parachain: UNIQUE_CHAIN},949              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},950            ],951          },952        },953      };954955      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');956957      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);958959      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;960      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));961      expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;962963      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);964965      expect(unqRandomAccountAsset).to.be.null;966967      balanceForeignUnqTokenFinal = 0n;968969      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;970      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));971      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;972    });973974    await helper.wait.newBlocks(3);975976    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);977    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;978    expect(actuallyDelivered > 0).to.be.true;979980    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));981982    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;983    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));984    expect(unqFees == 0n).to.be.true;985  });986});987988describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {989  let alice: IKeyringPair;990  let randomAccount: IKeyringPair;991992  const UNQ_ASSET_ID_ON_SHIDEN = 1;993  const UNQ_MINIMAL_BALANCE_ON_SHIDEN = 1n;994995  // Unique -> Astar996  const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Shiden.997  const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?998  const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ999  const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Shiden takes a commision in foreign tokens1000  const senderIinitialBalanceUNQ = 100n * (10n ** UNQ_DECIMALS); // How many UNQ sender has initially1001  const senderBalanceAfterXCM = 89_941967662676666465n; // 89.94... UNQ after XCM call10021003  // Astar -> Unique1004  const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1005  const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ10061007  before(async () => {1008    await usingPlaygrounds(async (helper, privateKey) => {1009      alice = await privateKey('//Alice');1010      [randomAccount] = await helper.arrange.createAccounts([100n], alice);1011      console.log('randomAccount', randomAccount.address);1012    });10131014    await usingAstarPlaygrounds(astarUrl, async (helper) => {1015      console.log('1. Create foreign asset and metadata');1016      // TODO update metadata with values from production1017      await helper.assets.create(1018        alice,1019        UNQ_ASSET_ID_ON_SHIDEN,1020        alice.address,1021        UNQ_MINIMAL_BALANCE_ON_SHIDEN,1022      );10231024      await helper.assets.setMetadata(1025        alice,1026        UNQ_ASSET_ID_ON_SHIDEN,1027        'Cross chain UNQ',1028        'xcUNQ',1029        Number(UNQ_DECIMALS),1030      );10311032      console.log('2. Register asset location on Astar');1033      const assetLocation = {1034        V1: {1035          parents: 1,1036          interior: {1037            X1: {1038              Parachain: UNIQUE_CHAIN,1039            },1040          },1041        },1042      };10431044      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_SHIDEN]);10451046      console.log('3. Set UNQ payment for XCM execution on Astar');1047      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);10481049      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1050      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1051    });1052  });10531054  itSub('Should connect and send UNQ to Astar', async ({helper}) => {1055    const destination = {1056      V1: {1057        parents: 1,1058        interior: {1059          X1: {1060            Parachain: ASTAR_CHAIN,1061          },1062        },1063      },1064    };10651066    const beneficiary = {1067      V1: {1068        parents: 0,1069        interior: {1070          X1: {1071            AccountId32: {1072              network: 'Any',1073              id: randomAccount.addressRaw,1074            },1075          },1076        },1077      },1078    };10791080    const assets = {1081      V1: [1082        {1083          id: {1084            Concrete: {1085              parents: 0,1086              interior: 'Here',1087            },1088          },1089          fun: {1090            Fungible: unqToAstarTransferred,1091          },1092        },1093      ],1094    };10951096    // Initial balance is 100 UNQ1097    const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1098    console.log(`Initial balance is: ${balanceBefore}`);1099    expect(balanceBefore).to.eq(senderIinitialBalanceUNQ);11001101    const feeAssetItem = 0;1102    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');11031104    // Balance after reserve transfer is less than 901105    const balanceAfter = await helper.balance.getSubstrate(randomAccount.address);1106    console.log(`UNQ Balance on Unique after XCM is: ${balanceAfter}`);1107    console.log(`Unique's UNQ commission is: ${balanceBefore - balanceAfter}`);1108    expect(balanceAfter).to.eq(senderBalanceAfterXCM);11091110    await usingAstarPlaygrounds(astarUrl, async (helper) => {1111      await helper.wait.newBlocks(3);1112      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1113      const astarBalance = await helper.balance.getSubstrate(randomAccount.address);11141115      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1116      console.log(`Astar's UNQ commission is: ${unqToAstarTransferred - xcUNQbalance!}`);11171118      expect(xcUNQbalance).to.eq(unqToAstarArrived);1119      // Astar balance does not changed1120      expect(astarBalance).to.eq(astarInitialBalance);1121    });1122  });11231124  itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1125    await usingAstarPlaygrounds(astarUrl, async (helper) => {1126      const destination = {1127        V1: {1128          parents: 1,1129          interior: {1130            X1: {1131              Parachain: UNIQUE_CHAIN,1132            },1133          },1134        },1135      };11361137      const beneficiary = {1138        V1: {1139          parents: 0,1140          interior: {1141            X1: {1142              AccountId32: {1143                network: 'Any',1144                id: randomAccount.addressRaw,1145              },1146            },1147          },1148        },1149      };11501151      const assets = {1152        V1: [1153          {1154            id: {1155              Concrete: {1156                parents: 1,1157                interior: {1158                  X1: {1159                    Parachain: UNIQUE_CHAIN,1160                  },1161                },1162              },1163            },1164            fun: {1165              Fungible: unqFromAstarTransfered,1166            },1167          },1168        ],1169      };11701171      // Initial balance is 1 ASTR1172      const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1173      console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1174      expect(balanceASTRbefore).to.eq(astarInitialBalance);11751176      const feeAssetItem = 0;1177      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1178      await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);11791180      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1181      const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1182      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);11831184      // Assert: xcUNQ balance correctly decreased1185      expect(xcUNQbalance).to.eq(unqOnAstarLeft);1186      // Assert: ASTR balance is 0.996...1187      expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1188    });11891190    await helper.wait.newBlocks(3);1191    const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1192    console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1193    expect(balanceUNQ).to.eq(senderBalanceAfterXCM + unqFromAstarTransfered);1194  });11951196  itSub.skip('Should not accept limitedReserveTransfer of UNQ from ASTAR', async ({helper}) => {1197    await usingAstarPlaygrounds(astarUrl, async (helper) => {1198      const destination = {1199        V1: {1200          parents: 1,1201          interior: {1202            X1: {1203              Parachain: UNIQUE_CHAIN,1204            },1205          },1206        },1207      };12081209      const beneficiary = {1210        V1: {1211          parents: 0,1212          interior: {1213            X1: {1214              AccountId32: {1215                network: 'Any',1216                id: randomAccount.addressRaw,1217              },1218            },1219          },1220        },1221      };12221223      const assets = {1224        V1: [1225          {1226            id: {1227              Concrete: {1228                parents: 1,1229                interior: {1230                  X1: {1231                    Parachain: UNIQUE_CHAIN,1232                  },1233                },1234              },1235            },1236            fun: {1237              Fungible: unqFromAstarTransfered,1238            },1239          },1240        ],1241      };12421243      // Initial balance is 1 ASTAR1244      expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(astarInitialBalance);12451246      const feeAssetItem = 0;1247      // TODO: expect rejected:1248      await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');1249    });1250  });1251});