difftreelog
fix(xcm unique test) typo
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 });534535 await usingPlaygrounds(async (helper) => {536 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);537 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);538 });539 });540541 itSub('Should connect and send UNQ to Acala', async ({helper}) => {542543 const destination = {544 V2: {545 parents: 1,546 interior: {547 X1: {548 Parachain: ACALA_CHAIN,549 },550 },551 },552 };553554 const beneficiary = {555 V2: {556 parents: 0,557 interior: {558 X1: {559 AccountId32: {560 network: 'Any',561 id: randomAccount.addressRaw,562 },563 },564 },565 },566 };567568 const assets = {569 V2: [570 {571 id: {572 Concrete: {573 parents: 0,574 interior: 'Here',575 },576 },577 fun: {578 Fungible: TRANSFER_AMOUNT,579 },580 },581 ],582 };583584 const feeAssetItem = 0;585586 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');587 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);588589 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;590 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));591 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;592593 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {594 await helper.wait.newBlocks(3);595596 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});597 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);598599 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;600 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;601 acalaBackwardTransferAmount = unqIncomeTransfer;602603 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;604605 console.log(606 '[Unique -> Acala] transaction fees on Acala: %s ACA',607 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),608 );609 console.log(610 '[Unique -> Acala] transaction fees on Acala: %s UNQ',611 helper.util.bigIntToDecimals(acaUnqFees),612 );613 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));614 expect(acaFees == 0n).to.be.true;615616 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;617618 expect(619 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,620 'Acala took different income fee, check the Acala foreign asset config',621 ).to.be.true;622 });623 });624625 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {626 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {627 const destination = {628 V2: {629 parents: 1,630 interior: {631 X2: [632 {Parachain: UNIQUE_CHAIN},633 {634 AccountId32: {635 network: 'Any',636 id: randomAccount.addressRaw,637 },638 },639 ],640 },641 },642 };643644 const id = {645 ForeignAsset: 0,646 };647648 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');649 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);650 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);651652 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;653 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;654655 console.log(656 '[Acala -> Unique] transaction fees on Acala: %s ACA',657 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),658 );659 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));660661 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;662 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;663 });664665 await helper.wait.newBlocks(3);666667 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);668 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;669 expect(actuallyDelivered > 0).to.be.true;670671 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));672673 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;674 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));675 expect(unqFees == 0n).to.be.true;676 });677678 itSub('Acala can send only up to its balance', async ({helper}) => {679 // set Acala's sovereign account's balance680 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);681 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);682 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);683684 const moreThanAcalaHas = acalaBalance * 2n;685686 let targetAccountBalance = 0n;687 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);688689 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(690 targetAccount.addressRaw,691 {692 Concrete: {693 parents: 0,694 interior: 'Here',695 },696 },697 moreThanAcalaHas,698 );699700 let maliciousXcmProgramSent: any;701 const maxWaitBlocks = 3;702703 // Try to trick Unique704 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {705 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);706707 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);708 });709710 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash711 && event.outcome.isFailedToTransactAsset);712713 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);714 expect(targetAccountBalance).to.be.equal(0n);715716 // But Acala still can send the correct amount717 const validTransferAmount = acalaBalance / 2n;718 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(719 targetAccount.addressRaw,720 {721 Concrete: {722 parents: 0,723 interior: 'Here',724 },725 },726 validTransferAmount,727 );728729 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {730 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);731 });732733 await helper.wait.newBlocks(maxWaitBlocks);734735 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);736 expect(targetAccountBalance).to.be.equal(validTransferAmount);737 });738739 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {740 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);741 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);742743 const uniqueMultilocation = {744 V2: {745 parents: 1,746 interior: {747 X1: {748 Parachain: UNIQUE_CHAIN,749 },750 },751 },752 };753754 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(755 targetAccount.addressRaw,756 {757 Concrete: {758 parents: 1,759 interior: {760 X1: {761 Parachain: UNIQUE_CHAIN,762 },763 },764 },765 },766 testAmount,767 );768769 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(770 targetAccount.addressRaw,771 {772 Concrete: {773 parents: 0,774 interior: 'Here',775 },776 },777 testAmount,778 );779780 let maliciousXcmProgramFullIdSent: any;781 let maliciousXcmProgramHereIdSent: any;782 const maxWaitBlocks = 3;783784 // Try to trick Unique using full UNQ identification785 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {786 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);787788 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);789 });790791 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash792 && event.outcome.isUntrustedReserveLocation);793794 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);795 expect(accountBalance).to.be.equal(0n);796797 // Try to trick Unique using shortened UNQ identification798 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {799 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);800801 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);802 });803804 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash805 && event.outcome.isUntrustedReserveLocation);806807 accountBalance = await helper.balance.getSubstrate(targetAccount.address);808 expect(accountBalance).to.be.equal(0n);809 });810});811812describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {813 let alice: IKeyringPair;814 let randomAccount: IKeyringPair;815 let unqFees: bigint;816 let balanceUniqueTokenInit: bigint;817 let balanceUniqueTokenMiddle: bigint;818 let balanceUniqueTokenFinal: bigint;819 const maxWaitBlocks = 6;820821 const uniqueAssetId = {822 Concrete: {823 parents: 1,824 interior: {825 X1: {826 Parachain: UNIQUE_CHAIN,827 },828 },829 },830 };831832 before(async () => {833 await usingPlaygrounds(async (helper, privateKey) => {834 alice = await privateKey('//Alice');835 [randomAccount] = await helper.arrange.createAccounts([0n], alice);836837 // Set the default version to wrap the first message to other chains.838 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);839 });840841 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {842 const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', []))843 .toJSON() as [])844 .map(nToBigInt).length != 0;845 /*846 Check whether the Unique token has been added847 to the whitelist, since an error will occur848 if it is added again. Needed for debugging849 when this test is run multiple times.850 */851 if(!isWhitelisted) {852 await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);853 }854855 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);856 });857858 await usingPlaygrounds(async (helper) => {859 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);860 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);861 });862 });863864 itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {865866 const destination = {867 V2: {868 parents: 1,869 interior: {870 X1: {871 Parachain: POLKADEX_CHAIN,872 },873 },874 },875 };876877 const beneficiary = {878 V2: {879 parents: 0,880 interior: {881 X1: {882 AccountId32: {883 network: 'Any',884 id: randomAccount.addressRaw,885 },886 },887 },888 },889 };890891 const assets = {892 V2: [893 {894 id: {895 Concrete: {896 parents: 0,897 interior: 'Here',898 },899 },900 fun: {901 Fungible: TRANSFER_AMOUNT,902 },903 },904 ],905 };906907 const feeAssetItem = 0;908909 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');910 const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);911 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);912913 unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;914 console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));915 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;916917 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {918 /*919 Since only the parachain part of the Polkadex920 infrastructure is launched (without their921 solochain validators), processing incoming922 assets will lead to an error.923 This error indicates that the Polkadex chain924 received a message from the Unique network,925 since the hash is being checked to ensure926 it matches what was sent.927 */928 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);929 });930 });931932933 itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {934935 const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(936 randomAccount.addressRaw,937 {938 Concrete: {939 parents: 1,940 interior: {941 X1: {Parachain: UNIQUE_CHAIN},942 },943 },944 },945 TRANSFER_AMOUNT,946 );947948 let xcmProgramSent: any;949950951 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {952 await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);953954 xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);955 });956957 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);958959 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);960961 expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);962 });963964 itSub('Polkadex can send only up to its balance', async ({helper}) => {965 const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);966 const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);967 await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);968 const moreThanPolkadexHas = 2n * polkadexBalance;969970 const targetAccount = helper.arrange.createEmptyAccount();971972 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(973 targetAccount.addressRaw,974 {975 Concrete: {976 parents: 0,977 interior: 'Here',978 },979 },980 moreThanPolkadexHas,981 );982983 let maliciousXcmProgramSent: any;984985986 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {987 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);988989 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);990 });991992 await expectFailedToTransact(helper, maliciousXcmProgramSent);993994 const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);995 expect(targetAccountBalance).to.be.equal(0n);996 });997998 itSub('Should not accept reserve transfer of UNQ from Polkadex', async ({helper}) => {999 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1000 const targetAccount = helper.arrange.createEmptyAccount();10011002 const uniqueMultilocation = {1003 V2: {1004 parents: 1,1005 interior: {1006 X1: {1007 Parachain: UNIQUE_CHAIN,1008 },1009 },1010 },1011 };10121013 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1014 targetAccount.addressRaw,1015 {1016 Concrete: {1017 parents: 1,1018 interior: {1019 X1: {1020 Parachain: UNIQUE_CHAIN,1021 },1022 },1023 },1024 },1025 testAmount,1026 );10271028 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1029 targetAccount.addressRaw,1030 {1031 Concrete: {1032 parents: 0,1033 interior: 'Here',1034 },1035 },1036 testAmount,1037 );10381039 let maliciousXcmProgramFullIdSent: any;1040 let maliciousXcmProgramHereIdSent: any;1041 const maxWaitBlocks = 3;10421043 // Try to trick Unique using full UNQ identification1044 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1045 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);10461047 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1048 });10491050 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramFullIdSent);10511052 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1053 expect(accountBalance).to.be.equal(0n);10541055 // Try to trick Unique using shortened UNQ identification1056 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1057 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);10581059 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1060 });10611062 await expectUntrustedReserveLocationFail(helper, maliciousXcmProgramHereIdSent);10631064 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1065 expect(accountBalance).to.be.equal(0n);1066 });1067});10681069// These tests are relevant only when1070// the the corresponding foreign assets are not registered1071describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {1072 let alice: IKeyringPair;1073 let alith: IKeyringPair;10741075 const testAmount = 100_000_000_000n;1076 let uniqueParachainJunction;1077 let uniqueAccountJunction;10781079 let uniqueParachainMultilocation: any;1080 let uniqueAccountMultilocation: any;1081 let uniqueCombinedMultilocation: any;1082 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V210831084 let messageSent: any;10851086 const maxWaitBlocks = 3;10871088 before(async () => {1089 await usingPlaygrounds(async (helper, privateKey) => {1090 alice = await privateKey('//Alice');10911092 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};1093 uniqueAccountJunction = {1094 AccountId32: {1095 network: 'Any',1096 id: alice.addressRaw,1097 },1098 };10991100 uniqueParachainMultilocation = {1101 V2: {1102 parents: 1,1103 interior: {1104 X1: uniqueParachainJunction,1105 },1106 },1107 };11081109 uniqueAccountMultilocation = {1110 V2: {1111 parents: 0,1112 interior: {1113 X1: uniqueAccountJunction,1114 },1115 },1116 };11171118 uniqueCombinedMultilocation = {1119 V2: {1120 parents: 1,1121 interior: {1122 X2: [uniqueParachainJunction, uniqueAccountJunction],1123 },1124 },1125 };11261127 uniqueCombinedMultilocationAcala = {1128 V2: {1129 parents: 1,1130 interior: {1131 X2: [uniqueParachainJunction, uniqueAccountJunction],1132 },1133 },1134 };11351136 // Set the default version to wrap the first message to other chains.1137 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1138 });11391140 // eslint-disable-next-line require-await1141 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1142 alith = helper.account.alithAccount();1143 });1144 });1145114611471148 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {1149 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {1150 const id = {1151 Token: 'ACA',1152 };1153 const destination = uniqueCombinedMultilocationAcala;1154 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');11551156 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1157 });11581159 await expectFailedToTransact(helper, messageSent);1160 });11611162 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {1163 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1164 const id = 'SelfReserve';1165 const destination = uniqueCombinedMultilocation;1166 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');11671168 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1169 });11701171 await expectFailedToTransact(helper, messageSent);1172 });11731174 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {1175 await usingAstarPlaygrounds(astarUrl, async (helper) => {1176 const destinationParachain = uniqueParachainMultilocation;1177 const beneficiary = uniqueAccountMultilocation;1178 const assets = {1179 V2: [{1180 id: {1181 Concrete: {1182 parents: 0,1183 interior: 'Here',1184 },1185 },1186 fun: {1187 Fungible: testAmount,1188 },1189 }],1190 };1191 const feeAssetItem = 0;11921193 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1194 destinationParachain,1195 beneficiary,1196 assets,1197 feeAssetItem,1198 ]);11991200 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1201 });12021203 await expectFailedToTransact(helper, messageSent);1204 });12051206 itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {12071208 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1209 helper.arrange.createEmptyAccount().addressRaw,1210 {1211 Concrete: {1212 parents: 1,1213 interior: {1214 X1: {1215 Parachain: POLKADEX_CHAIN,1216 },1217 },1218 },1219 },1220 testAmount,1221 );12221223 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1224 await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);1225 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1226 });12271228 await expectFailedToTransact(helper, messageSent);1229 });1230});12311232describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1233 // Unique constants1234 let alice: IKeyringPair;1235 let uniqueAssetLocation;12361237 let randomAccountUnique: IKeyringPair;1238 let randomAccountMoonbeam: IKeyringPair;12391240 // Moonbeam constants1241 let assetId: string;12421243 const uniqueAssetMetadata = {1244 name: 'xcUnique',1245 symbol: 'xcUNQ',1246 decimals: 18,1247 isFrozen: false,1248 minimalBalance: 1n,1249 };12501251 let balanceUniqueTokenInit: bigint;1252 let balanceUniqueTokenMiddle: bigint;1253 let balanceUniqueTokenFinal: bigint;1254 let balanceForeignUnqTokenInit: bigint;1255 let balanceForeignUnqTokenMiddle: bigint;1256 let balanceForeignUnqTokenFinal: bigint;1257 let balanceGlmrTokenInit: bigint;1258 let balanceGlmrTokenMiddle: bigint;1259 let balanceGlmrTokenFinal: bigint;12601261 before(async () => {1262 await usingPlaygrounds(async (helper, privateKey) => {1263 alice = await privateKey('//Alice');1264 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);12651266 balanceForeignUnqTokenInit = 0n;12671268 // Set the default version to wrap the first message to other chains.1269 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1270 });12711272 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1273 const alithAccount = helper.account.alithAccount();1274 const baltatharAccount = helper.account.baltatharAccount();1275 const dorothyAccount = helper.account.dorothyAccount();12761277 randomAccountMoonbeam = helper.account.create();12781279 // >>> Sponsoring Dorothy >>>1280 console.log('Sponsoring Dorothy.......');1281 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1282 console.log('Sponsoring Dorothy.......DONE');1283 // <<< Sponsoring Dorothy <<<12841285 uniqueAssetLocation = {1286 XCM: {1287 parents: 1,1288 interior: {X1: {Parachain: UNIQUE_CHAIN}},1289 },1290 };1291 const existentialDeposit = 1n;1292 const isSufficient = true;1293 const unitsPerSecond = 1n;1294 const numAssetsWeightHint = 0;12951296 if((await helper.assetManager.assetTypeId(uniqueAssetLocation)).toJSON()) {1297 console.log('Unique asset is already registered on MoonBeam');1298 } else {1299 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1300 location: uniqueAssetLocation,1301 metadata: uniqueAssetMetadata,1302 existentialDeposit,1303 isSufficient,1304 unitsPerSecond,1305 numAssetsWeightHint,1306 });13071308 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);13091310 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);13111312 // >>> Acquire Unique AssetId Info on Moonbeam >>>1313 console.log('Acquire Unique AssetId Info on Moonbeam.......');13141315 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();13161317 console.log('UNQ asset ID is %s', assetId);1318 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1319 }1320 // >>> Acquire Unique AssetId Info on Moonbeam >>>13211322 // >>> Sponsoring random Account >>>1323 console.log('Sponsoring random Account.......');1324 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1325 console.log('Sponsoring random Account.......DONE');1326 // <<< Sponsoring random Account <<<13271328 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1329 });13301331 await usingPlaygrounds(async (helper) => {1332 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1333 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1334 });1335 });13361337 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1338 const currencyId = {1339 NativeAssetId: 'Here',1340 };1341 const dest = {1342 V2: {1343 parents: 1,1344 interior: {1345 X2: [1346 {Parachain: MOONBEAM_CHAIN},1347 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1348 ],1349 },1350 },1351 };1352 const amount = TRANSFER_AMOUNT;13531354 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');13551356 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1357 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;13581359 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1360 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1361 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;13621363 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1364 await helper.wait.newBlocks(3);13651366 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);13671368 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1369 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1370 expect(glmrFees == 0n).to.be.true;13711372 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;13731374 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1375 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1376 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1377 });1378 });13791380 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1381 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1382 const asset = {1383 V2: {1384 id: {1385 Concrete: {1386 parents: 1,1387 interior: {1388 X1: {Parachain: UNIQUE_CHAIN},1389 },1390 },1391 },1392 fun: {1393 Fungible: TRANSFER_AMOUNT,1394 },1395 },1396 };1397 const destination = {1398 V2: {1399 parents: 1,1400 interior: {1401 X2: [1402 {Parachain: UNIQUE_CHAIN},1403 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1404 ],1405 },1406 },1407 };14081409 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');14101411 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);14121413 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1414 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1415 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;14161417 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);14181419 expect(unqRandomAccountAsset).to.be.null;14201421 balanceForeignUnqTokenFinal = 0n;14221423 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1424 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1425 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1426 });14271428 await helper.wait.newBlocks(3);14291430 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1431 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1432 expect(actuallyDelivered > 0).to.be.true;14331434 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));14351436 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1437 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1438 expect(unqFees == 0n).to.be.true;1439 });14401441 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1442 // set Moonbeam's sovereign account's balance1443 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1444 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1445 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);14461447 const moreThanMoonbeamHas = moonbeamBalance * 2n;14481449 let targetAccountBalance = 0n;1450 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);14511452 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1453 targetAccount.addressRaw,1454 {1455 Concrete: {1456 parents: 0,1457 interior: 'Here',1458 },1459 },1460 moreThanMoonbeamHas,1461 );14621463 let maliciousXcmProgramSent: any;1464 const maxWaitBlocks = 3;14651466 // Try to trick Unique1467 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1468 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);14691470 // Needed to bypass the call filter.1471 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1472 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);14731474 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1475 });14761477 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1478 && event.outcome.isFailedToTransactAsset);14791480 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1481 expect(targetAccountBalance).to.be.equal(0n);14821483 // But Moonbeam still can send the correct amount1484 const validTransferAmount = moonbeamBalance / 2n;1485 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1486 targetAccount.addressRaw,1487 {1488 Concrete: {1489 parents: 0,1490 interior: 'Here',1491 },1492 },1493 validTransferAmount,1494 );14951496 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1497 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);14981499 // Needed to bypass the call filter.1500 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1501 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1502 });15031504 await helper.wait.newBlocks(maxWaitBlocks);15051506 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1507 expect(targetAccountBalance).to.be.equal(validTransferAmount);1508 });15091510 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1511 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1512 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);15131514 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1515 targetAccount.addressRaw,1516 {1517 Concrete: {1518 parents: 0,1519 interior: {1520 X1: {1521 Parachain: UNIQUE_CHAIN,1522 },1523 },1524 },1525 },1526 testAmount,1527 );15281529 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1530 targetAccount.addressRaw,1531 {1532 Concrete: {1533 parents: 0,1534 interior: 'Here',1535 },1536 },1537 testAmount,1538 );15391540 let maliciousXcmProgramFullIdSent: any;1541 let maliciousXcmProgramHereIdSent: any;1542 const maxWaitBlocks = 3;15431544 // Try to trick Unique using full UNQ identification1545 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1546 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);15471548 // Needed to bypass the call filter.1549 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1550 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);15511552 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1553 });15541555 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1556 && event.outcome.isUntrustedReserveLocation);15571558 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1559 expect(accountBalance).to.be.equal(0n);15601561 // Try to trick Unique using shortened UNQ identification1562 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1563 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);15641565 // Needed to bypass the call filter.1566 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1567 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);15681569 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1570 });15711572 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1573 && event.outcome.isUntrustedReserveLocation);15741575 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1576 expect(accountBalance).to.be.equal(0n);1577 });1578});15791580describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1581 let alice: IKeyringPair;1582 let randomAccount: IKeyringPair;15831584 const UNQ_ASSET_ID_ON_ASTAR = 1;1585 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;15861587 // Unique -> Astar1588 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1589 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1590 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1591 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens15921593 // Astar -> Unique1594 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1595 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ15961597 let balanceAfterUniqueToAstarXCM: bigint;15981599 before(async () => {1600 await usingPlaygrounds(async (helper, privateKey) => {1601 alice = await privateKey('//Alice');1602 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1603 console.log('randomAccount', randomAccount.address);16041605 // Set the default version to wrap the first message to other chains.1606 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1607 });16081609 await usingAstarPlaygrounds(astarUrl, async (helper) => {1610 if(!(await helper.callRpc('api.query.assets.asset', [UNQ_ASSET_ID_ON_ASTAR])).toJSON()) {1611 console.log('1. Create foreign asset and metadata');1612 // TODO update metadata with values from production1613 await helper.assets.create(1614 alice,1615 UNQ_ASSET_ID_ON_ASTAR,1616 alice.address,1617 UNQ_MINIMAL_BALANCE_ON_ASTAR,1618 );16191620 await helper.assets.setMetadata(1621 alice,1622 UNQ_ASSET_ID_ON_ASTAR,1623 'Cross chain UNQ',1624 'xcUNQ',1625 Number(UNQ_DECIMALS),1626 );16271628 console.log('2. Register asset location on Astar');1629 const assetLocation = {1630 V2: {1631 parents: 1,1632 interior: {1633 X1: {1634 Parachain: UNIQUE_CHAIN,1635 },1636 },1637 },1638 };16391640 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);16411642 console.log('3. Set UNQ payment for XCM execution on Astar');1643 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);1644 }1645 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1646 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1647 });1648 });16491650 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1651 const destination = {1652 V2: {1653 parents: 1,1654 interior: {1655 X1: {1656 Parachain: ASTAR_CHAIN,1657 },1658 },1659 },1660 };16611662 const beneficiary = {1663 V2: {1664 parents: 0,1665 interior: {1666 X1: {1667 AccountId32: {1668 network: 'Any',1669 id: randomAccount.addressRaw,1670 },1671 },1672 },1673 },1674 };16751676 const assets = {1677 V2: [1678 {1679 id: {1680 Concrete: {1681 parents: 0,1682 interior: 'Here',1683 },1684 },1685 fun: {1686 Fungible: unqToAstarTransferred,1687 },1688 },1689 ],1690 };16911692 // Initial balance is 100 UNQ1693 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1694 console.log(`Initial balance is: ${balanceBefore}`);16951696 const feeAssetItem = 0;1697 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');16981699 // Balance after reserve transfer is less than 901700 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1701 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1702 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1703 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;17041705 await usingAstarPlaygrounds(astarUrl, async (helper) => {1706 await helper.wait.newBlocks(3);1707 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1708 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);17091710 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1711 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);17121713 expect(xcUNQbalance).to.eq(unqToAstarArrived);1714 // Astar balance does not changed1715 expect(astarBalance).to.eq(astarInitialBalance);1716 });1717 });17181719 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1720 await usingAstarPlaygrounds(astarUrl, async (helper) => {1721 const destination = {1722 V2: {1723 parents: 1,1724 interior: {1725 X1: {1726 Parachain: UNIQUE_CHAIN,1727 },1728 },1729 },1730 };17311732 const beneficiary = {1733 V2: {1734 parents: 0,1735 interior: {1736 X1: {1737 AccountId32: {1738 network: 'Any',1739 id: randomAccount.addressRaw,1740 },1741 },1742 },1743 },1744 };17451746 const assets = {1747 V2: [1748 {1749 id: {1750 Concrete: {1751 parents: 1,1752 interior: {1753 X1: {1754 Parachain: UNIQUE_CHAIN,1755 },1756 },1757 },1758 },1759 fun: {1760 Fungible: unqFromAstarTransfered,1761 },1762 },1763 ],1764 };17651766 // Initial balance is 1 ASTR1767 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1768 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1769 expect(balanceASTRbefore).to.eq(astarInitialBalance);17701771 const feeAssetItem = 0;1772 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1773 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);17741775 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1776 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1777 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);17781779 // Assert: xcUNQ balance correctly decreased1780 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1781 // Assert: ASTR balance is 0.996...1782 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1783 });17841785 await helper.wait.newBlocks(3);1786 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1787 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1788 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1789 });17901791 itSub('Astar can send only up to its balance', async ({helper}) => {1792 // set Astar's sovereign account's balance1793 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1794 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1795 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);17961797 const moreThanAstarHas = astarBalance * 2n;17981799 let targetAccountBalance = 0n;1800 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);18011802 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1803 targetAccount.addressRaw,1804 {1805 Concrete: {1806 parents: 0,1807 interior: 'Here',1808 },1809 },1810 moreThanAstarHas,1811 );18121813 let maliciousXcmProgramSent: any;1814 const maxWaitBlocks = 3;18151816 // Try to trick Unique1817 await usingAstarPlaygrounds(astarUrl, async (helper) => {1818 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);18191820 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1821 });18221823 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1824 && event.outcome.isFailedToTransactAsset);18251826 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1827 expect(targetAccountBalance).to.be.equal(0n);18281829 // But Astar still can send the correct amount1830 const validTransferAmount = astarBalance / 2n;1831 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1832 targetAccount.addressRaw,1833 {1834 Concrete: {1835 parents: 0,1836 interior: 'Here',1837 },1838 },1839 validTransferAmount,1840 );18411842 await usingAstarPlaygrounds(astarUrl, async (helper) => {1843 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1844 });18451846 await helper.wait.newBlocks(maxWaitBlocks);18471848 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1849 expect(targetAccountBalance).to.be.equal(validTransferAmount);1850 });18511852 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1853 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1854 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);18551856 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1857 targetAccount.addressRaw,1858 {1859 Concrete: {1860 parents: 1,1861 interior: {1862 X1: {1863 Parachain: UNIQUE_CHAIN,1864 },1865 },1866 },1867 },1868 testAmount,1869 );18701871 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1872 targetAccount.addressRaw,1873 {1874 Concrete: {1875 parents: 0,1876 interior: 'Here',1877 },1878 },1879 testAmount,1880 );18811882 let maliciousXcmProgramFullIdSent: any;1883 let maliciousXcmProgramHereIdSent: any;1884 const maxWaitBlocks = 3;18851886 // Try to trick Unique using full UNQ identification1887 await usingAstarPlaygrounds(astarUrl, async (helper) => {1888 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);18891890 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1891 });18921893 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1894 && event.outcome.isUntrustedReserveLocation);18951896 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1897 expect(accountBalance).to.be.equal(0n);18981899 // Try to trick Unique using shortened UNQ identification1900 await usingAstarPlaygrounds(astarUrl, async (helper) => {1901 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);19021903 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1904 });19051906 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1907 && event.outcome.isUntrustedReserveLocation);19081909 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1910 expect(accountBalance).to.be.equal(0n);1911 });1912});