git.delta.rocks / unique-network / refs/commits / 68bf2bb2d784

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 {XcmV2TraitsError, XcmV2TraitsOutcome} from '../interfaces';20import {itSub, expect, describeXcm, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds} from '../util/playgrounds';2122const UNIQUE_CHAIN = 2037;23const ACALA_CHAIN = 2000;24const MOONBEAM_CHAIN = 2004;2526const RELAY_PORT = 9844;27const ACALA_PORT = 9946;28const MOONBEAM_PORT = 9947;2930const relayUrl = 'ws://127.0.0.1:' + RELAY_PORT;31const acalaUrl = 'ws://127.0.0.1:' + ACALA_PORT;32const moonbeamUrl = 'ws://127.0.0.1:' + MOONBEAM_PORT;3334const ACALA_DECIMALS = 12;3536const TRANSFER_AMOUNT = 2000000000000000000000000n;3738describeXcm('[XCM] Integration test: Exchanging tokens with Acala', () => {39  let alice: IKeyringPair;40  let randomAccount: IKeyringPair;4142  let balanceUniqueTokenInit: bigint;43  let balanceUniqueTokenMiddle: bigint;44  let balanceUniqueTokenFinal: bigint;45  let balanceAcalaTokenInit: bigint;46  let balanceAcalaTokenMiddle: bigint;47  let balanceAcalaTokenFinal: bigint;48  let balanceUniqueForeignTokenInit: bigint;49  let balanceUniqueForeignTokenMiddle: bigint;50  let balanceUniqueForeignTokenFinal: bigint;5152  before(async () => {53    await usingPlaygrounds(async (helper, privateKey) => {54      alice = privateKey('//Alice');55      [randomAccount] = await helper.arrange.createAccounts([0n], alice);56    });5758    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {59      const destination = {60        V0: {61          X2: [62            'Parent',63            {64              Parachain: UNIQUE_CHAIN,65            },66          ],67        },68      };6970      const metadata = {71        name: 'UNQ',72        symbol: 'UNQ',73        decimals: 18,74        minimalBalance: 1n,75      };7677      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);78      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);79      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);80      balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});81    });8283    await usingPlaygrounds(async (helper) => {84      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);85      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);86    });87  });8889  itSub('Should connect and send UNQ to Acala', async ({helper}) => {9091    const destination = {92      V0: {93        X2: [94          'Parent',95          {96            Parachain: ACALA_CHAIN,97          },98        ],99      },100    };101102    const beneficiary = {103      V0: {104        X1: {105          AccountId32: {106            network: 'Any',107            id: randomAccount.addressRaw,108          },109        },110      },111    };112113    const assets = {114      V1: [115        {116          id: {117            Concrete: {118              parents: 0,119              interior: 'Here',120            },121          },122          fun: {123            Fungible: TRANSFER_AMOUNT,124          },125        },126      ],127    };128129    const feeAssetItem = 0;130    const weightLimit = 5000000000;131132    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, weightLimit);133134    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);135136    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;137    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));138    expect(unqFees > 0n).to.be.true;139140    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {141      await helper.wait.newBlocks(3);142143      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});144      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);145146      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;147      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;148149      console.log(150        '[Unique -> Acala] transaction fees on Acala: %s ACA',151        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),152      );153      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));154      expect(acaFees == 0n).to.be.true;155      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;156    });157  });158159  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {160    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {161      const destination = {162        V1: {163          parents: 1,164          interior: {165            X2: [166              {Parachain: UNIQUE_CHAIN},167              {168                AccountId32: {169                  network: 'Any',170                  id: randomAccount.addressRaw,171                },172              },173            ],174          },175        },176      };177178      const id = {179        ForeignAsset: 0,180      };181182      const destWeight = 50000000;183184      await helper.xTokens.transfer(randomAccount, id, TRANSFER_AMOUNT, destination, destWeight);185186      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);187      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);188189      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;190      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;191192      console.log(193        '[Acala -> Unique] transaction fees on Acala: %s ACA',194        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),195      );196      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));197198      expect(acaFees > 0).to.be.true;199      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;200    });201202    await helper.wait.newBlocks(3);203204    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);205    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;206    expect(actuallyDelivered > 0).to.be.true;207208    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));209210    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;211    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));212    expect(unqFees == 0n).to.be.true;213  });214});215216// These tests are relevant only when the foreign asset pallet is disabled217describeXcm('[XCM] Integration test: Unique rejects non-native tokens', () => {218  let alice: IKeyringPair;219220  before(async () => {221    await usingPlaygrounds(async (_helper, privateKey) => {222      alice = privateKey('//Alice');223    });224  });225226  itSub('Unique rejects tokens from the Relay', async ({helper}) => {227    await usingRelayPlaygrounds(relayUrl, async (helper) => {228      const destination = {229        V1: {230          parents: 0,231          interior: {X1: {232            Parachain: UNIQUE_CHAIN,233          },234          },235        }};236237      const beneficiary = {238        V1: {239          parents: 0,240          interior: {X1: {241            AccountId32: {242              network: 'Any',243              id: alice.addressRaw,244            },245          }},246        },247      };248249      const assets = {250        V1: [251          {252            id: {253              Concrete: {254                parents: 0,255                interior: 'Here',256              },257            },258            fun: {259              Fungible: 50_000_000_000_000_000n,260            },261          },262        ],263      };264265      const feeAssetItem = 0;266      const weightLimit = 5_000_000_000;267268      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, weightLimit);269    });270271    const maxWaitBlocks = 3;272273    const dmpQueueExecutedDownward = await helper.wait.event(maxWaitBlocks, 'dmpQueue', 'ExecutedDownward');274275    expect(276      dmpQueueExecutedDownward != null,277      '[Relay] dmpQueue.ExecutedDownward event is expected',278    ).to.be.true;279280    const event = dmpQueueExecutedDownward!.event;281    const outcome = event.data[1] as XcmV2TraitsOutcome;282283    expect(284      outcome.isIncomplete,285      '[Relay] The outcome of the XCM should be `Incomplete`',286    ).to.be.true;287288    const incomplete = outcome.asIncomplete;289    expect(290      incomplete[1].toString() == 'AssetNotFound',291      '[Relay] The XCM error should be `AssetNotFound`',292    ).to.be.true;293  });294295  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {296    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {297      const destination = {298        V1: {299          parents: 1,300          interior: {301            X2: [302              {Parachain: UNIQUE_CHAIN},303              {304                AccountId32: {305                  network: 'Any',306                  id: alice.addressRaw,307                },308              },309            ],310          },311        },312      };313314      const id = {315        Token: 'ACA',316      };317318      const destWeight = 50000000;319320      await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, destWeight);321    });322323    const maxWaitBlocks = 3;324325    const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');326327    expect(328      xcmpQueueFailEvent != null,329      '[Acala] xcmpQueue.FailEvent event is expected',330    ).to.be.true;331332    const event = xcmpQueueFailEvent!.event;333    const outcome = event.data[1] as XcmV2TraitsError;334335    expect(336      outcome.isUntrustedReserveLocation,337      '[Acala] The XCM error should be `UntrustedReserveLocation`',338    ).to.be.true;339  });340});341342describeXcm('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {343344  // Unique constants345  let uniqueDonor: IKeyringPair;346  let uniqueAssetLocation;347348  let randomAccountUnique: IKeyringPair;349  let randomAccountMoonbeam: IKeyringPair;350351  // Moonbeam constants352  let assetId: string;353354  const councilVotingThreshold = 2;355  const technicalCommitteeThreshold = 2;356  const votingPeriod = 3;357  const delayPeriod = 0;358359  const uniqueAssetMetadata = {360    name: 'xcUnique',361    symbol: 'xcUNQ',362    decimals: 18,363    isFrozen: false,364    minimalBalance: 1n,365  };366367  let balanceUniqueTokenInit: bigint;368  let balanceUniqueTokenMiddle: bigint;369  let balanceUniqueTokenFinal: bigint;370  let balanceForeignUnqTokenInit: bigint;371  let balanceForeignUnqTokenMiddle: bigint;372  let balanceForeignUnqTokenFinal: bigint;373  let balanceGlmrTokenInit: bigint;374  let balanceGlmrTokenMiddle: bigint;375  let balanceGlmrTokenFinal: bigint;376377  before(async () => {378    await usingPlaygrounds(async (helper, privateKey) => {379      uniqueDonor = privateKey('//Alice');380      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);381382      balanceForeignUnqTokenInit = 0n;383    });384385    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {386      const alithAccount = helper.account.alithAccount();387      const baltatharAccount = helper.account.baltatharAccount();388      const dorothyAccount = helper.account.dorothyAccount();389390      randomAccountMoonbeam = helper.account.create();391392      // >>> Sponsoring Dorothy >>>393      console.log('Sponsoring Dorothy.......');394      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);395      console.log('Sponsoring Dorothy.......DONE');396      // <<< Sponsoring Dorothy <<<397398      uniqueAssetLocation = {399        XCM: {400          parents: 1,401          interior: {X1: {Parachain: UNIQUE_CHAIN}},402        },403      };404      const existentialDeposit = 1n;405      const isSufficient = true;406      const unitsPerSecond = 1n;407      const numAssetsWeightHint = 0;408409      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({410        location: uniqueAssetLocation,411        metadata: uniqueAssetMetadata,412        existentialDeposit,413        isSufficient,414        unitsPerSecond,415        numAssetsWeightHint,416      });417      const proposalHash = blake2AsHex(encodedProposal);418419      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);420      console.log('Encoded length %d', encodedProposal.length);421      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);422423      // >>> Note motion preimage >>>424      console.log('Note motion preimage.......');425      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);426      console.log('Note motion preimage.......DONE');427      // <<< Note motion preimage <<<428429      // >>> Propose external motion through council >>>430      console.log('Propose external motion through council.......');431      const externalMotion = helper.democracy.externalProposeMajority(proposalHash);432      const encodedMotion = externalMotion?.method.toHex() || '';433      const motionHash = blake2AsHex(encodedMotion);434      console.log('Motion hash is %s', motionHash);435436      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);437438      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;439      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);440      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);441442      await helper.collective.council.close(dorothyAccount, motionHash, councilProposalIdx, 1_000_000_000, externalMotion.encodedLength);443      console.log('Propose external motion through council.......DONE');444      // <<< Propose external motion through council <<<445446      // >>> Fast track proposal through technical committee >>>447      console.log('Fast track proposal through technical committee.......');448      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);449      const encodedFastTrack = fastTrack?.method.toHex() || '';450      const fastTrackHash = blake2AsHex(encodedFastTrack);451      console.log('FastTrack hash is %s', fastTrackHash);452453      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);454455      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;456      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);457      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);458459      await helper.collective.techCommittee.close(baltatharAccount, fastTrackHash, techProposalIdx, 1_000_000_000, fastTrack.encodedLength);460      console.log('Fast track proposal through technical committee.......DONE');461      // <<< Fast track proposal through technical committee <<<462463      // >>> Referendum voting >>>464      console.log('Referendum voting.......');465      await helper.democracy.referendumVote(dorothyAccount, 0, {466        balance: 10_000_000_000_000_000_000n,467        vote: {aye: true, conviction: 1},468      });469      console.log('Referendum voting.......DONE');470      // <<< Referendum voting <<<471472      // >>> Acquire Unique AssetId Info on Moonbeam >>>473      console.log('Acquire Unique AssetId Info on Moonbeam.......');474475      // Wait for the democracy execute476      await helper.wait.newBlocks(5);477478      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();479480      console.log('UNQ asset ID is %s', assetId);481      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');482      // >>> Acquire Unique AssetId Info on Moonbeam >>>483484      // >>> Sponsoring random Account >>>485      console.log('Sponsoring random Account.......');486      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);487      console.log('Sponsoring random Account.......DONE');488      // <<< Sponsoring random Account <<<489490      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);491    });492493    await usingPlaygrounds(async (helper) => {494      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);495      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);496    });497  });498499  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {500    const currencyId = {501      NativeAssetId: 'Here',502    };503    const dest = {504      V1: {505        parents: 1,506        interior: {507          X2: [508            {Parachain: MOONBEAM_CHAIN},509            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},510          ],511        },512      },513    };514    const amount = TRANSFER_AMOUNT;515    const destWeight = 850000000;516517    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, destWeight);518519    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);520    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;521522    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;523    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));524    expect(transactionFees > 0).to.be.true;525526    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {527      await helper.wait.newBlocks(3);528529      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);530531      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;532      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));533      expect(glmrFees == 0n).to.be.true;534535      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;536537      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;538      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));539      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;540    });541  });542543  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {544    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {545      const asset = {546        V1: {547          id: {548            Concrete: {549              parents: 1,550              interior: {551                X1: {Parachain: UNIQUE_CHAIN},552              },553            },554          },555          fun: {556            Fungible: TRANSFER_AMOUNT,557          },558        },559      };560      const destination = {561        V1: {562          parents: 1,563          interior: {564            X2: [565              {Parachain: UNIQUE_CHAIN},566              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},567            ],568          },569        },570      };571      const destWeight = 50000000;572573      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, destWeight);574575      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);576577      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;578      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));579      expect(glmrFees > 0).to.be.true;580581      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);582583      expect(unqRandomAccountAsset).to.be.null;584      585      balanceForeignUnqTokenFinal = 0n;586587      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;588      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));589      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;590    });591592    await helper.wait.newBlocks(3);593594    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);595    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;596    expect(actuallyDelivered > 0).to.be.true;597598    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));599600    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;601    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));602    expect(unqFees == 0n).to.be.true;603  });604});