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

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;4041const TRANSFER_AMOUNT = 2000000000000000000000000n;4243const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4445const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4647const USDT_ASSET_ID = 100;48const USDT_ASSET_METADATA_DECIMALS = 18;49const USDT_ASSET_METADATA_NAME = 'USDT';50const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';51const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;52const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5354const SAFE_XCM_VERSION = 2;5556describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {57  let alice: IKeyringPair;58  let bob: IKeyringPair;5960  let balanceStmnBefore: bigint;61  let balanceStmnAfter: bigint;6263  let balanceUniqueBefore: bigint;64  let balanceUniqueAfter: bigint;65  let balanceUniqueFinal: bigint;6667  let balanceBobBefore: bigint;68  let balanceBobAfter: bigint;69  let balanceBobFinal: bigint;7071  let balanceBobRelayTokenBefore: bigint;72  let balanceBobRelayTokenAfter: bigint;737475  before(async () => {76    await usingPlaygrounds(async (helper, privateKey) => {77      alice = await privateKey('//Alice');78      bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor7980      // Set the default version to wrap the first message to other chains.81      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);82    });8384    await usingRelayPlaygrounds(relayUrl, async (helper) => {85      // Fund accounts on Statemint86      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);87      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);88    });8990    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {91      const sovereignFundingAmount = 3_500_000_000n;9293      await helper.assets.create(94        alice,95        USDT_ASSET_ID,96        alice.address,97        USDT_ASSET_METADATA_MINIMAL_BALANCE,98      );99      await helper.assets.setMetadata(100        alice,101        USDT_ASSET_ID,102        USDT_ASSET_METADATA_NAME,103        USDT_ASSET_METADATA_DESCRIPTION,104        USDT_ASSET_METADATA_DECIMALS,105      );106      await helper.assets.mint(107        alice,108        USDT_ASSET_ID,109        alice.address,110        USDT_ASSET_AMOUNT,111      );112113      // funding parachain sovereing account on Statemint.114      // The sovereign account should be created before any action115      // (the assets pallet on Statemint check if the sovereign account exists)116      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);117      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);118    });119120121    await usingPlaygrounds(async (helper) => {122      const location = {123        V2: {124          parents: 1,125          interior: {X3: [126            {127              Parachain: STATEMINT_CHAIN,128            },129            {130              PalletInstance: STATEMINT_PALLET_INSTANCE,131            },132            {133              GeneralIndex: USDT_ASSET_ID,134            },135          ]},136        },137      };138139      const metadata =140      {141        name: USDT_ASSET_ID,142        symbol: USDT_ASSET_METADATA_NAME,143        decimals: USDT_ASSET_METADATA_DECIMALS,144        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,145      };146      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);147      balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);148    });149150151    // Providing the relay currency to the unique sender account152    // (fee for USDT XCM are paid in relay tokens)153    await usingRelayPlaygrounds(relayUrl, async (helper) => {154      const destination = {155        V1: {156          parents: 0,157          interior: {X1: {158            Parachain: UNIQUE_CHAIN,159          },160          },161        }};162163      const beneficiary = {164        V1: {165          parents: 0,166          interior: {X1: {167            AccountId32: {168              network: 'Any',169              id: alice.addressRaw,170            },171          }},172        },173      };174175      const assets = {176        V1: [177          {178            id: {179              Concrete: {180                parents: 0,181                interior: 'Here',182              },183            },184            fun: {185              Fungible: TRANSFER_AMOUNT_RELAY,186            },187          },188        ],189      };190191      const feeAssetItem = 0;192193      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');194    });195196  });197198  itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {199    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {200      const dest = {201        V1: {202          parents: 1,203          interior: {X1: {204            Parachain: UNIQUE_CHAIN,205          },206          },207        }};208209      const beneficiary = {210        V1: {211          parents: 0,212          interior: {X1: {213            AccountId32: {214              network: 'Any',215              id: alice.addressRaw,216            },217          }},218        },219      };220221      const assets = {222        V1: [223          {224            id: {225              Concrete: {226                parents: 0,227                interior: {228                  X2: [229                    {230                      PalletInstance: STATEMINT_PALLET_INSTANCE,231                    },232                    {233                      GeneralIndex: USDT_ASSET_ID,234                    },235                  ]},236              },237            },238            fun: {239              Fungible: TRANSFER_AMOUNT,240            },241          },242        ],243      };244245      const feeAssetItem = 0;246247      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);248      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');249250      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);251252      // common good parachain take commission in it native token253      console.log(254        '[Statemint -> Unique] transaction fees on Statemint: %s WND',255        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),256      );257      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;258259    });260261262    // ensure that asset has been delivered263    await helper.wait.newBlocks(3);264265    // expext collection id will be with id 1266    const free = await helper.ft.getBalance(1, {Substrate: alice.address});267268    balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);269270    console.log(271      '[Statemint -> Unique] transaction fees on Unique: %s USDT',272      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),273    );274    console.log(275      '[Statemint -> Unique] transaction fees on Unique: %s UNQ',276      helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),277    );278    // commission has not paid in USDT token279    expect(free).to.be.equal(TRANSFER_AMOUNT);280    // ... and parachain native token281    expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;282  });283284  itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {285    const destination = {286      V2: {287        parents: 1,288        interior: {X2: [289          {290            Parachain: STATEMINT_CHAIN,291          },292          {293            AccountId32: {294              network: 'Any',295              id: alice.addressRaw,296            },297          },298        ]},299      },300    };301302    const relayFee = 400_000_000_000_000n;303    const currencies: [any, bigint][] = [304      [305        {306          ForeignAssetId: 0,307        },308        TRANSFER_AMOUNT,309      ],310      [311        {312          NativeAssetId: 'Parent',313        },314        relayFee,315      ],316    ];317318    const feeItem = 1;319320    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');321322    // the commission has been paid in parachain native token323    balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);324    console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));325    expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;326327    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {328      await helper.wait.newBlocks(3);329330      // The USDT token never paid fees. Its amount not changed from begin value.331      // Also check that xcm transfer has been succeeded332      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;333    });334  });335336  itSub('Should connect and send Relay token to Unique', async ({helper}) => {337    balanceBobBefore = await helper.balance.getSubstrate(bob.address);338    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});339340    await usingRelayPlaygrounds(relayUrl, async (helper) => {341      const destination = {342        V1: {343          parents: 0,344          interior: {X1: {345            Parachain: UNIQUE_CHAIN,346          },347          },348        }};349350      const beneficiary = {351        V1: {352          parents: 0,353          interior: {X1: {354            AccountId32: {355              network: 'Any',356              id: bob.addressRaw,357            },358          }},359        },360      };361362      const assets = {363        V1: [364          {365            id: {366              Concrete: {367                parents: 0,368                interior: 'Here',369              },370            },371            fun: {372              Fungible: TRANSFER_AMOUNT_RELAY,373            },374          },375        ],376      };377378      const feeAssetItem = 0;379380      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');381    });382383    await helper.wait.newBlocks(3);384385    balanceBobAfter = await helper.balance.getSubstrate(bob.address);386    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});387388    const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;389    const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;390    console.log(391      '[Relay (Westend) -> Unique] transaction fees: %s UNQ',392      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),393    );394    console.log(395      '[Relay (Westend) -> Unique] transaction fees: %s WND',396      helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),397    );398    console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);399    expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;400    expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;401  });402403  itSub('Should connect and send Relay token back', async ({helper}) => {404    let relayTokenBalanceBefore: bigint;405    let relayTokenBalanceAfter: bigint;406    await usingRelayPlaygrounds(relayUrl, async (helper) => {407      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);408    });409410    const destination = {411      V2: {412        parents: 1,413        interior: {414          X1:{415            AccountId32: {416              network: 'Any',417              id: bob.addressRaw,418            },419          },420        },421      },422    };423424    const currencies: any = [425      [426        {427          NativeAssetId: 'Parent',428        },429        TRANSFER_AMOUNT_RELAY,430      ],431    ];432433    const feeItem = 0;434435    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');436437    balanceBobFinal = await helper.balance.getSubstrate(bob.address);438    console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));439440    await usingRelayPlaygrounds(relayUrl, async (helper) => {441      await helper.wait.newBlocks(10);442      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);443444      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;445      console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));446      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;447    });448  });449});450451describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {452  let alice: IKeyringPair;453  let randomAccount: IKeyringPair;454455  let balanceUniqueTokenInit: bigint;456  let balanceUniqueTokenMiddle: bigint;457  let balanceUniqueTokenFinal: bigint;458  let balanceAcalaTokenInit: bigint;459  let balanceAcalaTokenMiddle: bigint;460  let balanceAcalaTokenFinal: bigint;461  let balanceUniqueForeignTokenInit: bigint;462  let balanceUniqueForeignTokenMiddle: bigint;463  let balanceUniqueForeignTokenFinal: bigint;464465  // computed by a test transfer from prod Unique to prod Acala.466  // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48467  // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)468  const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;469470  const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;471472  before(async () => {473    await usingPlaygrounds(async (helper, privateKey) => {474      alice = await privateKey('//Alice');475      [randomAccount] = await helper.arrange.createAccounts([0n], alice);476477      // Set the default version to wrap the first message to other chains.478      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);479    });480481    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {482      const destination = {483        V1: {484          parents: 1,485          interior: {486            X1: {487              Parachain: UNIQUE_CHAIN,488            },489          },490        },491      };492493      const metadata = {494        name: 'Unique Network',495        symbol: 'UNQ',496        decimals: 18,497        minimalBalance: 1250000000000000000n,498      };499500      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);501      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);502      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);503      balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});504    });505506    await usingPlaygrounds(async (helper) => {507      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);508      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);509    });510  });511512  itSub('Should connect and send UNQ to Acala', async ({helper}) => {513514    const destination = {515      V2: {516        parents: 1,517        interior: {518          X1: {519            Parachain: ACALA_CHAIN,520          },521        },522      },523    };524525    const beneficiary = {526      V2: {527        parents: 0,528        interior: {529          X1: {530            AccountId32: {531              network: 'Any',532              id: randomAccount.addressRaw,533            },534          },535        },536      },537    };538539    const assets = {540      V2: [541        {542          id: {543            Concrete: {544              parents: 0,545              interior: 'Here',546            },547          },548          fun: {549            Fungible: TRANSFER_AMOUNT,550          },551        },552      ],553    };554555    const feeAssetItem = 0;556557    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');558    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);559560    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;561    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));562    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;563564    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {565      await helper.wait.newBlocks(3);566567      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});568      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);569570      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;571      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;572      const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;573574      console.log(575        '[Unique -> Acala] transaction fees on Acala: %s ACA',576        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),577      );578      console.log(579        '[Unique -> Acala] transaction fees on Acala: %s UNQ',580        helper.util.bigIntToDecimals(acaUnqFees),581      );582      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));583      expect(acaFees == 0n).to.be.true;584      expect(585        acaUnqFees == expectedAcalaIncomeFee,586        'Acala took different income fee, check the Acala foreign asset config',587      ).to.be.true;588    });589  });590591  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {592    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {593      const destination = {594        V1: {595          parents: 1,596          interior: {597            X2: [598              {Parachain: UNIQUE_CHAIN},599              {600                AccountId32: {601                  network: 'Any',602                  id: randomAccount.addressRaw,603                },604              },605            ],606          },607        },608      };609610      const id = {611        ForeignAsset: 0,612      };613614      await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');615      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);616      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);617618      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;619      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;620621      console.log(622        '[Acala -> Unique] transaction fees on Acala: %s ACA',623        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),624      );625      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));626627      expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;628      expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;629    });630631    await helper.wait.newBlocks(3);632633    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);634    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;635    expect(actuallyDelivered > 0).to.be.true;636637    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));638639    const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;640    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));641    expect(unqFees == 0n).to.be.true;642  });643});644645// These tests are relevant only when the foreign asset pallet is disabled646describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {647  let alice: IKeyringPair;648649  before(async () => {650    await usingPlaygrounds(async (helper, privateKey) => {651      alice = await privateKey('//Alice');652653      // Set the default version to wrap the first message to other chains.654      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);655    });656  });657658  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {659    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {660      const destination = {661        V1: {662          parents: 1,663          interior: {664            X2: [665              {Parachain: UNIQUE_CHAIN},666              {667                AccountId32: {668                  network: 'Any',669                  id: alice.addressRaw,670                },671              },672            ],673          },674        },675      };676677      const id = {678        Token: 'ACA',679      };680681      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');682    });683684    const maxWaitBlocks = 3;685686    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');687688    expect(689      xcmpQueueFailEvent != null,690      '[Acala] xcmpQueue.FailEvent event is expected',691    ).to.be.true;692693    const event = xcmpQueueFailEvent!.event;694    const outcome = event.data[1] as XcmV2TraitsError;695696    expect(697      outcome.isFailedToTransactAsset,698      '[Acala] The XCM error should be `FailedToTransactAsset`',699    ).to.be.true;700  });701});702703describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {704  // Unique constants705  let uniqueDonor: IKeyringPair;706  let uniqueAssetLocation;707708  let randomAccountUnique: IKeyringPair;709  let randomAccountMoonbeam: IKeyringPair;710711  // Moonbeam constants712  let assetId: string;713714  const councilVotingThreshold = 2;715  const technicalCommitteeThreshold = 2;716  const votingPeriod = 3;717  const delayPeriod = 0;718719  const uniqueAssetMetadata = {720    name: 'xcUnique',721    symbol: 'xcUNQ',722    decimals: 18,723    isFrozen: false,724    minimalBalance: 1n,725  };726727  let balanceUniqueTokenInit: bigint;728  let balanceUniqueTokenMiddle: bigint;729  let balanceUniqueTokenFinal: bigint;730  let balanceForeignUnqTokenInit: bigint;731  let balanceForeignUnqTokenMiddle: bigint;732  let balanceForeignUnqTokenFinal: bigint;733  let balanceGlmrTokenInit: bigint;734  let balanceGlmrTokenMiddle: bigint;735  let balanceGlmrTokenFinal: bigint;736737  before(async () => {738    await usingPlaygrounds(async (helper, privateKey) => {739      uniqueDonor = await privateKey('//Alice');740      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);741742      balanceForeignUnqTokenInit = 0n;743744      // Set the default version to wrap the first message to other chains.745      const alice = uniqueDonor;746      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);747    });748749    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {750      const alithAccount = helper.account.alithAccount();751      const baltatharAccount = helper.account.baltatharAccount();752      const dorothyAccount = helper.account.dorothyAccount();753754      randomAccountMoonbeam = helper.account.create();755756      // >>> Sponsoring Dorothy >>>757      console.log('Sponsoring Dorothy.......');758      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);759      console.log('Sponsoring Dorothy.......DONE');760      // <<< Sponsoring Dorothy <<<761762      uniqueAssetLocation = {763        XCM: {764          parents: 1,765          interior: {X1: {Parachain: UNIQUE_CHAIN}},766        },767      };768      const existentialDeposit = 1n;769      const isSufficient = true;770      const unitsPerSecond = 1n;771      const numAssetsWeightHint = 0;772773      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({774        location: uniqueAssetLocation,775        metadata: uniqueAssetMetadata,776        existentialDeposit,777        isSufficient,778        unitsPerSecond,779        numAssetsWeightHint,780      });781      const proposalHash = blake2AsHex(encodedProposal);782783      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);784      console.log('Encoded length %d', encodedProposal.length);785      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);786787      // >>> Note motion preimage >>>788      console.log('Note motion preimage.......');789      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);790      console.log('Note motion preimage.......DONE');791      // <<< Note motion preimage <<<792793      // >>> Propose external motion through council >>>794      console.log('Propose external motion through council.......');795      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});796      const encodedMotion = externalMotion?.method.toHex() || '';797      const motionHash = blake2AsHex(encodedMotion);798      console.log('Motion hash is %s', motionHash);799800      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);801802      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;803      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);804      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);805806      await helper.collective.council.close(807        dorothyAccount,808        motionHash,809        councilProposalIdx,810        {811          refTime: 1_000_000_000,812          proofSize: 1_000_000,813        },814        externalMotion.encodedLength,815      );816      console.log('Propose external motion through council.......DONE');817      // <<< Propose external motion through council <<<818819      // >>> Fast track proposal through technical committee >>>820      console.log('Fast track proposal through technical committee.......');821      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);822      const encodedFastTrack = fastTrack?.method.toHex() || '';823      const fastTrackHash = blake2AsHex(encodedFastTrack);824      console.log('FastTrack hash is %s', fastTrackHash);825826      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);827828      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;829      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);830      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);831832      await helper.collective.techCommittee.close(833        baltatharAccount,834        fastTrackHash,835        techProposalIdx,836        {837          refTime: 1_000_000_000,838          proofSize: 1_000_000,839        },840        fastTrack.encodedLength,841      );842      console.log('Fast track proposal through technical committee.......DONE');843      // <<< Fast track proposal through technical committee <<<844845      // >>> Referendum voting >>>846      console.log('Referendum voting.......');847      await helper.democracy.referendumVote(dorothyAccount, 0, {848        balance: 10_000_000_000_000_000_000n,849        vote: {aye: true, conviction: 1},850      });851      console.log('Referendum voting.......DONE');852      // <<< Referendum voting <<<853854      // >>> Acquire Unique AssetId Info on Moonbeam >>>855      console.log('Acquire Unique AssetId Info on Moonbeam.......');856857      // Wait for the democracy execute858      await helper.wait.newBlocks(5);859860      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();861862      console.log('UNQ asset ID is %s', assetId);863      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');864      // >>> Acquire Unique AssetId Info on Moonbeam >>>865866      // >>> Sponsoring random Account >>>867      console.log('Sponsoring random Account.......');868      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);869      console.log('Sponsoring random Account.......DONE');870      // <<< Sponsoring random Account <<<871872      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);873    });874875    await usingPlaygrounds(async (helper) => {876      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);877      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);878    });879  });880881  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {882    const currencyId = {883      NativeAssetId: 'Here',884    };885    const dest = {886      V2: {887        parents: 1,888        interior: {889          X2: [890            {Parachain: MOONBEAM_CHAIN},891            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},892          ],893        },894      },895    };896    const amount = TRANSFER_AMOUNT;897898    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');899900    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);901    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;902903    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;904    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));905    expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;906907    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {908      await helper.wait.newBlocks(3);909910      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);911912      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;913      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));914      expect(glmrFees == 0n).to.be.true;915916      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;917918      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;919      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));920      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;921    });922  });923924  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {925    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {926      const asset = {927        V1: {928          id: {929            Concrete: {930              parents: 1,931              interior: {932                X1: {Parachain: UNIQUE_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: UNIQUE_CHAIN},947              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},948            ],949          },950        },951      };952953      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');954955      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);956957      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;958      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));959      expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;960961      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);962963      expect(unqRandomAccountAsset).to.be.null;964965      balanceForeignUnqTokenFinal = 0n;966967      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;968      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));969      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;970    });971972    await helper.wait.newBlocks(3);973974    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);975    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;976    expect(actuallyDelivered > 0).to.be.true;977978    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));979980    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;981    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));982    expect(unqFees == 0n).to.be.true;983  });984});985986describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {987  let alice: IKeyringPair;988  let randomAccount: IKeyringPair;989990  const astarInitialBalance = 1n * (10n ** 18n);991  const unqToAstarAmount = 10n * (10n ** 18n);992993  before(async () => {994    await usingPlaygrounds(async (helper, privateKey) => {995      alice = await privateKey('//Alice');996      [randomAccount] = await helper.arrange.createAccounts([100n], alice);997      console.log('randomAccount', randomAccount.address);998    });9991000    await usingAstarPlaygrounds(astarUrl, async (helper) => {1001      console.log('1. Create foreign asset and metadata');1002      await helper.assets.create(1003        alice,1004        1,1005        alice.address,1006        1n,1007      );10081009      await helper.assets.setMetadata(1010        alice,1011        1,1012        'Cross chain UNQ',1013        'xcUNQ',1014        18,1015      );10161017      console.log('2. Register asset location');1018      const assetLocation = {1019        V1: {1020          parents: 1,1021          interior: {1022            X1: {1023              Parachain: UNIQUE_CHAIN,1024            },1025          },1026        },1027      };10281029      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, 1]);10301031      console.log('3. Set payment for computation');1032      // TODO this is Phala's price, what price will be for Unique?1033      const unitsPerSecond = 228_000_000_000n;1034      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);10351036      console.log('4. Transfer 1 ASTR to recepient');1037      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1038    });1039  });10401041  itSub.only('Should connect and send UNQ to Astar', async ({helper}) => {1042    const destination = {1043      V1: {1044        parents: 1,1045        interior: {1046          X1: {1047            Parachain: ASTAR_CHAIN,1048          },1049        },1050      },1051    };10521053    const beneficiary = {1054      V1: {1055        parents: 0,1056        interior: {1057          X1: {1058            AccountId32: {1059              network: 'Any',1060              id: randomAccount.addressRaw,1061            },1062          },1063        },1064      },1065    };10661067    const assets = {1068      V1: [1069        {1070          id: {1071            Concrete: {1072              parents: 0,1073              interior: 'Here',1074            },1075          },1076          fun: {1077            Fungible: unqToAstarAmount,1078          },1079        },1080      ],1081    };10821083    // Initial balance is 100 UNQ1084    expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(100n * (10n ** 18n));10851086    const feeAssetItem = 0;1087    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');10881089    // Balance after reserve transfer is less than 901090    expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(89_941967662676666465n);10911092    await usingAstarPlaygrounds(astarUrl, async (helper) => {1093      await helper.wait.newBlocks(3);1094      const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1095      const astarBalance = await helper.balance.getSubstrate(randomAccount.address);10961097      expect(xcUNQbalance).to.eq(9_999_999_999_088_000_000n);1098      // Astar balance does not changed1099      expect(astarBalance).to.eq(1_000_000_000_000_000_000n);1100    });1101  });11021103  itSub.only('Should connect to Astar and send UNQ back', async ({helper}) => {1104    await usingAstarPlaygrounds(astarUrl, async (helper) => {1105      const destination = {1106        V1: {1107          parents: 1,1108          interior: {1109            X1: {1110              Parachain: UNIQUE_CHAIN,1111            },1112          },1113        },1114      };11151116      const beneficiary = {1117        V1: {1118          parents: 0,1119          interior: {1120            X1: {1121              AccountId32: {1122                network: 'Any',1123                id: randomAccount.addressRaw,1124              },1125            },1126          },1127        },1128      };11291130      const assets = {1131        V1: [1132          {1133            id: {1134              Concrete: {1135                parents: 1,1136                interior: {1137                  X1: {1138                    Parachain: UNIQUE_CHAIN,1139                  },1140                },1141              },1142            },1143            fun: {1144              Fungible: 5_000_000_000_000_000_000n,1145            },1146          },1147        ],1148      };11491150      // Initial balance is 1 ASTR1151      expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(1_000_000_000_000_000_000n);11521153      const feeAssetItem = 0;1154      await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);11551156      const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1157      const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);11581159      // Assert: xcUNQ balance decreased1160      expect(xcUNQbalance).to.eq(4_999_999_999_088_000_000n);1161      // Assert: ASTR balance is 0.996...1162      expect(balanceAstar / (10n ** 15n)).to.eq(996n);1163    });11641165    await helper.wait.newBlocks(3);1166    const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1167    expect(balanceUNQ).to.eq(89_941967662676666465n + 5_000_000_000_000_000_000n);1168  });11691170  itSub.skip('Should not accept limitedReserveTransfer of UNQ from ASTAR', async ({helper}) => {1171    await usingAstarPlaygrounds(astarUrl, async (helper) => {1172      const destination = {1173        V1: {1174          parents: 1,1175          interior: {1176            X1: {1177              Parachain: UNIQUE_CHAIN,1178            },1179          },1180        },1181      };11821183      const beneficiary = {1184        V1: {1185          parents: 0,1186          interior: {1187            X1: {1188              AccountId32: {1189                network: 'Any',1190                id: randomAccount.addressRaw,1191              },1192            },1193          },1194        },1195      };11961197      const assets = {1198        V1: [1199          {1200            id: {1201              Concrete: {1202                parents: 1,1203                interior: {1204                  X1: {1205                    Parachain: UNIQUE_CHAIN,1206                  },1207                },1208              },1209            },1210            fun: {1211              Fungible: 5_000_000_000_000_000_000n, // TODO set another value1212            },1213          },1214        ],1215      };12161217      // Initial balance is 1 ASTAR1218      expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(1_000_000_000_000_000_000n);12191220      const feeAssetItem = 0;1221      await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');12221223      // Balance after reserve transfer is less than 1 ASTAR1224      const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1225      const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);12261227      // xcUNQ balance decreased1228      expect(xcUNQbalance).to.eq(4_999_999_999_088_000_000n);1229      // Astar balance is 0.997...1230      expect(balanceAstar / (10n ** 15n)).to.eq(997n);1231    });12321233    await helper.wait.newBlocks(3);1234    const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1235    expect(balanceUNQ).to.eq(89_941967662676666465n + 5_000_000_000_000_000_000n);1236  });1237});