difftreelog
fix(unq xcm tests) restore state for the Acala
in: master
1 file changed
tests/src/xcm/xcmUnique.test.tsdiffbeforeafterboth1// 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 config from '../config';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';21import {hexToString, nToBigInt} from '@polkadot/util';2223const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);24const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);25const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);26const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);27const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);28const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);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;37const polkadexUrl = config.polkadexUrl;3839const RELAY_DECIMALS = 12;40const STATEMINT_DECIMALS = 12;41const ACALA_DECIMALS = 12;42const ASTAR_DECIMALS = 18n;43const UNQ_DECIMALS = 18n;4445const TRANSFER_AMOUNT = 2000000000000000000000000n;4647const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4849const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;5051const USDT_ASSET_ID = 100;52const USDT_ASSET_METADATA_DECIMALS = 18;53const USDT_ASSET_METADATA_NAME = 'USDT';54const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';55const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;56const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5758const SAFE_XCM_VERSION = 2;59const maxWaitBlocks = 6;6061const uniqueMultilocation = {62 V2: {63 parents: 1,64 interior: {65 X1: {66 Parachain: UNIQUE_CHAIN,67 },68 },69 },70};7172const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {73 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash74 && event.outcome.isFailedToTransactAsset);75};76const expectUntrustedReserveLocationFail = async (helper: DevUniqueHelper, messageSent: any) => {77 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash78 && event.outcome.isUntrustedReserveLocation);79};80describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {81 let alice: IKeyringPair;82 let bob: IKeyringPair;8384 let balanceStmnBefore: bigint;85 let balanceStmnAfter: bigint;8687 let balanceUniqueBefore: bigint;88 let balanceUniqueAfter: bigint;89 let balanceUniqueFinal: bigint;9091 let balanceBobBefore: bigint;92 let balanceBobAfter: bigint;93 let balanceBobFinal: bigint;9495 let balanceBobRelayTokenBefore: bigint;96 let balanceBobRelayTokenAfter: bigint;979899 before(async () => {100 await usingPlaygrounds(async (helper, privateKey) => {101 alice = await privateKey('//Alice');102 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor103104 // Set the default version to wrap the first message to other chains.105 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);106 });107108 await usingRelayPlaygrounds(relayUrl, async (helper) => {109 // Fund accounts on Statemint110 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);111 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);112 });113114 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {115 const sovereignFundingAmount = 3_500_000_000n;116117 await helper.assets.create(118 alice,119 USDT_ASSET_ID,120 alice.address,121 USDT_ASSET_METADATA_MINIMAL_BALANCE,122 );123 await helper.assets.setMetadata(124 alice,125 USDT_ASSET_ID,126 USDT_ASSET_METADATA_NAME,127 USDT_ASSET_METADATA_DESCRIPTION,128 USDT_ASSET_METADATA_DECIMALS,129 );130 await helper.assets.mint(131 alice,132 USDT_ASSET_ID,133 alice.address,134 USDT_ASSET_AMOUNT,135 );136137 // funding parachain sovereing account on Statemint.138 // The sovereign account should be created before any action139 // (the assets pallet on Statemint check if the sovereign account exists)140 const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);141 await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);142 });143144145 await usingPlaygrounds(async (helper) => {146 const location = {147 V2: {148 parents: 1,149 interior: {X3: [150 {151 Parachain: STATEMINT_CHAIN,152 },153 {154 PalletInstance: STATEMINT_PALLET_INSTANCE,155 },156 {157 GeneralIndex: USDT_ASSET_ID,158 },159 ]},160 },161 };162163 const metadata =164 {165 name: USDT_ASSET_ID,166 symbol: USDT_ASSET_METADATA_NAME,167 decimals: USDT_ASSET_METADATA_DECIMALS,168 minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,169 };170 await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);171 balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);172 });173174175 // Providing the relay currency to the unique sender account176 // (fee for USDT XCM are paid in relay tokens)177 await usingRelayPlaygrounds(relayUrl, async (helper) => {178 const destination = {179 V2: {180 parents: 0,181 interior: {X1: {182 Parachain: UNIQUE_CHAIN,183 },184 },185 }};186187 const beneficiary = {188 V2: {189 parents: 0,190 interior: {X1: {191 AccountId32: {192 network: 'Any',193 id: alice.addressRaw,194 },195 }},196 },197 };198199 const assets = {200 V2: [201 {202 id: {203 Concrete: {204 parents: 0,205 interior: 'Here',206 },207 },208 fun: {209 Fungible: TRANSFER_AMOUNT_RELAY,210 },211 },212 ],213 };214215 const feeAssetItem = 0;216217 await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');218 });219220 });221222 itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {223 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {224 const dest = {225 V2: {226 parents: 1,227 interior: {X1: {228 Parachain: UNIQUE_CHAIN,229 },230 },231 }};232233 const beneficiary = {234 V2: {235 parents: 0,236 interior: {X1: {237 AccountId32: {238 network: 'Any',239 id: alice.addressRaw,240 },241 }},242 },243 };244245 const assets = {246 V2: [247 {248 id: {249 Concrete: {250 parents: 0,251 interior: {252 X2: [253 {254 PalletInstance: STATEMINT_PALLET_INSTANCE,255 },256 {257 GeneralIndex: USDT_ASSET_ID,258 },259 ]},260 },261 },262 fun: {263 Fungible: TRANSFER_AMOUNT,264 },265 },266 ],267 };268269 const feeAssetItem = 0;270271 balanceStmnBefore = await helper.balance.getSubstrate(alice.address);272 await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');273274 balanceStmnAfter = await helper.balance.getSubstrate(alice.address);275276 // common good parachain take commission in it native token277 console.log(278 '[Statemint -> Unique] transaction fees on Statemint: %s WND',279 helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),280 );281 expect(balanceStmnBefore > balanceStmnAfter).to.be.true;282283 });284285286 // ensure that asset has been delivered287 await helper.wait.newBlocks(3);288289 // expext collection id will be with id 1290 const free = await helper.ft.getBalance(1, {Substrate: alice.address});291292 balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);293294 console.log(295 '[Statemint -> Unique] transaction fees on Unique: %s USDT',296 helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),297 );298 console.log(299 '[Statemint -> Unique] transaction fees on Unique: %s UNQ',300 helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),301 );302 // commission has not paid in USDT token303 expect(free).to.be.equal(TRANSFER_AMOUNT);304 // ... and parachain native token305 expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;306 });307308 itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {309 const destination = {310 V2: {311 parents: 1,312 interior: {X2: [313 {314 Parachain: STATEMINT_CHAIN,315 },316 {317 AccountId32: {318 network: 'Any',319 id: alice.addressRaw,320 },321 },322 ]},323 },324 };325326 const relayFee = 400_000_000_000_000n;327 const currencies: [any, bigint][] = [328 [329 {330 ForeignAssetId: 0,331 },332 TRANSFER_AMOUNT,333 ],334 [335 {336 NativeAssetId: 'Parent',337 },338 relayFee,339 ],340 ];341342 const feeItem = 1;343344 await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');345346 // the commission has been paid in parachain native token347 balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);348 console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));349 expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;350351 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {352 await helper.wait.newBlocks(3);353354 // The USDT token never paid fees. Its amount not changed from begin value.355 // Also check that xcm transfer has been succeeded356 expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;357 });358 });359360 itSub('Should connect and send Relay token to Unique', async ({helper}) => {361 balanceBobBefore = await helper.balance.getSubstrate(bob.address);362 balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});363364 await usingRelayPlaygrounds(relayUrl, async (helper) => {365 const destination = {366 V2: {367 parents: 0,368 interior: {X1: {369 Parachain: UNIQUE_CHAIN,370 },371 },372 }};373374 const beneficiary = {375 V2: {376 parents: 0,377 interior: {X1: {378 AccountId32: {379 network: 'Any',380 id: bob.addressRaw,381 },382 }},383 },384 };385386 const assets = {387 V2: [388 {389 id: {390 Concrete: {391 parents: 0,392 interior: 'Here',393 },394 },395 fun: {396 Fungible: TRANSFER_AMOUNT_RELAY,397 },398 },399 ],400 };401402 const feeAssetItem = 0;403404 await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');405 });406407 await helper.wait.newBlocks(3);408409 balanceBobAfter = await helper.balance.getSubstrate(bob.address);410 balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});411412 const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;413 const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;414 console.log(415 '[Relay (Westend) -> Unique] transaction fees: %s UNQ',416 helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),417 );418 console.log(419 '[Relay (Westend) -> Unique] transaction fees: %s WND',420 helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),421 );422 console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);423 expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;424 expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;425 });426427 itSub('Should connect and send Relay token back', async ({helper}) => {428 let relayTokenBalanceBefore: bigint;429 let relayTokenBalanceAfter: bigint;430 await usingRelayPlaygrounds(relayUrl, async (helper) => {431 relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);432 });433434 const destination = {435 V2: {436 parents: 1,437 interior: {438 X1:{439 AccountId32: {440 network: 'Any',441 id: bob.addressRaw,442 },443 },444 },445 },446 };447448 const currencies: any = [449 [450 {451 NativeAssetId: 'Parent',452 },453 TRANSFER_AMOUNT_RELAY,454 ],455 ];456457 const feeItem = 0;458459 await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');460461 balanceBobFinal = await helper.balance.getSubstrate(bob.address);462 console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ', helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));463464 await usingRelayPlaygrounds(relayUrl, async (helper) => {465 await helper.wait.newBlocks(10);466 relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);467468 const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;469 console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));470 expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;471 });472 });473});474475describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {476 let alice: IKeyringPair;477 let randomAccount: IKeyringPair;478479 let balanceUniqueTokenInit: bigint;480 let balanceUniqueTokenMiddle: bigint;481 let balanceUniqueTokenFinal: bigint;482 let balanceAcalaTokenInit: bigint;483 let balanceAcalaTokenMiddle: bigint;484 let balanceAcalaTokenFinal: bigint;485 let balanceUniqueForeignTokenInit: bigint;486 let balanceUniqueForeignTokenMiddle: bigint;487 let balanceUniqueForeignTokenFinal: bigint;488489 // computed by a test transfer from prod Unique to prod Acala.490 // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48491 // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)492 const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;493 const acalaEps = 8n * 10n ** 16n;494495 let acalaBackwardTransferAmount: bigint;496497 before(async () => {498 await usingPlaygrounds(async (helper, privateKey) => {499 alice = await privateKey('//Alice');500 [randomAccount] = await helper.arrange.createAccounts([0n], alice);501502 // Set the default version to wrap the first message to other chains.503 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);504 });505506 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {507 const destination = {508 V2: {509 parents: 1,510 interior: {511 X1: {512 Parachain: UNIQUE_CHAIN,513 },514 },515 },516 };517518 const metadata = {519 name: 'Unique Network',520 symbol: 'UNQ',521 decimals: 18,522 minimalBalance: 1250000000000000000n,523 };524 const assets = (await (helper.callRpc('api.query.assetRegistry.assetMetadatas.entries'))).map(([_k, v] : [any, any]) =>525 hexToString(v.toJSON()['symbol'])) as string[];526527 if(!assets.includes('UNQ')) {528 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);529 } else {530 console.log('UNQ token already registered on Acala assetRegistry pallet');531 }532 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);533 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);534 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});535 });536537 await usingPlaygrounds(async (helper) => {538 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);539 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);540 });541 });542543 itSub('Should connect and send UNQ to Acala', async ({helper}) => {544545 const destination = {546 V2: {547 parents: 1,548 interior: {549 X1: {550 Parachain: ACALA_CHAIN,551 },552 },553 },554 };555556 const beneficiary = {557 V2: {558 parents: 0,559 interior: {560 X1: {561 AccountId32: {562 network: 'Any',563 id: randomAccount.addressRaw,564 },565 },566 },567 },568 };569570 const assets = {571 V2: [572 {573 id: {574 Concrete: {575 parents: 0,576 interior: 'Here',577 },578 },579 fun: {580 Fungible: TRANSFER_AMOUNT,581 },582 },583 ],584 };585586 const feeAssetItem = 0;587588 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');589 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);590591 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;592 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));593 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;594595 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {596 await helper.wait.newBlocks(3);597598 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});599 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);600601 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;602 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;603 acalaBackwardTransferAmount = unqIncomeTransfer;604605 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;606607 console.log(608 '[Unique -> Acala] transaction fees on Acala: %s ACA',609 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),610 );611 console.log(612 '[Unique -> Acala] transaction fees on Acala: %s UNQ',613 helper.util.bigIntToDecimals(acaUnqFees),614 );615 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));616 expect(acaFees == 0n).to.be.true;617618 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;619620 expect(621 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,622 'Acala took different income fee, check the Acala foreign asset config',623 ).to.be.true;624 });625 });626627 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {628 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {629 const destination = {630 V2: {631 parents: 1,632 interior: {633 X2: [634 {Parachain: UNIQUE_CHAIN},635 {636 AccountId32: {637 network: 'Any',638 id: randomAccount.addressRaw,639 },640 },641 ],642 },643 },644 };645646 const id = {647 ForeignAsset: 0,648 };649650 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');651 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);652 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);653654 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;655 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;656657 console.log(658 '[Acala -> Unique] transaction fees on Acala: %s ACA',659 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),660 );661 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));662663 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;664 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;665 });666667 await helper.wait.newBlocks(3);668669 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);670 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;671 expect(actuallyDelivered > 0).to.be.true;672673 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));674675 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;676 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));677 expect(unqFees == 0n).to.be.true;678 });679680 itSub('Acala can send only up to its balance', async ({helper}) => {681 // set Acala's sovereign account's balance682 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);683 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);684 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);685686 const moreThanAcalaHas = acalaBalance * 2n;687688 let targetAccountBalance = 0n;689 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);690691 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(692 targetAccount.addressRaw,693 {694 Concrete: {695 parents: 0,696 interior: 'Here',697 },698 },699 moreThanAcalaHas,700 );701702 let maliciousXcmProgramSent: any;703 const maxWaitBlocks = 3;704705 // Try to trick Unique706 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {707 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);708709 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);710 });711712 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash713 && event.outcome.isFailedToTransactAsset);714715 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);716 expect(targetAccountBalance).to.be.equal(0n);717718 // But Acala still can send the correct amount719 const validTransferAmount = acalaBalance / 2n;720 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(721 targetAccount.addressRaw,722 {723 Concrete: {724 parents: 0,725 interior: 'Here',726 },727 },728 validTransferAmount,729 );730731 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {732 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);733 });734735 await helper.wait.newBlocks(maxWaitBlocks);736737 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);738 expect(targetAccountBalance).to.be.equal(validTransferAmount);739 });740741 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {742 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);743 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);744745 const uniqueMultilocation = {746 V2: {747 parents: 1,748 interior: {749 X1: {750 Parachain: UNIQUE_CHAIN,751 },752 },753 },754 };755756 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(757 targetAccount.addressRaw,758 {759 Concrete: {760 parents: 1,761 interior: {762 X1: {763 Parachain: UNIQUE_CHAIN,764 },765 },766 },767 },768 testAmount,769 );770771 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(772 targetAccount.addressRaw,773 {774 Concrete: {775 parents: 0,776 interior: 'Here',777 },778 },779 testAmount,780 );781782 let maliciousXcmProgramFullIdSent: any;783 let maliciousXcmProgramHereIdSent: any;784 const maxWaitBlocks = 3;785786 // Try to trick Unique using full UNQ identification787 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {788 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);789790 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);791 });792793 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash794 && event.outcome.isUntrustedReserveLocation);795796 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);797 expect(accountBalance).to.be.equal(0n);798799 // Try to trick Unique using shortened UNQ identification800 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {801 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);802803 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);804 });805806 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash807 && event.outcome.isUntrustedReserveLocation);808809 accountBalance = await helper.balance.getSubstrate(targetAccount.address);810 expect(accountBalance).to.be.equal(0n);811 });812});813814describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {815 let alice: IKeyringPair;816 let randomAccount: IKeyringPair;817 let unqFees: bigint;818 let balanceUniqueTokenInit: bigint;819 let balanceUniqueTokenMiddle: bigint;820 let balanceUniqueTokenFinal: bigint;821 const maxWaitBlocks = 6;822823 const uniqueAssetId = {824 Concrete: {825 parents: 1,826 interior: {827 X1: {828 Parachain: UNIQUE_CHAIN,829 },830 },831 },832 };833834 before(async () => {835 await usingPlaygrounds(async (helper, privateKey) => {836 alice = await privateKey('//Alice');837 [randomAccount] = await helper.arrange.createAccounts([0n], alice);838839 // Set the default version to wrap the first message to other chains.840 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);841 });842843 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {844 const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', []))845 .toJSON() as [])846 .map(nToBigInt).length != 0;847 /*848 Check whether the Unique token has been added849 to the whitelist, since an error will occur850 if it is added again. Needed for debugging851 when this test is run multiple times.852 */853 if(!isWhitelisted) {854 await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);855 }856857 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);858 });859860 await usingPlaygrounds(async (helper) => {861 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);862 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);863 });864 });865866 itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {867868 const destination = {869 V2: {870 parents: 1,871 interior: {872 X1: {873 Parachain: POLKADEX_CHAIN,874 },875 },876 },877 };878879 const beneficiary = {880 V2: {881 parents: 0,882 interior: {883 X1: {884 AccountId32: {885 network: 'Any',886 id: randomAccount.addressRaw,887 },888 },889 },890 },891 };892893 const assets = {894 V2: [895 {896 id: {897 Concrete: {898 parents: 0,899 interior: 'Here',900 },901 },902 fun: {903 Fungible: TRANSFER_AMOUNT,904 },905 },906 ],907 };908909 const feeAssetItem = 0;910911 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');912 const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);913 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);914915 unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;916 console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));917 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;918919 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {920 /*921 Since only the parachain part of the Polkadex922 infrastructure is launched (without their923 solochain validators), processing incoming924 assets will lead to an error.925 This error indicates that the Polkadex chain926 received a message from the Unique network,927 since the hash is being checked to ensure928 it matches what was sent.929 */930 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);931 });932 });933934935 itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {936937 const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(938 randomAccount.addressRaw,939 {940 Concrete: {941 parents: 1,942 interior: {943 X1: {Parachain: UNIQUE_CHAIN},944 },945 },946 },947 TRANSFER_AMOUNT,948 );949950 let xcmProgramSent: any;951952953 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {954 await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);955956 xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);957 });958959 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);960961 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);962963 expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);964 });965966 itSub('Polkadex can send only up to its balance', async ({helper}) => {967 const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);968 const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);969 await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);970 const moreThanPolkadexHas = 2n * polkadexBalance;971972 const targetAccount = helper.arrange.createEmptyAccount();973974 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(975 targetAccount.addressRaw,976 {977 Concrete: {978 parents: 0,979 interior: 'Here',980 },981 },982 moreThanPolkadexHas,983 );984985 let maliciousXcmProgramSent: any;986987988 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {989 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);990991 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);992 });993994 await expectFailedToTransact(helper, maliciousXcmProgramSent);995996 const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);997 expect(targetAccountBalance).to.be.equal(0n);998 });9991000 itSub('Should not accept reserve transfer of UNQ from Polkadex', async ({helper}) => {1001 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1002 const targetAccount = helper.arrange.createEmptyAccount();10031004 const uniqueMultilocation = {1005 V2: {1006 parents: 1,1007 interior: {1008 X1: {1009 Parachain: UNIQUE_CHAIN,1010 },1011 },1012 },1013 };10141015 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1016 targetAccount.addressRaw,1017 {1018 Concrete: {1019 parents: 1,1020 interior: {1021 X1: {1022 Parachain: UNIQUE_CHAIN,1023 },1024 },1025 },1026 },1027 testAmount,1028 );10291030 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1031 targetAccount.addressRaw,1032 {1033 Concrete: {1034 parents: 0,1035 interior: 'Here',1036 },1037 },1038 testAmount,1039 );10401041 let maliciousXcmProgramFullIdSent: any;1042 let maliciousXcmProgramHereIdSent: any;1043 const maxWaitBlocks = 3;10441045 // Try to trick Unique using full UNQ identification1046 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1047 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);10481049 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1050 });10511052 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramFullIdSent);10531054 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1055 expect(accountBalance).to.be.equal(0n);10561057 // Try to trick Unique using shortened UNQ identification1058 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1059 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);10601061 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1062 });10631064 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramHereIdSent);10651066 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1067 expect(accountBalance).to.be.equal(0n);1068 });1069});10701071// These tests are relevant only when1072// the the corresponding foreign assets are not registered1073describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {1074 let alice: IKeyringPair;1075 let alith: IKeyringPair;10761077 const testAmount = 100_000_000_000n;1078 let uniqueParachainJunction;1079 let uniqueAccountJunction;10801081 let uniqueParachainMultilocation: any;1082 let uniqueAccountMultilocation: any;1083 let uniqueCombinedMultilocation: any;1084 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V210851086 let messageSent: any;10871088 const maxWaitBlocks = 3;10891090 before(async () => {1091 await usingPlaygrounds(async (helper, privateKey) => {1092 alice = await privateKey('//Alice');10931094 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};1095 uniqueAccountJunction = {1096 AccountId32: {1097 network: 'Any',1098 id: alice.addressRaw,1099 },1100 };11011102 uniqueParachainMultilocation = {1103 V2: {1104 parents: 1,1105 interior: {1106 X1: uniqueParachainJunction,1107 },1108 },1109 };11101111 uniqueAccountMultilocation = {1112 V2: {1113 parents: 0,1114 interior: {1115 X1: uniqueAccountJunction,1116 },1117 },1118 };11191120 uniqueCombinedMultilocation = {1121 V2: {1122 parents: 1,1123 interior: {1124 X2: [uniqueParachainJunction, uniqueAccountJunction],1125 },1126 },1127 };11281129 uniqueCombinedMultilocationAcala = {1130 V2: {1131 parents: 1,1132 interior: {1133 X2: [uniqueParachainJunction, uniqueAccountJunction],1134 },1135 },1136 };11371138 // Set the default version to wrap the first message to other chains.1139 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1140 });11411142 // eslint-disable-next-line require-await1143 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1144 alith = helper.account.alithAccount();1145 });1146 });1147114811491150 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {1151 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {1152 const id = {1153 Token: 'ACA',1154 };1155 const destination = uniqueCombinedMultilocationAcala;1156 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');11571158 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1159 });11601161 await expectFailedToTransact(helper, messageSent);1162 });11631164 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {1165 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1166 const id = 'SelfReserve';1167 const destination = uniqueCombinedMultilocation;1168 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');11691170 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1171 });11721173 await expectFailedToTransact(helper, messageSent);1174 });11751176 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {1177 await usingAstarPlaygrounds(astarUrl, async (helper) => {1178 const destinationParachain = uniqueParachainMultilocation;1179 const beneficiary = uniqueAccountMultilocation;1180 const assets = {1181 V2: [{1182 id: {1183 Concrete: {1184 parents: 0,1185 interior: 'Here',1186 },1187 },1188 fun: {1189 Fungible: testAmount,1190 },1191 }],1192 };1193 const feeAssetItem = 0;11941195 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1196 destinationParachain,1197 beneficiary,1198 assets,1199 feeAssetItem,1200 ]);12011202 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1203 });12041205 await expectFailedToTransact(helper, messageSent);1206 });12071208 itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {12091210 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1211 helper.arrange.createEmptyAccount().addressRaw,1212 {1213 Concrete: {1214 parents: 1,1215 interior: {1216 X1: {1217 Parachain: POLKADEX_CHAIN,1218 },1219 },1220 },1221 },1222 testAmount,1223 );12241225 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1226 await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);1227 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1228 });12291230 await expectFailedToTransact(helper, messageSent);1231 });1232});12331234describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1235 // Unique constants1236 let alice: IKeyringPair;1237 let uniqueAssetLocation;12381239 let randomAccountUnique: IKeyringPair;1240 let randomAccountMoonbeam: IKeyringPair;12411242 // Moonbeam constants1243 let assetId: string;12441245 const uniqueAssetMetadata = {1246 name: 'xcUnique',1247 symbol: 'xcUNQ',1248 decimals: 18,1249 isFrozen: false,1250 minimalBalance: 1n,1251 };12521253 let balanceUniqueTokenInit: bigint;1254 let balanceUniqueTokenMiddle: bigint;1255 let balanceUniqueTokenFinal: bigint;1256 let balanceForeignUnqTokenInit: bigint;1257 let balanceForeignUnqTokenMiddle: bigint;1258 let balanceForeignUnqTokenFinal: bigint;1259 let balanceGlmrTokenInit: bigint;1260 let balanceGlmrTokenMiddle: bigint;1261 let balanceGlmrTokenFinal: bigint;12621263 before(async () => {1264 await usingPlaygrounds(async (helper, privateKey) => {1265 alice = await privateKey('//Alice');1266 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);12671268 balanceForeignUnqTokenInit = 0n;12691270 // Set the default version to wrap the first message to other chains.1271 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1272 });12731274 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1275 const alithAccount = helper.account.alithAccount();1276 const baltatharAccount = helper.account.baltatharAccount();1277 const dorothyAccount = helper.account.dorothyAccount();12781279 randomAccountMoonbeam = helper.account.create();12801281 // >>> Sponsoring Dorothy >>>1282 console.log('Sponsoring Dorothy.......');1283 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1284 console.log('Sponsoring Dorothy.......DONE');1285 // <<< Sponsoring Dorothy <<<12861287 uniqueAssetLocation = {1288 XCM: {1289 parents: 1,1290 interior: {X1: {Parachain: UNIQUE_CHAIN}},1291 },1292 };1293 const existentialDeposit = 1n;1294 const isSufficient = true;1295 const unitsPerSecond = 1n;1296 const numAssetsWeightHint = 0;12971298 if((await helper.assetManager.assetTypeId(uniqueAssetLocation)).toJSON()) {1299 console.log('Unique asset is already registered on MoonBeam');1300 } else {1301 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1302 location: uniqueAssetLocation,1303 metadata: uniqueAssetMetadata,1304 existentialDeposit,1305 isSufficient,1306 unitsPerSecond,1307 numAssetsWeightHint,1308 });13091310 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);13111312 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);13131314 // >>> Acquire Unique AssetId Info on Moonbeam >>>1315 console.log('Acquire Unique AssetId Info on Moonbeam.......');13161317 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();13181319 console.log('UNQ asset ID is %s', assetId);1320 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1321 }1322 // >>> Acquire Unique AssetId Info on Moonbeam >>>13231324 // >>> Sponsoring random Account >>>1325 console.log('Sponsoring random Account.......');1326 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1327 console.log('Sponsoring random Account.......DONE');1328 // <<< Sponsoring random Account <<<13291330 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1331 });13321333 await usingPlaygrounds(async (helper) => {1334 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1335 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1336 });1337 });13381339 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1340 const currencyId = {1341 NativeAssetId: 'Here',1342 };1343 const dest = {1344 V2: {1345 parents: 1,1346 interior: {1347 X2: [1348 {Parachain: MOONBEAM_CHAIN},1349 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1350 ],1351 },1352 },1353 };1354 const amount = TRANSFER_AMOUNT;13551356 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');13571358 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1359 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;13601361 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1362 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1363 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;13641365 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1366 await helper.wait.newBlocks(3);1367 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);13681369 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1370 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1371 expect(glmrFees == 0n).to.be.true;13721373 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;13741375 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1376 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1377 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1378 });1379 });13801381 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1382 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1383 const asset = {1384 V2: {1385 id: {1386 Concrete: {1387 parents: 1,1388 interior: {1389 X1: {Parachain: UNIQUE_CHAIN},1390 },1391 },1392 },1393 fun: {1394 Fungible: TRANSFER_AMOUNT,1395 },1396 },1397 };1398 const destination = {1399 V2: {1400 parents: 1,1401 interior: {1402 X2: [1403 {Parachain: UNIQUE_CHAIN},1404 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1405 ],1406 },1407 },1408 };14091410 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');14111412 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);14131414 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1415 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1416 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;14171418 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);14191420 expect(unqRandomAccountAsset).to.be.null;14211422 balanceForeignUnqTokenFinal = 0n;14231424 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1425 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1426 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1427 });14281429 await helper.wait.newBlocks(3);14301431 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1432 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1433 expect(actuallyDelivered > 0).to.be.true;14341435 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));14361437 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1438 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1439 expect(unqFees == 0n).to.be.true;1440 });14411442 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1443 // set Moonbeam's sovereign account's balance1444 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1445 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1446 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);14471448 const moreThanMoonbeamHas = moonbeamBalance * 2n;14491450 let targetAccountBalance = 0n;1451 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);14521453 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1454 targetAccount.addressRaw,1455 {1456 Concrete: {1457 parents: 0,1458 interior: 'Here',1459 },1460 },1461 moreThanMoonbeamHas,1462 );14631464 let maliciousXcmProgramSent: any;1465 const maxWaitBlocks = 3;14661467 // Try to trick Unique1468 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1469 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);14701471 // Needed to bypass the call filter.1472 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1473 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);14741475 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1476 });14771478 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1479 && event.outcome.isFailedToTransactAsset);14801481 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1482 expect(targetAccountBalance).to.be.equal(0n);14831484 // But Moonbeam still can send the correct amount1485 const validTransferAmount = moonbeamBalance / 2n;1486 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1487 targetAccount.addressRaw,1488 {1489 Concrete: {1490 parents: 0,1491 interior: 'Here',1492 },1493 },1494 validTransferAmount,1495 );14961497 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1498 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);14991500 // Needed to bypass the call filter.1501 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1502 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1503 });15041505 await helper.wait.newBlocks(maxWaitBlocks);15061507 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1508 expect(targetAccountBalance).to.be.equal(validTransferAmount);1509 });15101511 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1512 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1513 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);15141515 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1516 targetAccount.addressRaw,1517 {1518 Concrete: {1519 parents: 0,1520 interior: {1521 X1: {1522 Parachain: UNIQUE_CHAIN,1523 },1524 },1525 },1526 },1527 testAmount,1528 );15291530 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1531 targetAccount.addressRaw,1532 {1533 Concrete: {1534 parents: 0,1535 interior: 'Here',1536 },1537 },1538 testAmount,1539 );15401541 let maliciousXcmProgramFullIdSent: any;1542 let maliciousXcmProgramHereIdSent: any;1543 const maxWaitBlocks = 3;15441545 // Try to trick Unique using full UNQ identification1546 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1547 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);15481549 // Needed to bypass the call filter.1550 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1551 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);15521553 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1554 });15551556 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1557 && event.outcome.isUntrustedReserveLocation);15581559 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1560 expect(accountBalance).to.be.equal(0n);15611562 // Try to trick Unique using shortened UNQ identification1563 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1564 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);15651566 // Needed to bypass the call filter.1567 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1568 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);15691570 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1571 });15721573 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1574 && event.outcome.isUntrustedReserveLocation);15751576 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1577 expect(accountBalance).to.be.equal(0n);1578 });1579});15801581describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1582 let alice: IKeyringPair;1583 let randomAccount: IKeyringPair;15841585 const UNQ_ASSET_ID_ON_ASTAR = 1;1586 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;15871588 // Unique -> Astar1589 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1590 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1591 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1592 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens15931594 // Astar -> Unique1595 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1596 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ15971598 let balanceAfterUniqueToAstarXCM: bigint;15991600 before(async () => {1601 await usingPlaygrounds(async (helper, privateKey) => {1602 alice = await privateKey('//Alice');1603 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1604 console.log('randomAccount', randomAccount.address);16051606 // Set the default version to wrap the first message to other chains.1607 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1608 });16091610 await usingAstarPlaygrounds(astarUrl, async (helper) => {1611 if(!(await helper.callRpc('api.query.assets.asset', [UNQ_ASSET_ID_ON_ASTAR])).toJSON()) {1612 console.log('1. Create foreign asset and metadata');1613 // TODO update metadata with values from production1614 await helper.assets.create(1615 alice,1616 UNQ_ASSET_ID_ON_ASTAR,1617 alice.address,1618 UNQ_MINIMAL_BALANCE_ON_ASTAR,1619 );16201621 await helper.assets.setMetadata(1622 alice,1623 UNQ_ASSET_ID_ON_ASTAR,1624 'Cross chain UNQ',1625 'xcUNQ',1626 Number(UNQ_DECIMALS),1627 );16281629 console.log('2. Register asset location on Astar');1630 const assetLocation = {1631 V2: {1632 parents: 1,1633 interior: {1634 X1: {1635 Parachain: UNIQUE_CHAIN,1636 },1637 },1638 },1639 };16401641 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);16421643 console.log('3. Set UNQ payment for XCM execution on Astar');1644 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1645 }1646 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1647 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1648 });1649 });16501651 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1652 const destination = {1653 V2: {1654 parents: 1,1655 interior: {1656 X1: {1657 Parachain: ASTAR_CHAIN,1658 },1659 },1660 },1661 };16621663 const beneficiary = {1664 V2: {1665 parents: 0,1666 interior: {1667 X1: {1668 AccountId32: {1669 network: 'Any',1670 id: randomAccount.addressRaw,1671 },1672 },1673 },1674 },1675 };16761677 const assets = {1678 V2: [1679 {1680 id: {1681 Concrete: {1682 parents: 0,1683 interior: 'Here',1684 },1685 },1686 fun: {1687 Fungible: unqToAstarTransferred,1688 },1689 },1690 ],1691 };16921693 // Initial balance is 100 UNQ1694 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1695 console.log(`Initial balance is: ${balanceBefore}`);16961697 const feeAssetItem = 0;1698 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');16991700 // Balance after reserve transfer is less than 901701 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1702 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1703 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1704 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;17051706 await usingAstarPlaygrounds(astarUrl, async (helper) => {1707 await helper.wait.newBlocks(3);1708 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1709 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);17101711 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1712 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);17131714 expect(xcUNQbalance).to.eq(unqToAstarArrived);1715 // Astar balance does not changed1716 expect(astarBalance).to.eq(astarInitialBalance);1717 });1718 });17191720 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1721 await usingAstarPlaygrounds(astarUrl, async (helper) => {1722 const destination = {1723 V2: {1724 parents: 1,1725 interior: {1726 X1: {1727 Parachain: UNIQUE_CHAIN,1728 },1729 },1730 },1731 };17321733 const beneficiary = {1734 V2: {1735 parents: 0,1736 interior: {1737 X1: {1738 AccountId32: {1739 network: 'Any',1740 id: randomAccount.addressRaw,1741 },1742 },1743 },1744 },1745 };17461747 const assets = {1748 V2: [1749 {1750 id: {1751 Concrete: {1752 parents: 1,1753 interior: {1754 X1: {1755 Parachain: UNIQUE_CHAIN,1756 },1757 },1758 },1759 },1760 fun: {1761 Fungible: unqFromAstarTransfered,1762 },1763 },1764 ],1765 };17661767 // Initial balance is 1 ASTR1768 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1769 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1770 expect(balanceASTRbefore).to.eq(astarInitialBalance);17711772 const feeAssetItem = 0;1773 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1774 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);17751776 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1777 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1778 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);17791780 // Assert: xcUNQ balance correctly decreased1781 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1782 // Assert: ASTR balance is 0.996...1783 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1784 });17851786 await helper.wait.newBlocks(3);1787 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1788 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1789 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1790 });17911792 itSub('Astar can send only up to its balance', async ({helper}) => {1793 // set Astar's sovereign account's balance1794 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1795 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1796 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);17971798 const moreThanAstarHas = astarBalance * 2n;17991800 let targetAccountBalance = 0n;1801 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);18021803 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1804 targetAccount.addressRaw,1805 {1806 Concrete: {1807 parents: 0,1808 interior: 'Here',1809 },1810 },1811 moreThanAstarHas,1812 );18131814 let maliciousXcmProgramSent: any;1815 const maxWaitBlocks = 3;18161817 // Try to trick Unique1818 await usingAstarPlaygrounds(astarUrl, async (helper) => {1819 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);18201821 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1822 });18231824 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1825 && event.outcome.isFailedToTransactAsset);18261827 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1828 expect(targetAccountBalance).to.be.equal(0n);18291830 // But Astar still can send the correct amount1831 const validTransferAmount = astarBalance / 2n;1832 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1833 targetAccount.addressRaw,1834 {1835 Concrete: {1836 parents: 0,1837 interior: 'Here',1838 },1839 },1840 validTransferAmount,1841 );18421843 await usingAstarPlaygrounds(astarUrl, async (helper) => {1844 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1845 });18461847 await helper.wait.newBlocks(maxWaitBlocks);18481849 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1850 expect(targetAccountBalance).to.be.equal(validTransferAmount);1851 });18521853 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1854 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1855 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);18561857 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1858 targetAccount.addressRaw,1859 {1860 Concrete: {1861 parents: 1,1862 interior: {1863 X1: {1864 Parachain: UNIQUE_CHAIN,1865 },1866 },1867 },1868 },1869 testAmount,1870 );18711872 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1873 targetAccount.addressRaw,1874 {1875 Concrete: {1876 parents: 0,1877 interior: 'Here',1878 },1879 },1880 testAmount,1881 );18821883 let maliciousXcmProgramFullIdSent: any;1884 let maliciousXcmProgramHereIdSent: any;1885 const maxWaitBlocks = 3;18861887 // Try to trick Unique using full UNQ identification1888 await usingAstarPlaygrounds(astarUrl, async (helper) => {1889 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);18901891 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1892 });18931894 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1895 && event.outcome.isUntrustedReserveLocation);18961897 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1898 expect(accountBalance).to.be.equal(0n);18991900 // Try to trick Unique using shortened UNQ identification1901 await usingAstarPlaygrounds(astarUrl, async (helper) => {1902 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);19031904 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1905 });19061907 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1908 && event.outcome.isUntrustedReserveLocation);19091910 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1911 expect(accountBalance).to.be.equal(0n);1912 });1913});