difftreelog
Fixes after review
in: master
6 files changed
.docker/xcm-config/launch-config-xcm-quartz.j2diffbeforeafterboth--- a/.docker/xcm-config/launch-config-xcm-quartz.j2
+++ b/.docker/xcm-config/launch-config-xcm-quartz.j2
@@ -169,7 +169,7 @@
{
"bin": "/astar/target/release/astar",
"id": "2007",
- "chain": "astar-dev",
+ "chain": "shiden-dev",
"balance": "1000000000000000000000000",
"nodes": [
{
@@ -224,12 +224,12 @@
},
{
"sender": 2007,
- "recipient": 1000,
+ "recipient": 2095,
"maxCapacity": 8,
"maxMessageSize": 512
},
{
- "sender": 1000,
+ "sender": 2095,
"recipient": 2007,
"maxCapacity": 8,
"maxMessageSize": 512
.docker/xcm-config/launch-config-xcm-unique.j2diffbeforeafterboth--- a/.docker/xcm-config/launch-config-xcm-unique.j2
+++ b/.docker/xcm-config/launch-config-xcm-unique.j2
@@ -224,12 +224,12 @@
},
{
"sender": 2006,
- "recipient": 1000,
+ "recipient": 2037,
"maxCapacity": 8,
"maxMessageSize": 512
},
{
- "sender": 1000,
+ "sender": 2037,
"recipient": 2006,
"maxCapacity": 8,
"maxMessageSize": 512
tests/src/util/index.tsdiffbeforeafterboth--- a/tests/src/util/index.ts
+++ b/tests/src/util/index.ts
@@ -11,7 +11,7 @@
import config from '../config';
import {ChainHelperBase} from './playgrounds/unique';
import {ILogger} from './playgrounds/types';
-import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper} from './playgrounds/unique.dev';
+import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper} from './playgrounds/unique.dev';
import {dirname} from 'path';
import {fileURLToPath} from 'url';
@@ -105,6 +105,9 @@
return usingPlaygroundsGeneral<DevAstarHelper>(DevAstarHelper, url, code);
};
+export const usingShidenPlaygrounds = (url: string, code: (helper: DevShidenHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevShidenHelper>(DevShidenHelper, url, code);
+};
export const MINIMUM_DONOR_FUND = 100_000n;
export const DONOR_FUNDING = 2_000_000n;
tests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -184,6 +184,17 @@
}
}
+export class DevShidenHelper extends AstarHelper {
+ wait: WaitGroup;
+
+ constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
+ options.helperBase = options.helperBase ?? DevShidenHelper;
+
+ super(logger, options);
+ this.wait = new WaitGroup(this);
+ }
+}
+
export class DevAcalaHelper extends AcalaHelper {
wait: WaitGroup;
tests/src/xcm/xcmQuartz.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmQuartz.test.ts
+++ b/tests/src/xcm/xcmQuartz.test.ts
@@ -18,7 +18,7 @@
import {blake2AsHex} from '@polkadot/util-crypto';
import config from '../config';
import {XcmV2TraitsError} from '../interfaces';
-import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingAstarPlaygrounds} from '../util';
+import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util';
const QUARTZ_CHAIN = 2095;
const STATEMINE_CHAIN = 1000;
@@ -983,19 +983,28 @@
describeXCM('[XCM] Integration test: Exchanging tokens with Shiden', () => {
let alice: IKeyringPair;
- let randomAccount: IKeyringPair;
+ let sender: IKeyringPair;
+
+ // Quartz -> Shiden
+ const shidenInitialBalance = 1n * (10n ** 18n); // 1 SHD, existencial deposit required in order to perform XCM call
+ const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?
+ const qtzToShidenTransferred = 10n * (10n ** 18n); // 10 QTZ
+ const qtzToShidenArrived = 9_999_999_999_088_000_000n; // 9.999 ... QTZ, Shiden takes a commision in foreign tokens
+ const senderIinitialBalanceQTZ = 100n * (10n ** 18n); // How many QTZ sender has initially
+ const senderBalanceAfterXCM = 89_941967662676666465n; // 89.94... QTZ after XCM call
- const shidenInitialBalance = 1n * (10n ** 18n);
- const qtzToShidenAmount = 10n * (10n ** 18n);
+ // Shiden -> Quartz
+ const qtzFromShidenTransfered = 5n * (10n ** 18n); // 5 QTZ
+ const qtzOnShidenLeft = qtzToShidenArrived - qtzFromShidenTransfered; // 4.999_999_999_088_000_000n QTZ
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
alice = await privateKey('//Alice');
- [randomAccount] = await helper.arrange.createAccounts([100n], alice);
- console.log('randomAccount', randomAccount.address);
+ [sender] = await helper.arrange.createAccounts([100n], alice);
+ console.log('sender', sender.address);
});
- await usingAstarPlaygrounds(shidenUrl, async (helper) => {
+ await usingShidenPlaygrounds(shidenUrl, async (helper) => {
console.log('1. Create foreign asset and metadata');
await helper.assets.create(
alice,
@@ -1027,12 +1036,10 @@
await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, 1]);
console.log('3. Set payment for computation');
- // TODO this is Phala's price, what price will be for Unique?
- const unitsPerSecond = 228_000_000_000n;
await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
console.log('4. Transfer 1 SDN to recepient');
- await helper.balance.transferToSubstrate(alice, randomAccount.address, shidenInitialBalance);
+ await helper.balance.transferToSubstrate(alice, sender.address, shidenInitialBalance);
});
});
@@ -1055,7 +1062,7 @@
X1: {
AccountId32: {
network: 'Any',
- id: randomAccount.addressRaw,
+ id: sender.addressRaw,
},
},
},
@@ -1072,34 +1079,42 @@
},
},
fun: {
- Fungible: qtzToShidenAmount,
+ Fungible: qtzToShidenTransferred,
},
},
],
};
- // Initial balance is 100 UNQ
- expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(100n * (10n ** 18n));
+ // Initial balance is 100 QTZ
+ const balanceBefore = await helper.balance.getSubstrate(sender.address);
+ console.log(`Initial balance is: ${balanceBefore}`);
+ expect(balanceBefore).to.eq(senderIinitialBalanceQTZ);
const feeAssetItem = 0;
- await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');
+ await helper.xcm.limitedReserveTransferAssets(sender, destination, beneficiary, assets, feeAssetItem, 'Unlimited');
// Balance after reserve transfer is less than 90
- expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(89_941967662676666465n);
+ const balanceAfter = await helper.balance.getSubstrate(sender.address);
+ console.log(`QTZ Balance on Quartz after XCM is: ${balanceAfter}`);
+ console.log(`Quartz's QTZ commission is: ${balanceBefore - balanceAfter}`);
+ expect(balanceAfter).to.eq(senderBalanceAfterXCM);
- await usingAstarPlaygrounds(shidenUrl, async (helper) => {
+ await usingShidenPlaygrounds(shidenUrl, async (helper) => {
await helper.wait.newBlocks(3);
- const xcUNQbalance = await helper.assets.account(1, randomAccount.address);
- const astarBalance = await helper.balance.getSubstrate(randomAccount.address);
+ const xcQTZbalance = await helper.assets.account(1, sender.address);
+ const shidenBalance = await helper.balance.getSubstrate(sender.address);
- expect(xcUNQbalance).to.eq(9_999_999_999_088_000_000n);
- // Astar balance does not changed
- expect(astarBalance).to.eq(1_000_000_000_000_000_000n);
+ console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);
+ console.log(`Shiden's QTZ commission is: ${qtzToShidenTransferred - xcQTZbalance!}`);
+
+ expect(xcQTZbalance).to.eq(qtzToShidenArrived);
+ // SHD balance does not changed:
+ expect(shidenBalance).to.eq(shidenInitialBalance);
});
});
itSub.only('Should connect to Shiden and send QTZ back', async ({helper}) => {
- await usingAstarPlaygrounds(shidenUrl, async (helper) => {
+ await usingShidenPlaygrounds(shidenUrl, async (helper) => {
const destination = {
V1: {
parents: 1,
@@ -1118,7 +1133,7 @@
X1: {
AccountId32: {
network: 'Any',
- id: randomAccount.addressRaw,
+ id: sender.addressRaw,
},
},
},
@@ -1139,30 +1154,35 @@
},
},
fun: {
- Fungible: 5_000_000_000_000_000_000n,
+ Fungible: qtzFromShidenTransfered,
},
},
],
};
// Initial balance is 1 SDN
- expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(1_000_000_000_000_000_000n);
+ const balanceSDNbefore = await helper.balance.getSubstrate(sender.address);
+ console.log(`SDN balance is: ${balanceSDNbefore}, it does not changed`);
+ expect(balanceSDNbefore).to.eq(shidenInitialBalance);
const feeAssetItem = 0;
- await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);
+ // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw
+ await helper.executeExtrinsic(sender, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);
// Balance after reserve transfer is less than 1 SDN
- const xcUNQbalance = await helper.assets.account(1, randomAccount.address);
- const balanceSDN = await helper.balance.getSubstrate(randomAccount.address);
+ const xcQTZbalance = await helper.assets.account(1, sender.address);
+ const balanceSDN = await helper.balance.getSubstrate(sender.address);
+ console.log(`xcQTZ balance on Shiden after XCM is: ${xcQTZbalance}`);
- // Assert: xcQTZ balance decreased
- expect(xcUNQbalance).to.eq(4_999_999_999_088_000_000n);
+ // Assert: xcQTZ balance correctly decreased
+ expect(xcQTZbalance).to.eq(qtzOnShidenLeft);
// Assert: SDN balance is 0.996...
expect(balanceSDN / (10n ** 15n)).to.eq(996n);
});
await helper.wait.newBlocks(3);
- const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);
- expect(balanceUNQ).to.eq(89_941967662676666465n + 5_000_000_000_000_000_000n);
+ const balanceQTZ = await helper.balance.getSubstrate(sender.address);
+ console.log(`QTZ Balance on Quartz after XCM is: ${balanceQTZ}`);
+ expect(balanceQTZ).to.eq(senderBalanceAfterXCM + qtzFromShidenTransfered);
});
});
tests/src/xcm/xcmUnique.test.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {blake2AsHex} from '@polkadot/util-crypto';19import config from '../config';20import {XcmV2TraitsError} from '../interfaces';21import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds} from '../util';2223const UNIQUE_CHAIN = 2037;24const STATEMINT_CHAIN = 1000;25const ACALA_CHAIN = 2000;26const MOONBEAM_CHAIN = 2004;27const ASTAR_CHAIN = 2006;2829const STATEMINT_PALLET_INSTANCE = 50;3031const relayUrl = config.relayUrl;32const statemintUrl = config.statemintUrl;33const acalaUrl = config.acalaUrl;34const moonbeamUrl = config.moonbeamUrl;35const astarUrl = config.astarUrl;3637const RELAY_DECIMALS = 12;38const STATEMINT_DECIMALS = 12;39const ACALA_DECIMALS = 12;4041const TRANSFER_AMOUNT = 2000000000000000000000000n;4243const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4445const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4647const USDT_ASSET_ID = 100;48const USDT_ASSET_METADATA_DECIMALS = 18;49const USDT_ASSET_METADATA_NAME = 'USDT';50const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';51const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;52const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5354const SAFE_XCM_VERSION = 2;5556describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {57 let alice: IKeyringPair;58 let bob: IKeyringPair;5960 let balanceStmnBefore: bigint;61 let balanceStmnAfter: bigint;6263 let balanceUniqueBefore: bigint;64 let balanceUniqueAfter: bigint;65 let balanceUniqueFinal: bigint;6667 let balanceBobBefore: bigint;68 let balanceBobAfter: bigint;69 let balanceBobFinal: bigint;7071 let balanceBobRelayTokenBefore: bigint;72 let balanceBobRelayTokenAfter: bigint;737475 before(async () => {76 await usingPlaygrounds(async (helper, privateKey) => {77 alice = await privateKey('//Alice');78 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor7980 // Set the default version to wrap the first message to other chains.81 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);82 });8384 await usingRelayPlaygrounds(relayUrl, async (helper) => {85 // Fund accounts on Statemint86 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);87 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);88 });8990 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {91 const sovereignFundingAmount = 3_500_000_000n;9293 await helper.assets.create(94 alice,95 USDT_ASSET_ID,96 alice.address,97 USDT_ASSET_METADATA_MINIMAL_BALANCE,98 );99 await helper.assets.setMetadata(100 alice,101 USDT_ASSET_ID,102 USDT_ASSET_METADATA_NAME,103 USDT_ASSET_METADATA_DESCRIPTION,104 USDT_ASSET_METADATA_DECIMALS,105 );106 await helper.assets.mint(107 alice,108 USDT_ASSET_ID,109 alice.address,110 USDT_ASSET_AMOUNT,111 );112113 // funding parachain sovereing account on Statemint.114 // The sovereign account should be created before any action115 // (the assets pallet on Statemint check if the sovereign account exists)116 const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);117 await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);118 });119120121 await usingPlaygrounds(async (helper) => {122 const location = {123 V2: {124 parents: 1,125 interior: {X3: [126 {127 Parachain: STATEMINT_CHAIN,128 },129 {130 PalletInstance: STATEMINT_PALLET_INSTANCE,131 },132 {133 GeneralIndex: USDT_ASSET_ID,134 },135 ]},136 },137 };138139 const metadata =140 {141 name: USDT_ASSET_ID,142 symbol: USDT_ASSET_METADATA_NAME,143 decimals: USDT_ASSET_METADATA_DECIMALS,144 minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,145 };146 await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);147 balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);148 });149150151 // Providing the relay currency to the unique sender account152 // (fee for USDT XCM are paid in relay tokens)153 await usingRelayPlaygrounds(relayUrl, async (helper) => {154 const destination = {155 V1: {156 parents: 0,157 interior: {X1: {158 Parachain: UNIQUE_CHAIN,159 },160 },161 }};162163 const beneficiary = {164 V1: {165 parents: 0,166 interior: {X1: {167 AccountId32: {168 network: 'Any',169 id: alice.addressRaw,170 },171 }},172 },173 };174175 const assets = {176 V1: [177 {178 id: {179 Concrete: {180 parents: 0,181 interior: 'Here',182 },183 },184 fun: {185 Fungible: TRANSFER_AMOUNT_RELAY,186 },187 },188 ],189 };190191 const feeAssetItem = 0;192193 await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');194 });195196 });197198 itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {199 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {200 const dest = {201 V1: {202 parents: 1,203 interior: {X1: {204 Parachain: UNIQUE_CHAIN,205 },206 },207 }};208209 const beneficiary = {210 V1: {211 parents: 0,212 interior: {X1: {213 AccountId32: {214 network: 'Any',215 id: alice.addressRaw,216 },217 }},218 },219 };220221 const assets = {222 V1: [223 {224 id: {225 Concrete: {226 parents: 0,227 interior: {228 X2: [229 {230 PalletInstance: STATEMINT_PALLET_INSTANCE,231 },232 {233 GeneralIndex: USDT_ASSET_ID,234 },235 ]},236 },237 },238 fun: {239 Fungible: TRANSFER_AMOUNT,240 },241 },242 ],243 };244245 const feeAssetItem = 0;246247 balanceStmnBefore = await helper.balance.getSubstrate(alice.address);248 await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');249250 balanceStmnAfter = await helper.balance.getSubstrate(alice.address);251252 // common good parachain take commission in it native token253 console.log(254 '[Statemint -> Unique] transaction fees on Statemint: %s WND',255 helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),256 );257 expect(balanceStmnBefore > balanceStmnAfter).to.be.true;258259 });260261262 // ensure that asset has been delivered263 await helper.wait.newBlocks(3);264265 // expext collection id will be with id 1266 const free = await helper.ft.getBalance(1, {Substrate: alice.address});267268 balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);269270 console.log(271 '[Statemint -> Unique] transaction fees on Unique: %s USDT',272 helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),273 );274 console.log(275 '[Statemint -> Unique] transaction fees on Unique: %s UNQ',276 helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),277 );278 // commission has not paid in USDT token279 expect(free).to.be.equal(TRANSFER_AMOUNT);280 // ... and parachain native token281 expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;282 });283284 itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {285 const destination = {286 V2: {287 parents: 1,288 interior: {X2: [289 {290 Parachain: STATEMINT_CHAIN,291 },292 {293 AccountId32: {294 network: 'Any',295 id: alice.addressRaw,296 },297 },298 ]},299 },300 };301302 const relayFee = 400_000_000_000_000n;303 const currencies: [any, bigint][] = [304 [305 {306 ForeignAssetId: 0,307 },308 TRANSFER_AMOUNT,309 ],310 [311 {312 NativeAssetId: 'Parent',313 },314 relayFee,315 ],316 ];317318 const feeItem = 1;319320 await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');321322 // the commission has been paid in parachain native token323 balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);324 console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));325 expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;326327 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {328 await helper.wait.newBlocks(3);329330 // The USDT token never paid fees. Its amount not changed from begin value.331 // Also check that xcm transfer has been succeeded332 expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;333 });334 });335336 itSub('Should connect and send Relay token to Unique', async ({helper}) => {337 balanceBobBefore = await helper.balance.getSubstrate(bob.address);338 balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});339340 await usingRelayPlaygrounds(relayUrl, async (helper) => {341 const destination = {342 V1: {343 parents: 0,344 interior: {X1: {345 Parachain: UNIQUE_CHAIN,346 },347 },348 }};349350 const beneficiary = {351 V1: {352 parents: 0,353 interior: {X1: {354 AccountId32: {355 network: 'Any',356 id: bob.addressRaw,357 },358 }},359 },360 };361362 const assets = {363 V1: [364 {365 id: {366 Concrete: {367 parents: 0,368 interior: 'Here',369 },370 },371 fun: {372 Fungible: TRANSFER_AMOUNT_RELAY,373 },374 },375 ],376 };377378 const feeAssetItem = 0;379380 await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');381 });382383 await helper.wait.newBlocks(3);384385 balanceBobAfter = await helper.balance.getSubstrate(bob.address);386 balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});387388 const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;389 const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;390 console.log(391 '[Relay (Westend) -> Unique] transaction fees: %s UNQ',392 helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),393 );394 console.log(395 '[Relay (Westend) -> Unique] transaction fees: %s WND',396 helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),397 );398 console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);399 expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;400 expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;401 });402403 itSub('Should connect and send Relay token back', async ({helper}) => {404 let relayTokenBalanceBefore: bigint;405 let relayTokenBalanceAfter: bigint;406 await usingRelayPlaygrounds(relayUrl, async (helper) => {407 relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);408 });409410 const destination = {411 V2: {412 parents: 1,413 interior: {414 X1:{415 AccountId32: {416 network: 'Any',417 id: bob.addressRaw,418 },419 },420 },421 },422 };423424 const currencies: any = [425 [426 {427 NativeAssetId: 'Parent',428 },429 TRANSFER_AMOUNT_RELAY,430 ],431 ];432433 const feeItem = 0;434435 await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');436437 balanceBobFinal = await helper.balance.getSubstrate(bob.address);438 console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ', helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));439440 await usingRelayPlaygrounds(relayUrl, async (helper) => {441 await helper.wait.newBlocks(10);442 relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);443444 const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;445 console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));446 expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;447 });448 });449});450451describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {452 let alice: IKeyringPair;453 let randomAccount: IKeyringPair;454455 let balanceUniqueTokenInit: bigint;456 let balanceUniqueTokenMiddle: bigint;457 let balanceUniqueTokenFinal: bigint;458 let balanceAcalaTokenInit: bigint;459 let balanceAcalaTokenMiddle: bigint;460 let balanceAcalaTokenFinal: bigint;461 let balanceUniqueForeignTokenInit: bigint;462 let balanceUniqueForeignTokenMiddle: bigint;463 let balanceUniqueForeignTokenFinal: bigint;464465 // computed by a test transfer from prod Unique to prod Acala.466 // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48467 // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)468 const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;469470 const ACALA_BACKWARD_TRANSFER_AMOUNT = TRANSFER_AMOUNT - expectedAcalaIncomeFee;471472 before(async () => {473 await usingPlaygrounds(async (helper, privateKey) => {474 alice = await privateKey('//Alice');475 [randomAccount] = await helper.arrange.createAccounts([0n], alice);476477 // Set the default version to wrap the first message to other chains.478 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);479 });480481 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {482 const destination = {483 V1: {484 parents: 1,485 interior: {486 X1: {487 Parachain: UNIQUE_CHAIN,488 },489 },490 },491 };492493 const metadata = {494 name: 'Unique Network',495 symbol: 'UNQ',496 decimals: 18,497 minimalBalance: 1250000000000000000n,498 };499500 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);501 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);502 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);503 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});504 });505506 await usingPlaygrounds(async (helper) => {507 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);508 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);509 });510 });511512 itSub('Should connect and send UNQ to Acala', async ({helper}) => {513514 const destination = {515 V2: {516 parents: 1,517 interior: {518 X1: {519 Parachain: ACALA_CHAIN,520 },521 },522 },523 };524525 const beneficiary = {526 V2: {527 parents: 0,528 interior: {529 X1: {530 AccountId32: {531 network: 'Any',532 id: randomAccount.addressRaw,533 },534 },535 },536 },537 };538539 const assets = {540 V2: [541 {542 id: {543 Concrete: {544 parents: 0,545 interior: 'Here',546 },547 },548 fun: {549 Fungible: TRANSFER_AMOUNT,550 },551 },552 ],553 };554555 const feeAssetItem = 0;556557 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');558 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);559560 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;561 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));562 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;563564 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {565 await helper.wait.newBlocks(3);566567 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});568 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);569570 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;571 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;572 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;573574 console.log(575 '[Unique -> Acala] transaction fees on Acala: %s ACA',576 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),577 );578 console.log(579 '[Unique -> Acala] transaction fees on Acala: %s UNQ',580 helper.util.bigIntToDecimals(acaUnqFees),581 );582 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));583 expect(acaFees == 0n).to.be.true;584 expect(585 acaUnqFees == expectedAcalaIncomeFee,586 'Acala took different income fee, check the Acala foreign asset config',587 ).to.be.true;588 });589 });590591 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {592 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {593 const destination = {594 V1: {595 parents: 1,596 interior: {597 X2: [598 {Parachain: UNIQUE_CHAIN},599 {600 AccountId32: {601 network: 'Any',602 id: randomAccount.addressRaw,603 },604 },605 ],606 },607 },608 };609610 const id = {611 ForeignAsset: 0,612 };613614 await helper.xTokens.transfer(randomAccount, id, ACALA_BACKWARD_TRANSFER_AMOUNT, destination, 'Unlimited');615 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);616 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);617618 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;619 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;620621 console.log(622 '[Acala -> Unique] transaction fees on Acala: %s ACA',623 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),624 );625 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));626627 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;628 expect(unqOutcomeTransfer == ACALA_BACKWARD_TRANSFER_AMOUNT).to.be.true;629 });630631 await helper.wait.newBlocks(3);632633 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);634 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;635 expect(actuallyDelivered > 0).to.be.true;636637 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));638639 const unqFees = ACALA_BACKWARD_TRANSFER_AMOUNT - actuallyDelivered;640 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));641 expect(unqFees == 0n).to.be.true;642 });643});644645// These tests are relevant only when the foreign asset pallet is disabled646describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {647 let alice: IKeyringPair;648649 before(async () => {650 await usingPlaygrounds(async (helper, privateKey) => {651 alice = await privateKey('//Alice');652653 // Set the default version to wrap the first message to other chains.654 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);655 });656 });657658 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {659 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {660 const destination = {661 V1: {662 parents: 1,663 interior: {664 X2: [665 {Parachain: UNIQUE_CHAIN},666 {667 AccountId32: {668 network: 'Any',669 id: alice.addressRaw,670 },671 },672 ],673 },674 },675 };676677 const id = {678 Token: 'ACA',679 };680681 await helper.xTokens.transfer(alice, id, 100_000_000_000n, destination, 'Unlimited');682 });683684 const maxWaitBlocks = 3;685686 const xcmpQueueFailEvent = await helper.wait.event(maxWaitBlocks, 'xcmpQueue', 'Fail');687688 expect(689 xcmpQueueFailEvent != null,690 '[Acala] xcmpQueue.FailEvent event is expected',691 ).to.be.true;692693 const event = xcmpQueueFailEvent!.event;694 const outcome = event.data[1] as XcmV2TraitsError;695696 expect(697 outcome.isFailedToTransactAsset,698 '[Acala] The XCM error should be `FailedToTransactAsset`',699 ).to.be.true;700 });701});702703describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {704 // Unique constants705 let uniqueDonor: IKeyringPair;706 let uniqueAssetLocation;707708 let randomAccountUnique: IKeyringPair;709 let randomAccountMoonbeam: IKeyringPair;710711 // Moonbeam constants712 let assetId: string;713714 const councilVotingThreshold = 2;715 const technicalCommitteeThreshold = 2;716 const votingPeriod = 3;717 const delayPeriod = 0;718719 const uniqueAssetMetadata = {720 name: 'xcUnique',721 symbol: 'xcUNQ',722 decimals: 18,723 isFrozen: false,724 minimalBalance: 1n,725 };726727 let balanceUniqueTokenInit: bigint;728 let balanceUniqueTokenMiddle: bigint;729 let balanceUniqueTokenFinal: bigint;730 let balanceForeignUnqTokenInit: bigint;731 let balanceForeignUnqTokenMiddle: bigint;732 let balanceForeignUnqTokenFinal: bigint;733 let balanceGlmrTokenInit: bigint;734 let balanceGlmrTokenMiddle: bigint;735 let balanceGlmrTokenFinal: bigint;736737 before(async () => {738 await usingPlaygrounds(async (helper, privateKey) => {739 uniqueDonor = await privateKey('//Alice');740 [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);741742 balanceForeignUnqTokenInit = 0n;743744 // Set the default version to wrap the first message to other chains.745 const alice = uniqueDonor;746 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);747 });748749 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {750 const alithAccount = helper.account.alithAccount();751 const baltatharAccount = helper.account.baltatharAccount();752 const dorothyAccount = helper.account.dorothyAccount();753754 randomAccountMoonbeam = helper.account.create();755756 // >>> Sponsoring Dorothy >>>757 console.log('Sponsoring Dorothy.......');758 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);759 console.log('Sponsoring Dorothy.......DONE');760 // <<< Sponsoring Dorothy <<<761762 uniqueAssetLocation = {763 XCM: {764 parents: 1,765 interior: {X1: {Parachain: UNIQUE_CHAIN}},766 },767 };768 const existentialDeposit = 1n;769 const isSufficient = true;770 const unitsPerSecond = 1n;771 const numAssetsWeightHint = 0;772773 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({774 location: uniqueAssetLocation,775 metadata: uniqueAssetMetadata,776 existentialDeposit,777 isSufficient,778 unitsPerSecond,779 numAssetsWeightHint,780 });781 const proposalHash = blake2AsHex(encodedProposal);782783 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);784 console.log('Encoded length %d', encodedProposal.length);785 console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);786787 // >>> Note motion preimage >>>788 console.log('Note motion preimage.......');789 await helper.democracy.notePreimage(baltatharAccount, encodedProposal);790 console.log('Note motion preimage.......DONE');791 // <<< Note motion preimage <<<792793 // >>> Propose external motion through council >>>794 console.log('Propose external motion through council.......');795 const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});796 const encodedMotion = externalMotion?.method.toHex() || '';797 const motionHash = blake2AsHex(encodedMotion);798 console.log('Motion hash is %s', motionHash);799800 await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);801802 const councilProposalIdx = await helper.collective.council.proposalCount() - 1;803 await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);804 await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);805806 await helper.collective.council.close(807 dorothyAccount,808 motionHash,809 councilProposalIdx,810 {811 refTime: 1_000_000_000,812 proofSize: 1_000_000,813 },814 externalMotion.encodedLength,815 );816 console.log('Propose external motion through council.......DONE');817 // <<< Propose external motion through council <<<818819 // >>> Fast track proposal through technical committee >>>820 console.log('Fast track proposal through technical committee.......');821 const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);822 const encodedFastTrack = fastTrack?.method.toHex() || '';823 const fastTrackHash = blake2AsHex(encodedFastTrack);824 console.log('FastTrack hash is %s', fastTrackHash);825826 await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);827828 const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;829 await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);830 await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);831832 await helper.collective.techCommittee.close(833 baltatharAccount,834 fastTrackHash,835 techProposalIdx,836 {837 refTime: 1_000_000_000,838 proofSize: 1_000_000,839 },840 fastTrack.encodedLength,841 );842 console.log('Fast track proposal through technical committee.......DONE');843 // <<< Fast track proposal through technical committee <<<844845 // >>> Referendum voting >>>846 console.log('Referendum voting.......');847 await helper.democracy.referendumVote(dorothyAccount, 0, {848 balance: 10_000_000_000_000_000_000n,849 vote: {aye: true, conviction: 1},850 });851 console.log('Referendum voting.......DONE');852 // <<< Referendum voting <<<853854 // >>> Acquire Unique AssetId Info on Moonbeam >>>855 console.log('Acquire Unique AssetId Info on Moonbeam.......');856857 // Wait for the democracy execute858 await helper.wait.newBlocks(5);859860 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();861862 console.log('UNQ asset ID is %s', assetId);863 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');864 // >>> Acquire Unique AssetId Info on Moonbeam >>>865866 // >>> Sponsoring random Account >>>867 console.log('Sponsoring random Account.......');868 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);869 console.log('Sponsoring random Account.......DONE');870 // <<< Sponsoring random Account <<<871872 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);873 });874875 await usingPlaygrounds(async (helper) => {876 await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);877 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);878 });879 });880881 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {882 const currencyId = {883 NativeAssetId: 'Here',884 };885 const dest = {886 V2: {887 parents: 1,888 interior: {889 X2: [890 {Parachain: MOONBEAM_CHAIN},891 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},892 ],893 },894 },895 };896 const amount = TRANSFER_AMOUNT;897898 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');899900 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);901 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;902903 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;904 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));905 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;906907 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {908 await helper.wait.newBlocks(3);909910 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);911912 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;913 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));914 expect(glmrFees == 0n).to.be.true;915916 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;917918 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;919 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));920 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;921 });922 });923924 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {925 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {926 const asset = {927 V1: {928 id: {929 Concrete: {930 parents: 1,931 interior: {932 X1: {Parachain: UNIQUE_CHAIN},933 },934 },935 },936 fun: {937 Fungible: TRANSFER_AMOUNT,938 },939 },940 };941 const destination = {942 V1: {943 parents: 1,944 interior: {945 X2: [946 {Parachain: UNIQUE_CHAIN},947 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},948 ],949 },950 },951 };952953 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');954955 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);956957 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;958 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));959 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;960961 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);962963 expect(unqRandomAccountAsset).to.be.null;964965 balanceForeignUnqTokenFinal = 0n;966967 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;968 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));969 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;970 });971972 await helper.wait.newBlocks(3);973974 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);975 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;976 expect(actuallyDelivered > 0).to.be.true;977978 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));979980 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;981 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));982 expect(unqFees == 0n).to.be.true;983 });984});985986describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {987 let alice: IKeyringPair;988 let randomAccount: IKeyringPair;989990 const astarInitialBalance = 1n * (10n ** 18n);991 const unqToAstarAmount = 10n * (10n ** 18n);992993 before(async () => {994 await usingPlaygrounds(async (helper, privateKey) => {995 alice = await privateKey('//Alice');996 [randomAccount] = await helper.arrange.createAccounts([100n], alice);997 console.log('randomAccount', randomAccount.address);998 });9991000 await usingAstarPlaygrounds(astarUrl, async (helper) => {1001 console.log('1. Create foreign asset and metadata');1002 await helper.assets.create(1003 alice,1004 1,1005 alice.address,1006 1n,1007 );10081009 await helper.assets.setMetadata(1010 alice,1011 1,1012 'Cross chain UNQ',1013 'xcUNQ',1014 18,1015 );10161017 console.log('2. Register asset location');1018 const assetLocation = {1019 V1: {1020 parents: 1,1021 interior: {1022 X1: {1023 Parachain: UNIQUE_CHAIN,1024 },1025 },1026 },1027 };10281029 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, 1]);10301031 console.log('3. Set payment for computation');1032 // TODO this is Phala's price, what price will be for Unique?1033 const unitsPerSecond = 228_000_000_000n;1034 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);10351036 console.log('4. Transfer 1 ASTR to recepient');1037 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1038 });1039 });10401041 itSub.only('Should connect and send UNQ to Astar', async ({helper}) => {1042 const destination = {1043 V1: {1044 parents: 1,1045 interior: {1046 X1: {1047 Parachain: ASTAR_CHAIN,1048 },1049 },1050 },1051 };10521053 const beneficiary = {1054 V1: {1055 parents: 0,1056 interior: {1057 X1: {1058 AccountId32: {1059 network: 'Any',1060 id: randomAccount.addressRaw,1061 },1062 },1063 },1064 },1065 };10661067 const assets = {1068 V1: [1069 {1070 id: {1071 Concrete: {1072 parents: 0,1073 interior: 'Here',1074 },1075 },1076 fun: {1077 Fungible: unqToAstarAmount,1078 },1079 },1080 ],1081 };10821083 // Initial balance is 100 UNQ1084 expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(100n * (10n ** 18n));10851086 const feeAssetItem = 0;1087 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');10881089 // Balance after reserve transfer is less than 901090 expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(89_941967662676666465n);10911092 await usingAstarPlaygrounds(astarUrl, async (helper) => {1093 await helper.wait.newBlocks(3);1094 const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1095 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);10961097 expect(xcUNQbalance).to.eq(9_999_999_999_088_000_000n);1098 // Astar balance does not changed1099 expect(astarBalance).to.eq(1_000_000_000_000_000_000n);1100 });1101 });11021103 itSub.only('Should connect to Astar and send UNQ back', async ({helper}) => {1104 await usingAstarPlaygrounds(astarUrl, async (helper) => {1105 const destination = {1106 V1: {1107 parents: 1,1108 interior: {1109 X1: {1110 Parachain: UNIQUE_CHAIN,1111 },1112 },1113 },1114 };11151116 const beneficiary = {1117 V1: {1118 parents: 0,1119 interior: {1120 X1: {1121 AccountId32: {1122 network: 'Any',1123 id: randomAccount.addressRaw,1124 },1125 },1126 },1127 },1128 };11291130 const assets = {1131 V1: [1132 {1133 id: {1134 Concrete: {1135 parents: 1,1136 interior: {1137 X1: {1138 Parachain: UNIQUE_CHAIN,1139 },1140 },1141 },1142 },1143 fun: {1144 Fungible: 5_000_000_000_000_000_000n,1145 },1146 },1147 ],1148 };11491150 // Initial balance is 1 ASTR1151 expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(1_000_000_000_000_000_000n);11521153 const feeAssetItem = 0;1154 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);11551156 const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1157 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);11581159 // Assert: xcUNQ balance decreased1160 expect(xcUNQbalance).to.eq(4_999_999_999_088_000_000n);1161 // Assert: ASTR balance is 0.996...1162 expect(balanceAstar / (10n ** 15n)).to.eq(996n);1163 });11641165 await helper.wait.newBlocks(3);1166 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1167 expect(balanceUNQ).to.eq(89_941967662676666465n + 5_000_000_000_000_000_000n);1168 });11691170 itSub.skip('Should not accept limitedReserveTransfer of UNQ from ASTAR', async ({helper}) => {1171 await usingAstarPlaygrounds(astarUrl, async (helper) => {1172 const destination = {1173 V1: {1174 parents: 1,1175 interior: {1176 X1: {1177 Parachain: UNIQUE_CHAIN,1178 },1179 },1180 },1181 };11821183 const beneficiary = {1184 V1: {1185 parents: 0,1186 interior: {1187 X1: {1188 AccountId32: {1189 network: 'Any',1190 id: randomAccount.addressRaw,1191 },1192 },1193 },1194 },1195 };11961197 const assets = {1198 V1: [1199 {1200 id: {1201 Concrete: {1202 parents: 1,1203 interior: {1204 X1: {1205 Parachain: UNIQUE_CHAIN,1206 },1207 },1208 },1209 },1210 fun: {1211 Fungible: 5_000_000_000_000_000_000n, // TODO set another value1212 },1213 },1214 ],1215 };12161217 // Initial balance is 1 ASTAR1218 expect(await helper.balance.getSubstrate(randomAccount.address)).to.eq(1_000_000_000_000_000_000n);12191220 const feeAssetItem = 0;1221 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');12221223 // Balance after reserve transfer is less than 1 ASTAR1224 const xcUNQbalance = await helper.assets.account(1, randomAccount.address);1225 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);12261227 // xcUNQ balance decreased1228 expect(xcUNQbalance).to.eq(4_999_999_999_088_000_000n);1229 // Astar balance is 0.997...1230 expect(balanceAstar / (10n ** 15n)).to.eq(997n);1231 });12321233 await helper.wait.newBlocks(3);1234 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1235 expect(balanceUNQ).to.eq(89_941967662676666465n + 5_000_000_000_000_000_000n);1236 });1237});