`f628606f8371`

source

tests/src/xcm/xcmUnique.test.ts32.6 KiBsource history
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} from '../util';2223const UNIQUE_CHAIN = 2037;24const STATEMINT_CHAIN = 1000;25const ACALA_CHAIN = 2000;26const MOONBEAM_CHAIN = 2004;2728const STATEMINT_PALLET_INSTANCE = 50;2930const relayUrl = config.relayUrl;31const statemintUrl = config.statemintUrl;32const acalaUrl = config.acalaUrl;33const moonbeamUrl = config.moonbeamUrl;3435const RELAY_DECIMALS = 12;36const STATEMINT_DECIMALS = 12;37const ACALA_DECIMALS = 12;3839const TRANSFER_AMOUNT = 2000000000000000000000000n;4041const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4243const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4445const USDT_ASSET_ID = 100;46const USDT_ASSET_METADATA_DECIMALS = 18;47const USDT_ASSET_METADATA_NAME = 'USDT';48const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';49const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;50const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5152const SAFE_XCM_VERSION = 2;5354describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {55  let alice: IKeyringPair;56  let bob: IKeyringPair;5758  let balanceStmnBefore: bigint;59  let balanceStmnAfter: bigint;6061  let balanceUniqueBefore: bigint;62  let balanceUniqueAfter: bigint;63  let balanceUniqueFinal: bigint;6465  let balanceBobBefore: bigint;66  let balanceBobAfter: bigint;67  let balanceBobFinal: bigint;6869  let balanceBobRelayTokenBefore: bigint;70  let balanceBobRelayTokenAfter: bigint;717273  before(async () => {74    await usingPlaygrounds(async (helper, privateKey) => {75      alice = await privateKey('//Alice');76      bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor7778      // Set the default version to wrap the first message to other chains.79      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);80    });8182    await usingRelayPlaygrounds(relayUrl, async (helper) => {83      // Fund accounts on Statemint84      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);85      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);86    });8788    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {89      const sovereignFundingAmount = 3_500_000_000n;9091      await helper.assets.create(92        alice,93        USDT_ASSET_ID,94        alice.address,95        USDT_ASSET_METADATA_MINIMAL_BALANCE,96      );97      await helper.assets.setMetadata(98        alice,99        USDT_ASSET_ID,100        USDT_ASSET_METADATA_NAME,101        USDT_ASSET_METADATA_DESCRIPTION,102        USDT_ASSET_METADATA_DECIMALS,103      );104      await helper.assets.mint(105        alice,106        USDT_ASSET_ID,107        alice.address,108        USDT_ASSET_AMOUNT,109      );110111      // funding parachain sovereing account on Statemint.112      // The sovereign account should be created before any action113      // (the assets pallet on Statemint check if the sovereign account exists)114      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);115      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);116    });117118119    await usingPlaygrounds(async (helper) => {120      const location = {121        V2: {122          parents: 1,123          interior: {X3: [124            {125              Parachain: STATEMINT_CHAIN,126            },127            {128              PalletInstance: STATEMINT_PALLET_INSTANCE,129            },130            {131              GeneralIndex: USDT_ASSET_ID,132            },133          ]},134        },135      };136137      const metadata =138      {139        name: USDT_ASSET_ID,140        symbol: USDT_ASSET_METADATA_NAME,141        decimals: USDT_ASSET_METADATA_DECIMALS,142        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,143      };144      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);145      balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);146    });147148149    // Providing the relay currency to the unique sender account150    // (fee for USDT XCM are paid in relay tokens)151    await usingRelayPlaygrounds(relayUrl, async (helper) => {152      const destination = {153        V1: {154          parents: 0,155          interior: {X1: {156            Parachain: UNIQUE_CHAIN,157          },158          },159        }};160161      const beneficiary = {162        V1: {163          parents: 0,164          interior: {X1: {165            AccountId32: {166              network: 'Any',167              id: alice.addressRaw,168            },169          }},170        },171      };172173      const assets = {174        V1: [175          {176            id: {177              Concrete: {178                parents: 0,179                interior: 'Here',180              },181            },182            fun: {183              Fungible: TRANSFER_AMOUNT_RELAY,184            },185          },186        ],187      };188189      const feeAssetItem = 0;190191      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');192    });193194  });195196  itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {197    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {198      const dest = {199        V1: {200          parents: 1,201          interior: {X1: {202            Parachain: UNIQUE_CHAIN,203          },204          },205        }};206207      const beneficiary = {208        V1: {209          parents: 0,210          interior: {X1: {211            AccountId32: {212              network: 'Any',213              id: alice.addressRaw,214            },215          }},216        },217      };218219      const assets = {220        V1: [221          {222            id: {223              Concrete: {224                parents: 0,225                interior: {226                  X2: [227                    {228                      PalletInstance: STATEMINT_PALLET_INSTANCE,229                    },230                    {231                      GeneralIndex: USDT_ASSET_ID,232                    },233                  ]},234              },235            },236            fun: {237              Fungible: TRANSFER_AMOUNT,238            },239          },240        ],241      };242243      const feeAssetItem = 0;244245      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);246      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');247248      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);249250      // common good parachain take commission in it native token251      console.log(252        '[Statemint -> Unique] transaction fees on Statemint: %s WND',253        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),254      );255      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;256257    });258259260    // ensure that asset has been delivered261    await helper.wait.newBlocks(3);262263    // expext collection id will be with id 1264    const free = await helper.ft.getBalance(1, {Substrate: alice.address});265266    balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);267268    console.log(269      '[Statemint -> Unique] transaction fees on Unique: %s USDT',270      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),271    );272    console.log(273      '[Statemint -> Unique] transaction fees on Unique: %s UNQ',274      helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),275    );276    // commission has not paid in USDT token277    expect(free).to.be.equal(TRANSFER_AMOUNT);278    // ... and parachain native token279    expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;280  });281282  itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {283    const destination = {284      V2: {285        parents: 1,286        interior: {X2: [287          {288            Parachain: STATEMINT_CHAIN,289          },290          {291            AccountId32: {292              network: 'Any',293              id: alice.addressRaw,294            },295          },296        ]},297      },298    };299300    const relayFee = 400_000_000_000_000n;301    const currencies: [any, bigint][] = [302      [303        {304          ForeignAssetId: 0,305        },306        TRANSFER_AMOUNT,307      ],308      [309        {310          NativeAssetId: 'Parent',311        },312        relayFee,313      ],314    ];315316    const feeItem = 1;317318    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');319320    // the commission has been paid in parachain native token321    balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);322    console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));323    expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;324325    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {326      await helper.wait.newBlocks(3);327328      // The USDT token never paid fees. Its amount not changed from begin value.329      // Also check that xcm transfer has been succeeded330      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;331    });332  });333334  itSub('Should connect and send Relay token to Unique', async ({helper}) => {335    balanceBobBefore = await helper.balance.getSubstrate(bob.address);336    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});337338    await usingRelayPlaygrounds(relayUrl, async (helper) => {339      const destination = {340        V1: {341          parents: 0,342          interior: {X1: {343            Parachain: UNIQUE_CHAIN,344          },345          },346        }};347348      const beneficiary = {349        V1: {350          parents: 0,351          interior: {X1: {352            AccountId32: {353              network: 'Any',354              id: bob.addressRaw,355            },356          }},357        },358      };359360      const assets = {361        V1: [362          {363            id: {364              Concrete: {365                parents: 0,366                interior: 'Here',367              },368            },369            fun: {370              Fungible: TRANSFER_AMOUNT_RELAY,371            },372          },373        ],374      };375376      const feeAssetItem = 0;377378      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');379    });380381    await helper.wait.newBlocks(3);382383    balanceBobAfter = await helper.balance.getSubstrate(bob.address);384    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});385386    const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;387    const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;388    console.log(389      '[Relay (Westend) -> Unique] transaction fees: %s UNQ',390      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),391    );392    console.log(393      '[Relay (Westend) -> Unique] transaction fees: %s WND',394      helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),395    );396    console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);397    expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;398    expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;399  });400401  itSub('Should connect and send Relay token back', async ({helper}) => {402    let relayTokenBalanceBefore: bigint;403    let relayTokenBalanceAfter: bigint;404    await usingRelayPlaygrounds(relayUrl, async (helper) => {405      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);406    });407408    const destination = {409      V2: {410        parents: 1,411        interior: {412          X1:{413            AccountId32: {414              network: 'Any',415              id: bob.addressRaw,416            },417          },418        },419      },420    };421422    const currencies: any = [423      [424        {425          NativeAssetId: 'Parent',426        },427        TRANSFER_AMOUNT_RELAY,428      ],429    ];430431    const feeItem = 0;432433    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');434435    balanceBobFinal = await helper.balance.getSubstrate(bob.address);436    console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));437438    await usingRelayPlaygrounds(relayUrl, async (helper) => {439      await helper.wait.newBlocks(10);440      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);441442      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;443      console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));444      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;445    });446  });447});448449describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {450  let alice: IKeyringPair;451  let randomAccount: IKeyringPair;452453  let balanceUniqueTokenInit: bigint;454  let balanceUniqueTokenMiddle: bigint;455  let balanceUniqueTokenFinal: bigint;456  let balanceAcalaTokenInit: bigint;457  let balanceAcalaTokenMiddle: bigint;458  let balanceAcalaTokenFinal: bigint;459  let balanceUniqueForeignTokenInit: bigint;460  let balanceUniqueForeignTokenMiddle: bigint;461  let balanceUniqueForeignTokenFinal: bigint;462463  // computed by a test transfer from prod Unique to prod Acala.464  // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48465  // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)466  const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;467468  const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;469470  before(async () => {471    await usingPlaygrounds(async (helper, privateKey) => {472      alice = await privateKey('//Alice');473      [randomAccount] = await helper.arrange.createAccounts([0n], alice);474475      // Set the default version to wrap the first message to other chains.476      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);477    });478479    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {480      const destination = {481        V1: {482          parents: 1,483          interior: {484            X1: {485              Parachain: UNIQUE_CHAIN,486            },487          },488        },489      };490491      const metadata = {492        name: 'Unique Network',493        symbol: 'UNQ',494        decimals: 18,495        minimalBalance: 1250000000000000000n,496      };497498      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);499      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);500      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);501      balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});502    });503504    await usingPlaygrounds(async (helper) => {505      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);506      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);507    });508  });509510  itSub('Should connect and send UNQ to Acala', async ({helper}) => {511512    const destination = {513      V2: {514        parents: 1,515        interior: {516          X1: {517            Parachain: ACALA_CHAIN,518          },519        },520      },521    };522523    const beneficiary = {524      V2: {525        parents: 0,526        interior: {527          X1: {528            AccountId32: {529              network: 'Any',530              id: randomAccount.addressRaw,531            },532          },533        },534      },535    };536537    const assets = {538      V2: [539        {540          id: {541            Concrete: {542              parents: 0,543              interior: 'Here',544            },545          },546          fun: {547            Fungible: TRANSFER_AMOUNT,548          },549        },550      ],551    };552553    const feeAssetItem = 0;554555    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');556    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);557558    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;559    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));560    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;561562    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {563      await helper.wait.newBlocks(3);564565      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});566      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);567568      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;569      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;570      const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;571572      console.log(573        '[Unique -> Acala] transaction fees on Acala: %s ACA',574        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),575      );576      console.log(577        '[Unique -> Acala] transaction fees on Acala: %s UNQ',578        helper.util.bigIntToDecimals(acaUnqFees),579      );580      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));581      expect(acaFees == 0n).to.be.true;582      expect(583        acaUnqFees == expectedAcalaIncomeFee,584        'Acala took different income fee, check the Acala foreign asset config',585      ).to.be.true;586    });587  });588589  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {590    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {591      const destination = {592        V1: {593          parents: 1,594          interior: {595            X2: [596              {Parachain: UNIQUE_CHAIN},597              {598                AccountId32: {599                  network: 'Any',600                  id: randomAccount.addressRaw,601                },602              },603            ],604          },605        },606      };607608      const id = {609        ForeignAsset: 0,610      };611612      await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');613      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);614      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);615616      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;617      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;618619      console.log(620        '[Acala -> Unique] transaction fees on Acala: %s ACA',621        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),622      );623      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));624625      expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;626      expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;627    });628629    await helper.wait.newBlocks(3);630631    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);632    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;633    expect(actuallyDelivered > 0).to.be.true;634635    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));636637    const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;638    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));639    expect(unqFees == 0n).to.be.true;640  });641});642643// These tests are relevant only when the foreign asset pallet is disabled644describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {645  let alice: IKeyringPair;646647  before(async () => {648    await usingPlaygrounds(async (helper, privateKey) => {649      alice = await privateKey('//Alice');650651      // Set the default version to wrap the first message to other chains.652      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);653    });654  });655656  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {657    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {658      const destination = {659        V1: {660          parents: 1,661          interior: {662            X2: [663              {Parachain: UNIQUE_CHAIN},664              {665                AccountId32: {666                  network: 'Any',667                  id: alice.addressRaw,668                },669              },670            ],671          },672        },673      };674675      const id = {676        Token: 'ACA',677      };678679      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');680    });681682    const maxWaitBlocks = 3;683684    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');685686    expect(687      xcmpQueueFailEvent != null,688      '[Acala] xcmpQueue.FailEvent event is expected',689    ).to.be.true;690691    const event = xcmpQueueFailEvent!.event;692    const outcome = event.data[1] as XcmV2TraitsError;693694    expect(695      outcome.isFailedToTransactAsset,696      '[Acala] The XCM error should be `FailedToTransactAsset`',697    ).to.be.true;698  });699});700701describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {702  // Unique constants703  let uniqueDonor: IKeyringPair;704  let uniqueAssetLocation;705706  let randomAccountUnique: IKeyringPair;707  let randomAccountMoonbeam: IKeyringPair;708709  // Moonbeam constants710  let assetId: string;711712  const councilVotingThreshold = 2;713  const technicalCommitteeThreshold = 2;714  const votingPeriod = 3;715  const delayPeriod = 0;716717  const uniqueAssetMetadata = {718    name: 'xcUnique',719    symbol: 'xcUNQ',720    decimals: 18,721    isFrozen: false,722    minimalBalance: 1n,723  };724725  let balanceUniqueTokenInit: bigint;726  let balanceUniqueTokenMiddle: bigint;727  let balanceUniqueTokenFinal: bigint;728  let balanceForeignUnqTokenInit: bigint;729  let balanceForeignUnqTokenMiddle: bigint;730  let balanceForeignUnqTokenFinal: bigint;731  let balanceGlmrTokenInit: bigint;732  let balanceGlmrTokenMiddle: bigint;733  let balanceGlmrTokenFinal: bigint;734735  before(async () => {736    await usingPlaygrounds(async (helper, privateKey) => {737      uniqueDonor = await privateKey('//Alice');738      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);739740      balanceForeignUnqTokenInit = 0n;741742      // Set the default version to wrap the first message to other chains.743      const alice = uniqueDonor;744      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);745    });746747    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {748      const alithAccount = helper.account.alithAccount();749      const baltatharAccount = helper.account.baltatharAccount();750      const dorothyAccount = helper.account.dorothyAccount();751752      randomAccountMoonbeam = helper.account.create();753754      // >>> Sponsoring Dorothy >>>755      console.log('Sponsoring Dorothy.......');756      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);757      console.log('Sponsoring Dorothy.......DONE');758      // <<< Sponsoring Dorothy <<<759760      uniqueAssetLocation = {761        XCM: {762          parents: 1,763          interior: {X1: {Parachain: UNIQUE_CHAIN}},764        },765      };766      const existentialDeposit = 1n;767      const isSufficient = true;768      const unitsPerSecond = 1n;769      const numAssetsWeightHint = 0;770771      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({772        location: uniqueAssetLocation,773        metadata: uniqueAssetMetadata,774        existentialDeposit,775        isSufficient,776        unitsPerSecond,777        numAssetsWeightHint,778      });779      const proposalHash = blake2AsHex(encodedProposal);780781      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);782      console.log('Encoded length %d', encodedProposal.length);783      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);784785      // >>> Note motion preimage >>>786      console.log('Note motion preimage.......');787      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);788      console.log('Note motion preimage.......DONE');789      // <<< Note motion preimage <<<790791      // >>> Propose external motion through council >>>792      console.log('Propose external motion through council.......');793      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});794      const encodedMotion = externalMotion?.method.toHex() || '';795      const motionHash = blake2AsHex(encodedMotion);796      console.log('Motion hash is %s', motionHash);797798      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);799800      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;801      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);802      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);803804      await helper.collective.council.close(805        dorothyAccount,806        motionHash,807        councilProposalIdx,808        {809          refTime: 1_000_000_000,810          proofSize: 1_000_000,811        },812        externalMotion.encodedLength,813      );814      console.log('Propose external motion through council.......DONE');815      // <<< Propose external motion through council <<<816817      // >>> Fast track proposal through technical committee >>>818      console.log('Fast track proposal through technical committee.......');819      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);820      const encodedFastTrack = fastTrack?.method.toHex() || '';821      const fastTrackHash = blake2AsHex(encodedFastTrack);822      console.log('FastTrack hash is %s', fastTrackHash);823824      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);825826      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;827      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);828      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);829830      await helper.collective.techCommittee.close(831        baltatharAccount,832        fastTrackHash,833        techProposalIdx,834        {835          refTime: 1_000_000_000,836          proofSize: 1_000_000,837        },838        fastTrack.encodedLength,839      );840      console.log('Fast track proposal through technical committee.......DONE');841      // <<< Fast track proposal through technical committee <<<842843      // >>> Referendum voting >>>844      console.log('Referendum voting.......');845      await helper.democracy.referendumVote(dorothyAccount, 0, {846        balance: 10_000_000_000_000_000_000n,847        vote: {aye: true, conviction: 1},848      });849      console.log('Referendum voting.......DONE');850      // <<< Referendum voting <<<851852      // >>> Acquire Unique AssetId Info on Moonbeam >>>853      console.log('Acquire Unique AssetId Info on Moonbeam.......');854855      // Wait for the democracy execute856      await helper.wait.newBlocks(5);857858      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();859860      console.log('UNQ asset ID is %s', assetId);861      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');862      // >>> Acquire Unique AssetId Info on Moonbeam >>>863864      // >>> Sponsoring random Account >>>865      console.log('Sponsoring random Account.......');866      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);867      console.log('Sponsoring random Account.......DONE');868      // <<< Sponsoring random Account <<<869870      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);871    });872873    await usingPlaygrounds(async (helper) => {874      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);875      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);876    });877  });878879  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {880    const currencyId = {881      NativeAssetId: 'Here',882    };883    const dest = {884      V2: {885        parents: 1,886        interior: {887          X2: [888            {Parachain: MOONBEAM_CHAIN},889            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},890          ],891        },892      },893    };894    const amount = TRANSFER_AMOUNT;895896    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');897898    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);899    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;900901    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;902    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));903    expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;904905    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {906      await helper.wait.newBlocks(3);907908      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);909910      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;911      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));912      expect(glmrFees == 0n).to.be.true;913914      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;915916      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;917      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));918      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;919    });920  });921922  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {923    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {924      const asset = {925        V1: {926          id: {927            Concrete: {928              parents: 1,929              interior: {930                X1: {Parachain: UNIQUE_CHAIN},931              },932            },933          },934          fun: {935            Fungible: TRANSFER_AMOUNT,936          },937        },938      };939      const destination = {940        V1: {941          parents: 1,942          interior: {943            X2: [944              {Parachain: UNIQUE_CHAIN},945              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},946            ],947          },948        },949      };950951      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');952953      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);954955      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;956      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));957      expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;958959      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);960961      expect(unqRandomAccountAsset).to.be.null;962963      balanceForeignUnqTokenFinal = 0n;964965      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;966      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));967      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;968    });969970    await helper.wait.newBlocks(3);971972    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);973    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;974    expect(actuallyDelivered > 0).to.be.true;975976    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));977978    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;979    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));980    expect(unqFees == 0n).to.be.true;981  });982});