git.delta.rocks / unique-network / refs/commits / 2d2f157aedaf

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';22import {DevUniqueHelper} from '../util/playgrounds/unique.dev';2324const UNIQUE_CHAIN = 2037;25const STATEMINT_CHAIN = 1000;26const ACALA_CHAIN = 2000;27const MOONBEAM_CHAIN = 2004;28const ASTAR_CHAIN = 2006;2930const STATEMINT_PALLET_INSTANCE = 50;3132const relayUrl = config.relayUrl;33const statemintUrl = config.statemintUrl;34const acalaUrl = config.acalaUrl;35const moonbeamUrl = config.moonbeamUrl;36const astarUrl = config.astarUrl;3738const RELAY_DECIMALS = 12;39const STATEMINT_DECIMALS = 12;40const ACALA_DECIMALS = 12;41const ASTAR_DECIMALS = 18n;42const UNQ_DECIMALS = 18n;4344const TRANSFER_AMOUNT = 2000000000000000000000000n;4546const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4748const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4950const USDT_ASSET_ID = 100;51const USDT_ASSET_METADATA_DECIMALS = 18;52const USDT_ASSET_METADATA_NAME = 'USDT';53const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';54const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;55const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5657const SAFE_XCM_VERSION = 2;5859describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {60  let alice: IKeyringPair;61  let bob: IKeyringPair;6263  let balanceStmnBefore: bigint;64  let balanceStmnAfter: bigint;6566  let balanceUniqueBefore: bigint;67  let balanceUniqueAfter: bigint;68  let balanceUniqueFinal: bigint;6970  let balanceBobBefore: bigint;71  let balanceBobAfter: bigint;72  let balanceBobFinal: bigint;7374  let balanceBobRelayTokenBefore: bigint;75  let balanceBobRelayTokenAfter: bigint;767778  before(async () => {79    await usingPlaygrounds(async (helper, privateKey) => {80      alice = await privateKey('//Alice');81      bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor8283      // Set the default version to wrap the first message to other chains.84      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);85    });8687    await usingRelayPlaygrounds(relayUrl, async (helper) => {88      // Fund accounts on Statemint89      const relayXcmVersion = 2;90      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT, relayXcmVersion);91      await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT, relayXcmVersion);92    });9394    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {95      const sovereignFundingAmount = 3_500_000_000n;9697      await helper.assets.create(98        alice,99        USDT_ASSET_ID,100        alice.address,101        USDT_ASSET_METADATA_MINIMAL_BALANCE,102      );103      await helper.assets.setMetadata(104        alice,105        USDT_ASSET_ID,106        USDT_ASSET_METADATA_NAME,107        USDT_ASSET_METADATA_DESCRIPTION,108        USDT_ASSET_METADATA_DECIMALS,109      );110      await helper.assets.mint(111        alice,112        USDT_ASSET_ID,113        alice.address,114        USDT_ASSET_AMOUNT,115      );116117      // funding parachain sovereing account on Statemint.118      // The sovereign account should be created before any action119      // (the assets pallet on Statemint check if the sovereign account exists)120      const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);121      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);122    });123124125    await usingPlaygrounds(async (helper) => {126      const location = {127        V2: {128          parents: 1,129          interior: {X3: [130            {131              Parachain: STATEMINT_CHAIN,132            },133            {134              PalletInstance: STATEMINT_PALLET_INSTANCE,135            },136            {137              GeneralIndex: USDT_ASSET_ID,138            },139          ]},140        },141      };142143      const metadata =144      {145        name: USDT_ASSET_ID,146        symbol: USDT_ASSET_METADATA_NAME,147        decimals: USDT_ASSET_METADATA_DECIMALS,148        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,149      };150      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);151      balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);152    });153154155    // Providing the relay currency to the unique sender account156    // (fee for USDT XCM are paid in relay tokens)157    await usingRelayPlaygrounds(relayUrl, async (helper) => {158      const destination = {159        V1: {160          parents: 0,161          interior: {X1: {162            Parachain: UNIQUE_CHAIN,163          },164          },165        }};166167      const beneficiary = {168        V1: {169          parents: 0,170          interior: {X1: {171            AccountId32: {172              network: 'Any',173              id: alice.addressRaw,174            },175          }},176        },177      };178179      const assets = {180        V1: [181          {182            id: {183              Concrete: {184                parents: 0,185                interior: 'Here',186              },187            },188            fun: {189              Fungible: TRANSFER_AMOUNT_RELAY,190            },191          },192        ],193      };194195      const feeAssetItem = 0;196197      await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');198    });199200  });201202  itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {203    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {204      const dest = {205        V1: {206          parents: 1,207          interior: {X1: {208            Parachain: UNIQUE_CHAIN,209          },210          },211        }};212213      const beneficiary = {214        V1: {215          parents: 0,216          interior: {X1: {217            AccountId32: {218              network: 'Any',219              id: alice.addressRaw,220            },221          }},222        },223      };224225      const assets = {226        V1: [227          {228            id: {229              Concrete: {230                parents: 0,231                interior: {232                  X2: [233                    {234                      PalletInstance: STATEMINT_PALLET_INSTANCE,235                    },236                    {237                      GeneralIndex: USDT_ASSET_ID,238                    },239                  ]},240              },241            },242            fun: {243              Fungible: TRANSFER_AMOUNT,244            },245          },246        ],247      };248249      const feeAssetItem = 0;250251      balanceStmnBefore = await helper.balance.getSubstrate(alice.address);252      await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');253254      balanceStmnAfter = await helper.balance.getSubstrate(alice.address);255256      // common good parachain take commission in it native token257      console.log(258        '[Statemint -> Unique] transaction fees on Statemint: %s WND',259        helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),260      );261      expect(balanceStmnBefore > balanceStmnAfter).to.be.true;262263    });264265266    // ensure that asset has been delivered267    await helper.wait.newBlocks(3);268269    // expext collection id will be with id 1270    const free = await helper.ft.getBalance(1, {Substrate: alice.address});271272    balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);273274    console.log(275      '[Statemint -> Unique] transaction fees on Unique: %s USDT',276      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),277    );278    console.log(279      '[Statemint -> Unique] transaction fees on Unique: %s UNQ',280      helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),281    );282    // commission has not paid in USDT token283    expect(free).to.be.equal(TRANSFER_AMOUNT);284    // ... and parachain native token285    expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;286  });287288  itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {289    const destination = {290      V2: {291        parents: 1,292        interior: {X2: [293          {294            Parachain: STATEMINT_CHAIN,295          },296          {297            AccountId32: {298              network: 'Any',299              id: alice.addressRaw,300            },301          },302        ]},303      },304    };305306    const relayFee = 400_000_000_000_000n;307    const currencies: [any, bigint][] = [308      [309        {310          ForeignAssetId: 0,311        },312        TRANSFER_AMOUNT,313      ],314      [315        {316          NativeAssetId: 'Parent',317        },318        relayFee,319      ],320    ];321322    const feeItem = 1;323324    await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');325326    // the commission has been paid in parachain native token327    balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);328    console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));329    expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;330331    await usingStatemintPlaygrounds(statemintUrl, async (helper) => {332      await helper.wait.newBlocks(3);333334      // The USDT token never paid fees. Its amount not changed from begin value.335      // Also check that xcm transfer has been succeeded336      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;337    });338  });339340  itSub('Should connect and send Relay token to Unique', async ({helper}) => {341    balanceBobBefore = await helper.balance.getSubstrate(bob.address);342    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});343344    await usingRelayPlaygrounds(relayUrl, async (helper) => {345      const destination = {346        V1: {347          parents: 0,348          interior: {X1: {349            Parachain: UNIQUE_CHAIN,350          },351          },352        }};353354      const beneficiary = {355        V1: {356          parents: 0,357          interior: {X1: {358            AccountId32: {359              network: 'Any',360              id: bob.addressRaw,361            },362          }},363        },364      };365366      const assets = {367        V1: [368          {369            id: {370              Concrete: {371                parents: 0,372                interior: 'Here',373              },374            },375            fun: {376              Fungible: TRANSFER_AMOUNT_RELAY,377            },378          },379        ],380      };381382      const feeAssetItem = 0;383384      await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');385    });386387    await helper.wait.newBlocks(3);388389    balanceBobAfter = await helper.balance.getSubstrate(bob.address);390    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});391392    const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;393    const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;394    console.log(395      '[Relay (Westend) -> Unique] transaction fees: %s UNQ',396      helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),397    );398    console.log(399      '[Relay (Westend) -> Unique] transaction fees: %s WND',400      helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),401    );402    console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);403    expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;404    expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;405  });406407  itSub('Should connect and send Relay token back', async ({helper}) => {408    let relayTokenBalanceBefore: bigint;409    let relayTokenBalanceAfter: bigint;410    await usingRelayPlaygrounds(relayUrl, async (helper) => {411      relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);412    });413414    const destination = {415      V2: {416        parents: 1,417        interior: {418          X1:{419            AccountId32: {420              network: 'Any',421              id: bob.addressRaw,422            },423          },424        },425      },426    };427428    const currencies: any = [429      [430        {431          NativeAssetId: 'Parent',432        },433        TRANSFER_AMOUNT_RELAY,434      ],435    ];436437    const feeItem = 0;438439    await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');440441    balanceBobFinal = await helper.balance.getSubstrate(bob.address);442    console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ',  helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));443444    await usingRelayPlaygrounds(relayUrl, async (helper) => {445      await helper.wait.newBlocks(10);446      relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);447448      const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;449      console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));450      expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;451    });452  });453});454455describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {456  let alice: IKeyringPair;457  let randomAccount: IKeyringPair;458459  let balanceUniqueTokenInit: bigint;460  let balanceUniqueTokenMiddle: bigint;461  let balanceUniqueTokenFinal: bigint;462  let balanceAcalaTokenInit: bigint;463  let balanceAcalaTokenMiddle: bigint;464  let balanceAcalaTokenFinal: bigint;465  let balanceUniqueForeignTokenInit: bigint;466  let balanceUniqueForeignTokenMiddle: bigint;467  let balanceUniqueForeignTokenFinal: bigint;468469  // computed by a test transfer from prod Unique to prod Acala.470  // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48471  // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)472  const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;473474  const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;475476  before(async () => {477    await usingPlaygrounds(async (helper, privateKey) => {478      alice = await privateKey('//Alice');479      [randomAccount] = await helper.arrange.createAccounts([0n], alice);480481      // Set the default version to wrap the first message to other chains.482      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);483    });484485    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {486      const destination = {487        V1: {488          parents: 1,489          interior: {490            X1: {491              Parachain: UNIQUE_CHAIN,492            },493          },494        },495      };496497      const metadata = {498        name: 'Unique Network',499        symbol: 'UNQ',500        decimals: 18,501        minimalBalance: 1250000000000000000n,502      };503504      await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);505      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);506      balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);507      balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});508    });509510    await usingPlaygrounds(async (helper) => {511      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);512      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);513    });514  });515516  itSub('Should connect and send UNQ to Acala', async ({helper}) => {517518    const destination = {519      V2: {520        parents: 1,521        interior: {522          X1: {523            Parachain: ACALA_CHAIN,524          },525        },526      },527    };528529    const beneficiary = {530      V2: {531        parents: 0,532        interior: {533          X1: {534            AccountId32: {535              network: 'Any',536              id: randomAccount.addressRaw,537            },538          },539        },540      },541    };542543    const assets = {544      V2: [545        {546          id: {547            Concrete: {548              parents: 0,549              interior: 'Here',550            },551          },552          fun: {553            Fungible: TRANSFER_AMOUNT,554          },555        },556      ],557    };558559    const feeAssetItem = 0;560561    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');562    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);563564    const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;565    console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));566    expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;567568    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {569      await helper.wait.newBlocks(3);570571      balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});572      balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);573574      const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;575      const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;576      const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;577578      console.log(579        '[Unique -> Acala] transaction fees on Acala: %s ACA',580        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),581      );582      console.log(583        '[Unique -> Acala] transaction fees on Acala: %s UNQ',584        helper.util.bigIntToDecimals(acaUnqFees),585      );586      console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));587      expect(acaFees == 0n).to.be.true;588      expect(589        acaUnqFees == expectedAcalaIncomeFee,590        'Acala took different income fee, check the Acala foreign asset config',591      ).to.be.true;592    });593  });594595  itSub('Should connect to Acala and send UNQ back', async ({helper}) => {596    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {597      const destination = {598        V1: {599          parents: 1,600          interior: {601            X2: [602              {Parachain: UNIQUE_CHAIN},603              {604                AccountId32: {605                  network: 'Any',606                  id: randomAccount.addressRaw,607                },608              },609            ],610          },611        },612      };613614      const id = {615        ForeignAsset: 0,616      };617618      await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');619      balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);620      balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);621622      const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;623      const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;624625      console.log(626        '[Acala -> Unique] transaction fees on Acala: %s ACA',627        helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),628      );629      console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));630631      expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;632      expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;633    });634635    await helper.wait.newBlocks(3);636637    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);638    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;639    expect(actuallyDelivered > 0).to.be.true;640641    console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));642643    const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;644    console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));645    expect(unqFees == 0n).to.be.true;646  });647648  itSub('Acala can send only up to its balance', async ({helper}) => {649    // set Acala's sovereign account's balance650    const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);651    const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);652    await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);653654    const moreThanAcalaHas = acalaBalance * 2n;655656    let targetAccountBalance = 0n;657    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);658659    const uniqueMultilocation = {660      V1: {661        parents: 1,662        interior: {663          X1: {Parachain: UNIQUE_CHAIN},664        },665      },666    };667668    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(669      targetAccount.addressRaw,670      {671        Concrete: {672          parents: 0,673          interior: 'Here',674        },675      },676      moreThanAcalaHas,677    );678679    // Try to trick Unique680    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {681      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);682    });683684    const maxWaitBlocks = 3;685686    const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(687      maxWaitBlocks,688      'xcmpQueue',689      'Fail',690    );691692    expect(693      xcmpQueueFailEvent != null,694      `'xcmpQueue.FailEvent' event is expected`,695    ).to.be.true;696697    expect(698      xcmpQueueFailEvent!.isFailedToTransactAsset,699      `The XCM error should be 'FailedToTransactAsset'`,700    ).to.be.true;701702    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);703    expect(targetAccountBalance).to.be.equal(0n);704705    // But Acala still can send the correct amount706    const validTransferAmount = acalaBalance / 2n;707    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(708      targetAccount.addressRaw,709      {710        Concrete: {711          parents: 0,712          interior: 'Here',713        },714      },715      validTransferAmount,716    );717718    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {719      await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);720    });721722    await helper.wait.newBlocks(maxWaitBlocks);723724    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);725    expect(targetAccountBalance).to.be.equal(validTransferAmount);726  });727728  itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {729    const testAmount = 10_000n * (10n ** UNQ_DECIMALS);730    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);731732    const uniqueMultilocation = {733      V1: {734        parents: 1,735        interior: {736          X1: {737            Parachain: UNIQUE_CHAIN,738          },739        },740      },741    };742743    const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(744      targetAccount.addressRaw,745      {746        Concrete: {747          parents: 1,748          interior: {749            X1: {750              Parachain: UNIQUE_CHAIN,751            },752          },753        },754      },755      testAmount,756    );757758    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {759      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);760    });761762    const maxWaitBlocks = 3;763764    const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(765      maxWaitBlocks,766      'xcmpQueue',767      'Fail',768    );769770    expect(771      xcmpQueueFailEvent != null,772      `'xcmpQueue.FailEvent' event is expected`,773    ).to.be.true;774775    expect(776      xcmpQueueFailEvent!.isUntrustedReserveLocation,777      `The XCM error should be 'isUntrustedReserveLocation'`,778    ).to.be.true;779780    const accountBalance = await helper.balance.getSubstrate(targetAccount.address);781    expect(accountBalance).to.be.equal(0n);782  });783});784785// These tests are relevant only when786// the the corresponding foreign assets are not registered787describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {788  let alice: IKeyringPair;789  let alith: IKeyringPair;790791  const testAmount = 100_000_000_000n;792  let uniqueParachainJunction;793  let uniqueAccountJunction;794795  let uniqueParachainMultilocation: any;796  let uniqueAccountMultilocation: any;797  let uniqueCombinedMultilocation: any;798799  before(async () => {800    await usingPlaygrounds(async (helper, privateKey) => {801      alice = await privateKey('//Alice');802803      uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};804      uniqueAccountJunction = {805        AccountId32: {806          network: 'Any',807          id: alice.addressRaw,808        },809      };810811      uniqueParachainMultilocation = {812        V1: {813          parents: 1,814          interior: {815            X1: uniqueParachainJunction,816          },817        },818      };819820      uniqueAccountMultilocation = {821        V1: {822          parents: 0,823          interior: {824            X1: uniqueAccountJunction,825          },826        },827      };828829      uniqueCombinedMultilocation = {830        V1: {831          parents: 1,832          interior: {833            X2: [uniqueParachainJunction, uniqueAccountJunction],834          },835        },836      };837838      // Set the default version to wrap the first message to other chains.839      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);840    });841842    // eslint-disable-next-line require-await843    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {844      alith = helper.account.alithAccount();845    });846  });847848  const expectFailedToTransact = async (network: string, helper: DevUniqueHelper) => {849    const maxWaitBlocks = 3;850851    const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(852      maxWaitBlocks,853      'xcmpQueue',854      'Fail',855    );856857    expect(858      xcmpQueueFailEvent != null,859      `[reject ${network} tokens] 'xcmpQueue.FailEvent' event is expected`,860    ).to.be.true;861862    expect(863      xcmpQueueFailEvent!.isFailedToTransactAsset,864      `[reject ${network} tokens] The XCM error should be 'FailedToTransactAsset'`,865    ).to.be.true;866  };867868  itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {869    await usingAcalaPlaygrounds(acalaUrl, async (helper) => {870      const id = {871        Token: 'ACA',872      };873      const destination = uniqueCombinedMultilocation;874      await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');875    });876877    await expectFailedToTransact('ACA', helper);878  });879880  itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {881    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {882      const id = 'SelfReserve';883      const destination = uniqueCombinedMultilocation;884      await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');885    });886887    await expectFailedToTransact('GLMR', helper);888  });889890  itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {891    await usingAstarPlaygrounds(astarUrl, async (helper) => {892      const destinationParachain = uniqueParachainMultilocation;893      const beneficiary = uniqueAccountMultilocation;894      const assets = {895        V1: [{896          id: {897            Concrete: {898              parents: 0,899              interior: 'Here',900            },901          },902          fun: {903            Fungible: testAmount,904          },905        }],906      };907      const feeAssetItem = 0;908909      await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [910        destinationParachain,911        beneficiary,912        assets,913        feeAssetItem,914      ]);915    });916917    await expectFailedToTransact('ASTR', helper);918  });919});920921describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {922  // Unique constants923  let uniqueDonor: IKeyringPair;924  let uniqueAssetLocation;925926  let randomAccountUnique: IKeyringPair;927  let randomAccountMoonbeam: IKeyringPair;928929  // Moonbeam constants930  let assetId: string;931932  const councilVotingThreshold = 2;933  const technicalCommitteeThreshold = 2;934  const votingPeriod = 3;935  const delayPeriod = 0;936937  const uniqueAssetMetadata = {938    name: 'xcUnique',939    symbol: 'xcUNQ',940    decimals: 18,941    isFrozen: false,942    minimalBalance: 1n,943  };944945  let balanceUniqueTokenInit: bigint;946  let balanceUniqueTokenMiddle: bigint;947  let balanceUniqueTokenFinal: bigint;948  let balanceForeignUnqTokenInit: bigint;949  let balanceForeignUnqTokenMiddle: bigint;950  let balanceForeignUnqTokenFinal: bigint;951  let balanceGlmrTokenInit: bigint;952  let balanceGlmrTokenMiddle: bigint;953  let balanceGlmrTokenFinal: bigint;954955  before(async () => {956    await usingPlaygrounds(async (helper, privateKey) => {957      uniqueDonor = await privateKey('//Alice');958      [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);959960      balanceForeignUnqTokenInit = 0n;961962      // Set the default version to wrap the first message to other chains.963      const alice = uniqueDonor;964      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);965    });966967    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {968      const alithAccount = helper.account.alithAccount();969      const baltatharAccount = helper.account.baltatharAccount();970      const dorothyAccount = helper.account.dorothyAccount();971972      randomAccountMoonbeam = helper.account.create();973974      // >>> Sponsoring Dorothy >>>975      console.log('Sponsoring Dorothy.......');976      await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);977      console.log('Sponsoring Dorothy.......DONE');978      // <<< Sponsoring Dorothy <<<979980      uniqueAssetLocation = {981        XCM: {982          parents: 1,983          interior: {X1: {Parachain: UNIQUE_CHAIN}},984        },985      };986      const existentialDeposit = 1n;987      const isSufficient = true;988      const unitsPerSecond = 1n;989      const numAssetsWeightHint = 0;990991      const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({992        location: uniqueAssetLocation,993        metadata: uniqueAssetMetadata,994        existentialDeposit,995        isSufficient,996        unitsPerSecond,997        numAssetsWeightHint,998      });999      const proposalHash = blake2AsHex(encodedProposal);10001001      console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);1002      console.log('Encoded length %d', encodedProposal.length);1003      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);10041005      // >>> Note motion preimage >>>1006      console.log('Note motion preimage.......');1007      await helper.democracy.notePreimage(baltatharAccount, encodedProposal);1008      console.log('Note motion preimage.......DONE');1009      // <<< Note motion preimage <<<10101011      // >>> Propose external motion through council >>>1012      console.log('Propose external motion through council.......');1013      const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});1014      const encodedMotion = externalMotion?.method.toHex() || '';1015      const motionHash = blake2AsHex(encodedMotion);1016      console.log('Motion hash is %s', motionHash);10171018      await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);10191020      const councilProposalIdx = await helper.collective.council.proposalCount() - 1;1021      await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);1022      await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);10231024      await helper.collective.council.close(1025        dorothyAccount,1026        motionHash,1027        councilProposalIdx,1028        {1029          refTime: 1_000_000_000,1030          proofSize: 1_000_000,1031        },1032        externalMotion.encodedLength,1033      );1034      console.log('Propose external motion through council.......DONE');1035      // <<< Propose external motion through council <<<10361037      // >>> Fast track proposal through technical committee >>>1038      console.log('Fast track proposal through technical committee.......');1039      const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);1040      const encodedFastTrack = fastTrack?.method.toHex() || '';1041      const fastTrackHash = blake2AsHex(encodedFastTrack);1042      console.log('FastTrack hash is %s', fastTrackHash);10431044      await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);10451046      const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;1047      await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);1048      await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);10491050      await helper.collective.techCommittee.close(1051        baltatharAccount,1052        fastTrackHash,1053        techProposalIdx,1054        {1055          refTime: 1_000_000_000,1056          proofSize: 1_000_000,1057        },1058        fastTrack.encodedLength,1059      );1060      console.log('Fast track proposal through technical committee.......DONE');1061      // <<< Fast track proposal through technical committee <<<10621063      // >>> Referendum voting >>>1064      console.log('Referendum voting.......');1065      await helper.democracy.referendumVote(dorothyAccount, 0, {1066        balance: 10_000_000_000_000_000_000n,1067        vote: {aye: true, conviction: 1},1068      });1069      console.log('Referendum voting.......DONE');1070      // <<< Referendum voting <<<10711072      // >>> Acquire Unique AssetId Info on Moonbeam >>>1073      console.log('Acquire Unique AssetId Info on Moonbeam.......');10741075      // Wait for the democracy execute1076      await helper.wait.newBlocks(5);10771078      assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();10791080      console.log('UNQ asset ID is %s', assetId);1081      console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1082      // >>> Acquire Unique AssetId Info on Moonbeam >>>10831084      // >>> Sponsoring random Account >>>1085      console.log('Sponsoring random Account.......');1086      await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1087      console.log('Sponsoring random Account.......DONE');1088      // <<< Sponsoring random Account <<<10891090      balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1091    });10921093    await usingPlaygrounds(async (helper) => {1094      await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1095      balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1096    });1097  });10981099  itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1100    const currencyId = {1101      NativeAssetId: 'Here',1102    };1103    const dest = {1104      V2: {1105        parents: 1,1106        interior: {1107          X2: [1108            {Parachain: MOONBEAM_CHAIN},1109            {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1110          ],1111        },1112      },1113    };1114    const amount = TRANSFER_AMOUNT;11151116    await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');11171118    balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1119    expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;11201121    const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1122    console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1123    expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;11241125    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1126      await helper.wait.newBlocks(3);11271128      balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);11291130      const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1131      console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1132      expect(glmrFees == 0n).to.be.true;11331134      balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;11351136      const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1137      console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1138      expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1139    });1140  });11411142  itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1143    await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1144      const asset = {1145        V1: {1146          id: {1147            Concrete: {1148              parents: 1,1149              interior: {1150                X1: {Parachain: UNIQUE_CHAIN},1151              },1152            },1153          },1154          fun: {1155            Fungible: TRANSFER_AMOUNT,1156          },1157        },1158      };1159      const destination = {1160        V1: {1161          parents: 1,1162          interior: {1163            X2: [1164              {Parachain: UNIQUE_CHAIN},1165              {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1166            ],1167          },1168        },1169      };11701171      await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');11721173      balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);11741175      const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1176      console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1177      expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;11781179      const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);11801181      expect(unqRandomAccountAsset).to.be.null;11821183      balanceForeignUnqTokenFinal = 0n;11841185      const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1186      console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1187      expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1188    });11891190    await helper.wait.newBlocks(3);11911192    balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1193    const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1194    expect(actuallyDelivered > 0).to.be.true;11951196    console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));11971198    const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1199    console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1200    expect(unqFees == 0n).to.be.true;1201  });12021203  itSub.skip('Moonbeam can send only up to its balance', async ({helper}) => {1204    throw Error("Not yet implemented");1205  });12061207  itSub.skip('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1208    throw Error("Not yet implemented");1209  });1210});12111212describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1213  let alice: IKeyringPair;1214  let randomAccount: IKeyringPair;12151216  const UNQ_ASSET_ID_ON_SHIDEN = 1;1217  const UNQ_MINIMAL_BALANCE_ON_SHIDEN = 1n;12181219  // Unique -> Astar1220  const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Shiden.1221  const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1222  const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1223  const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Shiden takes a commision in foreign tokens12241225  // Astar -> Unique1226  const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1227  const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ12281229  let balanceAfterUniqueToAstarXCM: bigint;12301231  before(async () => {1232    await usingPlaygrounds(async (helper, privateKey) => {1233      alice = await privateKey('//Alice');1234      [randomAccount] = await helper.arrange.createAccounts([100n], alice);1235      console.log('randomAccount', randomAccount.address);12361237      // Set the default version to wrap the first message to other chains.1238      await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1239    });12401241    await usingAstarPlaygrounds(astarUrl, async (helper) => {1242      console.log('1. Create foreign asset and metadata');1243      // TODO update metadata with values from production1244      await helper.assets.create(1245        alice,1246        UNQ_ASSET_ID_ON_SHIDEN,1247        alice.address,1248        UNQ_MINIMAL_BALANCE_ON_SHIDEN,1249      );12501251      await helper.assets.setMetadata(1252        alice,1253        UNQ_ASSET_ID_ON_SHIDEN,1254        'Cross chain UNQ',1255        'xcUNQ',1256        Number(UNQ_DECIMALS),1257      );12581259      console.log('2. Register asset location on Astar');1260      const assetLocation = {1261        V1: {1262          parents: 1,1263          interior: {1264            X1: {1265              Parachain: UNIQUE_CHAIN,1266            },1267          },1268        },1269      };12701271      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_SHIDEN]);12721273      console.log('3. Set UNQ payment for XCM execution on Astar');1274      await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);12751276      console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1277      await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1278    });1279  });12801281  itSub('Should connect and send UNQ to Astar', async ({helper}) => {1282    const destination = {1283      V2: {1284        parents: 1,1285        interior: {1286          X1: {1287            Parachain: ASTAR_CHAIN,1288          },1289        },1290      },1291    };12921293    const beneficiary = {1294      V2: {1295        parents: 0,1296        interior: {1297          X1: {1298            AccountId32: {1299              network: 'Any',1300              id: randomAccount.addressRaw,1301            },1302          },1303        },1304      },1305    };13061307    const assets = {1308      V2: [1309        {1310          id: {1311            Concrete: {1312              parents: 0,1313              interior: 'Here',1314            },1315          },1316          fun: {1317            Fungible: unqToAstarTransferred,1318          },1319        },1320      ],1321    };13221323    // Initial balance is 100 UNQ1324    const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1325    console.log(`Initial balance is: ${balanceBefore}`);13261327    const feeAssetItem = 0;1328    await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');13291330    // Balance after reserve transfer is less than 901331    balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1332    console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1333    console.log(`Unique's UNQ commission is: ${balanceBefore - balanceAfterUniqueToAstarXCM}`);1334    expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;13351336    await usingAstarPlaygrounds(astarUrl, async (helper) => {1337      await helper.wait.newBlocks(3);1338      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1339      const astarBalance = await helper.balance.getSubstrate(randomAccount.address);13401341      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1342      console.log(`Astar's UNQ commission is: ${unqToAstarTransferred - xcUNQbalance!}`);13431344      expect(xcUNQbalance).to.eq(unqToAstarArrived);1345      // Astar balance does not changed1346      expect(astarBalance).to.eq(astarInitialBalance);1347    });1348  });13491350  itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1351    await usingAstarPlaygrounds(astarUrl, async (helper) => {1352      const destination = {1353        V1: {1354          parents: 1,1355          interior: {1356            X1: {1357              Parachain: UNIQUE_CHAIN,1358            },1359          },1360        },1361      };13621363      const beneficiary = {1364        V1: {1365          parents: 0,1366          interior: {1367            X1: {1368              AccountId32: {1369                network: 'Any',1370                id: randomAccount.addressRaw,1371              },1372            },1373          },1374        },1375      };13761377      const assets = {1378        V1: [1379          {1380            id: {1381              Concrete: {1382                parents: 1,1383                interior: {1384                  X1: {1385                    Parachain: UNIQUE_CHAIN,1386                  },1387                },1388              },1389            },1390            fun: {1391              Fungible: unqFromAstarTransfered,1392            },1393          },1394        ],1395      };13961397      // Initial balance is 1 ASTR1398      const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1399      console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1400      expect(balanceASTRbefore).to.eq(astarInitialBalance);14011402      const feeAssetItem = 0;1403      // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1404      await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);14051406      const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);1407      const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1408      console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);14091410      // Assert: xcUNQ balance correctly decreased1411      expect(xcUNQbalance).to.eq(unqOnAstarLeft);1412      // Assert: ASTR balance is 0.996...1413      expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1414    });14151416    await helper.wait.newBlocks(3);1417    const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1418    console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1419    expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1420  });14211422  itSub('Astar can send only up to its balance', async ({helper}) => {1423    // set Astar's sovereign account's balance1424    const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1425    const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1426    await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);14271428    const moreThanShidenHas = astarBalance * 2n;14291430    let targetAccountBalance = 0n;1431    const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);14321433    const uniqueMultilocation = {1434      V1: {1435        parents: 1,1436        interior: {1437          X1: {Parachain: UNIQUE_CHAIN},1438        },1439      },1440    };14411442    const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1443      targetAccount.addressRaw,1444      {1445        Concrete: {1446          parents: 0,1447          interior: 'Here',1448        },1449      },1450      moreThanShidenHas,1451    );14521453    // Try to trick Unique1454    await usingAstarPlaygrounds(astarUrl, async (helper) => {1455      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);1456    });14571458    const maxWaitBlocks = 3;14591460    const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(1461      maxWaitBlocks,1462      'xcmpQueue',1463      'Fail',1464    );14651466    expect(1467      xcmpQueueFailEvent != null,1468      `'xcmpQueue.FailEvent' event is expected`,1469    ).to.be.true;14701471    expect(1472      xcmpQueueFailEvent!.isFailedToTransactAsset,1473      `The XCM error should be 'FailedToTransactAsset'`,1474    ).to.be.true;14751476    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1477    expect(targetAccountBalance).to.be.equal(0n);14781479    // But Astar still can send the correct amount1480    const validTransferAmount = astarBalance / 2n;1481    const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1482      targetAccount.addressRaw,1483      {1484        Concrete: {1485          parents: 0,1486          interior: 'Here',1487        },1488      },1489      validTransferAmount,1490    );14911492    await usingAstarPlaygrounds(astarUrl, async (helper) => {1493      await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1494    });14951496    await helper.wait.newBlocks(maxWaitBlocks);14971498    targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1499    expect(targetAccountBalance).to.be.equal(validTransferAmount);1500  });15011502  itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1503    const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1504    const [targetAccount] = await helper.arrange.createAccounts([0n], alice);15051506    const uniqueMultilocation = {1507      V1: {1508        parents: 1,1509        interior: {1510          X1: {1511            Parachain: UNIQUE_CHAIN,1512          },1513        },1514      },1515    };15161517    const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(1518      targetAccount.addressRaw,1519      {1520        Concrete: {1521          parents: 1,1522          interior: {1523            X1: {1524              Parachain: UNIQUE_CHAIN,1525            },1526          },1527        },1528      },1529      testAmount,1530    );15311532    await usingAstarPlaygrounds(astarUrl, async (helper) => {1533      await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);1534    });15351536    const maxWaitBlocks = 3;15371538    const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(1539      maxWaitBlocks,1540      'xcmpQueue',1541      'Fail',1542    );15431544    expect(1545      xcmpQueueFailEvent != null,1546      `'xcmpQueue.FailEvent' event is expected`,1547    ).to.be.true;15481549    expect(1550      xcmpQueueFailEvent!.isUntrustedReserveLocation,1551      `The XCM error should be 'isUntrustedReserveLocation'`,1552    ).to.be.true;15531554    const accountBalance = await helper.balance.getSubstrate(targetAccount.address);1555    expect(accountBalance).to.be.equal(0n);1556  });15571558});