--- /dev/null
+++ b/tests/src/xcmTransferAcala.test.ts
@@ -0,0 +1,260 @@
+// 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 actuallySent1: bigint;
+ let actuallySent2: bigint;
+
+ let balanceUnique1: bigint;
+ let balanceUnique2: bigint;
+ let balanceUnique3: bigint;
+
+ let balanceAcalaUnq1: bigint;
+ let balanceAcalaUnq2: bigint;
+ let balanceAcalaUnq3: bigint;
+
+ let balanceAcalaAca1: bigint;
+ let balanceAcalaAca2: bigint;
+ let balanceAcalaAca3: 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;
+
+ [balanceAcalaAca1] = await getBalance(api, [randomAccount.address]);
+ {
+ const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceAcalaUnq1 = 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;
+
+ [balanceUnique1] = 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;
+
+ [balanceUnique2] = await getBalance(api, [randomAccount.address]);
+
+ const transactionFees = balanceUnique1 - balanceUnique2 - TRANSFER_AMOUNT;
+ actuallySent1 = TRANSFER_AMOUNT; // Why not TRANSFER_AMOUNT - transactionFees ???
+ console.log('Unique to Acala 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);
+ const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceAcalaUnq2 = BigInt(free);
+ expect(balanceAcalaUnq2 > balanceAcalaUnq1).to.be.true;
+
+ [balanceAcalaAca2] = await getBalance(api, [randomAccount.address]);
+
+ const acaFees = balanceAcalaAca1 - balanceAcalaAca2;
+ const unqFees = actuallySent1 - balanceAcalaUnq2 + balanceAcalaUnq1;
+ 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;
+
+ [balanceAcalaAca3] = await getBalance(api, [randomAccount.address]);
+ {
+ const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceAcalaUnq3 = BigInt(free);
+ }
+
+ const acaFees = balanceAcalaAca2 - balanceAcalaAca3;
+ const unqFees = balanceAcalaUnq2 - balanceAcalaUnq3 - amount;
+ actuallySent2 = amount; // Why not amount - UNQFees ???
+ 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);
+
+ [balanceUnique3] = await getBalance(api, [randomAccount.address]);
+ const actuallyDelivered = balanceUnique3 - balanceUnique2;
+ expect(actuallyDelivered > 0).to.be.true;
+
+ const unqFees = actuallySent2 - 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/xcmTransferKarura.test.ts
@@ -0,0 +1,260 @@
+// 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 KARURA_CHAIN = 2000;
+const KARURA_PORT = '9946';
+const TRANSFER_AMOUNT = 2000000000000000000000000n;
+
+describe('Integration test: Exchanging QTZ with Karura', () => {
+ let alice: IKeyringPair;
+ let randomAccount: IKeyringPair;
+
+ let actuallySent1: bigint;
+ let actuallySent2: bigint;
+
+ let balanceQuartz1: bigint;
+ let balanceQuartz2: bigint;
+ let balanceQuartz3: bigint;
+
+ let balanceKaruraQtz1: bigint;
+ let balanceKaruraQtz2: bigint;
+ let balanceKaruraQtz3: bigint;
+
+ let balanceKaruraKar1: bigint;
+ let balanceKaruraKar2: bigint;
+ let balanceKaruraKar3: bigint;
+
+ before(async () => {
+ await usingApi(async (api, privateKeyWrapper) => {
+ alice = privateKeyWrapper('//Alice');
+ randomAccount = generateKeyringPair();
+ });
+
+ 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;
+
+ 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;
+
+ [balanceKaruraKar1] = await getBalance(api, [randomAccount.address]);
+ {
+ const {free} = (await api.query.tokens.accounts(alice.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceKaruraQtz1 = BigInt(free);
+ }
+ },
+ karuraApiOptions,
+ );
+
+ 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;
+
+ [balanceQuartz1] = await getBalance(api, [randomAccount.address]);
+ });
+ });
+
+ it('Should connect and send QTZ to Karura', async () => {
+
+ await usingApi(async (api) => {
+
+ const destination = {
+ V0: {
+ X2: [
+ 'Parent',
+ {
+ Parachain: KARURA_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;
+
+ [balanceQuartz2] = await getBalance(api, [randomAccount.address]);
+
+ const transactionFees = balanceQuartz1 - balanceQuartz2 - TRANSFER_AMOUNT;
+ actuallySent1 = TRANSFER_AMOUNT; // Why not TRANSFER_AMOUNT - transactionFees ???
+ console.log('Quartz to Karura transaction fees on Quartz: %s QTZ', 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);
+ const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceKaruraQtz2 = BigInt(free);
+ expect(balanceKaruraQtz2 > balanceKaruraQtz1).to.be.true;
+
+ [balanceKaruraKar2] = await getBalance(api, [randomAccount.address]);
+
+ const karFees = balanceKaruraKar1 - balanceKaruraKar2;
+ const qtzFees = actuallySent1 - balanceKaruraQtz2 + balanceKaruraQtz1;
+ console.log('Quartz to Karura transaction fees on Karura: %s KAR', karFees);
+ console.log('Quartz to Karura transaction fees on Karura: %s QTZ', qtzFees);
+ expect(karFees == 0n).to.be.true;
+ expect(qtzFees == 0n).to.be.true;
+ },
+ {provider: new WsProvider('ws://127.0.0.1:' + KARURA_PORT)},
+ );
+ });
+
+ it('Should connect to Karura and send QTZ 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;
+
+ [balanceKaruraKar3] = await getBalance(api, [randomAccount.address]);
+ {
+ const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+ balanceKaruraQtz3 = BigInt(free);
+ }
+
+ const karFees = balanceKaruraKar2 - balanceKaruraKar3;
+ const qtzFees = balanceKaruraQtz2 - balanceKaruraQtz3 - amount;
+ actuallySent2 = amount; // Why not amount - qtzFees ???
+ console.log('Karura to Quartz transaction fees on Karura: %s KAR', karFees);
+ console.log('Karura to Quartz transaction fees on Karura: %s QTZ', qtzFees);
+ expect(karFees > 0).to.be.true;
+ expect(qtzFees == 0n).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);
+
+ [balanceQuartz3] = await getBalance(api, [randomAccount.address]);
+ const actuallyDelivered = balanceQuartz3 - balanceQuartz2;
+ expect(actuallyDelivered > 0).to.be.true;
+
+ const qtzFees = actuallySent2 - actuallyDelivered;
+ console.log('Karura to Quartz transaction fees on Quartz: %s QTZ', qtzFees);
+ expect(qtzFees > 0).to.be.true;
+ });
+ });
+});
\ No newline at end of file
--- /dev/null
+++ b/tests/src/xcmTransferMoonbeam.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 {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;
+
+ 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 <<<
+
+ [balanceMoonbeamGlmr1] = 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;
+
+ [balanceUnique1] = 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;
+
+ [balanceUnique2] = await getBalance(api, [randomAccountUnique.address]);
+ expect(balanceUnique2 < balanceUnique1).to.be.true;
+
+ const transactionFees = balanceUnique1 - balanceUnique2 - TRANSFER_AMOUNT;
+ actuallySent1 = TRANSFER_AMOUNT; // Why not TRANSFER_AMOUNT - transactionFees ???
+ 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);
+
+ [balanceMoonbeamGlmr2] = await getBalance(api, [randomAccountMoonbeam.address]);
+
+ const glmrFees = balanceMoonbeamGlmr1 - balanceMoonbeamGlmr2;
+ 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;
+
+ [balanceMoonbeamGlmr3] = await getBalance(api, [randomAccountMoonbeam.address]);
+
+ const glmrFees = balanceMoonbeamGlmr2 - balanceMoonbeamGlmr3;
+ actuallySent2 = amount;
+ 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);
+
+ [balanceUnique3] = await getBalance(api, [randomAccountUnique.address]);
+ const actuallyDelivered = balanceUnique3 - balanceUnique2;
+ expect(actuallyDelivered > 0).to.be.true;
+
+ const unqFees = actuallySent2 - actuallyDelivered;
+ console.log('Moonbeam to Unique transaction fees on Unique: %s UNQ', unqFees);
+ expect(unqFees > 0).to.be.true;
+ });
+ });
+});
--- /dev/null
+++ b/tests/src/xcmTransferMoonriver.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 {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 QUARTZ_CHAIN = 5000;
+const MOONRIVER_CHAIN = 1000;
+const QUARTZ_PORT = '9944';
+const MOONRIVER_PORT = '9946';
+const TRANSFER_AMOUNT = 2000000000000000000000000n;
+
+describe('Integration test: Exchanging QTZ with Moonriver', () => {
+
+ // Unique constants
+ let quartzAlice: IKeyringPair;
+ let quartzAssetLocation;
+
+ let randomAccountQuartz: IKeyringPair;
+ let randomAccountMoonriver: IKeyringPair;
+
+ // Moonriver constants
+ let assetId: Uint8Array;
+
+ const moonriverKeyring = new Keyring({type: 'ethereum'});
+ const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';
+ const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';
+ const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';
+
+ const alithAccount = moonriverKeyring.addFromUri(alithPrivateKey, undefined, 'ethereum');
+ const baltatharAccount = moonriverKeyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');
+ const dorothyAccount = moonriverKeyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');
+
+ const councilVotingThreshold = 2;
+ const technicalCommitteeThreshold = 2;
+ const votingPeriod = 3;
+ const delayPeriod = 0;
+
+ const uniqueAssetMetadata = {
+ name: 'xcQuartz',
+ symbol: 'xcQTZ',
+ decimals: 18,
+ isFrozen: false,
+ minimalBalance: 1,
+ };
+
+ let actuallySent1: bigint;
+ let actuallySent2: bigint;
+
+ let balanceQuartz1: bigint;
+ let balanceQuartz2: bigint;
+ let balanceQuartz3: bigint;
+
+ let balanceMoonriverMovr1: bigint;
+ let balanceMoonriverMovr2: bigint;
+ let balanceMoonriverMovr3: bigint;
+
+ before(async () => {
+ await usingApi(async (api, privateKeyWrapper) => {
+ quartzAlice = privateKeyWrapper('//Alice');
+ randomAccountQuartz = generateKeyringPair();
+ randomAccountMoonriver = generateKeyringPair('ethereum');
+ });
+
+ const moonriverApiOptions: ApiOptions = {
+ provider: new WsProvider('ws://127.0.0.1:' + MOONRIVER_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: QUARTZ_CHAIN}},
+ },
+ );
+
+ assetId = api.registry.hash(sourceLocation.toU8a()).slice(0, 16).reverse();
+ console.log('Internal asset ID is %s', assetId);
+ quartzAssetLocation = {XCM: sourceLocation};
+ const existentialDeposit = 1;
+ const isSufficient = true;
+ const unitsPerSecond = '1';
+ const numAssetsWeightHint = 0;
+
+ const registerTx = api.tx.assetManager.registerForeignAsset(
+ quartzAssetLocation,
+ uniqueAssetMetadata,
+ existentialDeposit,
+ isSufficient,
+ );
+ console.log('Encoded proposal for registerAsset is %s', registerTx.method.toHex() || '');
+
+ const setUnitsTx = api.tx.assetManager.setAssetUnitsPerSecond(
+ quartzAssetLocation,
+ 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(randomAccountMoonriver.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 <<<
+
+ [balanceMoonriverMovr1] = await getBalance(api, [randomAccountMoonriver.address]);
+ },
+ moonriverApiOptions,
+ );
+
+ await usingApi(async (api) => {
+ const tx0 = api.tx.balances.transfer(randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
+ const events0 = await submitTransactionAsync(quartzAlice, tx0);
+ const result0 = getGenericResult(events0);
+ expect(result0.success).to.be.true;
+
+ [balanceQuartz1] = await getBalance(api, [randomAccountQuartz.address]);
+ });
+ });
+
+ it('Should connect and send QTZ to Moonriver', async () => {
+ await usingApi(async (api) => {
+ const currencyId = {
+ NativeAssetId: 'Here',
+ };
+ const dest = {
+ V1: {
+ parents: 1,
+ interior: {
+ X2: [
+ {Parachain: MOONRIVER_CHAIN},
+ {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},
+ ],
+ },
+ },
+ };
+ const amount = TRANSFER_AMOUNT;
+ const destWeight = 50000000;
+
+ const tx = api.tx.xTokens.transfer(currencyId, amount, dest, destWeight);
+ const events = await submitTransactionAsync(quartzAlice, tx);
+ const result = getGenericResult(events);
+ expect(result.success).to.be.true;
+
+ [balanceQuartz2] = await getBalance(api, [randomAccountQuartz.address]);
+ expect(balanceQuartz2 < balanceQuartz1).to.be.true;
+
+ const transactionFees = balanceQuartz1 - balanceQuartz2 - TRANSFER_AMOUNT;
+ actuallySent1 = TRANSFER_AMOUNT; // Why not TRANSFER_AMOUNT - transactionFees ???
+ console.log('Quartz to Moonriver transaction fees on Quartz: %s QTZ', 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);
+
+ [balanceMoonriverMovr2] = await getBalance(api, [randomAccountMoonriver.address]);
+
+ const movrFees = balanceMoonriverMovr1 - balanceMoonriverMovr2;
+ console.log('Quartz to Moonriver transaction fees on Moonriver: %s MOVR', movrFees);
+ expect(movrFees == 0n).to.be.true;
+ },
+ {provider: new WsProvider('ws://127.0.0.1:' + MOONRIVER_PORT)},
+ );
+ });
+
+ it('Should connect to Moonriver and send QTZ back', async () => {
+ await usingApi(
+ async (api) => {
+ const amount = TRANSFER_AMOUNT / 2n;
+ const asset = {
+ V1: {
+ id: {
+ Concrete: {
+ parents: 1,
+ interior: {
+ X1: {Parachain: QUARTZ_CHAIN},
+ },
+ },
+ },
+ fun: {
+ Fungible: amount,
+ },
+ },
+ };
+ const destination = {
+ V1: {
+ parents: 1,
+ interior: {
+ X2: [
+ {Parachain: QUARTZ_CHAIN},
+ {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},
+ ],
+ },
+ },
+ };
+ const destWeight = 50000000;
+
+ const tx = api.tx.xTokens.transferMultiasset(asset, destination, destWeight);
+ const events = await submitTransactionAsync(randomAccountMoonriver, tx);
+ const result = getGenericResult(events);
+ expect(result.success).to.be.true;
+
+ [balanceMoonriverMovr3] = await getBalance(api, [randomAccountMoonriver.address]);
+
+ const movrFees = balanceMoonriverMovr2 - balanceMoonriverMovr3;
+ actuallySent2 = amount;
+ console.log('Moonriver to Quartz transaction fees on Moonriver: %s MOVR', movrFees);
+ expect(movrFees > 0).to.be.true;
+ },
+ {provider: new WsProvider('ws://127.0.0.1:' + MOONRIVER_PORT)},
+ );
+
+ await usingApi(async (api) => {
+ // todo do something about instant sealing, where there might not be any new blocks
+ await waitNewBlocks(api, 3);
+
+ [balanceQuartz3] = await getBalance(api, [randomAccountQuartz.address]);
+ const actuallyDelivered = balanceQuartz3 - balanceQuartz2;
+ expect(actuallyDelivered > 0).to.be.true;
+
+ const qtzFees = actuallySent2 - actuallyDelivered;
+ console.log('Moonriver to Quartz transaction fees on Quartz: %s QTZ', qtzFees);
+ expect(qtzFees > 0).to.be.true;
+ });
+ });
+});
--- /dev/null
+++ b/tests/src/xcmTransferStatemine.test.ts
@@ -0,0 +1,321 @@
+// 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 = 5000;
+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: 5000)
+ const parachainSovereingAccount = '0x7369626c88130000000000000000000000000000000000000000000000000000';
+ 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