difftreelog
fix remove outdated xcm tests
in: master
4 files changed
tests/src/xcm/xcmTransfer.test.tsdiffbeforeafterboth--- a/tests/src/xcm/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 <http://www.gnu.org/licenses/>.
-
-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;
- });
- });
-});
tests/src/xcm/xcmTransferAcala.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmTransferAcala.test.ts
+++ /dev/null
@@ -1,265 +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 <http://www.gnu.org/licenses/>.
-
-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
tests/src/xcm/xcmTransferMoonbeam.test.tsdiffbeforeafterbothno changes
tests/src/xcm/xcmTransferStatemine.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmTransferStatemine.test.ts
+++ /dev/null
@@ -1,360 +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 <http://www.gnu.org/licenses/>.
-
-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 = '9948';
-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