difftreelog
test added CI for the Polkadex network
in: master
7 files changed
tests/.mocha.envdiffbeforeafterboth--- /dev/null
+++ b/tests/.mocha.env
@@ -0,0 +1,20 @@
+RELAY_ACALA_ID=1002
+RELAY_ASTAR_ID=1005
+RELAY_MOONBEAM_ID=1003
+RELAY_POLKADEX_ID=1006
+RELAY_STATEMINT_ID=1004
+RELAY_UNIQUE_ID=1001
+RELAY_HTTP_URL=http://127.0.0.1:9699/relay/
+RELAY_ACALA_HTTP_URL=http://127.0.0.1:9699/relay-acala/
+RELAY_ASTAR_HTTP_URL=http://127.0.0.1:9699/relay-astar/
+RELAY_MOONBEAM_HTTP_URL=http://127.0.0.1:9699/relay-moonbeam/
+RELAY_POLKADEX_HTTP_URL=http://127.0.0.1:9699/relay-polkadex/
+RELAY_STATEMINT_HTTP_URL=http://127.0.0.1:9699/relay-statemint/
+RELAY_UNIQUE_HTTP_URL=http://127.0.0.1:9699/relay-unique/
+RELAY_URL=ws://127.0.0.1:9699/relay/
+RELAY_ACALA_URL=ws://127.0.0.1:9699/relay-acala/
+RELAY_ASTAR_URL=ws://127.0.0.1:9699/relay-astar/
+RELAY_MOONBEAM_URL=ws://127.0.0.1:9699/relay-moonbeam/
+RELAY_POLKADEX_URL=ws://127.0.0.1:9699/relay-polkadex/
+RELAY_STATEMINT_URL=ws://127.0.0.1:9699/relay-statemint/
+RELAY_UNIQUE_URL=ws://127.0.0.1:9699/relay-unique/
tests/.vscode/settings.jsondiffbeforeafterboth--- a/tests/.vscode/settings.json
+++ b/tests/.vscode/settings.json
@@ -1,6 +1,10 @@
{
- "mocha.enabled": true,
- "mochaExplorer.files": "**/*.test.ts",
+ "mochaExplorer.env": {
+ "RUN_GOV_TESTS": "1",
+ "RUN_XCM_TESTS": "1"
+ },
+ "mochaExplorer.files": "src/**/*.test.ts",
+ "mochaExplorer.envPath": ".mocha.env",
"mochaExplorer.require": "ts-node/register",
"eslint.format.enable": true,
"[javascript]": {
tests/src/config.tsdiffbeforeafterboth--- a/tests/src/config.ts
+++ b/tests/src/config.ts
@@ -28,6 +28,7 @@
westmintUrl: process.env.RELAY_WESTMINT_URL || 'ws://127.0.0.1:9948',
statemineUrl: process.env.RELAY_STATEMINE_URL || 'ws://127.0.0.1:9948',
statemintUrl: process.env.RELAY_STATEMINT_URL || 'ws://127.0.0.1:9948',
+ polkadexUrl: process.env.RELAY_POLKADEX_URL || 'ws://127.0.0.1:9950',
};
export default config;
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, DevShidenHelper} from './playgrounds/unique.dev';
+import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper, DevPolkadexHelper} from './playgrounds/unique.dev';
import {dirname} from 'path';
import {fileURLToPath} from 'url';
@@ -89,6 +89,8 @@
export const usingShidenPlaygrounds = (url: string, code: (helper: DevShidenHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevShidenHelper>(DevShidenHelper, url, code);
+export const usingPolkadexPlaygrounds = (url: string, code: (helper: DevPolkadexHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevPolkadexHelper>(DevPolkadexHelper, url, code);
+
export const MINIMUM_DONOR_FUND = 4_000_000n;
export const DONOR_FUNDING = 4_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
@@ -3,7 +3,7 @@
import {stringToU8a} from '@polkadot/util';
import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
-import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper} from './unique';
+import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper, PolkadexHelper} from './unique';
import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
import * as defs from '../../interfaces/definitions';
import {IKeyringPair} from '@polkadot/types/types';
@@ -249,6 +249,10 @@
messageHash: eventJsonData(data, 0),
}));
+ static Success = this.Method('Success', data => ({
+ messageHash: eventJsonData(data, 0),
+ }));
+
static Fail = this.Method('Fail', data => ({
messageHash: eventJsonData(data, 0),
outcome: eventData<XcmV2TraitsError>(data, 1),
@@ -406,6 +410,16 @@
}
}
+export class DevPolkadexHelper extends PolkadexHelper {
+ wait: WaitGroup;
+ constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
+ options.helperBase = options.helperBase ?? PolkadexHelper;
+
+ super(logger, options);
+ this.wait = new WaitGroup(this);
+ }
+}
+
export class DevKaruraHelper extends DevAcalaHelper {}
export class ArrangeGroup {
tests/src/util/playgrounds/unique.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -3694,6 +3694,12 @@
}
}
+class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {
+ async whitelistToken(signer: TSigner, assetId: any) {
+ await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);
+ }
+}
+
class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {
async accounts(address: string, currencyId: any) {
const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;
@@ -3977,6 +3983,30 @@
}
}
+export class PolkadexHelper extends XcmChainHelper {
+ assets: AssetsGroup<PolkadexHelper>;
+ balance: SubstrateBalanceGroup<PolkadexHelper>;
+ xTokens: XTokensGroup<PolkadexHelper>;
+ xcm: XcmGroup<PolkadexHelper>;
+ xcmHelper: PolkadexXcmHelperGroup<PolkadexHelper>;
+
+ constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
+ super(logger, options.helperBase ?? PolkadexHelper);
+
+ this.assets = new AssetsGroup(this);
+ this.balance = new SubstrateBalanceGroup(this);
+ this.xTokens = new XTokensGroup(this);
+ this.xcm = new XcmGroup(this, 'polkadotXcm');
+ this.xcmHelper = new PolkadexXcmHelperGroup(this);
+ }
+
+ getSudo<T extends PolkadexHelper>() {
+ // eslint-disable-next-line @typescript-eslint/naming-convention
+ const SudoHelperType = SudoHelper(this.helperBase);
+ return this.clone(SudoHelperType) as T;
+ }
+}
+
// eslint-disable-next-line @typescript-eslint/naming-convention
function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {
return class extends Base {
tests/src/xcm/xcmUnique.test.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import config from '../config';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds} from '../util';20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';2122const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);23const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);24const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);25const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);26const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);2728const STATEMINT_PALLET_INSTANCE = 50;2930const relayUrl = config.relayUrl;31const statemintUrl = config.statemintUrl;32const acalaUrl = config.acalaUrl;33const moonbeamUrl = config.moonbeamUrl;34const astarUrl = config.astarUrl;3536const RELAY_DECIMALS = 12;37const STATEMINT_DECIMALS = 12;38const ACALA_DECIMALS = 12;39const ASTAR_DECIMALS = 18n;40const UNQ_DECIMALS = 18n;4142const TRANSFER_AMOUNT = 2000000000000000000000000n;4344const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4546const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;4748const USDT_ASSET_ID = 100;49const USDT_ASSET_METADATA_DECIMALS = 18;50const USDT_ASSET_METADATA_NAME = 'USDT';51const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';52const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;53const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5455const SAFE_XCM_VERSION = 2;5657describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {58 let alice: IKeyringPair;59 let bob: IKeyringPair;6061 let balanceStmnBefore: bigint;62 let balanceStmnAfter: bigint;6364 let balanceUniqueBefore: bigint;65 let balanceUniqueAfter: bigint;66 let balanceUniqueFinal: bigint;6768 let balanceBobBefore: bigint;69 let balanceBobAfter: bigint;70 let balanceBobFinal: bigint;7172 let balanceBobRelayTokenBefore: bigint;73 let balanceBobRelayTokenAfter: bigint;747576 before(async () => {77 await usingPlaygrounds(async (helper, privateKey) => {78 alice = await privateKey('//Alice');79 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor8081 // Set the default version to wrap the first message to other chains.82 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);83 });8485 await usingRelayPlaygrounds(relayUrl, async (helper) => {86 // Fund accounts on Statemint87 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);88 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);89 });9091 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {92 const sovereignFundingAmount = 3_500_000_000n;9394 await helper.assets.create(95 alice,96 USDT_ASSET_ID,97 alice.address,98 USDT_ASSET_METADATA_MINIMAL_BALANCE,99 );100 await helper.assets.setMetadata(101 alice,102 USDT_ASSET_ID,103 USDT_ASSET_METADATA_NAME,104 USDT_ASSET_METADATA_DESCRIPTION,105 USDT_ASSET_METADATA_DECIMALS,106 );107 await helper.assets.mint(108 alice,109 USDT_ASSET_ID,110 alice.address,111 USDT_ASSET_AMOUNT,112 );113114 // funding parachain sovereing account on Statemint.115 // The sovereign account should be created before any action116 // (the assets pallet on Statemint check if the sovereign account exists)117 const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);118 await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);119 });120121122 await usingPlaygrounds(async (helper) => {123 const location = {124 V2: {125 parents: 1,126 interior: {X3: [127 {128 Parachain: STATEMINT_CHAIN,129 },130 {131 PalletInstance: STATEMINT_PALLET_INSTANCE,132 },133 {134 GeneralIndex: USDT_ASSET_ID,135 },136 ]},137 },138 };139140 const metadata =141 {142 name: USDT_ASSET_ID,143 symbol: USDT_ASSET_METADATA_NAME,144 decimals: USDT_ASSET_METADATA_DECIMALS,145 minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,146 };147 await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);148 balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);149 });150151152 // Providing the relay currency to the unique sender account153 // (fee for USDT XCM are paid in relay tokens)154 await usingRelayPlaygrounds(relayUrl, async (helper) => {155 const destination = {156 V2: {157 parents: 0,158 interior: {X1: {159 Parachain: UNIQUE_CHAIN,160 },161 },162 }};163164 const beneficiary = {165 V2: {166 parents: 0,167 interior: {X1: {168 AccountId32: {169 network: 'Any',170 id: alice.addressRaw,171 },172 }},173 },174 };175176 const assets = {177 V2: [178 {179 id: {180 Concrete: {181 parents: 0,182 interior: 'Here',183 },184 },185 fun: {186 Fungible: TRANSFER_AMOUNT_RELAY,187 },188 },189 ],190 };191192 const feeAssetItem = 0;193194 await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');195 });196197 });198199 itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {200 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {201 const dest = {202 V2: {203 parents: 1,204 interior: {X1: {205 Parachain: UNIQUE_CHAIN,206 },207 },208 }};209210 const beneficiary = {211 V2: {212 parents: 0,213 interior: {X1: {214 AccountId32: {215 network: 'Any',216 id: alice.addressRaw,217 },218 }},219 },220 };221222 const assets = {223 V2: [224 {225 id: {226 Concrete: {227 parents: 0,228 interior: {229 X2: [230 {231 PalletInstance: STATEMINT_PALLET_INSTANCE,232 },233 {234 GeneralIndex: USDT_ASSET_ID,235 },236 ]},237 },238 },239 fun: {240 Fungible: TRANSFER_AMOUNT,241 },242 },243 ],244 };245246 const feeAssetItem = 0;247248 balanceStmnBefore = await helper.balance.getSubstrate(alice.address);249 await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');250251 balanceStmnAfter = await helper.balance.getSubstrate(alice.address);252253 // common good parachain take commission in it native token254 console.log(255 '[Statemint -> Unique] transaction fees on Statemint: %s WND',256 helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),257 );258 expect(balanceStmnBefore > balanceStmnAfter).to.be.true;259260 });261262263 // ensure that asset has been delivered264 await helper.wait.newBlocks(3);265266 // expext collection id will be with id 1267 const free = await helper.ft.getBalance(1, {Substrate: alice.address});268269 balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);270271 console.log(272 '[Statemint -> Unique] transaction fees on Unique: %s USDT',273 helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),274 );275 console.log(276 '[Statemint -> Unique] transaction fees on Unique: %s UNQ',277 helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),278 );279 // commission has not paid in USDT token280 expect(free).to.be.equal(TRANSFER_AMOUNT);281 // ... and parachain native token282 expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;283 });284285 itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {286 const destination = {287 V2: {288 parents: 1,289 interior: {X2: [290 {291 Parachain: STATEMINT_CHAIN,292 },293 {294 AccountId32: {295 network: 'Any',296 id: alice.addressRaw,297 },298 },299 ]},300 },301 };302303 const relayFee = 400_000_000_000_000n;304 const currencies: [any, bigint][] = [305 [306 {307 ForeignAssetId: 0,308 },309 TRANSFER_AMOUNT,310 ],311 [312 {313 NativeAssetId: 'Parent',314 },315 relayFee,316 ],317 ];318319 const feeItem = 1;320321 await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');322323 // the commission has been paid in parachain native token324 balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);325 console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));326 expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;327328 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {329 await helper.wait.newBlocks(3);330331 // The USDT token never paid fees. Its amount not changed from begin value.332 // Also check that xcm transfer has been succeeded333 expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;334 });335 });336337 itSub('Should connect and send Relay token to Unique', async ({helper}) => {338 balanceBobBefore = await helper.balance.getSubstrate(bob.address);339 balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});340341 await usingRelayPlaygrounds(relayUrl, async (helper) => {342 const destination = {343 V2: {344 parents: 0,345 interior: {X1: {346 Parachain: UNIQUE_CHAIN,347 },348 },349 }};350351 const beneficiary = {352 V2: {353 parents: 0,354 interior: {X1: {355 AccountId32: {356 network: 'Any',357 id: bob.addressRaw,358 },359 }},360 },361 };362363 const assets = {364 V2: [365 {366 id: {367 Concrete: {368 parents: 0,369 interior: 'Here',370 },371 },372 fun: {373 Fungible: TRANSFER_AMOUNT_RELAY,374 },375 },376 ],377 };378379 const feeAssetItem = 0;380381 await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');382 });383384 await helper.wait.newBlocks(3);385386 balanceBobAfter = await helper.balance.getSubstrate(bob.address);387 balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});388389 const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;390 const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;391 console.log(392 '[Relay (Westend) -> Unique] transaction fees: %s UNQ',393 helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),394 );395 console.log(396 '[Relay (Westend) -> Unique] transaction fees: %s WND',397 helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),398 );399 console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);400 expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;401 expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;402 });403404 itSub('Should connect and send Relay token back', async ({helper}) => {405 let relayTokenBalanceBefore: bigint;406 let relayTokenBalanceAfter: bigint;407 await usingRelayPlaygrounds(relayUrl, async (helper) => {408 relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);409 });410411 const destination = {412 V2: {413 parents: 1,414 interior: {415 X1:{416 AccountId32: {417 network: 'Any',418 id: bob.addressRaw,419 },420 },421 },422 },423 };424425 const currencies: any = [426 [427 {428 NativeAssetId: 'Parent',429 },430 TRANSFER_AMOUNT_RELAY,431 ],432 ];433434 const feeItem = 0;435436 await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');437438 balanceBobFinal = await helper.balance.getSubstrate(bob.address);439 console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ', helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));440441 await usingRelayPlaygrounds(relayUrl, async (helper) => {442 await helper.wait.newBlocks(10);443 relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);444445 const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;446 console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));447 expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;448 });449 });450});451452describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {453 let alice: IKeyringPair;454 let randomAccount: IKeyringPair;455456 let balanceUniqueTokenInit: bigint;457 let balanceUniqueTokenMiddle: bigint;458 let balanceUniqueTokenFinal: bigint;459 let balanceAcalaTokenInit: bigint;460 let balanceAcalaTokenMiddle: bigint;461 let balanceAcalaTokenFinal: bigint;462 let balanceUniqueForeignTokenInit: bigint;463 let balanceUniqueForeignTokenMiddle: bigint;464 let balanceUniqueForeignTokenFinal: bigint;465466 // computed by a test transfer from prod Unique to prod Acala.467 // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48468 // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)469 const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;470 const acalaEps = 8n * 10n ** 16n;471472 let acalaBackwardTransferAmount: bigint;473474 before(async () => {475 await usingPlaygrounds(async (helper, privateKey) => {476 alice = await privateKey('//Alice');477 [randomAccount] = await helper.arrange.createAccounts([0n], alice);478479 // Set the default version to wrap the first message to other chains.480 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);481 });482483 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {484 const destination = {485 V2: {486 parents: 1,487 interior: {488 X1: {489 Parachain: UNIQUE_CHAIN,490 },491 },492 },493 };494495 const metadata = {496 name: 'Unique Network',497 symbol: 'UNQ',498 decimals: 18,499 minimalBalance: 1250000000000000000n,500 };501502 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);503 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);504 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);505 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});506 });507508 await usingPlaygrounds(async (helper) => {509 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);510 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);511 });512 });513514 itSub('Should connect and send UNQ to Acala', async ({helper}) => {515516 const destination = {517 V2: {518 parents: 1,519 interior: {520 X1: {521 Parachain: ACALA_CHAIN,522 },523 },524 },525 };526527 const beneficiary = {528 V2: {529 parents: 0,530 interior: {531 X1: {532 AccountId32: {533 network: 'Any',534 id: randomAccount.addressRaw,535 },536 },537 },538 },539 };540541 const assets = {542 V2: [543 {544 id: {545 Concrete: {546 parents: 0,547 interior: 'Here',548 },549 },550 fun: {551 Fungible: TRANSFER_AMOUNT,552 },553 },554 ],555 };556557 const feeAssetItem = 0;558559 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');560 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);561562 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;563 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));564 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;565566 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {567 await helper.wait.newBlocks(3);568569 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});570 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);571572 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;573 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;574 acalaBackwardTransferAmount = unqIncomeTransfer;575576 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;577578 console.log(579 '[Unique -> Acala] transaction fees on Acala: %s ACA',580 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),581 );582 console.log(583 '[Unique -> Acala] transaction fees on Acala: %s UNQ',584 helper.util.bigIntToDecimals(acaUnqFees),585 );586 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));587 expect(acaFees == 0n).to.be.true;588589 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;590591 expect(592 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,593 'Acala took different income fee, check the Acala foreign asset config',594 ).to.be.true;595 });596 });597598 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {599 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {600 const destination = {601 V2: {602 parents: 1,603 interior: {604 X2: [605 {Parachain: UNIQUE_CHAIN},606 {607 AccountId32: {608 network: 'Any',609 id: randomAccount.addressRaw,610 },611 },612 ],613 },614 },615 };616617 const id = {618 ForeignAsset: 0,619 };620621 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');622 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);623 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);624625 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;626 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;627628 console.log(629 '[Acala -> Unique] transaction fees on Acala: %s ACA',630 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),631 );632 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));633634 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;635 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;636 });637638 await helper.wait.newBlocks(3);639640 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);641 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;642 expect(actuallyDelivered > 0).to.be.true;643644 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));645646 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;647 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));648 expect(unqFees == 0n).to.be.true;649 });650651 itSub('Acala can send only up to its balance', async ({helper}) => {652 // set Acala's sovereign account's balance653 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);654 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);655 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);656657 const moreThanAcalaHas = acalaBalance * 2n;658659 let targetAccountBalance = 0n;660 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);661662 const uniqueMultilocation = {663 V2: {664 parents: 1,665 interior: {666 X1: {Parachain: UNIQUE_CHAIN},667 },668 },669 };670671 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(672 targetAccount.addressRaw,673 {674 Concrete: {675 parents: 0,676 interior: 'Here',677 },678 },679 moreThanAcalaHas,680 );681682 let maliciousXcmProgramSent: any;683 const maxWaitBlocks = 3;684685 // Try to trick Unique686 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {687 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);688689 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);690 });691692 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash693 && event.outcome.isFailedToTransactAsset);694695 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);696 expect(targetAccountBalance).to.be.equal(0n);697698 // But Acala still can send the correct amount699 const validTransferAmount = acalaBalance / 2n;700 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(701 targetAccount.addressRaw,702 {703 Concrete: {704 parents: 0,705 interior: 'Here',706 },707 },708 validTransferAmount,709 );710711 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {712 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);713 });714715 await helper.wait.newBlocks(maxWaitBlocks);716717 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);718 expect(targetAccountBalance).to.be.equal(validTransferAmount);719 });720721 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {722 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);723 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);724725 const uniqueMultilocation = {726 V2: {727 parents: 1,728 interior: {729 X1: {730 Parachain: UNIQUE_CHAIN,731 },732 },733 },734 };735736 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(737 targetAccount.addressRaw,738 {739 Concrete: {740 parents: 1,741 interior: {742 X1: {743 Parachain: UNIQUE_CHAIN,744 },745 },746 },747 },748 testAmount,749 );750751 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(752 targetAccount.addressRaw,753 {754 Concrete: {755 parents: 0,756 interior: 'Here',757 },758 },759 testAmount,760 );761762 let maliciousXcmProgramFullIdSent: any;763 let maliciousXcmProgramHereIdSent: any;764 const maxWaitBlocks = 3;765766 // Try to trick Unique using full UNQ identification767 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {768 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);769770 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);771 });772773 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash774 && event.outcome.isUntrustedReserveLocation);775776 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);777 expect(accountBalance).to.be.equal(0n);778779 // Try to trick Unique using shortened UNQ identification780 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {781 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);782783 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);784 });785786 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash787 && event.outcome.isUntrustedReserveLocation);788789 accountBalance = await helper.balance.getSubstrate(targetAccount.address);790 expect(accountBalance).to.be.equal(0n);791 });792});793794// These tests are relevant only when795// the the corresponding foreign assets are not registered796describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {797 let alice: IKeyringPair;798 let alith: IKeyringPair;799800 const testAmount = 100_000_000_000n;801 let uniqueParachainJunction;802 let uniqueAccountJunction;803804 let uniqueParachainMultilocation: any;805 let uniqueAccountMultilocation: any;806 let uniqueCombinedMultilocation: any;807 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V2808809 let messageSent: any;810811 const maxWaitBlocks = 3;812813 before(async () => {814 await usingPlaygrounds(async (helper, privateKey) => {815 alice = await privateKey('//Alice');816817 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};818 uniqueAccountJunction = {819 AccountId32: {820 network: 'Any',821 id: alice.addressRaw,822 },823 };824825 uniqueParachainMultilocation = {826 V2: {827 parents: 1,828 interior: {829 X1: uniqueParachainJunction,830 },831 },832 };833834 uniqueAccountMultilocation = {835 V2: {836 parents: 0,837 interior: {838 X1: uniqueAccountJunction,839 },840 },841 };842843 uniqueCombinedMultilocation = {844 V2: {845 parents: 1,846 interior: {847 X2: [uniqueParachainJunction, uniqueAccountJunction],848 },849 },850 };851852 uniqueCombinedMultilocationAcala = {853 V2: {854 parents: 1,855 interior: {856 X2: [uniqueParachainJunction, uniqueAccountJunction],857 },858 },859 };860861 // Set the default version to wrap the first message to other chains.862 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);863 });864865 // eslint-disable-next-line require-await866 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {867 alith = helper.account.alithAccount();868 });869 });870871 const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {872 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash873 && event.outcome.isFailedToTransactAsset);874 };875876 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {877 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {878 const id = {879 Token: 'ACA',880 };881 const destination = uniqueCombinedMultilocationAcala;882 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');883884 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);885 });886887 await expectFailedToTransact(helper, messageSent);888 });889890 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {891 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {892 const id = 'SelfReserve';893 const destination = uniqueCombinedMultilocation;894 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');895896 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);897 });898899 await expectFailedToTransact(helper, messageSent);900 });901902 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {903 await usingAstarPlaygrounds(astarUrl, async (helper) => {904 const destinationParachain = uniqueParachainMultilocation;905 const beneficiary = uniqueAccountMultilocation;906 const assets = {907 V2: [{908 id: {909 Concrete: {910 parents: 0,911 interior: 'Here',912 },913 },914 fun: {915 Fungible: testAmount,916 },917 }],918 };919 const feeAssetItem = 0;920921 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [922 destinationParachain,923 beneficiary,924 assets,925 feeAssetItem,926 ]);927928 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);929 });930931 await expectFailedToTransact(helper, messageSent);932 });933});934935describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {936 // Unique constants937 let alice: IKeyringPair;938 let uniqueAssetLocation;939940 let randomAccountUnique: IKeyringPair;941 let randomAccountMoonbeam: IKeyringPair;942943 // Moonbeam constants944 let assetId: string;945946 const uniqueAssetMetadata = {947 name: 'xcUnique',948 symbol: 'xcUNQ',949 decimals: 18,950 isFrozen: false,951 minimalBalance: 1n,952 };953954 let balanceUniqueTokenInit: bigint;955 let balanceUniqueTokenMiddle: bigint;956 let balanceUniqueTokenFinal: bigint;957 let balanceForeignUnqTokenInit: bigint;958 let balanceForeignUnqTokenMiddle: bigint;959 let balanceForeignUnqTokenFinal: bigint;960 let balanceGlmrTokenInit: bigint;961 let balanceGlmrTokenMiddle: bigint;962 let balanceGlmrTokenFinal: bigint;963964 before(async () => {965 await usingPlaygrounds(async (helper, privateKey) => {966 alice = await privateKey('//Alice');967 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);968969 balanceForeignUnqTokenInit = 0n;970971 // Set the default version to wrap the first message to other chains.972 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);973 });974975 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {976 const alithAccount = helper.account.alithAccount();977 const baltatharAccount = helper.account.baltatharAccount();978 const dorothyAccount = helper.account.dorothyAccount();979980 randomAccountMoonbeam = helper.account.create();981982 // >>> Sponsoring Dorothy >>>983 console.log('Sponsoring Dorothy.......');984 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);985 console.log('Sponsoring Dorothy.......DONE');986 // <<< Sponsoring Dorothy <<<987988 uniqueAssetLocation = {989 XCM: {990 parents: 1,991 interior: {X1: {Parachain: UNIQUE_CHAIN}},992 },993 };994 const existentialDeposit = 1n;995 const isSufficient = true;996 const unitsPerSecond = 1n;997 const numAssetsWeightHint = 0;998999 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1000 location: uniqueAssetLocation,1001 metadata: uniqueAssetMetadata,1002 existentialDeposit,1003 isSufficient,1004 unitsPerSecond,1005 numAssetsWeightHint,1006 });10071008 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);10091010 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);10111012 // >>> Acquire Unique AssetId Info on Moonbeam >>>1013 console.log('Acquire Unique AssetId Info on Moonbeam.......');10141015 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();10161017 console.log('UNQ asset ID is %s', assetId);1018 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1019 // >>> Acquire Unique AssetId Info on Moonbeam >>>10201021 // >>> Sponsoring random Account >>>1022 console.log('Sponsoring random Account.......');1023 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1024 console.log('Sponsoring random Account.......DONE');1025 // <<< Sponsoring random Account <<<10261027 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1028 });10291030 await usingPlaygrounds(async (helper) => {1031 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1032 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1033 });1034 });10351036 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1037 const currencyId = {1038 NativeAssetId: 'Here',1039 };1040 const dest = {1041 V2: {1042 parents: 1,1043 interior: {1044 X2: [1045 {Parachain: MOONBEAM_CHAIN},1046 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1047 ],1048 },1049 },1050 };1051 const amount = TRANSFER_AMOUNT;10521053 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');10541055 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1056 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;10571058 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1059 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1060 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;10611062 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1063 await helper.wait.newBlocks(3);10641065 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);10661067 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1068 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1069 expect(glmrFees == 0n).to.be.true;10701071 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;10721073 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1074 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1075 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1076 });1077 });10781079 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1080 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1081 const asset = {1082 V2: {1083 id: {1084 Concrete: {1085 parents: 1,1086 interior: {1087 X1: {Parachain: UNIQUE_CHAIN},1088 },1089 },1090 },1091 fun: {1092 Fungible: TRANSFER_AMOUNT,1093 },1094 },1095 };1096 const destination = {1097 V2: {1098 parents: 1,1099 interior: {1100 X2: [1101 {Parachain: UNIQUE_CHAIN},1102 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1103 ],1104 },1105 },1106 };11071108 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');11091110 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);11111112 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1113 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1114 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;11151116 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);11171118 expect(unqRandomAccountAsset).to.be.null;11191120 balanceForeignUnqTokenFinal = 0n;11211122 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1123 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1124 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1125 });11261127 await helper.wait.newBlocks(3);11281129 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1130 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1131 expect(actuallyDelivered > 0).to.be.true;11321133 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));11341135 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1136 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1137 expect(unqFees == 0n).to.be.true;1138 });11391140 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1141 // set Moonbeam's sovereign account's balance1142 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1143 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1144 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);11451146 const moreThanMoonbeamHas = moonbeamBalance * 2n;11471148 let targetAccountBalance = 0n;1149 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);11501151 const uniqueMultilocation = {1152 V2: {1153 parents: 1,1154 interior: {1155 X1: {Parachain: UNIQUE_CHAIN},1156 },1157 },1158 };11591160 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1161 targetAccount.addressRaw,1162 {1163 Concrete: {1164 parents: 0,1165 interior: 'Here',1166 },1167 },1168 moreThanMoonbeamHas,1169 );11701171 let maliciousXcmProgramSent: any;1172 const maxWaitBlocks = 3;11731174 // Try to trick Unique1175 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1176 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);11771178 // Needed to bypass the call filter.1179 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1180 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);11811182 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1183 });11841185 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1186 && event.outcome.isFailedToTransactAsset);11871188 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1189 expect(targetAccountBalance).to.be.equal(0n);11901191 // But Moonbeam still can send the correct amount1192 const validTransferAmount = moonbeamBalance / 2n;1193 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1194 targetAccount.addressRaw,1195 {1196 Concrete: {1197 parents: 0,1198 interior: 'Here',1199 },1200 },1201 validTransferAmount,1202 );12031204 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1205 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);12061207 // Needed to bypass the call filter.1208 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1209 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1210 });12111212 await helper.wait.newBlocks(maxWaitBlocks);12131214 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1215 expect(targetAccountBalance).to.be.equal(validTransferAmount);1216 });12171218 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1219 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1220 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);12211222 const uniqueMultilocation = {1223 V2: {1224 parents: 1,1225 interior: {1226 X1: {1227 Parachain: UNIQUE_CHAIN,1228 },1229 },1230 },1231 };12321233 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1234 targetAccount.addressRaw,1235 {1236 Concrete: {1237 parents: 0,1238 interior: {1239 X1: {1240 Parachain: UNIQUE_CHAIN,1241 },1242 },1243 },1244 },1245 testAmount,1246 );12471248 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1249 targetAccount.addressRaw,1250 {1251 Concrete: {1252 parents: 0,1253 interior: 'Here',1254 },1255 },1256 testAmount,1257 );12581259 let maliciousXcmProgramFullIdSent: any;1260 let maliciousXcmProgramHereIdSent: any;1261 const maxWaitBlocks = 3;12621263 // Try to trick Unique using full UNQ identification1264 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1265 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);12661267 // Needed to bypass the call filter.1268 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1269 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);12701271 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1272 });12731274 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1275 && event.outcome.isUntrustedReserveLocation);12761277 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1278 expect(accountBalance).to.be.equal(0n);12791280 // Try to trick Unique using shortened UNQ identification1281 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1282 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);12831284 // Needed to bypass the call filter.1285 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1286 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);12871288 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1289 });12901291 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1292 && event.outcome.isUntrustedReserveLocation);12931294 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1295 expect(accountBalance).to.be.equal(0n);1296 });1297});12981299describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1300 let alice: IKeyringPair;1301 let randomAccount: IKeyringPair;13021303 const UNQ_ASSET_ID_ON_ASTAR = 1;1304 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;13051306 // Unique -> Astar1307 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1308 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1309 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1310 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens13111312 // Astar -> Unique1313 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1314 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ13151316 let balanceAfterUniqueToAstarXCM: bigint;13171318 before(async () => {1319 await usingPlaygrounds(async (helper, privateKey) => {1320 alice = await privateKey('//Alice');1321 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1322 console.log('randomAccount', randomAccount.address);13231324 // Set the default version to wrap the first message to other chains.1325 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1326 });13271328 await usingAstarPlaygrounds(astarUrl, async (helper) => {1329 console.log('1. Create foreign asset and metadata');1330 // TODO update metadata with values from production1331 await helper.assets.create(1332 alice,1333 UNQ_ASSET_ID_ON_ASTAR,1334 alice.address,1335 UNQ_MINIMAL_BALANCE_ON_ASTAR,1336 );13371338 await helper.assets.setMetadata(1339 alice,1340 UNQ_ASSET_ID_ON_ASTAR,1341 'Cross chain UNQ',1342 'xcUNQ',1343 Number(UNQ_DECIMALS),1344 );13451346 console.log('2. Register asset location on Astar');1347 const assetLocation = {1348 V2: {1349 parents: 1,1350 interior: {1351 X1: {1352 Parachain: UNIQUE_CHAIN,1353 },1354 },1355 },1356 };13571358 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);13591360 console.log('3. Set UNQ payment for XCM execution on Astar');1361 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);13621363 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1364 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1365 });1366 });13671368 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1369 const destination = {1370 V2: {1371 parents: 1,1372 interior: {1373 X1: {1374 Parachain: ASTAR_CHAIN,1375 },1376 },1377 },1378 };13791380 const beneficiary = {1381 V2: {1382 parents: 0,1383 interior: {1384 X1: {1385 AccountId32: {1386 network: 'Any',1387 id: randomAccount.addressRaw,1388 },1389 },1390 },1391 },1392 };13931394 const assets = {1395 V2: [1396 {1397 id: {1398 Concrete: {1399 parents: 0,1400 interior: 'Here',1401 },1402 },1403 fun: {1404 Fungible: unqToAstarTransferred,1405 },1406 },1407 ],1408 };14091410 // Initial balance is 100 UNQ1411 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1412 console.log(`Initial balance is: ${balanceBefore}`);14131414 const feeAssetItem = 0;1415 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');14161417 // Balance after reserve transfer is less than 901418 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1419 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1420 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1421 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;14221423 await usingAstarPlaygrounds(astarUrl, async (helper) => {1424 await helper.wait.newBlocks(3);1425 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1426 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);14271428 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1429 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);14301431 expect(xcUNQbalance).to.eq(unqToAstarArrived);1432 // Astar balance does not changed1433 expect(astarBalance).to.eq(astarInitialBalance);1434 });1435 });14361437 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1438 await usingAstarPlaygrounds(astarUrl, async (helper) => {1439 const destination = {1440 V2: {1441 parents: 1,1442 interior: {1443 X1: {1444 Parachain: UNIQUE_CHAIN,1445 },1446 },1447 },1448 };14491450 const beneficiary = {1451 V2: {1452 parents: 0,1453 interior: {1454 X1: {1455 AccountId32: {1456 network: 'Any',1457 id: randomAccount.addressRaw,1458 },1459 },1460 },1461 },1462 };14631464 const assets = {1465 V2: [1466 {1467 id: {1468 Concrete: {1469 parents: 1,1470 interior: {1471 X1: {1472 Parachain: UNIQUE_CHAIN,1473 },1474 },1475 },1476 },1477 fun: {1478 Fungible: unqFromAstarTransfered,1479 },1480 },1481 ],1482 };14831484 // Initial balance is 1 ASTR1485 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1486 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1487 expect(balanceASTRbefore).to.eq(astarInitialBalance);14881489 const feeAssetItem = 0;1490 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1491 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);14921493 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1494 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1495 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);14961497 // Assert: xcUNQ balance correctly decreased1498 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1499 // Assert: ASTR balance is 0.996...1500 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1501 });15021503 await helper.wait.newBlocks(3);1504 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1505 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1506 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1507 });15081509 itSub('Astar can send only up to its balance', async ({helper}) => {1510 // set Astar's sovereign account's balance1511 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1512 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1513 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);15141515 const moreThanAstarHas = astarBalance * 2n;15161517 let targetAccountBalance = 0n;1518 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);15191520 const uniqueMultilocation = {1521 V2: {1522 parents: 1,1523 interior: {1524 X1: {Parachain: UNIQUE_CHAIN},1525 },1526 },1527 };15281529 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1530 targetAccount.addressRaw,1531 {1532 Concrete: {1533 parents: 0,1534 interior: 'Here',1535 },1536 },1537 moreThanAstarHas,1538 );15391540 let maliciousXcmProgramSent: any;1541 const maxWaitBlocks = 3;15421543 // Try to trick Unique1544 await usingAstarPlaygrounds(astarUrl, async (helper) => {1545 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);15461547 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1548 });15491550 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1551 && event.outcome.isFailedToTransactAsset);15521553 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1554 expect(targetAccountBalance).to.be.equal(0n);15551556 // But Astar still can send the correct amount1557 const validTransferAmount = astarBalance / 2n;1558 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1559 targetAccount.addressRaw,1560 {1561 Concrete: {1562 parents: 0,1563 interior: 'Here',1564 },1565 },1566 validTransferAmount,1567 );15681569 await usingAstarPlaygrounds(astarUrl, async (helper) => {1570 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1571 });15721573 await helper.wait.newBlocks(maxWaitBlocks);15741575 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1576 expect(targetAccountBalance).to.be.equal(validTransferAmount);1577 });15781579 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1580 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1581 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);15821583 const uniqueMultilocation = {1584 V2: {1585 parents: 1,1586 interior: {1587 X1: {1588 Parachain: UNIQUE_CHAIN,1589 },1590 },1591 },1592 };15931594 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1595 targetAccount.addressRaw,1596 {1597 Concrete: {1598 parents: 1,1599 interior: {1600 X1: {1601 Parachain: UNIQUE_CHAIN,1602 },1603 },1604 },1605 },1606 testAmount,1607 );16081609 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1610 targetAccount.addressRaw,1611 {1612 Concrete: {1613 parents: 0,1614 interior: 'Here',1615 },1616 },1617 testAmount,1618 );16191620 let maliciousXcmProgramFullIdSent: any;1621 let maliciousXcmProgramHereIdSent: any;1622 const maxWaitBlocks = 3;16231624 // Try to trick Unique using full UNQ identification1625 await usingAstarPlaygrounds(astarUrl, async (helper) => {1626 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);16271628 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1629 });16301631 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1632 && event.outcome.isUntrustedReserveLocation);16331634 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1635 expect(accountBalance).to.be.equal(0n);16361637 // Try to trick Unique using shortened UNQ identification1638 await usingAstarPlaygrounds(astarUrl, async (helper) => {1639 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);16401641 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1642 });16431644 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1645 && event.outcome.isUntrustedReserveLocation);16461647 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1648 expect(accountBalance).to.be.equal(0n);1649 });1650});1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import config from '../config';19import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds} from '../util';20import {DevUniqueHelper, Event} from '../util/playgrounds/unique.dev';21import {nToBigInt} from '@polkadot/util';2223const UNIQUE_CHAIN = +(process.env.RELAY_UNIQUE_ID || 2037);24const STATEMINT_CHAIN = +(process.env.RELAY_STATEMINT_ID || 1000);25const ACALA_CHAIN = +(process.env.RELAY_ACALA_ID || 2000);26const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);27const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);28const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);2930const STATEMINT_PALLET_INSTANCE = 50;3132const relayUrl = config.relayUrl;33const statemintUrl = config.statemintUrl;34const acalaUrl = config.acalaUrl;35const moonbeamUrl = config.moonbeamUrl;36const astarUrl = config.astarUrl;37const polkadexUrl = config.polkadexUrl;3839const RELAY_DECIMALS = 12;40const STATEMINT_DECIMALS = 12;41const ACALA_DECIMALS = 12;42const ASTAR_DECIMALS = 18n;43const UNQ_DECIMALS = 18n;4445const TRANSFER_AMOUNT = 2000000000000000000000000n;4647const FUNDING_AMOUNT = 3_500_000_0000_000_000n;4849const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;5051const USDT_ASSET_ID = 100;52const USDT_ASSET_METADATA_DECIMALS = 18;53const USDT_ASSET_METADATA_NAME = 'USDT';54const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';55const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;56const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;5758const SAFE_XCM_VERSION = 2;5960describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {61 let alice: IKeyringPair;62 let bob: IKeyringPair;6364 let balanceStmnBefore: bigint;65 let balanceStmnAfter: bigint;6667 let balanceUniqueBefore: bigint;68 let balanceUniqueAfter: bigint;69 let balanceUniqueFinal: bigint;7071 let balanceBobBefore: bigint;72 let balanceBobAfter: bigint;73 let balanceBobFinal: bigint;7475 let balanceBobRelayTokenBefore: bigint;76 let balanceBobRelayTokenAfter: bigint;777879 before(async () => {80 await usingPlaygrounds(async (helper, privateKey) => {81 alice = await privateKey('//Alice');82 bob = await privateKey('//Bob'); // sovereign account on Statemint funds donor8384 // Set the default version to wrap the first message to other chains.85 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);86 });8788 await usingRelayPlaygrounds(relayUrl, async (helper) => {89 // Fund accounts on Statemint90 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, alice.addressRaw, FUNDING_AMOUNT);91 await helper.xcm.teleportNativeAsset(alice, STATEMINT_CHAIN, bob.addressRaw, FUNDING_AMOUNT);92 });9394 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {95 const sovereignFundingAmount = 3_500_000_000n;9697 await helper.assets.create(98 alice,99 USDT_ASSET_ID,100 alice.address,101 USDT_ASSET_METADATA_MINIMAL_BALANCE,102 );103 await helper.assets.setMetadata(104 alice,105 USDT_ASSET_ID,106 USDT_ASSET_METADATA_NAME,107 USDT_ASSET_METADATA_DESCRIPTION,108 USDT_ASSET_METADATA_DECIMALS,109 );110 await helper.assets.mint(111 alice,112 USDT_ASSET_ID,113 alice.address,114 USDT_ASSET_AMOUNT,115 );116117 // funding parachain sovereing account on Statemint.118 // The sovereign account should be created before any action119 // (the assets pallet on Statemint check if the sovereign account exists)120 const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);121 await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);122 });123124125 await usingPlaygrounds(async (helper) => {126 const location = {127 V2: {128 parents: 1,129 interior: {X3: [130 {131 Parachain: STATEMINT_CHAIN,132 },133 {134 PalletInstance: STATEMINT_PALLET_INSTANCE,135 },136 {137 GeneralIndex: USDT_ASSET_ID,138 },139 ]},140 },141 };142143 const metadata =144 {145 name: USDT_ASSET_ID,146 symbol: USDT_ASSET_METADATA_NAME,147 decimals: USDT_ASSET_METADATA_DECIMALS,148 minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,149 };150 await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);151 balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);152 });153154155 // Providing the relay currency to the unique sender account156 // (fee for USDT XCM are paid in relay tokens)157 await usingRelayPlaygrounds(relayUrl, async (helper) => {158 const destination = {159 V2: {160 parents: 0,161 interior: {X1: {162 Parachain: UNIQUE_CHAIN,163 },164 },165 }};166167 const beneficiary = {168 V2: {169 parents: 0,170 interior: {X1: {171 AccountId32: {172 network: 'Any',173 id: alice.addressRaw,174 },175 }},176 },177 };178179 const assets = {180 V2: [181 {182 id: {183 Concrete: {184 parents: 0,185 interior: 'Here',186 },187 },188 fun: {189 Fungible: TRANSFER_AMOUNT_RELAY,190 },191 },192 ],193 };194195 const feeAssetItem = 0;196197 await helper.xcm.limitedReserveTransferAssets(alice, destination, beneficiary, assets, feeAssetItem, 'Unlimited');198 });199200 });201202 itSub('Should connect and send USDT from Statemint to Unique', async ({helper}) => {203 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {204 const dest = {205 V2: {206 parents: 1,207 interior: {X1: {208 Parachain: UNIQUE_CHAIN,209 },210 },211 }};212213 const beneficiary = {214 V2: {215 parents: 0,216 interior: {X1: {217 AccountId32: {218 network: 'Any',219 id: alice.addressRaw,220 },221 }},222 },223 };224225 const assets = {226 V2: [227 {228 id: {229 Concrete: {230 parents: 0,231 interior: {232 X2: [233 {234 PalletInstance: STATEMINT_PALLET_INSTANCE,235 },236 {237 GeneralIndex: USDT_ASSET_ID,238 },239 ]},240 },241 },242 fun: {243 Fungible: TRANSFER_AMOUNT,244 },245 },246 ],247 };248249 const feeAssetItem = 0;250251 balanceStmnBefore = await helper.balance.getSubstrate(alice.address);252 await helper.xcm.limitedReserveTransferAssets(alice, dest, beneficiary, assets, feeAssetItem, 'Unlimited');253254 balanceStmnAfter = await helper.balance.getSubstrate(alice.address);255256 // common good parachain take commission in it native token257 console.log(258 '[Statemint -> Unique] transaction fees on Statemint: %s WND',259 helper.util.bigIntToDecimals(balanceStmnBefore - balanceStmnAfter, STATEMINT_DECIMALS),260 );261 expect(balanceStmnBefore > balanceStmnAfter).to.be.true;262263 });264265266 // ensure that asset has been delivered267 await helper.wait.newBlocks(3);268269 // expext collection id will be with id 1270 const free = await helper.ft.getBalance(1, {Substrate: alice.address});271272 balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);273274 console.log(275 '[Statemint -> Unique] transaction fees on Unique: %s USDT',276 helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),277 );278 console.log(279 '[Statemint -> Unique] transaction fees on Unique: %s UNQ',280 helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueBefore),281 );282 // commission has not paid in USDT token283 expect(free).to.be.equal(TRANSFER_AMOUNT);284 // ... and parachain native token285 expect(balanceUniqueAfter == balanceUniqueBefore).to.be.true;286 });287288 itSub('Should connect and send USDT from Unique to Statemint back', async ({helper}) => {289 const destination = {290 V2: {291 parents: 1,292 interior: {X2: [293 {294 Parachain: STATEMINT_CHAIN,295 },296 {297 AccountId32: {298 network: 'Any',299 id: alice.addressRaw,300 },301 },302 ]},303 },304 };305306 const relayFee = 400_000_000_000_000n;307 const currencies: [any, bigint][] = [308 [309 {310 ForeignAssetId: 0,311 },312 TRANSFER_AMOUNT,313 ],314 [315 {316 NativeAssetId: 'Parent',317 },318 relayFee,319 ],320 ];321322 const feeItem = 1;323324 await helper.xTokens.transferMulticurrencies(alice, currencies, feeItem, destination, 'Unlimited');325326 // the commission has been paid in parachain native token327 balanceUniqueFinal = await helper.balance.getSubstrate(alice.address);328 console.log('[Unique -> Statemint] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(balanceUniqueAfter - balanceUniqueFinal));329 expect(balanceUniqueAfter > balanceUniqueFinal).to.be.true;330331 await usingStatemintPlaygrounds(statemintUrl, async (helper) => {332 await helper.wait.newBlocks(3);333334 // The USDT token never paid fees. Its amount not changed from begin value.335 // Also check that xcm transfer has been succeeded336 expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;337 });338 });339340 itSub('Should connect and send Relay token to Unique', async ({helper}) => {341 balanceBobBefore = await helper.balance.getSubstrate(bob.address);342 balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});343344 await usingRelayPlaygrounds(relayUrl, async (helper) => {345 const destination = {346 V2: {347 parents: 0,348 interior: {X1: {349 Parachain: UNIQUE_CHAIN,350 },351 },352 }};353354 const beneficiary = {355 V2: {356 parents: 0,357 interior: {X1: {358 AccountId32: {359 network: 'Any',360 id: bob.addressRaw,361 },362 }},363 },364 };365366 const assets = {367 V2: [368 {369 id: {370 Concrete: {371 parents: 0,372 interior: 'Here',373 },374 },375 fun: {376 Fungible: TRANSFER_AMOUNT_RELAY,377 },378 },379 ],380 };381382 const feeAssetItem = 0;383384 await helper.xcm.limitedReserveTransferAssets(bob, destination, beneficiary, assets, feeAssetItem, 'Unlimited');385 });386387 await helper.wait.newBlocks(3);388389 balanceBobAfter = await helper.balance.getSubstrate(bob.address);390 balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});391392 const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;393 const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;394 console.log(395 '[Relay (Westend) -> Unique] transaction fees: %s UNQ',396 helper.util.bigIntToDecimals(balanceBobAfter - balanceBobBefore),397 );398 console.log(399 '[Relay (Westend) -> Unique] transaction fees: %s WND',400 helper.util.bigIntToDecimals(wndFeeOnUnique, STATEMINT_DECIMALS),401 );402 console.log('[Relay (Westend) -> Unique] actually delivered: %s WND', wndDiffOnUnique);403 expect(wndFeeOnUnique == 0n, 'No incoming WND fees should be taken').to.be.true;404 expect(balanceBobBefore == balanceBobAfter, 'No incoming UNQ fees should be taken').to.be.true;405 });406407 itSub('Should connect and send Relay token back', async ({helper}) => {408 let relayTokenBalanceBefore: bigint;409 let relayTokenBalanceAfter: bigint;410 await usingRelayPlaygrounds(relayUrl, async (helper) => {411 relayTokenBalanceBefore = await helper.balance.getSubstrate(bob.address);412 });413414 const destination = {415 V2: {416 parents: 1,417 interior: {418 X1:{419 AccountId32: {420 network: 'Any',421 id: bob.addressRaw,422 },423 },424 },425 },426 };427428 const currencies: any = [429 [430 {431 NativeAssetId: 'Parent',432 },433 TRANSFER_AMOUNT_RELAY,434 ],435 ];436437 const feeItem = 0;438439 await helper.xTokens.transferMulticurrencies(bob, currencies, feeItem, destination, 'Unlimited');440441 balanceBobFinal = await helper.balance.getSubstrate(bob.address);442 console.log('[Unique -> Relay (Westend)] transaction fees: %s UNQ', helper.util.bigIntToDecimals(balanceBobAfter - balanceBobFinal));443444 await usingRelayPlaygrounds(relayUrl, async (helper) => {445 await helper.wait.newBlocks(10);446 relayTokenBalanceAfter = await helper.balance.getSubstrate(bob.address);447448 const diff = relayTokenBalanceAfter - relayTokenBalanceBefore;449 console.log('[Unique -> Relay (Westend)] actually delivered: %s WND', helper.util.bigIntToDecimals(diff, RELAY_DECIMALS));450 expect(diff > 0, 'Relay tokens was not delivered back').to.be.true;451 });452 });453});454455describeXCM('[XCM] Integration test: Exchanging tokens with Acala', () => {456 let alice: IKeyringPair;457 let randomAccount: IKeyringPair;458459 let balanceUniqueTokenInit: bigint;460 let balanceUniqueTokenMiddle: bigint;461 let balanceUniqueTokenFinal: bigint;462 let balanceAcalaTokenInit: bigint;463 let balanceAcalaTokenMiddle: bigint;464 let balanceAcalaTokenFinal: bigint;465 let balanceUniqueForeignTokenInit: bigint;466 let balanceUniqueForeignTokenMiddle: bigint;467 let balanceUniqueForeignTokenFinal: bigint;468469 // computed by a test transfer from prod Unique to prod Acala.470 // 2 UNQ sent https://unique.subscan.io/xcm_message/polkadot-bad0b68847e2398af25d482e9ee6f9c1f9ec2a48471 // 1.898970000000000000 UNQ received (you can check Acala's chain state in the corresponding block)472 const expectedAcalaIncomeFee = 2000000000000000000n - 1898970000000000000n;473 const acalaEps = 8n * 10n ** 16n;474475 let acalaBackwardTransferAmount: bigint;476477 before(async () => {478 await usingPlaygrounds(async (helper, privateKey) => {479 alice = await privateKey('//Alice');480 [randomAccount] = await helper.arrange.createAccounts([0n], alice);481482 // Set the default version to wrap the first message to other chains.483 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);484 });485486 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {487 const destination = {488 V2: {489 parents: 1,490 interior: {491 X1: {492 Parachain: UNIQUE_CHAIN,493 },494 },495 },496 };497498 const metadata = {499 name: 'Unique Network',500 symbol: 'UNQ',501 decimals: 18,502 minimalBalance: 1250000000000000000n,503 };504505 await helper.getSudo().assetRegistry.registerForeignAsset(alice, destination, metadata);506 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);507 balanceAcalaTokenInit = await helper.balance.getSubstrate(randomAccount.address);508 balanceUniqueForeignTokenInit = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});509 });510511 await usingPlaygrounds(async (helper) => {512 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);513 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);514 });515 });516517 itSub('Should connect and send UNQ to Acala', async ({helper}) => {518519 const destination = {520 V2: {521 parents: 1,522 interior: {523 X1: {524 Parachain: ACALA_CHAIN,525 },526 },527 },528 };529530 const beneficiary = {531 V2: {532 parents: 0,533 interior: {534 X1: {535 AccountId32: {536 network: 'Any',537 id: randomAccount.addressRaw,538 },539 },540 },541 },542 };543544 const assets = {545 V2: [546 {547 id: {548 Concrete: {549 parents: 0,550 interior: 'Here',551 },552 },553 fun: {554 Fungible: TRANSFER_AMOUNT,555 },556 },557 ],558 };559560 const feeAssetItem = 0;561562 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');563 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);564565 const unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;566 console.log('[Unique -> Acala] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));567 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;568569 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {570 await helper.wait.newBlocks(3);571572 balanceUniqueForeignTokenMiddle = await helper.tokens.accounts(randomAccount.address, {ForeignAsset: 0});573 balanceAcalaTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);574575 const acaFees = balanceAcalaTokenInit - balanceAcalaTokenMiddle;576 const unqIncomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenInit;577 acalaBackwardTransferAmount = unqIncomeTransfer;578579 const acaUnqFees = TRANSFER_AMOUNT - unqIncomeTransfer;580581 console.log(582 '[Unique -> Acala] transaction fees on Acala: %s ACA',583 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),584 );585 console.log(586 '[Unique -> Acala] transaction fees on Acala: %s UNQ',587 helper.util.bigIntToDecimals(acaUnqFees),588 );589 console.log('[Unique -> Acala] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));590 expect(acaFees == 0n).to.be.true;591592 const bigintAbs = (n: bigint) => (n < 0n) ? -n : n;593594 expect(595 bigintAbs(acaUnqFees - expectedAcalaIncomeFee) < acalaEps,596 'Acala took different income fee, check the Acala foreign asset config',597 ).to.be.true;598 });599 });600601 itSub('Should connect to Acala and send UNQ back', async ({helper}) => {602 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {603 const destination = {604 V2: {605 parents: 1,606 interior: {607 X2: [608 {Parachain: UNIQUE_CHAIN},609 {610 AccountId32: {611 network: 'Any',612 id: randomAccount.addressRaw,613 },614 },615 ],616 },617 },618 };619620 const id = {621 ForeignAsset: 0,622 };623624 await helper.xTokens.transfer(randomAccount, id, acalaBackwardTransferAmount, destination, 'Unlimited');625 balanceAcalaTokenFinal = await helper.balance.getSubstrate(randomAccount.address);626 balanceUniqueForeignTokenFinal = await helper.tokens.accounts(randomAccount.address, id);627628 const acaFees = balanceAcalaTokenMiddle - balanceAcalaTokenFinal;629 const unqOutcomeTransfer = balanceUniqueForeignTokenMiddle - balanceUniqueForeignTokenFinal;630631 console.log(632 '[Acala -> Unique] transaction fees on Acala: %s ACA',633 helper.util.bigIntToDecimals(acaFees, ACALA_DECIMALS),634 );635 console.log('[Acala -> Unique] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));636637 expect(acaFees > 0, 'Negative fees ACA, looks like nothing was transferred').to.be.true;638 expect(unqOutcomeTransfer == acalaBackwardTransferAmount).to.be.true;639 });640641 await helper.wait.newBlocks(3);642643 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);644 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;645 expect(actuallyDelivered > 0).to.be.true;646647 console.log('[Acala -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));648649 const unqFees = acalaBackwardTransferAmount - actuallyDelivered;650 console.log('[Acala -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));651 expect(unqFees == 0n).to.be.true;652 });653654 itSub('Acala can send only up to its balance', async ({helper}) => {655 // set Acala's sovereign account's balance656 const acalaBalance = 10000n * (10n ** UNQ_DECIMALS);657 const acalaSovereignAccount = helper.address.paraSiblingSovereignAccount(ACALA_CHAIN);658 await helper.getSudo().balance.setBalanceSubstrate(alice, acalaSovereignAccount, acalaBalance);659660 const moreThanAcalaHas = acalaBalance * 2n;661662 let targetAccountBalance = 0n;663 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);664665 const uniqueMultilocation = {666 V2: {667 parents: 1,668 interior: {669 X1: {Parachain: UNIQUE_CHAIN},670 },671 },672 };673674 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(675 targetAccount.addressRaw,676 {677 Concrete: {678 parents: 0,679 interior: 'Here',680 },681 },682 moreThanAcalaHas,683 );684685 let maliciousXcmProgramSent: any;686 const maxWaitBlocks = 3;687688 // Try to trick Unique689 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {690 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);691692 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);693 });694695 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash696 && event.outcome.isFailedToTransactAsset);697698 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);699 expect(targetAccountBalance).to.be.equal(0n);700701 // But Acala still can send the correct amount702 const validTransferAmount = acalaBalance / 2n;703 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(704 targetAccount.addressRaw,705 {706 Concrete: {707 parents: 0,708 interior: 'Here',709 },710 },711 validTransferAmount,712 );713714 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {715 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);716 });717718 await helper.wait.newBlocks(maxWaitBlocks);719720 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);721 expect(targetAccountBalance).to.be.equal(validTransferAmount);722 });723724 itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {725 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);726 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);727728 const uniqueMultilocation = {729 V2: {730 parents: 1,731 interior: {732 X1: {733 Parachain: UNIQUE_CHAIN,734 },735 },736 },737 };738739 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(740 targetAccount.addressRaw,741 {742 Concrete: {743 parents: 1,744 interior: {745 X1: {746 Parachain: UNIQUE_CHAIN,747 },748 },749 },750 },751 testAmount,752 );753754 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(755 targetAccount.addressRaw,756 {757 Concrete: {758 parents: 0,759 interior: 'Here',760 },761 },762 testAmount,763 );764765 let maliciousXcmProgramFullIdSent: any;766 let maliciousXcmProgramHereIdSent: any;767 const maxWaitBlocks = 3;768769 // Try to trick Unique using full UNQ identification770 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {771 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);772773 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);774 });775776 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash777 && event.outcome.isUntrustedReserveLocation);778779 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);780 expect(accountBalance).to.be.equal(0n);781782 // Try to trick Unique using shortened UNQ identification783 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {784 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);785786 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);787 });788789 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash790 && event.outcome.isUntrustedReserveLocation);791792 accountBalance = await helper.balance.getSubstrate(targetAccount.address);793 expect(accountBalance).to.be.equal(0n);794 });795});796797describeXCM('[XCM] Integration test: Exchanging tokens with Polkadex', () => {798 let alice: IKeyringPair;799 let randomAccount: IKeyringPair;800 let unqFees: bigint;801 let balanceUniqueTokenInit: bigint;802 let balanceUniqueTokenMiddle: bigint;803 let balanceUniqueTokenFinal: bigint;804 const maxWaitBlocks = 6;805806 const uniqueAssetId = {807 Concrete: {808 parents: 1,809 interior: {810 X1: {811 Parachain: UNIQUE_CHAIN,812 },813 },814 },815 };816817 before(async () => {818 await usingPlaygrounds(async (helper, privateKey) => {819 alice = await privateKey('//Alice');820 [randomAccount] = await helper.arrange.createAccounts([0n], alice);821822 // Set the default version to wrap the first message to other chains.823 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);824 });825826 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {827 const isWhitelisted = ((await helper.callRpc('api.query.xcmHelper.whitelistedTokens', [])).toJSON() as [])828 .map(nToBigInt).length != 0;829830 if(!isWhitelisted) {831 await helper.getSudo().xcmHelper.whitelistToken(alice, uniqueAssetId);832 }833834 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);835 });836837 await usingPlaygrounds(async (helper) => {838 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);839 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccount.address);840 });841 });842843 itSub('Should connect and send UNQ to Polkadex', async ({helper}) => {844845 const destination = {846 V2: {847 parents: 1,848 interior: {849 X1: {850 Parachain: POLKADEX_CHAIN,851 },852 },853 },854 };855856 const beneficiary = {857 V2: {858 parents: 0,859 interior: {860 X1: {861 AccountId32: {862 network: 'Any',863 id: randomAccount.addressRaw,864 },865 },866 },867 },868 };869870 const assets = {871 V2: [872 {873 id: {874 Concrete: {875 parents: 0,876 interior: 'Here',877 },878 },879 fun: {880 Fungible: TRANSFER_AMOUNT,881 },882 },883 ],884 };885886 const feeAssetItem = 0;887888 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');889 const messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);890 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);891892 unqFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;893 console.log('[Unique -> Polkadex] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));894 expect(unqFees > 0n, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;895896 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {897 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);898 });899 });900901902 itSub('Should connect to Polkadex and send UNQ back', async ({helper}) => {903904 const uniqueMultilocation = {905 V2: {906 parents: 1,907 interior: {908 X1: {Parachain: UNIQUE_CHAIN},909 },910 },911 };912913 const xcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(914 randomAccount.addressRaw,915 {916 Concrete: {917 parents: 0,918 interior: 'Here',919 },920 },921 TRANSFER_AMOUNT,922 );923924 let xcmProgramSent: any;925926927 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {928 await helper.getSudo().xcm.send(alice, uniqueMultilocation, xcmProgram);929930 xcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);931 });932933 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == xcmProgramSent.messageHash);934935 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccount.address);936937 expect(balanceUniqueTokenFinal).to.be.equal(balanceUniqueTokenInit - unqFees);938 });939940 itSub('Polkadex can send only up to its balance', async ({helper}) => {941 const polkadexBalance = 10000n * (10n ** UNQ_DECIMALS);942 const polkadexSovereignAccount = helper.address.paraSiblingSovereignAccount(POLKADEX_CHAIN);943 await helper.getSudo().balance.setBalanceSubstrate(alice, polkadexSovereignAccount, polkadexBalance);944 const moreThanPolkadexHas = 2n * polkadexBalance;945946 const targetAccount = helper.arrange.createEmptyAccount();947948 const uniqueMultilocation = {949 V2: {950 parents: 1,951 interior: {952 X1: {Parachain: UNIQUE_CHAIN},953 },954 },955 };956957 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(958 targetAccount.addressRaw,959 {960 Concrete: {961 parents: 0,962 interior: 'Here',963 },964 },965 moreThanPolkadexHas,966 );967968 let maliciousXcmProgramSent: any;969970971 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {972 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);973974 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);975 });976977 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash);978979 const targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);980 expect(targetAccountBalance).to.be.equal(0n);981 });982});983984// These tests are relevant only when985// the the corresponding foreign assets are not registered986describeXCM('[XCM] Integration test: Unique rejects non-native tokens', () => {987 let alice: IKeyringPair;988 let alith: IKeyringPair;989990 const testAmount = 100_000_000_000n;991 let uniqueParachainJunction;992 let uniqueAccountJunction;993994 let uniqueParachainMultilocation: any;995 let uniqueAccountMultilocation: any;996 let uniqueCombinedMultilocation: any;997 let uniqueCombinedMultilocationAcala: any; // TODO remove when Acala goes V2998999 let messageSent: any;10001001 const maxWaitBlocks = 3;10021003 before(async () => {1004 await usingPlaygrounds(async (helper, privateKey) => {1005 alice = await privateKey('//Alice');10061007 uniqueParachainJunction = {Parachain: UNIQUE_CHAIN};1008 uniqueAccountJunction = {1009 AccountId32: {1010 network: 'Any',1011 id: alice.addressRaw,1012 },1013 };10141015 uniqueParachainMultilocation = {1016 V2: {1017 parents: 1,1018 interior: {1019 X1: uniqueParachainJunction,1020 },1021 },1022 };10231024 uniqueAccountMultilocation = {1025 V2: {1026 parents: 0,1027 interior: {1028 X1: uniqueAccountJunction,1029 },1030 },1031 };10321033 uniqueCombinedMultilocation = {1034 V2: {1035 parents: 1,1036 interior: {1037 X2: [uniqueParachainJunction, uniqueAccountJunction],1038 },1039 },1040 };10411042 uniqueCombinedMultilocationAcala = {1043 V2: {1044 parents: 1,1045 interior: {1046 X2: [uniqueParachainJunction, uniqueAccountJunction],1047 },1048 },1049 };10501051 // Set the default version to wrap the first message to other chains.1052 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1053 });10541055 // eslint-disable-next-line require-await1056 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1057 alith = helper.account.alithAccount();1058 });1059 });10601061 const expectFailedToTransact = async (helper: DevUniqueHelper, messageSent: any) => {1062 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash1063 && event.outcome.isFailedToTransactAsset);1064 };10651066 itSub('Unique rejects ACA tokens from Acala', async ({helper}) => {1067 await usingAcalaPlaygrounds(acalaUrl, async (helper) => {1068 const id = {1069 Token: 'ACA',1070 };1071 const destination = uniqueCombinedMultilocationAcala;1072 await helper.xTokens.transfer(alice, id, testAmount, destination, 'Unlimited');10731074 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1075 });10761077 await expectFailedToTransact(helper, messageSent);1078 });10791080 itSub('Unique rejects GLMR tokens from Moonbeam', async ({helper}) => {1081 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1082 const id = 'SelfReserve';1083 const destination = uniqueCombinedMultilocation;1084 await helper.xTokens.transfer(alith, id, testAmount, destination, 'Unlimited');10851086 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1087 });10881089 await expectFailedToTransact(helper, messageSent);1090 });10911092 itSub('Unique rejects ASTR tokens from Astar', async ({helper}) => {1093 await usingAstarPlaygrounds(astarUrl, async (helper) => {1094 const destinationParachain = uniqueParachainMultilocation;1095 const beneficiary = uniqueAccountMultilocation;1096 const assets = {1097 V2: [{1098 id: {1099 Concrete: {1100 parents: 0,1101 interior: 'Here',1102 },1103 },1104 fun: {1105 Fungible: testAmount,1106 },1107 }],1108 };1109 const feeAssetItem = 0;11101111 await helper.executeExtrinsic(alice, 'api.tx.polkadotXcm.reserveWithdrawAssets', [1112 destinationParachain,1113 beneficiary,1114 assets,1115 feeAssetItem,1116 ]);11171118 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1119 });11201121 await expectFailedToTransact(helper, messageSent);1122 });11231124 itSub('Unique rejects PDX tokens from Polkadex', async ({helper}) => {11251126 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1127 helper.arrange.createEmptyAccount().addressRaw,1128 {1129 Concrete: {1130 parents: 1,1131 interior: {1132 X1: {1133 Parachain: POLKADEX_CHAIN,1134 },1135 },1136 },1137 },1138 testAmount,1139 );11401141 await usingPolkadexPlaygrounds(polkadexUrl, async (helper) => {1142 await helper.getSudo().xcm.send(alice, uniqueParachainMultilocation, maliciousXcmProgramFullId);1143 messageSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1144 });11451146 await expectFailedToTransact(helper, messageSent);1147 });1148});11491150describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {1151 // Unique constants1152 let alice: IKeyringPair;1153 let uniqueAssetLocation;11541155 let randomAccountUnique: IKeyringPair;1156 let randomAccountMoonbeam: IKeyringPair;11571158 // Moonbeam constants1159 let assetId: string;11601161 const uniqueAssetMetadata = {1162 name: 'xcUnique',1163 symbol: 'xcUNQ',1164 decimals: 18,1165 isFrozen: false,1166 minimalBalance: 1n,1167 };11681169 let balanceUniqueTokenInit: bigint;1170 let balanceUniqueTokenMiddle: bigint;1171 let balanceUniqueTokenFinal: bigint;1172 let balanceForeignUnqTokenInit: bigint;1173 let balanceForeignUnqTokenMiddle: bigint;1174 let balanceForeignUnqTokenFinal: bigint;1175 let balanceGlmrTokenInit: bigint;1176 let balanceGlmrTokenMiddle: bigint;1177 let balanceGlmrTokenFinal: bigint;11781179 before(async () => {1180 await usingPlaygrounds(async (helper, privateKey) => {1181 alice = await privateKey('//Alice');1182 [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);11831184 balanceForeignUnqTokenInit = 0n;11851186 // Set the default version to wrap the first message to other chains.1187 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1188 });11891190 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1191 const alithAccount = helper.account.alithAccount();1192 const baltatharAccount = helper.account.baltatharAccount();1193 const dorothyAccount = helper.account.dorothyAccount();11941195 randomAccountMoonbeam = helper.account.create();11961197 // >>> Sponsoring Dorothy >>>1198 console.log('Sponsoring Dorothy.......');1199 await helper.balance.transferToEthereum(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);1200 console.log('Sponsoring Dorothy.......DONE');1201 // <<< Sponsoring Dorothy <<<12021203 uniqueAssetLocation = {1204 XCM: {1205 parents: 1,1206 interior: {X1: {Parachain: UNIQUE_CHAIN}},1207 },1208 };1209 const existentialDeposit = 1n;1210 const isSufficient = true;1211 const unitsPerSecond = 1n;1212 const numAssetsWeightHint = 0;12131214 const encodedProposal = helper.assetManager.makeRegisterForeignAssetProposal({1215 location: uniqueAssetLocation,1216 metadata: uniqueAssetMetadata,1217 existentialDeposit,1218 isSufficient,1219 unitsPerSecond,1220 numAssetsWeightHint,1221 });12221223 console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);12241225 await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);12261227 // >>> Acquire Unique AssetId Info on Moonbeam >>>1228 console.log('Acquire Unique AssetId Info on Moonbeam.......');12291230 assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();12311232 console.log('UNQ asset ID is %s', assetId);1233 console.log('Acquire Unique AssetId Info on Moonbeam.......DONE');1234 // >>> Acquire Unique AssetId Info on Moonbeam >>>12351236 // >>> Sponsoring random Account >>>1237 console.log('Sponsoring random Account.......');1238 await helper.balance.transferToEthereum(baltatharAccount, randomAccountMoonbeam.address, 11_000_000_000_000_000_000n);1239 console.log('Sponsoring random Account.......DONE');1240 // <<< Sponsoring random Account <<<12411242 balanceGlmrTokenInit = await helper.balance.getEthereum(randomAccountMoonbeam.address);1243 });12441245 await usingPlaygrounds(async (helper) => {1246 await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);1247 balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);1248 });1249 });12501251 itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {1252 const currencyId = {1253 NativeAssetId: 'Here',1254 };1255 const dest = {1256 V2: {1257 parents: 1,1258 interior: {1259 X2: [1260 {Parachain: MOONBEAM_CHAIN},1261 {AccountKey20: {network: 'Any', key: randomAccountMoonbeam.address}},1262 ],1263 },1264 },1265 };1266 const amount = TRANSFER_AMOUNT;12671268 await helper.xTokens.transfer(randomAccountUnique, currencyId, amount, dest, 'Unlimited');12691270 balanceUniqueTokenMiddle = await helper.balance.getSubstrate(randomAccountUnique.address);1271 expect(balanceUniqueTokenMiddle < balanceUniqueTokenInit).to.be.true;12721273 const transactionFees = balanceUniqueTokenInit - balanceUniqueTokenMiddle - TRANSFER_AMOUNT;1274 console.log('[Unique -> Moonbeam] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(transactionFees));1275 expect(transactionFees > 0, 'Negative fees UNQ, looks like nothing was transferred').to.be.true;12761277 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1278 await helper.wait.newBlocks(3);12791280 balanceGlmrTokenMiddle = await helper.balance.getEthereum(randomAccountMoonbeam.address);12811282 const glmrFees = balanceGlmrTokenInit - balanceGlmrTokenMiddle;1283 console.log('[Unique -> Moonbeam] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1284 expect(glmrFees == 0n).to.be.true;12851286 balanceForeignUnqTokenMiddle = (await helper.assets.account(assetId, randomAccountMoonbeam.address))!;12871288 const unqIncomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenInit;1289 console.log('[Unique -> Moonbeam] income %s UNQ', helper.util.bigIntToDecimals(unqIncomeTransfer));1290 expect(unqIncomeTransfer == TRANSFER_AMOUNT).to.be.true;1291 });1292 });12931294 itSub('Should connect to Moonbeam and send UNQ back', async ({helper}) => {1295 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1296 const asset = {1297 V2: {1298 id: {1299 Concrete: {1300 parents: 1,1301 interior: {1302 X1: {Parachain: UNIQUE_CHAIN},1303 },1304 },1305 },1306 fun: {1307 Fungible: TRANSFER_AMOUNT,1308 },1309 },1310 };1311 const destination = {1312 V2: {1313 parents: 1,1314 interior: {1315 X2: [1316 {Parachain: UNIQUE_CHAIN},1317 {AccountId32: {network: 'Any', id: randomAccountUnique.addressRaw}},1318 ],1319 },1320 },1321 };13221323 await helper.xTokens.transferMultiasset(randomAccountMoonbeam, asset, destination, 'Unlimited');13241325 balanceGlmrTokenFinal = await helper.balance.getEthereum(randomAccountMoonbeam.address);13261327 const glmrFees = balanceGlmrTokenMiddle - balanceGlmrTokenFinal;1328 console.log('[Moonbeam -> Unique] transaction fees on Moonbeam: %s GLMR', helper.util.bigIntToDecimals(glmrFees));1329 expect(glmrFees > 0, 'Negative fees GLMR, looks like nothing was transferred').to.be.true;13301331 const unqRandomAccountAsset = await helper.assets.account(assetId, randomAccountMoonbeam.address);13321333 expect(unqRandomAccountAsset).to.be.null;13341335 balanceForeignUnqTokenFinal = 0n;13361337 const unqOutcomeTransfer = balanceForeignUnqTokenMiddle - balanceForeignUnqTokenFinal;1338 console.log('[Unique -> Moonbeam] outcome %s UNQ', helper.util.bigIntToDecimals(unqOutcomeTransfer));1339 expect(unqOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;1340 });13411342 await helper.wait.newBlocks(3);13431344 balanceUniqueTokenFinal = await helper.balance.getSubstrate(randomAccountUnique.address);1345 const actuallyDelivered = balanceUniqueTokenFinal - balanceUniqueTokenMiddle;1346 expect(actuallyDelivered > 0).to.be.true;13471348 console.log('[Moonbeam -> Unique] actually delivered %s UNQ', helper.util.bigIntToDecimals(actuallyDelivered));13491350 const unqFees = TRANSFER_AMOUNT - actuallyDelivered;1351 console.log('[Moonbeam -> Unique] transaction fees on Unique: %s UNQ', helper.util.bigIntToDecimals(unqFees));1352 expect(unqFees == 0n).to.be.true;1353 });13541355 itSub('Moonbeam can send only up to its balance', async ({helper}) => {1356 // set Moonbeam's sovereign account's balance1357 const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);1358 const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);1359 await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);13601361 const moreThanMoonbeamHas = moonbeamBalance * 2n;13621363 let targetAccountBalance = 0n;1364 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);13651366 const uniqueMultilocation = {1367 V2: {1368 parents: 1,1369 interior: {1370 X1: {Parachain: UNIQUE_CHAIN},1371 },1372 },1373 };13741375 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1376 targetAccount.addressRaw,1377 {1378 Concrete: {1379 parents: 0,1380 interior: 'Here',1381 },1382 },1383 moreThanMoonbeamHas,1384 );13851386 let maliciousXcmProgramSent: any;1387 const maxWaitBlocks = 3;13881389 // Try to trick Unique1390 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1391 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);13921393 // Needed to bypass the call filter.1394 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1395 await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);13961397 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1398 });13991400 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1401 && event.outcome.isFailedToTransactAsset);14021403 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1404 expect(targetAccountBalance).to.be.equal(0n);14051406 // But Moonbeam still can send the correct amount1407 const validTransferAmount = moonbeamBalance / 2n;1408 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1409 targetAccount.addressRaw,1410 {1411 Concrete: {1412 parents: 0,1413 interior: 'Here',1414 },1415 },1416 validTransferAmount,1417 );14181419 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1420 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);14211422 // Needed to bypass the call filter.1423 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1424 await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);1425 });14261427 await helper.wait.newBlocks(maxWaitBlocks);14281429 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1430 expect(targetAccountBalance).to.be.equal(validTransferAmount);1431 });14321433 itSub('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {1434 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1435 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);14361437 const uniqueMultilocation = {1438 V2: {1439 parents: 1,1440 interior: {1441 X1: {1442 Parachain: UNIQUE_CHAIN,1443 },1444 },1445 },1446 };14471448 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1449 targetAccount.addressRaw,1450 {1451 Concrete: {1452 parents: 0,1453 interior: {1454 X1: {1455 Parachain: UNIQUE_CHAIN,1456 },1457 },1458 },1459 },1460 testAmount,1461 );14621463 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1464 targetAccount.addressRaw,1465 {1466 Concrete: {1467 parents: 0,1468 interior: 'Here',1469 },1470 },1471 testAmount,1472 );14731474 let maliciousXcmProgramFullIdSent: any;1475 let maliciousXcmProgramHereIdSent: any;1476 const maxWaitBlocks = 3;14771478 // Try to trick Unique using full UNQ identification1479 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1480 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);14811482 // Needed to bypass the call filter.1483 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1484 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);14851486 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1487 });14881489 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1490 && event.outcome.isUntrustedReserveLocation);14911492 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1493 expect(accountBalance).to.be.equal(0n);14941495 // Try to trick Unique using shortened UNQ identification1496 await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {1497 const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);14981499 // Needed to bypass the call filter.1500 const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);1501 await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);15021503 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1504 });15051506 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1507 && event.outcome.isUntrustedReserveLocation);15081509 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1510 expect(accountBalance).to.be.equal(0n);1511 });1512});15131514describeXCM('[XCM] Integration test: Exchanging tokens with Astar', () => {1515 let alice: IKeyringPair;1516 let randomAccount: IKeyringPair;15171518 const UNQ_ASSET_ID_ON_ASTAR = 1;1519 const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;15201521 // Unique -> Astar1522 const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.1523 const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?1524 const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ1525 const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens15261527 // Astar -> Unique1528 const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ1529 const unqOnAstarLeft = unqToAstarArrived - unqFromAstarTransfered; // 4.999_999_999_088_000_000n UNQ15301531 let balanceAfterUniqueToAstarXCM: bigint;15321533 before(async () => {1534 await usingPlaygrounds(async (helper, privateKey) => {1535 alice = await privateKey('//Alice');1536 [randomAccount] = await helper.arrange.createAccounts([100n], alice);1537 console.log('randomAccount', randomAccount.address);15381539 // Set the default version to wrap the first message to other chains.1540 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);1541 });15421543 await usingAstarPlaygrounds(astarUrl, async (helper) => {1544 console.log('1. Create foreign asset and metadata');1545 // TODO update metadata with values from production1546 await helper.assets.create(1547 alice,1548 UNQ_ASSET_ID_ON_ASTAR,1549 alice.address,1550 UNQ_MINIMAL_BALANCE_ON_ASTAR,1551 );15521553 await helper.assets.setMetadata(1554 alice,1555 UNQ_ASSET_ID_ON_ASTAR,1556 'Cross chain UNQ',1557 'xcUNQ',1558 Number(UNQ_DECIMALS),1559 );15601561 console.log('2. Register asset location on Astar');1562 const assetLocation = {1563 V2: {1564 parents: 1,1565 interior: {1566 X1: {1567 Parachain: UNIQUE_CHAIN,1568 },1569 },1570 },1571 };15721573 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);15741575 console.log('3. Set UNQ payment for XCM execution on Astar');1576 await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);15771578 console.log('4. Transfer 1 ASTR to recipient to create the account (needed due to existential balance)');1579 await helper.balance.transferToSubstrate(alice, randomAccount.address, astarInitialBalance);1580 });1581 });15821583 itSub('Should connect and send UNQ to Astar', async ({helper}) => {1584 const destination = {1585 V2: {1586 parents: 1,1587 interior: {1588 X1: {1589 Parachain: ASTAR_CHAIN,1590 },1591 },1592 },1593 };15941595 const beneficiary = {1596 V2: {1597 parents: 0,1598 interior: {1599 X1: {1600 AccountId32: {1601 network: 'Any',1602 id: randomAccount.addressRaw,1603 },1604 },1605 },1606 },1607 };16081609 const assets = {1610 V2: [1611 {1612 id: {1613 Concrete: {1614 parents: 0,1615 interior: 'Here',1616 },1617 },1618 fun: {1619 Fungible: unqToAstarTransferred,1620 },1621 },1622 ],1623 };16241625 // Initial balance is 100 UNQ1626 const balanceBefore = await helper.balance.getSubstrate(randomAccount.address);1627 console.log(`Initial balance is: ${balanceBefore}`);16281629 const feeAssetItem = 0;1630 await helper.xcm.limitedReserveTransferAssets(randomAccount, destination, beneficiary, assets, feeAssetItem, 'Unlimited');16311632 // Balance after reserve transfer is less than 901633 balanceAfterUniqueToAstarXCM = await helper.balance.getSubstrate(randomAccount.address);1634 console.log(`UNQ Balance on Unique after XCM is: ${balanceAfterUniqueToAstarXCM}`);1635 console.log(`Unique's UNQ commission is: ${balanceBefore-balanceAfterUniqueToAstarXCM}`);1636 expect(balanceBefore - balanceAfterUniqueToAstarXCM > 0).to.be.true;16371638 await usingAstarPlaygrounds(astarUrl, async (helper) => {1639 await helper.wait.newBlocks(3);1640 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1641 const astarBalance = await helper.balance.getSubstrate(randomAccount.address);16421643 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);1644 console.log(`Astar's UNQ commission is: ${unqToAstarTransferred-xcUNQbalance!}`);16451646 expect(xcUNQbalance).to.eq(unqToAstarArrived);1647 // Astar balance does not changed1648 expect(astarBalance).to.eq(astarInitialBalance);1649 });1650 });16511652 itSub('Should connect to Astar and send UNQ back', async ({helper}) => {1653 await usingAstarPlaygrounds(astarUrl, async (helper) => {1654 const destination = {1655 V2: {1656 parents: 1,1657 interior: {1658 X1: {1659 Parachain: UNIQUE_CHAIN,1660 },1661 },1662 },1663 };16641665 const beneficiary = {1666 V2: {1667 parents: 0,1668 interior: {1669 X1: {1670 AccountId32: {1671 network: 'Any',1672 id: randomAccount.addressRaw,1673 },1674 },1675 },1676 },1677 };16781679 const assets = {1680 V2: [1681 {1682 id: {1683 Concrete: {1684 parents: 1,1685 interior: {1686 X1: {1687 Parachain: UNIQUE_CHAIN,1688 },1689 },1690 },1691 },1692 fun: {1693 Fungible: unqFromAstarTransfered,1694 },1695 },1696 ],1697 };16981699 // Initial balance is 1 ASTR1700 const balanceASTRbefore = await helper.balance.getSubstrate(randomAccount.address);1701 console.log(`ASTR balance is: ${balanceASTRbefore}, it does not changed`);1702 expect(balanceASTRbefore).to.eq(astarInitialBalance);17031704 const feeAssetItem = 0;1705 // this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw1706 await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);17071708 const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);1709 const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);1710 console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);17111712 // Assert: xcUNQ balance correctly decreased1713 expect(xcUNQbalance).to.eq(unqOnAstarLeft);1714 // Assert: ASTR balance is 0.996...1715 expect(balanceAstar / (10n ** (ASTAR_DECIMALS - 3n))).to.eq(996n);1716 });17171718 await helper.wait.newBlocks(3);1719 const balanceUNQ = await helper.balance.getSubstrate(randomAccount.address);1720 console.log(`UNQ Balance on Unique after XCM is: ${balanceUNQ}`);1721 expect(balanceUNQ).to.eq(balanceAfterUniqueToAstarXCM + unqFromAstarTransfered);1722 });17231724 itSub('Astar can send only up to its balance', async ({helper}) => {1725 // set Astar's sovereign account's balance1726 const astarBalance = 10000n * (10n ** UNQ_DECIMALS);1727 const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);1728 await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);17291730 const moreThanAstarHas = astarBalance * 2n;17311732 let targetAccountBalance = 0n;1733 const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);17341735 const uniqueMultilocation = {1736 V2: {1737 parents: 1,1738 interior: {1739 X1: {Parachain: UNIQUE_CHAIN},1740 },1741 },1742 };17431744 const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1745 targetAccount.addressRaw,1746 {1747 Concrete: {1748 parents: 0,1749 interior: 'Here',1750 },1751 },1752 moreThanAstarHas,1753 );17541755 let maliciousXcmProgramSent: any;1756 const maxWaitBlocks = 3;17571758 // Try to trick Unique1759 await usingAstarPlaygrounds(astarUrl, async (helper) => {1760 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);17611762 maliciousXcmProgramSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1763 });17641765 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramSent.messageHash1766 && event.outcome.isFailedToTransactAsset);17671768 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1769 expect(targetAccountBalance).to.be.equal(0n);17701771 // But Astar still can send the correct amount1772 const validTransferAmount = astarBalance / 2n;1773 const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(1774 targetAccount.addressRaw,1775 {1776 Concrete: {1777 parents: 0,1778 interior: 'Here',1779 },1780 },1781 validTransferAmount,1782 );17831784 await usingAstarPlaygrounds(astarUrl, async (helper) => {1785 await helper.getSudo().xcm.send(alice, uniqueMultilocation, validXcmProgram);1786 });17871788 await helper.wait.newBlocks(maxWaitBlocks);17891790 targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);1791 expect(targetAccountBalance).to.be.equal(validTransferAmount);1792 });17931794 itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {1795 const testAmount = 10_000n * (10n ** UNQ_DECIMALS);1796 const [targetAccount] = await helper.arrange.createAccounts([0n], alice);17971798 const uniqueMultilocation = {1799 V2: {1800 parents: 1,1801 interior: {1802 X1: {1803 Parachain: UNIQUE_CHAIN,1804 },1805 },1806 },1807 };18081809 const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(1810 targetAccount.addressRaw,1811 {1812 Concrete: {1813 parents: 1,1814 interior: {1815 X1: {1816 Parachain: UNIQUE_CHAIN,1817 },1818 },1819 },1820 },1821 testAmount,1822 );18231824 const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(1825 targetAccount.addressRaw,1826 {1827 Concrete: {1828 parents: 0,1829 interior: 'Here',1830 },1831 },1832 testAmount,1833 );18341835 let maliciousXcmProgramFullIdSent: any;1836 let maliciousXcmProgramHereIdSent: any;1837 const maxWaitBlocks = 3;18381839 // Try to trick Unique using full UNQ identification1840 await usingAstarPlaygrounds(astarUrl, async (helper) => {1841 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);18421843 maliciousXcmProgramFullIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1844 });18451846 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramFullIdSent.messageHash1847 && event.outcome.isUntrustedReserveLocation);18481849 let accountBalance = await helper.balance.getSubstrate(targetAccount.address);1850 expect(accountBalance).to.be.equal(0n);18511852 // Try to trick Unique using shortened UNQ identification1853 await usingAstarPlaygrounds(astarUrl, async (helper) => {1854 await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);18551856 maliciousXcmProgramHereIdSent = await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.XcmpMessageSent);1857 });18581859 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == maliciousXcmProgramHereIdSent.messageHash1860 && event.outcome.isUntrustedReserveLocation);18611862 accountBalance = await helper.balance.getSubstrate(targetAccount.address);1863 expect(accountBalance).to.be.equal(0n);1864 });1865});