From e413fd637719a1e86ee8e0eeea997fdb59ea470a Mon Sep 17 00:00:00 2001 From: Dev Date: Tue, 30 Aug 2022 12:35:48 +0000 Subject: [PATCH] Tests --- --- a/tests/package.json +++ b/tests/package.json @@ -74,11 +74,10 @@ "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.test.ts", "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.test.ts", "testSchedulingEVM": "mocha --timeout 9999999 -r ts-node/register ./**/eth/scheduling.test.ts", - "testXcmTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/xcmTransfer.test.ts", - "testXcmTransferAcala": "mocha --timeout 9999999 -r ts-node/register ./**/xcmTransferAcala.test.ts", - "testXcmTransferKarura": "mocha --timeout 9999999 -r ts-node/register ./**/xcmTransferKarura.test.ts", - "testXcmTransferStatemine": "mocha --timeout 9999999 -r ts-node/register ./**/xcmTransferStatemine.test.ts", - "testXcmTransferMoonriver": "mocha --timeout 9999999 -r ts-node/register ./**/xcmTransferMoonriver.test.ts", + "testXcmTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransfer.test.ts", + "testXcmTransferAcala": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransferAcala.test.ts acalaId=2000 uniqueId=5000", + "testXcmTransferStatemine": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransferStatemine.test.ts statemineId=1000 uniqueId=5000", + "testXcmTransferMoonbeam": "mocha --timeout 9999999 -r ts-node/register ./**/xcm/xcmTransferMoonbeam.test.ts moonbeamId=2000 uniqueId=5000", "testPalletPresence": "mocha --timeout 9999999 -r ts-node/register ./**/pallet-presence.test.ts", "testBlockProduction": "mocha --timeout 9999999 -r ts-node/register ./**/block-production.test.ts", "testEnableDisableTransfers": "mocha --timeout 9999999 -r ts-node/register ./**/enableDisableTransfer.test.ts", --- /dev/null +++ b/tests/src/xcm/xcmTransfer.test.ts @@ -0,0 +1,186 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; + +import {WsProvider} from '@polkadot/api'; +import {ApiOptions} from '@polkadot/api/types'; +import {IKeyringPair} from '@polkadot/types/types'; +import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; +import {getGenericResult} from './util/helpers'; +import waitNewBlocks from './substrate/wait-new-blocks'; +import getBalance from './substrate/get-balance'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +const UNIQUE_CHAIN = 1000; +const KARURA_CHAIN = 2000; +const KARURA_PORT = '9946'; +const TRANSFER_AMOUNT = 2000000000000000000000000n; + +describe.skip('Integration test: Exchanging QTZ with Karura', () => { + let alice: IKeyringPair; + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + }); + + const karuraApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT), + }; + + await usingApi(async (api) => { + const destination = { + V0: { + X2: [ + 'Parent', + { + Parachain: UNIQUE_CHAIN, + }, + ], + }, + }; + + const metadata = + { + name: 'QTZ', + symbol: 'QTZ', + decimals: 18, + minimalBalance: 1, + }; + + const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata); + const sudoTx = api.tx.sudo.sudo(tx as any); + const events = await submitTransactionAsync(alice, sudoTx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + }, karuraApiOptions); + }); + + it('Should connect and send QTZ to Karura', async () => { + let balanceOnKaruraBefore: bigint; + + await usingApi(async (api) => { + const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; + balanceOnKaruraBefore = free; + }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); + + await usingApi(async (api) => { + const destination = { + V0: { + X2: [ + 'Parent', + { + Parachain: KARURA_CHAIN, + }, + ], + }, + }; + + const beneficiary = { + V0: { + X1: { + AccountId32: { + network: 'Any', + id: alice.addressRaw, + }, + }, + }, + }; + + const assets = { + V1: [ + { + id: { + Concrete: { + parents: 0, + interior: 'Here', + }, + }, + fun: { + Fungible: TRANSFER_AMOUNT, + }, + }, + ], + }; + + const feeAssetItem = 0; + + const weightLimit = { + Limited: 5000000000, + }; + + const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + }); + + await usingApi(async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; + expect(free > balanceOnKaruraBefore).to.be.true; + }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); + }); + + it('Should connect to Karura and send QTZ back', async () => { + let balanceBefore: bigint; + + await usingApi(async (api) => { + [balanceBefore] = await getBalance(api, [alice.address]); + }); + + await usingApi(async (api) => { + const destination = { + V1: { + parents: 1, + interior: { + X2: [ + {Parachain: UNIQUE_CHAIN}, + {AccountId32: { + network: 'Any', + id: alice.addressRaw, + }}, + ], + }, + }, + }; + + const id = { + ForeignAsset: 0, + }; + + const amount = TRANSFER_AMOUNT; + const destWeight = 50000000; + + const tx = api.tx.xTokens.transfer(id, amount, destination, destWeight); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); + + await usingApi(async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + const [balanceAfter] = await getBalance(api, [alice.address]); + expect(balanceAfter > balanceBefore).to.be.true; + }); + }); +}); --- /dev/null +++ b/tests/src/xcm/xcmTransferAcala.test.ts @@ -0,0 +1,265 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; + +import {WsProvider} from '@polkadot/api'; +import {ApiOptions} from '@polkadot/api/types'; +import {IKeyringPair} from '@polkadot/types/types'; +import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; +import {getGenericResult, generateKeyringPair} from './util/helpers'; +import waitNewBlocks from './substrate/wait-new-blocks'; +import getBalance from './substrate/get-balance'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +let UNIQUE_CHAIN = 0; +let ACALA_CHAIN = 0; + +// parse parachain id numbers +process.argv.forEach((val) => { + + const ai = val.indexOf('acalaId='); + const ui = val.indexOf('uniqueId='); + if (ai != -1) + { + ACALA_CHAIN = Number(val.substring('acalaId='.length)); + } + if (ui != -1) + { + UNIQUE_CHAIN = Number(val.substring('uniqueId='.length)); + } +}); + +const ACALA_PORT = '9946'; +const TRANSFER_AMOUNT = 2000000000000000000000000n; + +describe('Integration test: Exchanging UNQ with Acala', () => { + let alice: IKeyringPair; + let randomAccount: IKeyringPair; + + let balanceUniqueTokenBefore: bigint; + let balanceUniqueTokenAfter: bigint; + let balanceUniqueTokenFinal: bigint; + let balanceAcalaTokenBefore: bigint; + let balanceAcalaTokenAfter: bigint; + let balanceAcalaTokenFinal: bigint; + let balanceUniqueForeignTokenAfter: bigint; + let balanceUniqueForeignTokenBefore: bigint; + let balanceUniqueForeignTokenFinal: bigint; + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + randomAccount = generateKeyringPair(); + }); + + const acalaApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT), + }; + + await usingApi( + async (api) => { + const destination = { + V0: { + X2: [ + 'Parent', + { + Parachain: UNIQUE_CHAIN, + }, + ], + }, + }; + + const metadata = { + name: 'UNQ', + symbol: 'UNQ', + decimals: 18, + minimalBalance: 1, + }; + + const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata); + const sudoTx = api.tx.sudo.sudo(tx as any); + const events = await submitTransactionAsync(alice, sudoTx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + const tx1 = api.tx.balances.transfer(randomAccount.address, 10000000000000n); + const events1 = await submitTransactionAsync(alice, tx1); + const result1 = getGenericResult(events1); + expect(result1.success).to.be.true; + + [balanceAcalaTokenBefore] = await getBalance(api, [randomAccount.address]); + { + const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; + balanceUniqueForeignTokenBefore = BigInt(free); + } + }, + acalaApiOptions, + ); + + await usingApi(async (api) => { + const tx0 = api.tx.balances.transfer(randomAccount.address, 10n * TRANSFER_AMOUNT); + const events0 = await submitTransactionAsync(alice, tx0); + const result0 = getGenericResult(events0); + expect(result0.success).to.be.true; + + [balanceUniqueTokenBefore] = await getBalance(api, [randomAccount.address]); + }); + }); + + it('Should connect and send UNQ to Acala', async () => { + + await usingApi(async (api) => { + + const destination = { + V0: { + X2: [ + 'Parent', + { + Parachain: ACALA_CHAIN, + }, + ], + }, + }; + + const beneficiary = { + V0: { + X1: { + AccountId32: { + network: 'Any', + id: randomAccount.addressRaw, + }, + }, + }, + }; + + const assets = { + V1: [ + { + id: { + Concrete: { + parents: 0, + interior: 'Here', + }, + }, + fun: { + Fungible: TRANSFER_AMOUNT, + }, + }, + ], + }; + + const feeAssetItem = 0; + + const weightLimit = { + Limited: 5000000000, + }; + + const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); + const events = await submitTransactionAsync(randomAccount, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + [balanceUniqueTokenAfter] = await getBalance(api, [randomAccount.address]); + + expect((balanceUniqueTokenBefore - balanceUniqueTokenAfter) > 0n).to.be.true; + }); + + await usingApi( + async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any; + balanceUniqueForeignTokenAfter = BigInt(free); + + [balanceAcalaTokenAfter] = await getBalance(api, [randomAccount.address]); + const acaFees = balanceAcalaTokenBefore - balanceAcalaTokenAfter; + const unqFees = balanceUniqueForeignTokenBefore - balanceUniqueForeignTokenAfter; + console.log('Unique to Acala transaction fees on Acala: %s ACA', acaFees); + console.log('Unique to Acala transaction fees on Acala: %s UNQ', unqFees); + expect(acaFees == 0n).to.be.true; + expect(unqFees == 0n).to.be.true; + }, + {provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT)}, + ); + }); + + it('Should connect to Acala and send UNQ back', async () => { + + await usingApi( + async (api) => { + const destination = { + V1: { + parents: 1, + interior: { + X2: [ + {Parachain: UNIQUE_CHAIN}, + { + AccountId32: { + network: 'Any', + id: randomAccount.addressRaw, + }, + }, + ], + }, + }, + }; + + const id = { + ForeignAsset: 0, + }; + + const amount = TRANSFER_AMOUNT; + const destWeight = 50000000; + + const tx = api.tx.xTokens.transfer(id, amount, destination, destWeight); + const events = await submitTransactionAsync(randomAccount, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + [balanceAcalaTokenFinal] = await getBalance(api, [randomAccount.address]); + { + const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any; + balanceUniqueForeignTokenFinal = BigInt(free); + } + + const acaFees = balanceAcalaTokenFinal - balanceAcalaTokenAfter; + const unqFees = balanceUniqueForeignTokenFinal - balanceUniqueForeignTokenAfter; + console.log('Acala to Unique transaction fees on Acala: %s ACA', acaFees); + console.log('Acala to Unique transaction fees on Acala: %s UNQ', unqFees); + expect(acaFees > 0).to.be.true; + expect(unqFees == 0n).to.be.true; + }, + {provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT)}, + ); + + await usingApi(async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + + [balanceUniqueTokenFinal] = await getBalance(api, [randomAccount.address]); + const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenAfter; + expect(actuallyDelivered > 0).to.be.true; + + const unqFees = TRANSFER_AMOUNT - actuallyDelivered; + console.log('Acala to Unique transaction fees on Unique: %s UNQ', unqFees); + expect(unqFees > 0).to.be.true; + }); + }); +}); \ No newline at end of file --- /dev/null +++ b/tests/src/xcm/xcmTransferMoonbeam.test.ts @@ -0,0 +1,382 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; + +import {Keyring, WsProvider} from '@polkadot/api'; +import {ApiOptions} from '@polkadot/api/types'; +import {IKeyringPair} from '@polkadot/types/types'; +import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; +import {getGenericResult, generateKeyringPair} from './util/helpers'; +import {MultiLocation} from '@polkadot/types/interfaces'; +import {blake2AsHex} from '@polkadot/util-crypto'; +import getBalance from './substrate/get-balance'; +import waitNewBlocks from './substrate/wait-new-blocks'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + + +let UNIQUE_CHAIN = 0; +let MOONBEAM_CHAIN = 0; + +// parse parachain id numbers +process.argv.forEach((val) => { + + const ai = val.indexOf('moonbeamId='); + const ui = val.indexOf('uniqueId='); + if (ai != -1) + { + MOONBEAM_CHAIN = Number(val.substring('moonbeamId='.length)); + } + if (ui != -1) + { + UNIQUE_CHAIN = Number(val.substring('uniqueId='.length)); + } +}); + +const UNIQUE_PORT = '9944'; +const MOONBEAM_PORT = '9946'; +const TRANSFER_AMOUNT = 2000000000000000000000000n; + +describe('Integration test: Exchanging UNQ with Moonbeam', () => { + + // Unique constants + let uniqueAlice: IKeyringPair; + let uniqueAssetLocation; + + let randomAccountUnique: IKeyringPair; + let randomAccountMoonbeam: IKeyringPair; + + // Moonbeam constants + let assetId: Uint8Array; + + const moonbeamKeyring = new Keyring({type: 'ethereum'}); + const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'; + const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'; + const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'; + + const alithAccount = moonbeamKeyring.addFromUri(alithPrivateKey, undefined, 'ethereum'); + const baltatharAccount = moonbeamKeyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum'); + const dorothyAccount = moonbeamKeyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum'); + + const councilVotingThreshold = 2; + const technicalCommitteeThreshold = 2; + const votingPeriod = 3; + const delayPeriod = 0; + + const uniqueAssetMetadata = { + name: 'xcUnique', + symbol: 'xcUNQ', + decimals: 18, + isFrozen: false, + minimalBalance: 1, + }; + + // let actuallySent1: bigint; + // let actuallySent2: bigint; + + // let balanceUnique1: bigint; + // let balanceUnique2: bigint; + // let balanceUnique3: bigint; + + // let balanceMoonbeamGlmr1: bigint; + // let balanceMoonbeamGlmr2: bigint; + // let balanceMoonbeamGlmr3: bigint; + + let balanceUniqueTokenBefore: bigint; + let balanceUniqueTokenAfter: bigint; + let balanceUniqueTokenFinal: bigint; + let balanceGlmrTokenBefore: bigint; + let balanceGlmrTokenAfter: bigint; + let balanceGlmrTokenFinal: bigint; + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + uniqueAlice = privateKeyWrapper('//Alice'); + randomAccountUnique = generateKeyringPair(); + randomAccountMoonbeam = generateKeyringPair('ethereum'); + }); + + const moonbeamApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT), + }; + + await usingApi( + async (api) => { + + // >>> Sponsoring Dorothy >>> + const tx0 = api.tx.balances.transfer(dorothyAccount.address, 11_000_000_000_000_000_000n); + const events0 = await submitTransactionAsync(alithAccount, tx0); + const result0 = getGenericResult(events0); + expect(result0.success).to.be.true; + // <<< Sponsoring Dorothy <<< + + const sourceLocation: MultiLocation = api.createType( + 'MultiLocation', + { + parents: 1, + interior: {X1: {Parachain: UNIQUE_CHAIN}}, + }, + ); + + assetId = api.registry.hash(sourceLocation.toU8a()).slice(0, 16).reverse(); + console.log('Internal asset ID is %s', assetId); + uniqueAssetLocation = {XCM: sourceLocation}; + const existentialDeposit = 1; + const isSufficient = true; + const unitsPerSecond = '1'; + const numAssetsWeightHint = 0; + + const registerTx = api.tx.assetManager.registerForeignAsset( + uniqueAssetLocation, + uniqueAssetMetadata, + existentialDeposit, + isSufficient, + ); + console.log('Encoded proposal for registerAsset is %s', registerTx.method.toHex() || ''); + + const setUnitsTx = api.tx.assetManager.setAssetUnitsPerSecond( + uniqueAssetLocation, + unitsPerSecond, + numAssetsWeightHint, + ); + console.log('Encoded proposal for setAssetUnitsPerSecond is %s', setUnitsTx.method.toHex() || ''); + + const batchCall = api.tx.utility.batchAll([registerTx, setUnitsTx]); + console.log('Encoded proposal for batchCall is %s', batchCall.method.toHex() || ''); + + // >>> Note motion preimage >>> + const encodedProposal = batchCall?.method.toHex() || ''; + const proposalHash = blake2AsHex(encodedProposal); + console.log('Encoded proposal for batch utility after schedule is %s', encodedProposal); + console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash); + console.log('Encoded length %d', encodedProposal.length); + + const tx1 = api.tx.democracy.notePreimage(encodedProposal); + const events1 = await submitTransactionAsync(baltatharAccount, tx1); + const result1 = getGenericResult(events1); + expect(result1.success).to.be.true; + // <<< Note motion preimage <<< + + // >>> Propose external motion through council >>> + const externalMotion = api.tx.democracy.externalProposeMajority(proposalHash); + const tx2 = api.tx.councilCollective.propose( + councilVotingThreshold, + externalMotion, + externalMotion.encodedLength, + ); + const events2 = await submitTransactionAsync(baltatharAccount, tx2); + const result2 = getGenericResult(events2); + expect(result2.success).to.be.true; + + const encodedMotion = externalMotion?.method.toHex() || ''; + const motionHash = blake2AsHex(encodedMotion); + console.log('Motion hash is %s', motionHash); + + const tx3 = api.tx.councilCollective.vote(motionHash, 0, true); + { + const events3 = await submitTransactionAsync(dorothyAccount, tx3); + const result3 = getGenericResult(events3); + expect(result3.success).to.be.true; + } + { + const events3 = await submitTransactionAsync(baltatharAccount, tx3); + const result3 = getGenericResult(events3); + expect(result3.success).to.be.true; + } + + const tx4 = api.tx.councilCollective.close(motionHash, 0, 1_000_000_000, externalMotion.encodedLength); + const events4 = await submitTransactionAsync(dorothyAccount, tx4); + const result4 = getGenericResult(events4); + expect(result4.success).to.be.true; + // <<< Propose external motion through council <<< + + // >>> Fast track proposal through technical committee >>> + const fastTrack = api.tx.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod); + const tx5 = api.tx.techCommitteeCollective.propose( + technicalCommitteeThreshold, + fastTrack, + fastTrack.encodedLength, + ); + const events5 = await submitTransactionAsync(alithAccount, tx5); + const result5 = getGenericResult(events5); + expect(result5.success).to.be.true; + + const encodedFastTrack = fastTrack?.method.toHex() || ''; + const fastTrackHash = blake2AsHex(encodedFastTrack); + console.log('FastTrack hash is %s', fastTrackHash); + + const proposalIdx = Number(await api.query.techCommitteeCollective.proposalCount()) - 1; + const tx6 = api.tx.techCommitteeCollective.vote(fastTrackHash, proposalIdx, true); + { + const events6 = await submitTransactionAsync(baltatharAccount, tx6); + const result6 = getGenericResult(events6); + expect(result6.success).to.be.true; + } + { + const events6 = await submitTransactionAsync(alithAccount, tx6); + const result6 = getGenericResult(events6); + expect(result6.success).to.be.true; + } + + const tx7 = api.tx.techCommitteeCollective + .close(fastTrackHash, proposalIdx, 1_000_000_000, fastTrack.encodedLength); + const events7 = await submitTransactionAsync(baltatharAccount, tx7); + const result7 = getGenericResult(events7); + expect(result7.success).to.be.true; + // <<< Fast track proposal through technical committee <<< + + // >>> Referendum voting >>> + const tx8 = api.tx.democracy.vote( + 0, + {Standard: {balance: 10_000_000_000_000_000_000n, vote: {aye: true, conviction: 1}}}, + ); + const events8 = await submitTransactionAsync(dorothyAccount, tx8); + const result8 = getGenericResult(events8); + expect(result8.success).to.be.true; + // <<< Referendum voting <<< + + // >>> Sponsoring random Account >>> + const tx9 = api.tx.balances.transfer(randomAccountMoonbeam.address, 11_000_000_000_000_000_000n); + const events9 = await submitTransactionAsync(baltatharAccount, tx9); + const result9 = getGenericResult(events9); + expect(result9.success).to.be.true; + // <<< Sponsoring random Account <<< + + [balanceGlmrTokenBefore] = await getBalance(api, [randomAccountMoonbeam.address]); + }, + moonbeamApiOptions, + ); + + await usingApi(async (api) => { + const tx0 = api.tx.balances.transfer(randomAccountUnique.address, 10n * TRANSFER_AMOUNT); + const events0 = await submitTransactionAsync(uniqueAlice, tx0); + const result0 = getGenericResult(events0); + expect(result0.success).to.be.true; + + [balanceUniqueTokenBefore] = await getBalance(api, [randomAccountUnique.address]); + }); + }); + + it('Should connect and send UNQ to Moonbeam', async () => { + await usingApi(async (api) => { + const currencyId = { + NativeAssetId: 'Here', + }; + const dest = { + V1: { + parents: 1, + interior: { + X2: [ + {Parachain: MOONBEAM_CHAIN}, + {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}}, + ], + }, + }, + }; + const amount = TRANSFER_AMOUNT; + const destWeight = 50000000; + + const tx = api.tx.xTokens.transfer(currencyId, amount, dest, destWeight); + const events = await submitTransactionAsync(uniqueAlice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + [balanceUniqueTokenAfter] = await getBalance(api, [randomAccountUnique.address]); + expect(balanceUniqueTokenAfter < balanceUniqueTokenBefore).to.be.true; + + const transactionFees = balanceUniqueTokenBefore - balanceUniqueTokenAfter - TRANSFER_AMOUNT; + console.log('Unique to Moonbeam transaction fees on Unique: %s UNQ', transactionFees); + expect(transactionFees > 0).to.be.true; + }); + + await usingApi( + async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + + [balanceGlmrTokenAfter] = await getBalance(api, [randomAccountMoonbeam.address]); + + const glmrFees = balanceGlmrTokenBefore - balanceGlmrTokenAfter; + console.log('Unique to Moonbeam transaction fees on Moonbeam: %s GLMR', glmrFees); + expect(glmrFees == 0n).to.be.true; + }, + {provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT)}, + ); + }); + + it('Should connect to Moonbeam and send UNQ back', async () => { + await usingApi( + async (api) => { + const amount = TRANSFER_AMOUNT / 2n; + const asset = { + V1: { + id: { + Concrete: { + parents: 1, + interior: { + X1: {Parachain: UNIQUE_CHAIN}, + }, + }, + }, + fun: { + Fungible: amount, + }, + }, + }; + const destination = { + V1: { + parents: 1, + interior: { + X2: [ + {Parachain: UNIQUE_CHAIN}, + {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}}, + ], + }, + }, + }; + const destWeight = 50000000; + + const tx = api.tx.xTokens.transferMultiasset(asset, destination, destWeight); + const events = await submitTransactionAsync(randomAccountMoonbeam, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + [balanceGlmrTokenFinal] = await getBalance(api, [randomAccountMoonbeam.address]); + + const glmrFees = balanceGlmrTokenAfter - balanceGlmrTokenFinal; + console.log('Moonbeam to Unique transaction fees on Moonbeam: %s GLMR', glmrFees); + expect(glmrFees > 0).to.be.true; + }, + {provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT)}, + ); + + await usingApi(async (api) => { + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + + [balanceUniqueTokenFinal] = await getBalance(api, [randomAccountUnique.address]); + const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenAfter; + expect(actuallyDelivered > 0).to.be.true; + + const unqFees = TRANSFER_AMOUNT - actuallyDelivered; + console.log('Moonbeam to Unique transaction fees on Unique: %s UNQ', unqFees); + expect(unqFees > 0).to.be.true; + }); + }); +}); --- /dev/null +++ b/tests/src/xcm/xcmTransferStatemine.test.ts @@ -0,0 +1,360 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; + +import {WsProvider} from '@polkadot/api'; +import {ApiOptions} from '@polkadot/api/types'; +import {IKeyringPair} from '@polkadot/types/types'; +import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; +import {getGenericResult} from './util/helpers'; +import waitNewBlocks from './substrate/wait-new-blocks'; +import {normalizeAccountId} from './util/helpers'; +import getBalance from './substrate/get-balance'; + + +chai.use(chaiAsPromised); +const expect = chai.expect; + +// const STATEMINE_CHAIN = 1000; +// const UNIQUE_CHAIN = 2037; + +let UNIQUE_CHAIN = 0; +let STATEMINE_CHAIN = 0; + +// parse parachain id numbers +process.argv.forEach((val) => { + + const ai = val.indexOf('statemineId='); + const ui = val.indexOf('uniqueId='); + if (ai != -1) + { + STATEMINE_CHAIN = Number(val.substring('statemineId='.length)); + } + if (ui != -1) + { + UNIQUE_CHAIN = Number(val.substring('uniqueId='.length)); + } +}); + +const RELAY_PORT = '9844'; +const UNIQUE_PORT = '9944'; +const STATEMINE_PORT = '9946'; +const STATEMINE_PALLET_INSTANCE = 50; +const ASSET_ID = 100; +const ASSET_METADATA_DECIMALS = 18; +const ASSET_METADATA_NAME = 'USDT'; +const ASSET_METADATA_DESCRIPTION = 'USDT'; +const ASSET_METADATA_MINIMAL_BALANCE = 1; + +const TRANSFER_AMOUNT = 1_000_000_000_000_000_000n; +const TRANSFER_AMOUNT2 = 10_000_000_000_000_000n; + +describe('Integration test: Exchanging USDT with Statemine', () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + + let balanceStmnBefore: bigint; + let balanceStmnAfter: bigint; + let balanceStmnFinal: bigint; + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); // funds donor + }); + + const statemineApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + STATEMINE_PORT), + }; + + const uniqueApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), + }; + + const relayApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + RELAY_PORT), + }; + + await usingApi(async (api) => { + + // 10,000.00 (ten thousands) USDT + const assetAmount = 1_000_000_000_000_000_000_000n; + // 350.00 (three hundred fifty) DOT + const fundingAmount = 3_500_000_000_000; + + const tx = api.tx.assets.create(ASSET_ID, alice.addressRaw, ASSET_METADATA_MINIMAL_BALANCE); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + // set metadata + const tx2 = api.tx.assets.setMetadata(ASSET_ID, ASSET_METADATA_NAME, ASSET_METADATA_DESCRIPTION, ASSET_METADATA_DECIMALS); + const events2 = await submitTransactionAsync(alice, tx2); + const result2 = getGenericResult(events2); + expect(result2.success).to.be.true; + + // mint some amount of asset + const tx3 = api.tx.assets.mint(ASSET_ID, alice.addressRaw, assetAmount); + const events3 = await submitTransactionAsync(alice, tx3); + const result3 = getGenericResult(events3); + expect(result3.success).to.be.true; + + // funding parachain sovereing account (Parachain: 2037) + //const parachainSovereingAccount = '0x70617261f5070000000000000000000000000000000000000000000000000000'; + const parachainSovereingAccount = '0x7369626cf5070000000000000000000000000000000000000000000000000000'; + const tx4 = api.tx.balances.transfer(parachainSovereingAccount, fundingAmount); + const events4 = await submitTransactionAsync(bob, tx4); + const result4 = getGenericResult(events4); + expect(result4.success).to.be.true; + + }, statemineApiOptions); + + + await usingApi(async (api) => { + + const location = { + V1: { + parents: 1, + interior: {X3: [ + { + Parachain: STATEMINE_CHAIN, + }, + { + PalletInstance: STATEMINE_PALLET_INSTANCE, + }, + { + GeneralIndex: ASSET_ID, + }, + ]}, + }, + }; + + const metadata = + { + name: ASSET_ID, + symbol: ASSET_METADATA_NAME, + decimals: ASSET_METADATA_DECIMALS, + minimalBalance: ASSET_METADATA_MINIMAL_BALANCE, + }; + //registerForeignAsset(owner, location, metadata) + const tx = api.tx.foreingAssets.registerForeignAsset(alice.addressRaw, location, metadata); + const sudoTx = api.tx.sudo.sudo(tx as any); + const events = await submitTransactionAsync(alice, sudoTx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + }, uniqueApiOptions); + + + // Providing the relay currency to the unique sender account + await usingApi(async (api) => { + const destination = { + V1: { + parents: 0, + interior: {X1: { + Parachain: UNIQUE_CHAIN, + }, + }, + }}; + + const beneficiary = { + V1: { + parents: 0, + interior: {X1: { + AccountId32: { + network: 'Any', + id: alice.addressRaw, + }, + }}, + }, + }; + + const assets = { + V1: [ + { + id: { + Concrete: { + parents: 0, + interior: 'Here', + }, + }, + fun: { + Fungible: 50_000_000_000_000_000n, + }, + }, + ], + }; + + const feeAssetItem = 0; + + const weightLimit = { + Limited: 5_000_000_000, + }; + + const tx = api.tx.xcmPallet.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + }, relayApiOptions); + + }); + + it('Should connect and send USDT from Statemine to Unique', async () => { + + const statemineApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + STATEMINE_PORT), + }; + + const uniqueApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), + }; + + await usingApi(async (api) => { + + const dest = { + V1: { + parents: 1, + interior: {X1: { + Parachain: UNIQUE_CHAIN, + }, + }, + }}; + + const beneficiary = { + V1: { + parents: 0, + interior: {X1: { + AccountId32: { + network: 'Any', + id: alice.addressRaw, + }, + }}, + }, + }; + + const assets = { + V1: [ + { + id: { + Concrete: { + parents: 0, + interior: { + X2: [ + { + PalletInstance: STATEMINE_PALLET_INSTANCE, + }, + { + GeneralIndex: ASSET_ID, + }, + ]}, + }, + }, + fun: { + Fungible: TRANSFER_AMOUNT, + }, + }, + ], + }; + + const feeAssetItem = 0; + + const weightLimit = { + Limited: 5000000000, + }; + + [balanceStmnBefore] = await getBalance(api, [alice.address]); + + const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(dest, beneficiary, assets, feeAssetItem, weightLimit); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + [balanceStmnAfter] = await getBalance(api, [alice.address]); + expect(balanceStmnBefore > balanceStmnAfter).to.be.true; + + }, statemineApiOptions); + + + // ensure that asset has been delivered + await usingApi(async (api) => { + await waitNewBlocks(api, 3); + // expext collection id will be with id 1 + const free = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); + expect(free == TRANSFER_AMOUNT).to.be.true; + + }, uniqueApiOptions); + }); + + it('Should connect and send USDT from Unique to Statemine back', async () => { + let balanceBefore: bigint; + const uniqueApiOptions: ApiOptions = { + provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), + }; + + await usingApi(async (api) => { + balanceBefore = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); + + const destination = { + V1: { + parents: 1, + interior: {X2: [ + { + Parachain: STATEMINE_CHAIN, + }, + { + AccountId32: { + network: 'Any', + id: alice.addressRaw, + }, + }, + ]}, + }, + }; + + const currencies = [[ + { + ForeignAssetId: 0, + }, + 10_000_000_000_000_000n, + ], + [ + { + NativeAssetId: 'Parent', + }, + 400_000_000_000_000n, + ]]; + + const feeItem = 1; + const destWeight = 500000000000; + + const tx = api.tx.xTokens.transferMulticurrencies(currencies, feeItem, destination, destWeight); + const events = await submitTransactionAsync(alice, tx); + const result = getGenericResult(events); + expect(result.success).to.be.true; + + + [balanceStmnFinal] = await getBalance(api, [alice.address]); + expect(balanceStmnFinal > balanceStmnBefore).to.be.true; + + // todo do something about instant sealing, where there might not be any new blocks + await waitNewBlocks(api, 3); + const balanceAfter = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); + expect(balanceAfter < balanceBefore).to.be.true; + }, uniqueApiOptions); + }); +}); \ No newline at end of file --- a/tests/src/xcmTransfer.test.ts +++ /dev/null @@ -1,186 +0,0 @@ -// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. -// This file is part of Unique Network. - -// Unique Network is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Unique Network is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Unique Network. If not, see . - -import chai from 'chai'; -import chaiAsPromised from 'chai-as-promised'; - -import {WsProvider} from '@polkadot/api'; -import {ApiOptions} from '@polkadot/api/types'; -import {IKeyringPair} from '@polkadot/types/types'; -import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; -import {getGenericResult} from './util/helpers'; -import waitNewBlocks from './substrate/wait-new-blocks'; -import getBalance from './substrate/get-balance'; - -chai.use(chaiAsPromised); -const expect = chai.expect; - -const UNIQUE_CHAIN = 1000; -const KARURA_CHAIN = 2000; -const KARURA_PORT = '9946'; -const TRANSFER_AMOUNT = 2000000000000000000000000n; - -describe.skip('Integration test: Exchanging QTZ with Karura', () => { - let alice: IKeyringPair; - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - }); - - const karuraApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT), - }; - - await usingApi(async (api) => { - const destination = { - V0: { - X2: [ - 'Parent', - { - Parachain: UNIQUE_CHAIN, - }, - ], - }, - }; - - const metadata = - { - name: 'QTZ', - symbol: 'QTZ', - decimals: 18, - minimalBalance: 1, - }; - - const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata); - const sudoTx = api.tx.sudo.sudo(tx as any); - const events = await submitTransactionAsync(alice, sudoTx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - }, karuraApiOptions); - }); - - it('Should connect and send QTZ to Karura', async () => { - let balanceOnKaruraBefore: bigint; - - await usingApi(async (api) => { - const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; - balanceOnKaruraBefore = free; - }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); - - await usingApi(async (api) => { - const destination = { - V0: { - X2: [ - 'Parent', - { - Parachain: KARURA_CHAIN, - }, - ], - }, - }; - - const beneficiary = { - V0: { - X1: { - AccountId32: { - network: 'Any', - id: alice.addressRaw, - }, - }, - }, - }; - - const assets = { - V1: [ - { - id: { - Concrete: { - parents: 0, - interior: 'Here', - }, - }, - fun: { - Fungible: TRANSFER_AMOUNT, - }, - }, - ], - }; - - const feeAssetItem = 0; - - const weightLimit = { - Limited: 5000000000, - }; - - const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - }); - - await usingApi(async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; - expect(free > balanceOnKaruraBefore).to.be.true; - }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); - }); - - it('Should connect to Karura and send QTZ back', async () => { - let balanceBefore: bigint; - - await usingApi(async (api) => { - [balanceBefore] = await getBalance(api, [alice.address]); - }); - - await usingApi(async (api) => { - const destination = { - V1: { - parents: 1, - interior: { - X2: [ - {Parachain: UNIQUE_CHAIN}, - {AccountId32: { - network: 'Any', - id: alice.addressRaw, - }}, - ], - }, - }, - }; - - const id = { - ForeignAsset: 0, - }; - - const amount = TRANSFER_AMOUNT; - const destWeight = 50000000; - - const tx = api.tx.xTokens.transfer(id, amount, destination, destWeight); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - }, {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)}); - - await usingApi(async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - const [balanceAfter] = await getBalance(api, [alice.address]); - expect(balanceAfter > balanceBefore).to.be.true; - }); - }); -}); --- a/tests/src/xcmTransferAcala.test.ts +++ /dev/null @@ -1,249 +0,0 @@ -// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. -// This file is part of Unique Network. - -// Unique Network is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Unique Network is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Unique Network. If not, see . - -import chai from 'chai'; -import chaiAsPromised from 'chai-as-promised'; - -import {WsProvider} from '@polkadot/api'; -import {ApiOptions} from '@polkadot/api/types'; -import {IKeyringPair} from '@polkadot/types/types'; -import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; -import {getGenericResult, generateKeyringPair} from './util/helpers'; -import waitNewBlocks from './substrate/wait-new-blocks'; -import getBalance from './substrate/get-balance'; - -chai.use(chaiAsPromised); -const expect = chai.expect; - -const UNIQUE_CHAIN = 5000; -const ACALA_CHAIN = 2000; -const ACALA_PORT = '9946'; -const TRANSFER_AMOUNT = 2000000000000000000000000n; - -describe('Integration test: Exchanging UNQ with Acala', () => { - let alice: IKeyringPair; - let randomAccount: IKeyringPair; - - let balanceUniqueTokenBefore: bigint; - let balanceUniqueTokenAfter: bigint; - let balanceUniqueTokenFinal: bigint; - let balanceAcalaTokenBefore: bigint; - let balanceAcalaTokenAfter: bigint; - let balanceAcalaTokenFinal: bigint; - let balanceUniqueForeignTokenAfter: bigint; - let balanceUniqueForeignTokenBefore: bigint; - let balanceUniqueForeignTokenFinal: bigint; - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - randomAccount = generateKeyringPair(); - }); - - const acalaApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT), - }; - - await usingApi( - async (api) => { - const destination = { - V0: { - X2: [ - 'Parent', - { - Parachain: UNIQUE_CHAIN, - }, - ], - }, - }; - - const metadata = { - name: 'UNQ', - symbol: 'UNQ', - decimals: 18, - minimalBalance: 1, - }; - - const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata); - const sudoTx = api.tx.sudo.sudo(tx as any); - const events = await submitTransactionAsync(alice, sudoTx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - const tx1 = api.tx.balances.transfer(randomAccount.address, 10000000000000n); - const events1 = await submitTransactionAsync(alice, tx1); - const result1 = getGenericResult(events1); - expect(result1.success).to.be.true; - - [balanceAcalaTokenBefore] = await getBalance(api, [randomAccount.address]); - { - const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any; - balanceUniqueForeignTokenBefore = BigInt(free); - } - }, - acalaApiOptions, - ); - - await usingApi(async (api) => { - const tx0 = api.tx.balances.transfer(randomAccount.address, 10n * TRANSFER_AMOUNT); - const events0 = await submitTransactionAsync(alice, tx0); - const result0 = getGenericResult(events0); - expect(result0.success).to.be.true; - - [balanceUniqueTokenBefore] = await getBalance(api, [randomAccount.address]); - }); - }); - - it('Should connect and send UNQ to Acala', async () => { - - await usingApi(async (api) => { - - const destination = { - V0: { - X2: [ - 'Parent', - { - Parachain: ACALA_CHAIN, - }, - ], - }, - }; - - const beneficiary = { - V0: { - X1: { - AccountId32: { - network: 'Any', - id: randomAccount.addressRaw, - }, - }, - }, - }; - - const assets = { - V1: [ - { - id: { - Concrete: { - parents: 0, - interior: 'Here', - }, - }, - fun: { - Fungible: TRANSFER_AMOUNT, - }, - }, - ], - }; - - const feeAssetItem = 0; - - const weightLimit = { - Limited: 5000000000, - }; - - const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); - const events = await submitTransactionAsync(randomAccount, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - [balanceUniqueTokenAfter] = await getBalance(api, [randomAccount.address]); - - expect((balanceUniqueTokenBefore - balanceUniqueTokenAfter) > 0n).to.be.true; - }); - - await usingApi( - async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any; - balanceUniqueForeignTokenAfter = BigInt(free); - - [balanceAcalaTokenAfter] = await getBalance(api, [randomAccount.address]); - const acaFees = balanceAcalaTokenBefore - balanceAcalaTokenAfter; - const unqFees = balanceUniqueForeignTokenBefore - balanceUniqueForeignTokenAfter; - console.log('Unique to Acala transaction fees on Acala: %s ACA', acaFees); - console.log('Unique to Acala transaction fees on Acala: %s UNQ', unqFees); - expect(acaFees == 0n).to.be.true; - expect(unqFees == 0n).to.be.true; - }, - {provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT)}, - ); - }); - - it('Should connect to Acala and send UNQ back', async () => { - - await usingApi( - async (api) => { - const destination = { - V1: { - parents: 1, - interior: { - X2: [ - {Parachain: UNIQUE_CHAIN}, - { - AccountId32: { - network: 'Any', - id: randomAccount.addressRaw, - }, - }, - ], - }, - }, - }; - - const id = { - ForeignAsset: 0, - }; - - const amount = TRANSFER_AMOUNT; - const destWeight = 50000000; - - const tx = api.tx.xTokens.transfer(id, amount, destination, destWeight); - const events = await submitTransactionAsync(randomAccount, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - [balanceAcalaTokenFinal] = await getBalance(api, [randomAccount.address]); - { - const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any; - balanceUniqueForeignTokenFinal = BigInt(free); - } - - const acaFees = balanceAcalaTokenFinal - balanceAcalaTokenAfter; - const unqFees = balanceUniqueForeignTokenFinal - balanceUniqueForeignTokenAfter; - console.log('Acala to Unique transaction fees on Acala: %s ACA', acaFees); - console.log('Acala to Unique transaction fees on Acala: %s UNQ', unqFees); - expect(acaFees > 0).to.be.true; - expect(unqFees == 0n).to.be.true; - }, - {provider: new WsProvider('ws://127.0.0.1:' + ACALA_PORT)}, - ); - - await usingApi(async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - - [balanceUniqueTokenFinal] = await getBalance(api, [randomAccount.address]); - const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenAfter; - expect(actuallyDelivered > 0).to.be.true; - - const unqFees = TRANSFER_AMOUNT - actuallyDelivered; - console.log('Acala to Unique transaction fees on Unique: %s UNQ', unqFees); - expect(unqFees > 0).to.be.true; - }); - }); -}); \ No newline at end of file --- a/tests/src/xcmTransferMoonbeam.test.ts +++ /dev/null @@ -1,365 +0,0 @@ -// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. -// This file is part of Unique Network. - -// Unique Network is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Unique Network is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Unique Network. If not, see . - -import chai from 'chai'; -import chaiAsPromised from 'chai-as-promised'; - -import {Keyring, WsProvider} from '@polkadot/api'; -import {ApiOptions} from '@polkadot/api/types'; -import {IKeyringPair} from '@polkadot/types/types'; -import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; -import {getGenericResult, generateKeyringPair} from './util/helpers'; -import {MultiLocation} from '@polkadot/types/interfaces'; -import {blake2AsHex} from '@polkadot/util-crypto'; -import getBalance from './substrate/get-balance'; -import waitNewBlocks from './substrate/wait-new-blocks'; - -chai.use(chaiAsPromised); -const expect = chai.expect; - -const UNIQUE_CHAIN = 5000; -const MOONBEAM_CHAIN = 1000; -const UNIQUE_PORT = '9944'; -const MOONBEAM_PORT = '9946'; -const TRANSFER_AMOUNT = 2000000000000000000000000n; - -describe('Integration test: Exchanging UNQ with Moonbeam', () => { - - // Unique constants - let uniqueAlice: IKeyringPair; - let uniqueAssetLocation; - - let randomAccountUnique: IKeyringPair; - let randomAccountMoonbeam: IKeyringPair; - - // Moonbeam constants - let assetId: Uint8Array; - - const moonbeamKeyring = new Keyring({type: 'ethereum'}); - const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'; - const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'; - const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'; - - const alithAccount = moonbeamKeyring.addFromUri(alithPrivateKey, undefined, 'ethereum'); - const baltatharAccount = moonbeamKeyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum'); - const dorothyAccount = moonbeamKeyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum'); - - const councilVotingThreshold = 2; - const technicalCommitteeThreshold = 2; - const votingPeriod = 3; - const delayPeriod = 0; - - const uniqueAssetMetadata = { - name: 'xcUnique', - symbol: 'xcUNQ', - decimals: 18, - isFrozen: false, - minimalBalance: 1, - }; - - // let actuallySent1: bigint; - // let actuallySent2: bigint; - - // let balanceUnique1: bigint; - // let balanceUnique2: bigint; - // let balanceUnique3: bigint; - - // let balanceMoonbeamGlmr1: bigint; - // let balanceMoonbeamGlmr2: bigint; - // let balanceMoonbeamGlmr3: bigint; - - let balanceUniqueTokenBefore: bigint; - let balanceUniqueTokenAfter: bigint; - let balanceUniqueTokenFinal: bigint; - let balanceGlmrTokenBefore: bigint; - let balanceGlmrTokenAfter: bigint; - let balanceGlmrTokenFinal: bigint; - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - uniqueAlice = privateKeyWrapper('//Alice'); - randomAccountUnique = generateKeyringPair(); - randomAccountMoonbeam = generateKeyringPair('ethereum'); - }); - - const moonbeamApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT), - }; - - await usingApi( - async (api) => { - - // >>> Sponsoring Dorothy >>> - const tx0 = api.tx.balances.transfer(dorothyAccount.address, 11_000_000_000_000_000_000n); - const events0 = await submitTransactionAsync(alithAccount, tx0); - const result0 = getGenericResult(events0); - expect(result0.success).to.be.true; - // <<< Sponsoring Dorothy <<< - - const sourceLocation: MultiLocation = api.createType( - 'MultiLocation', - { - parents: 1, - interior: {X1: {Parachain: UNIQUE_CHAIN}}, - }, - ); - - assetId = api.registry.hash(sourceLocation.toU8a()).slice(0, 16).reverse(); - console.log('Internal asset ID is %s', assetId); - uniqueAssetLocation = {XCM: sourceLocation}; - const existentialDeposit = 1; - const isSufficient = true; - const unitsPerSecond = '1'; - const numAssetsWeightHint = 0; - - const registerTx = api.tx.assetManager.registerForeignAsset( - uniqueAssetLocation, - uniqueAssetMetadata, - existentialDeposit, - isSufficient, - ); - console.log('Encoded proposal for registerAsset is %s', registerTx.method.toHex() || ''); - - const setUnitsTx = api.tx.assetManager.setAssetUnitsPerSecond( - uniqueAssetLocation, - unitsPerSecond, - numAssetsWeightHint, - ); - console.log('Encoded proposal for setAssetUnitsPerSecond is %s', setUnitsTx.method.toHex() || ''); - - const batchCall = api.tx.utility.batchAll([registerTx, setUnitsTx]); - console.log('Encoded proposal for batchCall is %s', batchCall.method.toHex() || ''); - - // >>> Note motion preimage >>> - const encodedProposal = batchCall?.method.toHex() || ''; - const proposalHash = blake2AsHex(encodedProposal); - console.log('Encoded proposal for batch utility after schedule is %s', encodedProposal); - console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash); - console.log('Encoded length %d', encodedProposal.length); - - const tx1 = api.tx.democracy.notePreimage(encodedProposal); - const events1 = await submitTransactionAsync(baltatharAccount, tx1); - const result1 = getGenericResult(events1); - expect(result1.success).to.be.true; - // <<< Note motion preimage <<< - - // >>> Propose external motion through council >>> - const externalMotion = api.tx.democracy.externalProposeMajority(proposalHash); - const tx2 = api.tx.councilCollective.propose( - councilVotingThreshold, - externalMotion, - externalMotion.encodedLength, - ); - const events2 = await submitTransactionAsync(baltatharAccount, tx2); - const result2 = getGenericResult(events2); - expect(result2.success).to.be.true; - - const encodedMotion = externalMotion?.method.toHex() || ''; - const motionHash = blake2AsHex(encodedMotion); - console.log('Motion hash is %s', motionHash); - - const tx3 = api.tx.councilCollective.vote(motionHash, 0, true); - { - const events3 = await submitTransactionAsync(dorothyAccount, tx3); - const result3 = getGenericResult(events3); - expect(result3.success).to.be.true; - } - { - const events3 = await submitTransactionAsync(baltatharAccount, tx3); - const result3 = getGenericResult(events3); - expect(result3.success).to.be.true; - } - - const tx4 = api.tx.councilCollective.close(motionHash, 0, 1_000_000_000, externalMotion.encodedLength); - const events4 = await submitTransactionAsync(dorothyAccount, tx4); - const result4 = getGenericResult(events4); - expect(result4.success).to.be.true; - // <<< Propose external motion through council <<< - - // >>> Fast track proposal through technical committee >>> - const fastTrack = api.tx.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod); - const tx5 = api.tx.techCommitteeCollective.propose( - technicalCommitteeThreshold, - fastTrack, - fastTrack.encodedLength, - ); - const events5 = await submitTransactionAsync(alithAccount, tx5); - const result5 = getGenericResult(events5); - expect(result5.success).to.be.true; - - const encodedFastTrack = fastTrack?.method.toHex() || ''; - const fastTrackHash = blake2AsHex(encodedFastTrack); - console.log('FastTrack hash is %s', fastTrackHash); - - const proposalIdx = Number(await api.query.techCommitteeCollective.proposalCount()) - 1; - const tx6 = api.tx.techCommitteeCollective.vote(fastTrackHash, proposalIdx, true); - { - const events6 = await submitTransactionAsync(baltatharAccount, tx6); - const result6 = getGenericResult(events6); - expect(result6.success).to.be.true; - } - { - const events6 = await submitTransactionAsync(alithAccount, tx6); - const result6 = getGenericResult(events6); - expect(result6.success).to.be.true; - } - - const tx7 = api.tx.techCommitteeCollective - .close(fastTrackHash, proposalIdx, 1_000_000_000, fastTrack.encodedLength); - const events7 = await submitTransactionAsync(baltatharAccount, tx7); - const result7 = getGenericResult(events7); - expect(result7.success).to.be.true; - // <<< Fast track proposal through technical committee <<< - - // >>> Referendum voting >>> - const tx8 = api.tx.democracy.vote( - 0, - {Standard: {balance: 10_000_000_000_000_000_000n, vote: {aye: true, conviction: 1}}}, - ); - const events8 = await submitTransactionAsync(dorothyAccount, tx8); - const result8 = getGenericResult(events8); - expect(result8.success).to.be.true; - // <<< Referendum voting <<< - - // >>> Sponsoring random Account >>> - const tx9 = api.tx.balances.transfer(randomAccountMoonbeam.address, 11_000_000_000_000_000_000n); - const events9 = await submitTransactionAsync(baltatharAccount, tx9); - const result9 = getGenericResult(events9); - expect(result9.success).to.be.true; - // <<< Sponsoring random Account <<< - - [balanceGlmrTokenBefore] = await getBalance(api, [randomAccountMoonbeam.address]); - }, - moonbeamApiOptions, - ); - - await usingApi(async (api) => { - const tx0 = api.tx.balances.transfer(randomAccountUnique.address, 10n * TRANSFER_AMOUNT); - const events0 = await submitTransactionAsync(uniqueAlice, tx0); - const result0 = getGenericResult(events0); - expect(result0.success).to.be.true; - - [balanceUniqueTokenBefore] = await getBalance(api, [randomAccountUnique.address]); - }); - }); - - it('Should connect and send UNQ to Moonbeam', async () => { - await usingApi(async (api) => { - const currencyId = { - NativeAssetId: 'Here', - }; - const dest = { - V1: { - parents: 1, - interior: { - X2: [ - {Parachain: MOONBEAM_CHAIN}, - {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}}, - ], - }, - }, - }; - const amount = TRANSFER_AMOUNT; - const destWeight = 50000000; - - const tx = api.tx.xTokens.transfer(currencyId, amount, dest, destWeight); - const events = await submitTransactionAsync(uniqueAlice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - [balanceUniqueTokenAfter] = await getBalance(api, [randomAccountUnique.address]); - expect(balanceUniqueTokenAfter < balanceUniqueTokenBefore).to.be.true; - - const transactionFees = balanceUniqueTokenBefore - balanceUniqueTokenAfter - TRANSFER_AMOUNT; - console.log('Unique to Moonbeam transaction fees on Unique: %s UNQ', transactionFees); - expect(transactionFees > 0).to.be.true; - }); - - await usingApi( - async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - - [balanceGlmrTokenAfter] = await getBalance(api, [randomAccountMoonbeam.address]); - - const glmrFees = balanceGlmrTokenBefore - balanceGlmrTokenAfter; - console.log('Unique to Moonbeam transaction fees on Moonbeam: %s GLMR', glmrFees); - expect(glmrFees == 0n).to.be.true; - }, - {provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT)}, - ); - }); - - it('Should connect to Moonbeam and send UNQ back', async () => { - await usingApi( - async (api) => { - const amount = TRANSFER_AMOUNT / 2n; - const asset = { - V1: { - id: { - Concrete: { - parents: 1, - interior: { - X1: {Parachain: UNIQUE_CHAIN}, - }, - }, - }, - fun: { - Fungible: amount, - }, - }, - }; - const destination = { - V1: { - parents: 1, - interior: { - X2: [ - {Parachain: UNIQUE_CHAIN}, - {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}}, - ], - }, - }, - }; - const destWeight = 50000000; - - const tx = api.tx.xTokens.transferMultiasset(asset, destination, destWeight); - const events = await submitTransactionAsync(randomAccountMoonbeam, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - [balanceGlmrTokenFinal] = await getBalance(api, [randomAccountMoonbeam.address]); - - const glmrFees = balanceGlmrTokenAfter - balanceGlmrTokenFinal; - console.log('Moonbeam to Unique transaction fees on Moonbeam: %s GLMR', glmrFees); - expect(glmrFees > 0).to.be.true; - }, - {provider: new WsProvider('ws://127.0.0.1:' + MOONBEAM_PORT)}, - ); - - await usingApi(async (api) => { - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - - [balanceUniqueTokenFinal] = await getBalance(api, [randomAccountUnique.address]); - const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenAfter; - expect(actuallyDelivered > 0).to.be.true; - - const unqFees = TRANSFER_AMOUNT - actuallyDelivered; - console.log('Moonbeam to Unique transaction fees on Unique: %s UNQ', unqFees); - expect(unqFees > 0).to.be.true; - }); - }); -}); --- a/tests/src/xcmTransferStatemine.test.ts +++ /dev/null @@ -1,322 +0,0 @@ -// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. -// This file is part of Unique Network. - -// Unique Network is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Unique Network is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Unique Network. If not, see . - -import chai from 'chai'; -import chaiAsPromised from 'chai-as-promised'; - -import {WsProvider} from '@polkadot/api'; -import {ApiOptions} from '@polkadot/api/types'; -import {IKeyringPair} from '@polkadot/types/types'; -import usingApi, {submitTransactionAsync} from './substrate/substrate-api'; -import {getGenericResult} from './util/helpers'; -import waitNewBlocks from './substrate/wait-new-blocks'; -import {normalizeAccountId} from './util/helpers'; - - -chai.use(chaiAsPromised); -const expect = chai.expect; - -const RELAY_PORT = '9844'; -const UNIQUE_CHAIN = 2037; -const UNIQUE_PORT = '9944'; -const STATEMINE_CHAIN = 1000; -const STATEMINE_PORT = '9946'; -const STATEMINE_PALLET_INSTANCE = 50; -const ASSET_ID = 100; -const ASSET_METADATA_DECIMALS = 18; -const ASSET_METADATA_NAME = 'USDT'; -const ASSET_METADATA_DESCRIPTION = 'USDT'; -const ASSET_METADATA_MINIMAL_BALANCE = 1; - -describe('Integration test: Exchanging USDT with Statemine', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - bob = privateKeyWrapper('//Bob'); // funds donor - }); - - const statemineApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + STATEMINE_PORT), - }; - - const uniqueApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), - }; - - const relayApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + RELAY_PORT), - }; - - await usingApi(async (api) => { - - // 10,000.00 (ten thousands) USDT - const assetAmount = 1_000_000_000_000_000_000_000n; - // 350.00 (three hundred fifty) DOT - const fundingAmount = 3_500_000_000_000; - - const tx = api.tx.assets.create(ASSET_ID, alice.addressRaw, ASSET_METADATA_MINIMAL_BALANCE); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - // set metadata - const tx2 = api.tx.assets.setMetadata(ASSET_ID, ASSET_METADATA_NAME, ASSET_METADATA_DESCRIPTION, ASSET_METADATA_DECIMALS); - const events2 = await submitTransactionAsync(alice, tx2); - const result2 = getGenericResult(events2); - expect(result2.success).to.be.true; - - // mint some amount of asset - const tx3 = api.tx.assets.mint(ASSET_ID, alice.addressRaw, assetAmount); - const events3 = await submitTransactionAsync(alice, tx3); - const result3 = getGenericResult(events3); - expect(result3.success).to.be.true; - - // funding parachain sovereing account (Parachain: 2037) - //const parachainSovereingAccount = '0x70617261f5070000000000000000000000000000000000000000000000000000'; - const parachainSovereingAccount = '0x7369626cf5070000000000000000000000000000000000000000000000000000'; - const tx4 = api.tx.balances.transfer(parachainSovereingAccount, fundingAmount); - const events4 = await submitTransactionAsync(bob, tx4); - const result4 = getGenericResult(events4); - expect(result4.success).to.be.true; - - }, statemineApiOptions); - - - await usingApi(async (api) => { - - const location = { - V1: { - parents: 1, - interior: {X3: [ - { - Parachain: STATEMINE_CHAIN, - }, - { - PalletInstance: STATEMINE_PALLET_INSTANCE, - }, - { - GeneralIndex: ASSET_ID, - }, - ]}, - }, - }; - - const metadata = - { - name: ASSET_ID, - symbol: ASSET_METADATA_NAME, - decimals: ASSET_METADATA_DECIMALS, - minimalBalance: ASSET_METADATA_MINIMAL_BALANCE, - }; - //registerForeignAsset(owner, location, metadata) - const tx = api.tx.foreingAssets.registerForeignAsset(alice.addressRaw, location, metadata); - const sudoTx = api.tx.sudo.sudo(tx as any); - const events = await submitTransactionAsync(alice, sudoTx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - }, uniqueApiOptions); - - - // Providing the relay currency to the unique sender account - await usingApi(async (api) => { - const destination = { - V1: { - parents: 0, - interior: {X1: { - Parachain: UNIQUE_CHAIN, - }, - }, - }}; - - const beneficiary = { - V1: { - parents: 0, - interior: {X1: { - AccountId32: { - network: 'Any', - id: alice.addressRaw, - }, - }}, - }, - }; - - const assets = { - V1: [ - { - id: { - Concrete: { - parents: 0, - interior: 'Here', - }, - }, - fun: { - Fungible: 50_000_000_000_000_000n, - }, - }, - ], - }; - - const feeAssetItem = 0; - - const weightLimit = { - Limited: 5_000_000_000, - }; - - const tx = api.tx.xcmPallet.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - }, relayApiOptions); - - }); - - it('Should connect and send USDT from Statemine to Unique', async () => { - - const statemineApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + STATEMINE_PORT), - }; - - const uniqueApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), - }; - - await usingApi(async (api) => { - - const dest = { - V1: { - parents: 1, - interior: {X1: { - Parachain: UNIQUE_CHAIN, - }, - }, - }}; - - const beneficiary = { - V1: { - parents: 0, - interior: {X1: { - AccountId32: { - network: 'Any', - id: alice.addressRaw, - }, - }}, - }, - }; - - const assets = { - V1: [ - { - id: { - Concrete: { - parents: 0, - interior: { - X2: [ - { - PalletInstance: STATEMINE_PALLET_INSTANCE, - }, - { - GeneralIndex: ASSET_ID, - }, - ]}, - }, - }, - fun: { - Fungible: 1_000_000_000_000_000_000n, - }, - }, - ], - }; - - const feeAssetItem = 0; - - const weightLimit = { - Limited: 5000000000, - }; - - const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(dest, beneficiary, assets, feeAssetItem, weightLimit); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - }, statemineApiOptions); - - - // ensure that asset has been delivered - await usingApi(async (api) => { - await waitNewBlocks(api, 3); - // expext collection id will be with id 1 - const free = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); - expect(free > 0).to.be.true; - }, uniqueApiOptions); - }); - - it('Should connect and send USDT from Unique to Statemine back', async () => { - let balanceBefore: bigint; - const uniqueApiOptions: ApiOptions = { - provider: new WsProvider('ws://127.0.0.1:' + UNIQUE_PORT), - }; - - await usingApi(async (api) => { - balanceBefore = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); - - const destination = { - V1: { - parents: 1, - interior: {X2: [ - { - Parachain: STATEMINE_CHAIN, - }, - { - AccountId32: { - network: 'Any', - id: alice.addressRaw, - }, - }, - ]}, - }, - }; - - const currencies = [[ - { - ForeignAssetId: 0, - }, - 10_000_000_000_000_000n, - ], - [ - { - NativeAssetId: 'Parent', - }, - 400_000_000_000_000n, - ]]; - - const feeItem = 1; - const destWeight = 500000000000; - - const tx = api.tx.xTokens.transferMulticurrencies(currencies, feeItem, destination, destWeight); - const events = await submitTransactionAsync(alice, tx); - const result = getGenericResult(events); - expect(result.success).to.be.true; - - // todo do something about instant sealing, where there might not be any new blocks - await waitNewBlocks(api, 3); - const balanceAfter = (await api.query.fungible.balance(1, normalizeAccountId(alice.address))).toBigInt(); - expect(balanceAfter < balanceBefore).to.be.true; - }, uniqueApiOptions); - }); -}); \ No newline at end of file -- gitstuff