difftreelog
test(polkadex) added reserve malicious test
in: master
2 files 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 {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;5960describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {61 let alice: IKeyringPair;62 let bob: IKeyringPair;6364 let balanceStmnBefore: bigint;65 let balanceStmnAfter: bigint;6667 let balanceUniqueBefore: bigint;68 let balanceUniqueAfter: bigint;69 let balanceUniqueFinal: bigint;7071 let balanceBobBefore: bigint;72 let balanceBobAfter: bigint;73 let balanceBobFinal: bigint;7475 let balanceBobRelayTokenBefore: bigint;76 let balanceBobRelayTokenAfter: bigint;777879 before(async () => {80 await usingPlaygrounds(async (helper, privateKey) => {81 alice = await privateKey('//Alice');82 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor8384 // Set the default version to wrap the first message to other chains.85 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);86 });8788 await usingRelayPlaygrounds(relayUrl, async (helper) => {89 // Fund accounts on Statemint90 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);91 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);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 V2: {160 parents: 0,161 interior: {X1: {162 Parachain: UNIQUE_CHAIN,163 },164 },165 }};166167 const beneficiary = {168 V2: {169 parents: 0,170 interior: {X1: {171 AccountId32: {172 network: 'Any',173 id: alice.addressRaw,174 },175 }},176 },177 };178179 const assets = {180 V2: [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 V2: {206 parents: 1,207 interior: {X1: {208 Parachain: UNIQUE_CHAIN,209 },210 },211 }};212213 const beneficiary = {214 V2: {215 parents: 0,216 interior: {X1: {217 AccountId32: {218 network: 'Any',219 id: alice.addressRaw,220 },221 }},222 },223 };224225 const assets = {226 V2: [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 V2: {347 parents: 0,348 interior: {X1: {349 Parachain: UNIQUE_CHAIN,350 },351 },352 }};353354 const beneficiary = {355 V2: {356 parents: 0,357 interior: {X1: {358 AccountId32: {359 network: 'Any',360 id: bob.addressRaw,361 },362 }},363 },364 };365366 const assets = {367 V2: [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;473 const acalaEps = 8n * 10n ** 16n;474475 let acalaBackwardTransferAmount: bigint;476477 before(async () => {478 await usingPlaygrounds(async (helper, privateKey) => {479 alice = await privateKey('//Alice');480 [randomAccount] = await helper.arrange.createAccounts([0n], alice);481482 // Set the default version to wrap the first message to other chains.483 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);484 });485486 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {487 const destination = {488 V2: {489 parents: 1,490 interior: {491 X1: {492 Parachain: UNIQUE_CHAIN,493 },494 },495 },496 };497498 const metadata = {499 name: 'Unique Network',500 symbol: 'UNQ',501 decimals: 18,502 minimalBalance: 1250000000000000000n,503 };504505 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);506 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);507 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);508 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});509 });510511 await usingPlaygrounds(async (helper) => {512 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);513 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);514 });515 });516517 itSub('Should connect and send UNQ to Acala', async ({helper}) => {518519 const destination = {520 V2: {521 parents: 1,522 interior: {523 X1: {524 Parachain: ACALA_CHAIN,525 },526 },527 },528 };529530 const beneficiary = {531 V2: {532 parents: 0,533 interior: {534 X1: {535 AccountId32: {536 network: 'Any',537 id: randomAccount.addressRaw,538 },539 },540 },541 },542 };543544 const assets = {545 V2: [546 {547 id: {548 Concrete: {549 parents: 0,550 interior: 'Here',551 },552 },553 fun: {554 Fungible: TRANSFER_AMOUNT,555 },556 },557 ],558 };559560 const feeAssetItem = 0;561562 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');563 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);564565 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;566 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));567 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;568569 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {570 await helper.wait.newBlocks(3);571572 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});573 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);574575 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;576 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;577 acalaBackwardTransferAmount = unqIncomeTransfer;578579 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;580581 console.log(582 '[Unique -> Acala] transaction fees on Acala: %s ACA',583 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),584 );585 console.log(586 '[Unique -> Acala] transaction fees on Acala: %s UNQ',587 helper.util.bigIntToDecimals(acaUnqFees),588 );589 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));590 expect(acaFees == 0n).to.be.true;591592 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;593594 expect(595 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,596 'Acala took different income fee, check the Acala foreign asset config',597 ).to.be.true;598 });599 });600601 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {602 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {603 const destination = {604 V2: {605 parents: 1,606 interior: {607 X2: [608 {Parachain: UNIQUE_CHAIN},609 {610 AccountId32: {611 network: 'Any',612 id: randomAccount.addressRaw,613 },614 },615 ],616 },617 },618 };619620 const id = {621 ForeignAsset: 0,622 };623624 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');625 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);626 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);627628 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;629 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;630631 console.log(632 '[Acala -> Unique] transaction fees on Acala: %s ACA',633 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),634 );635 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));636637 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;638 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;639 });640641 await helper.wait.newBlocks(3);642643 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);644 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;645 expect(actuallyDelivered > 0).to.be.true;646647 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));648649 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;650 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));651 expect(unqFees == 0n).to.be.true;652 });653654 itSub('Acala can send only up to its balance', async ({helper}) => {655 // set Acala's sovereign account's balance656 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);657 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);658 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);659660 const moreThanAcalaHas = acalaBalance * 2n;661662 let targetAccountBalance = 0n;663 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);664665 const uniqueMultilocation = {666 V2: {667 parents: 1,668 interior: {669 X1: {Parachain: UNIQUE_CHAIN},670 },671 },672 };673674 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(675 targetAccount.addressRaw,676 {677 Concrete: {678 parents: 0,679 interior: 'Here',680 },681 },682 moreThanAcalaHas,683 );684685 let maliciousXcmProgramSent: any;686 const maxWaitBlocks = 3;687688 // Try to trick Unique689 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {690 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);691692 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);693 });694695 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash696 && event.outcome.isFailedToTransactAsset);697698 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);699 expect(targetAccountBalance).to.be.equal(0n);700701 // But Acala still can send the correct amount702 const validTransferAmount = acalaBalance / 2n;703 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(704 targetAccount.addressRaw,705 {706 Concrete: {707 parents: 0,708 interior: 'Here',709 },710 },711 validTransferAmount,712 );713714 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {715 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);716 });717718 await helper.wait.newBlocks(maxWaitBlocks);719720 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);721 expect(targetAccountBalance).to.be.equal(validTransferAmount);722 });723724 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {725 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);726 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);727728 const uniqueMultilocation = {729 V2: {730 parents: 1,731 interior: {732 X1: {733 Parachain: UNIQUE_CHAIN,734 },735 },736 },737 };738739 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(740 targetAccount.addressRaw,741 {742 Concrete: {743 parents: 1,744 interior: {745 X1: {746 Parachain: UNIQUE_CHAIN,747 },748 },749 },750 },751 testAmount,752 );753754 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(755 targetAccount.addressRaw,756 {757 Concrete: {758 parents: 0,759 interior: 'Here',760 },761 },762 testAmount,763 );764765 let maliciousXcmProgramFullIdSent: any;766 let maliciousXcmProgramHereIdSent: any;767 const maxWaitBlocks = 3;768769 // Try to trick Unique using full UNQ identification770 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {771 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);772773 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);774 });775776 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash777 && event.outcome.isUntrustedReserveLocation);778779 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);780 expect(accountBalance).to.be.equal(0n);781782 // Try to trick Unique using shortened UNQ identification783 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {784 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);785786 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);787 });788789 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash790 && event.outcome.isUntrustedReserveLocation);791792 accountBalance = await helper.balance.getSubstrate(targetAccount.address);793 expect(accountBalance).to.be.equal(0n);794 });795});796797describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {798 let alice: IKeyringPair;799 let randomAccount: IKeyringPair;800 let unqFees: bigint;801 let balanceUniqueTokenInit: bigint;802 let balanceUniqueTokenMiddle: bigint;803 let balanceUniqueTokenFinal: bigint;804 const maxWaitBlocks = 6;805806 const uniqueAssetId = {807 Concrete: {808 parents: 1,809 interior: {810 X1: {811 Parachain: UNIQUE_CHAIN,812 },813 },814 },815 };816817 before(async () => {818 await usingPlaygrounds(async (helper, privateKey) => {819 alice = await privateKey('//Alice');820 [randomAccount] = await helper.arrange.createAccounts([0n], alice);821822 // Set the default version to wrap the first message to other chains.823 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);824 });825826 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {827 const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', [])).toJSON() as [])828 .map(nToBigInt).length != 0;829830 if(!isWhitelisted) {831 await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);832 }833834 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);835 });836837 await usingPlaygrounds(async (helper) => {838 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);839 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);840 });841 });842843 itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {844845 const destination = {846 V2: {847 parents: 1,848 interior: {849 X1: {850 Parachain: POLKADEX_CHAIN,851 },852 },853 },854 };855856 const beneficiary = {857 V2: {858 parents: 0,859 interior: {860 X1: {861 AccountId32: {862 network: 'Any',863 id: randomAccount.addressRaw,864 },865 },866 },867 },868 };869870 const assets = {871 V2: [872 {873 id: {874 Concrete: {875 parents: 0,876 interior: 'Here',877 },878 },879 fun: {880 Fungible: TRANSFER_AMOUNT,881 },882 },883 ],884 };885886 const feeAssetItem = 0;887888 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');889 const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);890 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);891892 unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;893 console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));894 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;895896 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {897 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);898 });899 });900901902 itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {903904 const uniqueMultilocation = {905 V2: {906 parents: 1,907 interior: {908 X1: {Parachain: UNIQUE_CHAIN},909 },910 },911 };912913 const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(914 randomAccount.addressRaw,915 {916 Concrete: {917 parents: 0,918 interior: 'Here',919 },920 },921 TRANSFER_AMOUNT,922 );923924 let xcmProgramSent: any;925926927 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {928 await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);929930 xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);931 });932933 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);934935 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);936937 expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);938 });939940 itSub('Polkadex can send only up to its balance', async ({helper}) => {941 const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);942 const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);943 await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);944 const moreThanPolkadexHas = 2n * polkadexBalance;945946 const targetAccount = helper.arrange.createEmptyAccount();947948 const uniqueMultilocation = {949 V2: {950 parents: 1,951 interior: {952 X1: {Parachain: UNIQUE_CHAIN},953 },954 },955 };956957 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(958 targetAccount.addressRaw,959 {960 Concrete: {961 parents: 0,962 interior: 'Here',963 },964 },965 moreThanPolkadexHas,966 );967968 let maliciousXcmProgramSent: any;969970971 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {972 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);973974 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);975 });976977 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash);978979 const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);980 expect(targetAccountBalance).to.be.equal(0n);981 });982});983984// These tests are relevant only when985// the the corresponding foreign assets are not registered986describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {987 let alice: IKeyringPair;988 let alith: IKeyringPair;989990 const testAmount = 100_000_000_000n;991 let uniqueParachainJunction;992 let uniqueAccountJunction;993994 let uniqueParachainMultilocation: any;995 let uniqueAccountMultilocation: any;996 let uniqueCombinedMultilocation: any;997 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V2998999 let messageSent: any;10001001 const maxWaitBlocks = 3;10021003 before(async () => {1004 await usingPlaygrounds(async (helper, privateKey) => {1005 alice = await privateKey('//Alice');10061007 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};1008 uniqueAccountJunction = {1009 AccountId32: {1010 network: 'Any',1011 id: alice.addressRaw,1012 },1013 };10141015 uniqueParachainMultilocation = {1016 V2: {1017 parents: 1,1018 interior: {1019 X1: uniqueParachainJunction,1020 },1021 },1022 };10231024 uniqueAccountMultilocation = {1025 V2: {1026 parents: 0,1027 interior: {1028 X1: uniqueAccountJunction,1029 },1030 },1031 };10321033 uniqueCombinedMultilocation = {1034 V2: {1035 parents: 1,1036 interior: {1037 X2: [uniqueParachainJunction, uniqueAccountJunction],1038 },1039 },1040 };10411042 uniqueCombinedMultilocationAcala = {1043 V2: {1044 parents: 1,1045 interior: {1046 X2: [uniqueParachainJunction, uniqueAccountJunction],1047 },1048 },1049 };10501051 // Set the default version to wrap the first message to other chains.1052 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1053 });10541055 // eslint-disable-next-line require-await1056 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1057 alith = helper.account.alithAccount();1058 });1059 });10601061 const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {1062 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash1063 && event.outcome.isFailedToTransactAsset);1064 };10651066 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {1067 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {1068 const id = {1069 Token: 'ACA',1070 };1071 const destination = uniqueCombinedMultilocationAcala;1072 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');10731074 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1075 });10761077 await expectFailedToTransact(helper, messageSent);1078 });10791080 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {1081 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1082 const id = 'SelfReserve';1083 const destination = uniqueCombinedMultilocation;1084 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');10851086 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1087 });10881089 await expectFailedToTransact(helper, messageSent);1090 });10911092 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {1093 await usingAstarPlaygrounds(astarUrl, async (helper) => {1094 const destinationParachain = uniqueParachainMultilocation;1095 const beneficiary = uniqueAccountMultilocation;1096 const assets = {1097 V2: [{1098 id: {1099 Concrete: {1100 parents: 0,1101 interior: 'Here',1102 },1103 },1104 fun: {1105 Fungible: testAmount,1106 },1107 }],1108 };1109 const feeAssetItem = 0;11101111 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1112 destinationParachain,1113 beneficiary,1114 assets,1115 feeAssetItem,1116 ]);11171118 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1119 });11201121 await expectFailedToTransact(helper, messageSent);1122 });11231124 itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {11251126 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1127 helper.arrange.createEmptyAccount().addressRaw,1128 {1129 Concrete: {1130 parents: 1,1131 interior: {1132 X1: {1133 Parachain: POLKADEX_CHAIN,1134 },1135 },1136 },1137 },1138 testAmount,1139 );11401141 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1142 await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);1143 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1144 });11451146 await expectFailedToTransact(helper, messageSent);1147 });1148});11491150describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1151 // Unique constants1152 let alice: IKeyringPair;1153 let uniqueAssetLocation;11541155 let randomAccountUnique: IKeyringPair;1156 let randomAccountMoonbeam: IKeyringPair;11571158 // Moonbeam constants1159 let assetId: string;11601161 const uniqueAssetMetadata = {1162 name: 'xcUnique',1163 symbol: 'xcUNQ',1164 decimals: 18,1165 isFrozen: false,1166 minimalBalance: 1n,1167 };11681169 let balanceUniqueTokenInit: bigint;1170 let balanceUniqueTokenMiddle: bigint;1171 let balanceUniqueTokenFinal: bigint;1172 let balanceForeignUnqTokenInit: bigint;1173 let balanceForeignUnqTokenMiddle: bigint;1174 let balanceForeignUnqTokenFinal: bigint;1175 let balanceGlmrTokenInit: bigint;1176 let balanceGlmrTokenMiddle: bigint;1177 let balanceGlmrTokenFinal: bigint;11781179 before(async () => {1180 await usingPlaygrounds(async (helper, privateKey) => {1181 alice = await privateKey('//Alice');1182 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);11831184 balanceForeignUnqTokenInit = 0n;11851186 // Set the default version to wrap the first message to other chains.1187 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1188 });11891190 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1191 const alithAccount = helper.account.alithAccount();1192 const baltatharAccount = helper.account.baltatharAccount();1193 const dorothyAccount = helper.account.dorothyAccount();11941195 randomAccountMoonbeam = helper.account.create();11961197 // >>> Sponsoring Dorothy >>>1198 console.log('Sponsoring Dorothy.......');1199 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1200 console.log('Sponsoring Dorothy.......DONE');1201 // <<< Sponsoring Dorothy <<<12021203 uniqueAssetLocation = {1204 XCM: {1205 parents: 1,1206 interior: {X1: {Parachain: UNIQUE_CHAIN}},1207 },1208 };1209 const existentialDeposit = 1n;1210 const isSufficient = true;1211 const unitsPerSecond = 1n;1212 const numAssetsWeightHint = 0;12131214 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1215 location: uniqueAssetLocation,1216 metadata: uniqueAssetMetadata,1217 existentialDeposit,1218 isSufficient,1219 unitsPerSecond,1220 numAssetsWeightHint,1221 });12221223 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);12241225 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);12261227 // >>> Acquire Unique AssetId Info on Moonbeam >>>1228 console.log('Acquire Unique AssetId Info on Moonbeam.......');12291230 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();12311232 console.log('UNQ asset ID is %s', assetId);1233 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1234 // >>> Acquire Unique AssetId Info on Moonbeam >>>12351236 // >>> Sponsoring random Account >>>1237 console.log('Sponsoring random Account.......');1238 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1239 console.log('Sponsoring random Account.......DONE');1240 // <<< Sponsoring random Account <<<12411242 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1243 });12441245 await usingPlaygrounds(async (helper) => {1246 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1247 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1248 });1249 });12501251 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1252 const currencyId = {1253 NativeAssetId: 'Here',1254 };1255 const dest = {1256 V2: {1257 parents: 1,1258 interior: {1259 X2: [1260 {Parachain: MOONBEAM_CHAIN},1261 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1262 ],1263 },1264 },1265 };1266 const amount = TRANSFER_AMOUNT;12671268 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');12691270 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1271 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;12721273 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1274 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1275 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;12761277 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1278 await helper.wait.newBlocks(3);12791280 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);12811282 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1283 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1284 expect(glmrFees == 0n).to.be.true;12851286 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;12871288 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1289 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1290 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1291 });1292 });12931294 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1295 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1296 const asset = {1297 V2: {1298 id: {1299 Concrete: {1300 parents: 1,1301 interior: {1302 X1: {Parachain: UNIQUE_CHAIN},1303 },1304 },1305 },1306 fun: {1307 Fungible: TRANSFER_AMOUNT,1308 },1309 },1310 };1311 const destination = {1312 V2: {1313 parents: 1,1314 interior: {1315 X2: [1316 {Parachain: UNIQUE_CHAIN},1317 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1318 ],1319 },1320 },1321 };13221323 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');13241325 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);13261327 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1328 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1329 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;13301331 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);13321333 expect(unqRandomAccountAsset).to.be.null;13341335 balanceForeignUnqTokenFinal = 0n;13361337 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1338 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1339 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1340 });13411342 await helper.wait.newBlocks(3);13431344 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1345 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1346 expect(actuallyDelivered > 0).to.be.true;13471348 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));13491350 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1351 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1352 expect(unqFees == 0n).to.be.true;1353 });13541355 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1356 // set Moonbeam's sovereign account's balance1357 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1358 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1359 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);13601361 const moreThanMoonbeamHas = moonbeamBalance * 2n;13621363 let targetAccountBalance = 0n;1364 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);13651366 const uniqueMultilocation = {1367 V2: {1368 parents: 1,1369 interior: {1370 X1: {Parachain: UNIQUE_CHAIN},1371 },1372 },1373 };13741375 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1376 targetAccount.addressRaw,1377 {1378 Concrete: {1379 parents: 0,1380 interior: 'Here',1381 },1382 },1383 moreThanMoonbeamHas,1384 );13851386 let maliciousXcmProgramSent: any;1387 const maxWaitBlocks = 3;13881389 // Try to trick Unique1390 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1391 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);13921393 // Needed to bypass the call filter.1394 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1395 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);13961397 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1398 });13991400 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1401 && event.outcome.isFailedToTransactAsset);14021403 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1404 expect(targetAccountBalance).to.be.equal(0n);14051406 // But Moonbeam still can send the correct amount1407 const validTransferAmount = moonbeamBalance / 2n;1408 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1409 targetAccount.addressRaw,1410 {1411 Concrete: {1412 parents: 0,1413 interior: 'Here',1414 },1415 },1416 validTransferAmount,1417 );14181419 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1420 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);14211422 // Needed to bypass the call filter.1423 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1424 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1425 });14261427 await helper.wait.newBlocks(maxWaitBlocks);14281429 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1430 expect(targetAccountBalance).to.be.equal(validTransferAmount);1431 });14321433 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1434 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1435 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);14361437 const uniqueMultilocation = {1438 V2: {1439 parents: 1,1440 interior: {1441 X1: {1442 Parachain: UNIQUE_CHAIN,1443 },1444 },1445 },1446 };14471448 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1449 targetAccount.addressRaw,1450 {1451 Concrete: {1452 parents: 0,1453 interior: {1454 X1: {1455 Parachain: UNIQUE_CHAIN,1456 },1457 },1458 },1459 },1460 testAmount,1461 );14621463 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1464 targetAccount.addressRaw,1465 {1466 Concrete: {1467 parents: 0,1468 interior: 'Here',1469 },1470 },1471 testAmount,1472 );14731474 let maliciousXcmProgramFullIdSent: any;1475 let maliciousXcmProgramHereIdSent: any;1476 const maxWaitBlocks = 3;14771478 // Try to trick Unique using full UNQ identification1479 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1480 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);14811482 // Needed to bypass the call filter.1483 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1484 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);14851486 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1487 });14881489 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1490 && event.outcome.isUntrustedReserveLocation);14911492 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1493 expect(accountBalance).to.be.equal(0n);14941495 // Try to trick Unique using shortened UNQ identification1496 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1497 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);14981499 // Needed to bypass the call filter.1500 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1501 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);15021503 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1504 });15051506 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1507 && event.outcome.isUntrustedReserveLocation);15081509 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1510 expect(accountBalance).to.be.equal(0n);1511 });1512});15131514describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1515 let alice: IKeyringPair;1516 let randomAccount: IKeyringPair;15171518 const UNQ_ASSET_ID_ON_ASTAR = 1;1519 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;15201521 // Unique -> Astar1522 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1523 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1524 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1525 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens15261527 // Astar -> Unique1528 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1529 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ15301531 let balanceAfterUniqueToAstarXCM: bigint;15321533 before(async () => {1534 await usingPlaygrounds(async (helper, privateKey) => {1535 alice = await privateKey('//Alice');1536 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1537 console.log('randomAccount', randomAccount.address);15381539 // Set the default version to wrap the first message to other chains.1540 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1541 });15421543 await usingAstarPlaygrounds(astarUrl, async (helper) => {1544 console.log('1. Create foreign asset and metadata');1545 // TODO update metadata with values from production1546 await helper.assets.create(1547 alice,1548 UNQ_ASSET_ID_ON_ASTAR,1549 alice.address,1550 UNQ_MINIMAL_BALANCE_ON_ASTAR,1551 );15521553 await helper.assets.setMetadata(1554 alice,1555 UNQ_ASSET_ID_ON_ASTAR,1556 'Cross chain UNQ',1557 'xcUNQ',1558 Number(UNQ_DECIMALS),1559 );15601561 console.log('2. Register asset location on Astar');1562 const assetLocation = {1563 V2: {1564 parents: 1,1565 interior: {1566 X1: {1567 Parachain: UNIQUE_CHAIN,1568 },1569 },1570 },1571 };15721573 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);15741575 console.log('3. Set UNQ payment for XCM execution on Astar');1576 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);15771578 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1579 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1580 });1581 });15821583 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1584 const destination = {1585 V2: {1586 parents: 1,1587 interior: {1588 X1: {1589 Parachain: ASTAR_CHAIN,1590 },1591 },1592 },1593 };15941595 const beneficiary = {1596 V2: {1597 parents: 0,1598 interior: {1599 X1: {1600 AccountId32: {1601 network: 'Any',1602 id: randomAccount.addressRaw,1603 },1604 },1605 },1606 },1607 };16081609 const assets = {1610 V2: [1611 {1612 id: {1613 Concrete: {1614 parents: 0,1615 interior: 'Here',1616 },1617 },1618 fun: {1619 Fungible: unqToAstarTransferred,1620 },1621 },1622 ],1623 };16241625 // Initial balance is 100 UNQ1626 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1627 console.log(`Initial balance is: ${balanceBefore}`);16281629 const feeAssetItem = 0;1630 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');16311632 // Balance after reserve transfer is less than 901633 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1634 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1635 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1636 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;16371638 await usingAstarPlaygrounds(astarUrl, async (helper) => {1639 await helper.wait.newBlocks(3);1640 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1641 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);16421643 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1644 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);16451646 expect(xcUNQbalance).to.eq(unqToAstarArrived);1647 // Astar balance does not changed1648 expect(astarBalance).to.eq(astarInitialBalance);1649 });1650 });16511652 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1653 await usingAstarPlaygrounds(astarUrl, async (helper) => {1654 const destination = {1655 V2: {1656 parents: 1,1657 interior: {1658 X1: {1659 Parachain: UNIQUE_CHAIN,1660 },1661 },1662 },1663 };16641665 const beneficiary = {1666 V2: {1667 parents: 0,1668 interior: {1669 X1: {1670 AccountId32: {1671 network: 'Any',1672 id: randomAccount.addressRaw,1673 },1674 },1675 },1676 },1677 };16781679 const assets = {1680 V2: [1681 {1682 id: {1683 Concrete: {1684 parents: 1,1685 interior: {1686 X1: {1687 Parachain: UNIQUE_CHAIN,1688 },1689 },1690 },1691 },1692 fun: {1693 Fungible: unqFromAstarTransfered,1694 },1695 },1696 ],1697 };16981699 // Initial balance is 1 ASTR1700 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1701 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1702 expect(balanceASTRbefore).to.eq(astarInitialBalance);17031704 const feeAssetItem = 0;1705 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1706 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);17071708 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1709 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1710 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);17111712 // Assert: xcUNQ balance correctly decreased1713 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1714 // Assert: ASTR balance is 0.996...1715 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1716 });17171718 await helper.wait.newBlocks(3);1719 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1720 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1721 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1722 });17231724 itSub('Astar can send only up to its balance', async ({helper}) => {1725 // set Astar's sovereign account's balance1726 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1727 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1728 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);17291730 const moreThanAstarHas = astarBalance * 2n;17311732 let targetAccountBalance = 0n;1733 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);17341735 const uniqueMultilocation = {1736 V2: {1737 parents: 1,1738 interior: {1739 X1: {Parachain: UNIQUE_CHAIN},1740 },1741 },1742 };17431744 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1745 targetAccount.addressRaw,1746 {1747 Concrete: {1748 parents: 0,1749 interior: 'Here',1750 },1751 },1752 moreThanAstarHas,1753 );17541755 let maliciousXcmProgramSent: any;1756 const maxWaitBlocks = 3;17571758 // Try to trick Unique1759 await usingAstarPlaygrounds(astarUrl, async (helper) => {1760 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);17611762 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1763 });17641765 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1766 && event.outcome.isFailedToTransactAsset);17671768 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1769 expect(targetAccountBalance).to.be.equal(0n);17701771 // But Astar still can send the correct amount1772 const validTransferAmount = astarBalance / 2n;1773 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1774 targetAccount.addressRaw,1775 {1776 Concrete: {1777 parents: 0,1778 interior: 'Here',1779 },1780 },1781 validTransferAmount,1782 );17831784 await usingAstarPlaygrounds(astarUrl, async (helper) => {1785 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1786 });17871788 await helper.wait.newBlocks(maxWaitBlocks);17891790 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1791 expect(targetAccountBalance).to.be.equal(validTransferAmount);1792 });17931794 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1795 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1796 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);17971798 const uniqueMultilocation = {1799 V2: {1800 parents: 1,1801 interior: {1802 X1: {1803 Parachain: UNIQUE_CHAIN,1804 },1805 },1806 },1807 };18081809 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1810 targetAccount.addressRaw,1811 {1812 Concrete: {1813 parents: 1,1814 interior: {1815 X1: {1816 Parachain: UNIQUE_CHAIN,1817 },1818 },1819 },1820 },1821 testAmount,1822 );18231824 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1825 targetAccount.addressRaw,1826 {1827 Concrete: {1828 parents: 0,1829 interior: 'Here',1830 },1831 },1832 testAmount,1833 );18341835 let maliciousXcmProgramFullIdSent: any;1836 let maliciousXcmProgramHereIdSent: any;1837 const maxWaitBlocks = 3;18381839 // Try to trick Unique using full UNQ identification1840 await usingAstarPlaygrounds(astarUrl, async (helper) => {1841 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);18421843 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1844 });18451846 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1847 && event.outcome.isUntrustedReserveLocation);18481849 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1850 expect(accountBalance).to.be.equal(0n);18511852 // Try to trick Unique using shortened UNQ identification1853 await usingAstarPlaygrounds(astarUrl, async (helper) => {1854 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);18551856 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1857 });18581859 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1860 && event.outcome.isUntrustedReserveLocation);18611862 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1863 expect(accountBalance).to.be.equal(0n);1864 });1865});vendor/baedeker-librarydiffbeforeafterbothbinary blob — no preview