git.delta.rocks / unique-network / refs/commits / 7e798e96a17d

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      const relayXcmVersion = 2;89      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT, relayXcmVersion);90      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT, relayXcmVersion);91    });9293    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {94      const sovereignFundingAmount = 3_500_000_000n;9596      await helper.assets.create(97        alice,98        USDT_ASSET_ID,99        alice.address,100        USDT_ASSET_METADATA_MINIMAL_BALANCE,101      );102      await helper.assets.setMetadata(103        alice,104        USDT_ASSET_ID,105        USDT_ASSET_METADATA_NAME,106        USDT_ASSET_METADATA_DESCRIPTION,107        USDT_ASSET_METADATA_DECIMALS,108      );109      await helper.assets.mint(110        alice,111        USDT_ASSET_ID,112        alice.address,113        USDT_ASSET_AMOUNT,114      );115116      // funding parachain sovereing account on Statemint.117      // The sovereign account should be created before any action118      // (the assets pallet on Statemint check if the sovereign account exists)119      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);120      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);121    });122123124    await usingPlaygrounds(async (helper) => {125      const location = {126        V2: {127          parents: 1,128          interior: {X3: [129            {130              Parachain: STATEMINT_CHAIN,131            },132            {133              PalletInstance: STATEMINT_PALLET_INSTANCE,134            },135            {136              GeneralIndex: USDT_ASSET_ID,137            },138          ]},139        },140      };141142      const metadata =143      {144        name: USDT_ASSET_ID,145        symbol: USDT_ASSET_METADATA_NAME,146        decimals: USDT_ASSET_METADATA_DECIMALS,147        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,148      };149      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);150      balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);151    });152153154    // Providing the relay currency to the unique sender account155    // (fee for USDT XCM are paid in relay tokens)156    await usingRelayPlaygrounds(relayUrl, async (helper) => {157      const destination = {158        V1: {159          parents: 0,160          interior: {X1: {161            Parachain: UNIQUE_CHAIN,162          },163          },164        }};165166      const beneficiary = {167        V1: {168          parents: 0,169          interior: {X1: {170            AccountId32: {171              network: 'Any',172              id: alice.addressRaw,173            },174          }},175        },176      };177178      const assets = {179        V1: [180          {181            id: {182              Concrete: {183                parents: 0,184                interior: 'Here',185              },186            },187            fun: {188              Fungible: TRANSFER_AMOUNT_RELAY,189            },190          },191        ],192      };193194      const feeAssetItem = 0;195196      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');197    });198199  });200201  itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {202    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {203      const dest = {204        V1: {205          parents: 1,206          interior: {X1: {207            Parachain: UNIQUE_CHAIN,208          },209          },210        }};211212      const beneficiary = {213        V1: {214          parents: 0,215          interior: {X1: {216            AccountId32: {217              network: 'Any',218              id: alice.addressRaw,219            },220          }},221        },222      };223224      const assets = {225        V1: [226          {227            id: {228              Concrete: {229                parents: 0,230                interior: {231                  X2: [232                    {233                      PalletInstance: STATEMINT_PALLET_INSTANCE,234                    },235                    {236                      GeneralIndex: USDT_ASSET_ID,237                    },238                  ]},239              },240            },241            fun: {242              Fungible: TRANSFER_AMOUNT,243            },244          },245        ],246      };247248      const feeAssetItem = 0;249250      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);251      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');252253      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);254255      // common good parachain take commission in it native token256      console.log(257        '[Statemint -> Unique] transaction fees on Statemint: %s WND',258        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),259      );260      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;261262    });263264265    // ensure that asset has been delivered266    await helper.wait.newBlocks(3);267268    // expext collection id will be with id 1269    const free = await helper.ft.getBalance(1, {Substrate: alice.address});270271    balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);272273    console.log(274      '[Statemint -> Unique] transaction fees on Unique: %s USDT',275      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),276    );277    console.log(278      '[Statemint -> Unique] transaction fees on Unique: %s UNQ',279      helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),280    );281    // commission has not paid in USDT token282    expect(free).to.be.equal(TRANSFER_AMOUNT);283    // ... and parachain native token284    expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;285  });286287  itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {288    const destination = {289      V2: {290        parents: 1,291        interior: {X2: [292          {293            Parachain: STATEMINT_CHAIN,294          },295          {296            AccountId32: {297              network: 'Any',298              id: alice.addressRaw,299            },300          },301        ]},302      },303    };304305    const relayFee = 400_000_000_000_000n;306    const currencies: [any, bigint][] = [307      [308        {309          ForeignAssetId: 0,310        },311        TRANSFER_AMOUNT,312      ],313      [314        {315          NativeAssetId: 'Parent',316        },317        relayFee,318      ],319    ];320321    const feeItem = 1;322323    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');324325    // the commission has been paid in parachain native token326    balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);327    console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));328    expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;329330    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {331      await helper.wait.newBlocks(3);332333      // The USDT token never paid fees. Its amount not changed from begin value.334      // Also check that xcm transfer has been succeeded335      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;336    });337  });338339  itSub('Should connect and send Relay token to Unique', async ({helper}) => {340    balanceBobBefore = await helper.balance.getSubstrate(bob.address);341    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});342343    await usingRelayPlaygrounds(relayUrl, async (helper) => {344      const destination = {345        V1: {346          parents: 0,347          interior: {X1: {348            Parachain: UNIQUE_CHAIN,349          },350          },351        }};352353      const beneficiary = {354        V1: {355          parents: 0,356          interior: {X1: {357            AccountId32: {358              network: 'Any',359              id: bob.addressRaw,360            },361          }},362        },363      };364365      const assets = {366        V1: [367          {368            id: {369              Concrete: {370                parents: 0,371                interior: 'Here',372              },373            },374            fun: {375              Fungible: TRANSFER_AMOUNT_RELAY,376            },377          },378        ],379      };380381      const feeAssetItem = 0;382383      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');384    });385386    await helper.wait.newBlocks(3);387388    balanceBobAfter = await helper.balance.getSubstrate(bob.address);389    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});390391    const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;392    const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;393    console.log(394      '[Relay (Westend) -> Unique] transaction fees: %s UNQ',395      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),396    );397    console.log(398      '[Relay (Westend) -> Unique] transaction fees: %s WND',399      helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),400    );401    console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);402    expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;403    expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;404  });405406  itSub('Should connect and send Relay token back', async ({helper}) => {407    let relayTokenBalanceBefore: bigint;408    let relayTokenBalanceAfter: bigint;409    await usingRelayPlaygrounds(relayUrl, async (helper) => {410      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);411    });412413    const destination = {414      V2: {415        parents: 1,416        interior: {417          X1:{418            AccountId32: {419              network: 'Any',420              id: bob.addressRaw,421            },422          },423        },424      },425    };426427    const currencies: any = [428      [429        {430          NativeAssetId: 'Parent',431        },432        TRANSFER_AMOUNT_RELAY,433      ],434    ];435436    const feeItem = 0;437438    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');439440    balanceBobFinal = await helper.balance.getSubstrate(bob.address);441    console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));442443    await usingRelayPlaygrounds(relayUrl, async (helper) => {444      await helper.wait.newBlocks(10);445      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);446447      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;448      console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));449      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;450    });451  });452});453454describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {455  let alice: IKeyringPair;456  let randomAccount: IKeyringPair;457458  let balanceUniqueTokenInit: bigint;459  let balanceUniqueTokenMiddle: bigint;460  let balanceUniqueTokenFinal: bigint;461  let balanceAcalaTokenInit: bigint;462  let balanceAcalaTokenMiddle: bigint;463  let balanceAcalaTokenFinal: bigint;464  let balanceUniqueForeignTokenInit: bigint;465  let balanceUniqueForeignTokenMiddle: bigint;466  let balanceUniqueForeignTokenFinal: bigint;467468  // computed by a test transfer from prod Unique to prod Acala.469  // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48470  // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)471  const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;472473  const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;474475  before(async () => {476    await usingPlaygrounds(async (helper, privateKey) => {477      alice = await privateKey('//Alice');478      [randomAccount] = await helper.arrange.createAccounts([0n], alice);479480      // Set the default version to wrap the first message to other chains.481      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);482    });483484    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {485      const destination = {486        V1: {487          parents: 1,488          interior: {489            X1: {490              Parachain: UNIQUE_CHAIN,491            },492          },493        },494      };495496      const metadata = {497        name: 'Unique Network',498        symbol: 'UNQ',499        decimals: 18,500        minimalBalance: 1250000000000000000n,501      };502503      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);504      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);505      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);506      balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});507    });508509    await usingPlaygrounds(async (helper) => {510      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);511      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);512    });513  });514515  itSub('Should connect and send UNQ to Acala', async ({helper}) => {516517    const destination = {518      V2: {519        parents: 1,520        interior: {521          X1: {522            Parachain: ACALA_CHAIN,523          },524        },525      },526    };527528    const beneficiary = {529      V2: {530        parents: 0,531        interior: {532          X1: {533            AccountId32: {534              network: 'Any',535              id: randomAccount.addressRaw,536            },537          },538        },539      },540    };541542    const assets = {543      V2: [544        {545          id: {546            Concrete: {547              parents: 0,548              interior: 'Here',549            },550          },551          fun: {552            Fungible: TRANSFER_AMOUNT,553          },554        },555      ],556    };557558    const feeAssetItem = 0;559560    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');561    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);562563    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;564    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));565    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;566567    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {568      await helper.wait.newBlocks(3);569570      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});571      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);572573      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;574      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;575      const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;576577      console.log(578        '[Unique -> Acala] transaction fees on Acala: %s ACA',579        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),580      );581      console.log(582        '[Unique -> Acala] transaction fees on Acala: %s UNQ',583        helper.util.bigIntToDecimals(acaUnqFees),584      );585      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));586      expect(acaFees == 0n).to.be.true;587      expect(588        acaUnqFees == expectedAcalaIncomeFee,589        'Acala took different income fee, check the Acala foreign asset config',590      ).to.be.true;591    });592  });593594  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {595    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {596      const destination = {597        V1: {598          parents: 1,599          interior: {600            X2: [601              {Parachain: UNIQUE_CHAIN},602              {603                AccountId32: {604                  network: 'Any',605                  id: randomAccount.addressRaw,606                },607              },608            ],609          },610        },611      };612613      const id = {614        ForeignAsset: 0,615      };616617      await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');618      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);619      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);620621      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;622      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;623624      console.log(625        '[Acala -> Unique] transaction fees on Acala: %s ACA',626        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),627      );628      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));629630      expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;631      expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;632    });633634    await helper.wait.newBlocks(3);635636    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);637    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;638    expect(actuallyDelivered > 0).to.be.true;639640    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));641642    const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;643    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));644    expect(unqFees == 0n).to.be.true;645  });646});647648// These tests are relevant only when the foreign asset pallet is disabled649describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {650  let alice: IKeyringPair;651652  before(async () => {653    await usingPlaygrounds(async (helper, privateKey) => {654      alice = await privateKey('//Alice');655656      // Set the default version to wrap the first message to other chains.657      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);658    });659  });660661  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {662    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {663      const destination = {664        V1: {665          parents: 1,666          interior: {667            X2: [668              {Parachain: UNIQUE_CHAIN},669              {670                AccountId32: {671                  network: 'Any',672                  id: alice.addressRaw,673                },674              },675            ],676          },677        },678      };679680      const id = {681        Token: 'ACA',682      };683684      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');685    });686687    const maxWaitBlocks = 3;688689    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');690691    expect(692      xcmpQueueFailEvent != null,693      '[Acala] xcmpQueue.FailEvent event is expected',694    ).to.be.true;695696    const event = xcmpQueueFailEvent!.event;697    const outcome = event.data[1] as XcmV2TraitsError;698699    expect(700      outcome.isFailedToTransactAsset,701      '[Acala] The XCM error should be `FailedToTransactAsset`',702    ).to.be.true;703  });704});705706describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {707  // Unique constants708  let uniqueDonor: IKeyringPair;709  let uniqueAssetLocation;710711  let randomAccountUnique: IKeyringPair;712  let randomAccountMoonbeam: IKeyringPair;713714  // Moonbeam constants715  let assetId: string;716717  const councilVotingThreshold = 2;718  const technicalCommitteeThreshold = 2;719  const votingPeriod = 3;720  const delayPeriod = 0;721722  const uniqueAssetMetadata = {723    name: 'xcUnique',724    symbol: 'xcUNQ',725    decimals: 18,726    isFrozen: false,727    minimalBalance: 1n,728  };729730  let balanceUniqueTokenInit: bigint;731  let balanceUniqueTokenMiddle: bigint;732  let balanceUniqueTokenFinal: bigint;733  let balanceForeignUnqTokenInit: bigint;734  let balanceForeignUnqTokenMiddle: bigint;735  let balanceForeignUnqTokenFinal: bigint;736  let balanceGlmrTokenInit: bigint;737  let balanceGlmrTokenMiddle: bigint;738  let balanceGlmrTokenFinal: bigint;739740  before(async () => {741    await usingPlaygrounds(async (helper, privateKey) => {742      uniqueDonor = await privateKey('//Alice');743      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);744745      balanceForeignUnqTokenInit = 0n;746747      // Set the default version to wrap the first message to other chains.748      const alice = uniqueDonor;749      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);750    });751752    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {753      const alithAccount = helper.account.alithAccount();754      const baltatharAccount = helper.account.baltatharAccount();755      const dorothyAccount = helper.account.dorothyAccount();756757      randomAccountMoonbeam = helper.account.create();758759      // >>> Sponsoring Dorothy >>>760      console.log('Sponsoring Dorothy.......');761      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);762      console.log('Sponsoring Dorothy.......DONE');763      // <<< Sponsoring Dorothy <<<764765      uniqueAssetLocation = {766        XCM: {767          parents: 1,768          interior: {X1: {Parachain: UNIQUE_CHAIN}},769        },770      };771      const existentialDeposit = 1n;772      const isSufficient = true;773      const unitsPerSecond = 1n;774      const numAssetsWeightHint = 0;775776      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({777        location: uniqueAssetLocation,778        metadata: uniqueAssetMetadata,779        existentialDeposit,780        isSufficient,781        unitsPerSecond,782        numAssetsWeightHint,783      });784      const proposalHash = blake2AsHex(encodedProposal);785786      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);787      console.log('Encoded length %d', encodedProposal.length);788      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);789790      // >>> Note motion preimage >>>791      console.log('Note motion preimage.......');792      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);793      console.log('Note motion preimage.......DONE');794      // <<< Note motion preimage <<<795796      // >>> Propose external motion through council >>>797      console.log('Propose external motion through council.......');798      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});799      const encodedMotion = externalMotion?.method.toHex() || '';800      const motionHash = blake2AsHex(encodedMotion);801      console.log('Motion hash is %s', motionHash);802803      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);804805      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;806      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);807      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);808809      await helper.collective.council.close(810        dorothyAccount,811        motionHash,812        councilProposalIdx,813        {814          refTime: 1_000_000_000,815          proofSize: 1_000_000,816        },817        externalMotion.encodedLength,818      );819      console.log('Propose external motion through council.......DONE');820      // <<< Propose external motion through council <<<821822      // >>> Fast track proposal through technical committee >>>823      console.log('Fast track proposal through technical committee.......');824      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);825      const encodedFastTrack = fastTrack?.method.toHex() || '';826      const fastTrackHash = blake2AsHex(encodedFastTrack);827      console.log('FastTrack hash is %s', fastTrackHash);828829      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);830831      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;832      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);833      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);834835      await helper.collective.techCommittee.close(836        baltatharAccount,837        fastTrackHash,838        techProposalIdx,839        {840          refTime: 1_000_000_000,841          proofSize: 1_000_000,842        },843        fastTrack.encodedLength,844      );845      console.log('Fast track proposal through technical committee.......DONE');846      // <<< Fast track proposal through technical committee <<<847848      // >>> Referendum voting >>>849      console.log('Referendum voting.......');850      await helper.democracy.referendumVote(dorothyAccount, 0, {851        balance: 10_000_000_000_000_000_000n,852        vote: {aye: true, conviction: 1},853      });854      console.log('Referendum voting.......DONE');855      // <<< Referendum voting <<<856857      // >>> Acquire Unique AssetId Info on Moonbeam >>>858      console.log('Acquire Unique AssetId Info on Moonbeam.......');859860      // Wait for the democracy execute861      await helper.wait.newBlocks(5);862863      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();864865      console.log('UNQ asset ID is %s', assetId);866      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');867      // >>> Acquire Unique AssetId Info on Moonbeam >>>868869      // >>> Sponsoring random Account >>>870      console.log('Sponsoring random Account.......');871      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);872      console.log('Sponsoring random Account.......DONE');873      // <<< Sponsoring random Account <<<874875      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);876    });877878    await usingPlaygrounds(async (helper) => {879      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);880      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);881    });882  });883884  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {885    const currencyId = {886      NativeAssetId: 'Here',887    };888    const dest = {889      V2: {890        parents: 1,891        interior: {892          X2: [893            {Parachain: MOONBEAM_CHAIN},894            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},895          ],896        },897      },898    };899    const amount = TRANSFER_AMOUNT;900901    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');902903    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);904    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;905906    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;907    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));908    expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;909910    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {911      await helper.wait.newBlocks(3);912913      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);914915      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;916      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));917      expect(glmrFees == 0n).to.be.true;918919      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;920921      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;922      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));923      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;924    });925  });926927  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {928    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {929      const asset = {930        V1: {931          id: {932            Concrete: {933              parents: 1,934              interior: {935                X1: {Parachain: UNIQUE_CHAIN},936              },937            },938          },939          fun: {940            Fungible: TRANSFER_AMOUNT,941          },942        },943      };944      const destination = {945        V1: {946          parents: 1,947          interior: {948            X2: [949              {Parachain: UNIQUE_CHAIN},950              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},951            ],952          },953        },954      };955956      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');957958      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);959960      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;961      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));962      expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;963964      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);965966      expect(unqRandomAccountAsset).to.be.null;967968      balanceForeignUnqTokenFinal = 0n;969970      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;971      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));972      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;973    });974975    await helper.wait.newBlocks(3);976977    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);978    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;979    expect(actuallyDelivered > 0).to.be.true;980981    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));982983    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;984    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));985    expect(unqFees == 0n).to.be.true;986  });987});988989describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {990  let alice: IKeyringPair;991  let randomAccount: IKeyringPair;992993  const UNQ_ASSET_ID_ON_SHIDEN = 1;994  const UNQ_MINIMAL_BALANCE_ON_SHIDEN = 1n;995996  // Unique -> Astar997  const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Shiden.998  const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?999  const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1000  const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Shiden takes a commision in foreign tokens10011002  // Astar -> Unique1003  const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1004  const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ10051006  let balanceAfterUniqueToAstarXCM: bigint;10071008  before(async () => {1009    await usingPlaygrounds(async (helper, privateKey) => {1010      alice = await privateKey('//Alice');1011      [randomAccount] = await helper.arrange.createAccounts([100n], alice);1012      console.log('randomAccount', randomAccount.address);10131014      // Set the default version to wrap the first message to other chains.1015      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1016    });10171018    await usingAstarPlaygrounds(astarUrl, async (helper) => {1019      console.log('1. Create foreign asset and metadata');1020      // TODO update metadata with values from production1021      await helper.assets.create(1022        alice,1023        UNQ_ASSET_ID_ON_SHIDEN,1024        alice.address,1025        UNQ_MINIMAL_BALANCE_ON_SHIDEN,1026      );10271028      await helper.assets.setMetadata(1029        alice,1030        UNQ_ASSET_ID_ON_SHIDEN,1031        'Cross chain UNQ',1032        'xcUNQ',1033        Number(UNQ_DECIMALS),1034      );10351036      console.log('2. Register asset location on Astar');1037      const assetLocation = {1038        V1: {1039          parents: 1,1040          interior: {1041            X1: {1042              Parachain: UNIQUE_CHAIN,1043            },1044          },1045        },1046      };10471048      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_SHIDEN]);10491050      console.log('3. Set UNQ payment for XCM execution on Astar');1051      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);10521053      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1054      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1055    });1056  });10571058  itSub('Should connect and send UNQ to Astar', async ({helper}) => {1059    const destination = {1060      V2: {1061        parents: 1,1062        interior: {1063          X1: {1064            Parachain: ASTAR_CHAIN,1065          },1066        },1067      },1068    };10691070    const beneficiary = {1071      V2: {1072        parents: 0,1073        interior: {1074          X1: {1075            AccountId32: {1076              network: 'Any',1077              id: randomAccount.addressRaw,1078            },1079          },1080        },1081      },1082    };10831084    const assets = {1085      V2: [1086        {1087          id: {1088            Concrete: {1089              parents: 0,1090              interior: 'Here',1091            },1092          },1093          fun: {1094            Fungible: unqToAstarTransferred,1095          },1096        },1097      ],1098    };10991100    // Initial balance is 100 UNQ1101    const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1102    console.log(`Initial balance is: ${balanceBefore}`);11031104    const feeAssetItem = 0;1105    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');11061107    // Balance after reserve transfer is less than 901108    balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1109    console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1110    console.log(`Unique's UNQ commission is: ${balanceBefore - balanceAfterUniqueToAstarXCM}`);1111    expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;11121113    await usingAstarPlaygrounds(astarUrl, async (helper) => {1114      await helper.wait.newBlocks(3);1115      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1116      const astarBalance = await helper.balance.getSubstrate(randomAccount.address);11171118      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1119      console.log(`Astar's UNQ commission is: ${unqToAstarTransferred - xcUNQbalance!}`);11201121      expect(xcUNQbalance).to.eq(unqToAstarArrived);1122      // Astar balance does not changed1123      expect(astarBalance).to.eq(astarInitialBalance);1124    });1125  });11261127  itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1128    await usingAstarPlaygrounds(astarUrl, async (helper) => {1129      const destination = {1130        V1: {1131          parents: 1,1132          interior: {1133            X1: {1134              Parachain: UNIQUE_CHAIN,1135            },1136          },1137        },1138      };11391140      const beneficiary = {1141        V1: {1142          parents: 0,1143          interior: {1144            X1: {1145              AccountId32: {1146                network: 'Any',1147                id: randomAccount.addressRaw,1148              },1149            },1150          },1151        },1152      };11531154      const assets = {1155        V1: [1156          {1157            id: {1158              Concrete: {1159                parents: 1,1160                interior: {1161                  X1: {1162                    Parachain: UNIQUE_CHAIN,1163                  },1164                },1165              },1166            },1167            fun: {1168              Fungible: unqFromAstarTransfered,1169            },1170          },1171        ],1172      };11731174      // Initial balance is 1 ASTR1175      const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1176      console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1177      expect(balanceASTRbefore).to.eq(astarInitialBalance);11781179      const feeAssetItem = 0;1180      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1181      await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);11821183      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1184      const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1185      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);11861187      // Assert: xcUNQ balance correctly decreased1188      expect(xcUNQbalance).to.eq(unqOnAstarLeft);1189      // Assert: ASTR balance is 0.996...1190      expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1191    });11921193    await helper.wait.newBlocks(3);1194    const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1195    console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1196    expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1197  });11981199  itSub.skip('Should not accept limitedReserveTransfer of UNQ from ASTAR', async ({helper}) => {1200    await usingAstarPlaygrounds(astarUrl, async (helper) => {1201      const destination = {1202        V1: {1203          parents: 1,1204          interior: {1205            X1: {1206              Parachain: UNIQUE_CHAIN,1207            },1208          },1209        },1210      };12111212      const beneficiary = {1213        V1: {1214          parents: 0,1215          interior: {1216            X1: {1217              AccountId32: {1218                network: 'Any',1219                id: randomAccount.addressRaw,1220              },1221            },1222          },1223        },1224      };12251226      const assets = {1227        V1: [1228          {1229            id: {1230              Concrete: {1231                parents: 1,1232                interior: {1233                  X1: {1234                    Parachain: UNIQUE_CHAIN,1235                  },1236                },1237              },1238            },1239            fun: {1240              Fungible: unqFromAstarTransfered,1241            },1242          },1243        ],1244      };12451246      // Initial balance is 1 ASTAR1247      expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(astarInitialBalance);12481249      const feeAssetItem = 0;1250      // TODO: expect rejected:1251      await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');1252    });1253  });1254});