git.delta.rocks / unique-network / refs/commits / 430b0201ea83

difftreelog

Merge pull request #1046 from UniqueNetwork/ci/hydra-xcm-integration

Yaroslav Bolyukin2023-12-14parents: #27ba026 #ef7fe00.patch.diff
in: master
hydra xcm integration

16 files changed

modified.baedeker/rewrites.example.jsonnetdiffbeforeafterboth
1local dotenv = {1local dotenv = {
2 [std.splitLimit(line, "=", 2)[0]]: std.splitLimit(line, "=", 2)[1]2 [std.splitLimit(line, '=', 2)[0]]: std.splitLimit(line, '=', 2)[1]
3 for line in std.split(importstr "../.env", "\n")3 for line in std.split(importstr '../.env', '\n')
4 if line != ""4 if line != ''
5 if std.member(line, "=")5 if std.member(line, '=')
6};6};
77
8function(prev, repoDir)8function(prev, repoDir)
9(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({9 (import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({
10 'bin/unique':'%s/target/release/unique-collator' % repoDir,10 'bin/unique': '%s/target/release/unique-collator' % repoDir,
11 'bin/polkadot':{dockerImage:'uniquenetwork/builder-polkadot:%s' % dotenv.POLKADOT_MAINNET_BRANCH},11 'bin/polkadot': { dockerImage: 'uniquenetwork/builder-polkadot:%s' % dotenv.POLKADOT_MAINNET_BRANCH },
12 'bin/acala':{dockerImage:'uniquenetwork/builder-acala:%s' % dotenv.ACALA_BUILD_BRANCH},12 'bin/acala': { dockerImage: 'uniquenetwork/builder-acala:%s' % dotenv.ACALA_BUILD_BRANCH },
13 'bin/moonbeam':{dockerImage:'uniquenetwork/builder-moonbeam:%s' % dotenv.MOONBEAM_BUILD_BRANCH},13 'bin/moonbeam': { dockerImage: 'uniquenetwork/builder-moonbeam:%s' % dotenv.MOONBEAM_BUILD_BRANCH },
14 'bin/cumulus':{dockerImage:'uniquenetwork/builder-cumulus:%s' % dotenv.STATEMINE_BUILD_BRANCH},14 'bin/cumulus': { dockerImage: 'uniquenetwork/builder-cumulus:%s' % dotenv.STATEMINE_BUILD_BRANCH },
15 'bin/astar':{dockerImage:'uniquenetwork/builder-astar:%s' % dotenv.ASTAR_BUILD_BRANCH},15 'bin/astar': { dockerImage: 'uniquenetwork/builder-astar:%s' % dotenv.ASTAR_BUILD_BRANCH },
16 'bin/polkadex':{dockerImage:'uniquenetwork/builder-polkadex:%s' % dotenv.POLKADEX_BUILD_BRANCH},16 'bin/polkadex': { dockerImage: 'uniquenetwork/builder-polkadex:%s' % dotenv.POLKADEX_BUILD_BRANCH },
17 'bin/hydradx': { dockerImage: 'uniquenetwork/builder-hydraDx:%s' % dotenv.HYDRADX_BUILD_BRANCH },
17})(prev)18 })(prev)
1819
modified.baedeker/xcm-opal.jsonnetdiffbeforeafterboth
19 [name]: {19 [name]: {
20 bin: $.bin,20 bin: $.bin,
21 wantedKeys: 'relay',21 wantedKeys: 'relay',
22 extraArgs: [
23 "-lxcm=trace"
24 ],
22 },25 },
23 for name in ['alice', 'bob', 'charlie', 'dave', 'eve']26 for name in ['alice', 'bob', 'charlie', 'dave', 'eve']
24 },27 },
35 [name]: {38 [name]: {
36 bin: $.bin,39 bin: $.bin,
37 wantedKeys: 'para',40 wantedKeys: 'para',
41 extraArgs: [
42 "-lxcm=trace"
43 ],
38 },44 },
39 for name in ['alice', 'bob']45 for name in ['alice', 'bob']
40 },46 },
52 [name]: {58 [name]: {
53 bin: $.bin,59 bin: $.bin,
54 wantedKeys: 'para',60 wantedKeys: 'para',
61 extraArgs: [
62 "-lxcm=trace"
63 ],
55 },64 },
56 for name in ['alice', 'bob']65 for name in ['alice', 'bob']
57 },66 },
modified.baedeker/xcm-quartz.jsonnetdiffbeforeafterboth
24 [name]: {24 [name]: {
25 bin: $.bin,25 bin: $.bin,
26 wantedKeys: 'relay',26 wantedKeys: 'relay',
27 extraArgs: [
28 "-lxcm=trace"
29 ],
27 },30 },
28 for name in ['alice', 'bob', 'charlie', 'dave', 'eve', 'ferdie']31 for name in ['alice', 'bob', 'charlie', 'dave', 'eve', 'ferdie']
29 },32 },
40 [name]: {43 [name]: {
41 bin: $.bin,44 bin: $.bin,
42 wantedKeys: 'para',45 wantedKeys: 'para',
46 extraArgs: [
47 "-lxcm=trace"
48 ],
43 },49 },
44 for name in ['alice', 'bob']50 for name in ['alice', 'bob']
45 },51 },
60 [name]: {66 [name]: {
61 bin: $.bin,67 bin: $.bin,
62 wantedKeys: 'para',68 wantedKeys: 'para',
69 extraArgs: [
70 "-lxcm=trace"
71 ],
63 },72 },
64 for name in ['alice', 'bob']73 for name in ['alice', 'bob']
65 },74 },
79 [name]: {88 [name]: {
80 bin: $.bin,89 bin: $.bin,
81 wantedKeys: 'para-nimbus',90 wantedKeys: 'para-nimbus',
91 extraArgs: [
92 "-lxcm=trace"
93 ],
82 },94 },
83 for name in ['alith', 'baltathar']95 for name in ['alith', 'baltathar']
84 },96 },
96 [name]: {108 [name]: {
97 bin: $.bin,109 bin: $.bin,
98 wantedKeys: 'para',110 wantedKeys: 'para',
111 extraArgs: [
112 "-lxcm=trace"
113 ],
99 },114 },
100 for name in ['alice', 'bob']115 for name in ['alice', 'bob']
101 },116 },
113 [name]: {128 [name]: {
114 bin: $.bin,129 bin: $.bin,
115 wantedKeys: 'para',130 wantedKeys: 'para',
131 extraArgs: [
132 "-lxcm=trace"
133 ],
116 },134 },
117 for name in ['alice', 'bob']135 for name in ['alice', 'bob']
118 },136 },
modified.baedeker/xcm-unique.jsonnetdiffbeforeafterboth
11 spec: {Genesis:{11 spec: {Genesis:{
12 chain: relay_spec,12 chain: relay_spec,
13 modify:: m.genericRelay($, hrmp = std.join([], [13 modify:: m.genericRelay($, hrmp = std.join([], [
14 [[$.parachains[a].paraId, $.parachains[b].paraId, 8, 512], [$.parachains[b].paraId, $.parachains[a].paraId, 8, 512]],14 // [[$.parachains[a].paraId, $.parachains[b].paraId, 8, 512], [$.parachains[b].paraId, $.parachains[a].paraId, 8, 512]],
15 for [a, b] in [15 // for [a, b] in [
16 // ['unique', 'acala'],16 // ['unique', 'acala'],
17 // ['unique', 'moonbeam'],17 // ['unique', 'moonbeam'],
18 // ['unique', 'statemint'],18 // ['unique', 'statemint'],
19 // ['unique', 'astar'],19 // ['unique', 'astar'],
20 // ['unique', 'polkadex'],20 // ['unique', 'polkadex'],
21 ]21 // ]
22 ])),22 ])),
23 }},23 }},
24 nodes: {24 nodes: {
25 [name]: {25 [name]: {
26 bin: $.bin,26 bin: $.bin,
27 wantedKeys: 'relay',27 wantedKeys: 'relay',
28 extraArgs: [
29 "-lxcm=trace"
30 ],
28 },31 },
29 for name in ['alice', 'bob', 'charlie', 'dave', 'eve', 'ferdie', 'gregory']32 for name in ['alice', 'bob', 'charlie', 'dave', 'eve', 'ferdie', 'gregory', 'holly']
30 },33 },
31};34};
3235
41 [name]: {44 [name]: {
42 bin: $.bin,45 bin: $.bin,
43 wantedKeys: 'para',46 wantedKeys: 'para',
47 extraArgs: [
48 "-lxcm=trace"
49 ],
44 },50 },
45 for name in ['alice', 'bob']51 for name in ['alice', 'bob']
46 },52 },
61 [name]: {67 [name]: {
62 bin: $.bin,68 bin: $.bin,
63 wantedKeys: 'para',69 wantedKeys: 'para',
70 extraArgs: [
71 "-lxcm=trace"
72 ],
64 },73 },
65 for name in ['alice', 'bob']74 for name in ['alice', 'bob']
66 },75 },
80 [name]: {89 [name]: {
81 bin: $.bin,90 bin: $.bin,
82 wantedKeys: 'para-nimbus',91 wantedKeys: 'para-nimbus',
92 extraArgs: [
93 "-lxcm=trace"
94 ],
83 },95 },
84 for name in ['alith', 'baltathar']96 for name in ['alith', 'baltathar']
85 },97 },
97 [name]: {109 [name]: {
98 bin: $.bin,110 bin: $.bin,
99 wantedKeys: 'para-ed',111 wantedKeys: 'para-ed',
112 extraArgs: [
113 "-lxcm=trace"
114 ],
100 },115 },
101 for name in ['alice', 'bob']116 for name in ['alice', 'bob']
102 },117 },
114 [name]: {129 [name]: {
115 bin: $.bin,130 bin: $.bin,
116 wantedKeys: 'para',131 wantedKeys: 'para',
132 extraArgs: [
133 "-lxcm=trace"
134 ],
117 },135 },
118 for name in ['alice', 'bob']136 for name in ['alice', 'bob']
119 },137 },
131 [name]: {149 [name]: {
132 bin: $.bin,150 bin: $.bin,
133 wantedKeys: 'para',151 wantedKeys: 'para',
152 extraArgs: [
153 "-lxcm=trace"
154 ],
134 },155 },
135 for name in ['alice', 'bob']156 for name in ['alice', 'bob']
136 },157 },
137};158};
138159
160local hydraDx = {
161 name: 'hydraDx',
162 bin: 'bin/hydradx',
163 paraId: 1007,
164 spec: {Genesis:{
165 chain: 'local',
166 modify:: m.genericPara($),
167 }},
168 nodes: {
169 [name]: {
170 bin: $.bin,
171 wantedKeys: 'para',
172 legacyRpc: true,
173 extraArgs: [
174 "-lxcm=trace"
175 ],
176 },
177 for name in ['alice', 'bob']
178 },
179};
180
181
139relay + {182relay + {
140 parachains: {183 parachains: {
141 [para.name]: para,184 [para.name]: para,
142 for para in [unique, acala, moonbeam, statemint, astar, polkadex]185 for para in [unique, acala, moonbeam, statemint, astar, polkadex, hydraDx]
143 },186 },
144}187}
145188
added.docker/Dockerfile-hydradx.j2diffbeforeafterboth

no changes

modified.envdiffbeforeafterboth
12UNIQUE_MAINNET_BRANCH=release-v1001006312UNIQUE_MAINNET_BRANCH=release-v10010063
13UNIQUE_REPLICA_FROM=wss://ws.unique.network:44313UNIQUE_REPLICA_FROM=wss://ws.unique.network:443
14POLKADEX_BUILD_BRANCH=v1.1.014POLKADEX_BUILD_BRANCH=v1.1.0
1515HYDRADX_BUILD_BRANCH=v20.1.1
1616
17KUSAMA_MAINNET_BRANCH=release-v1.0.017KUSAMA_MAINNET_BRANCH=release-v1.0.0
18STATEMINE_BUILD_BRANCH=release-parachains-v943018STATEMINE_BUILD_BRANCH=release-parachains-v9430
modified.github/workflows/xcm.ymldiffbeforeafterboth
36 uses: CertainLach/create-matrix-action@v436 uses: CertainLach/create-matrix-action@v4
37 id: create_matrix37 id: create_matrix
38 with:38 with:
39 matrix: |39 matrix: |
40 network {opal}, relay_branch {${{ env.UNIQUEWEST_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.WESTMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testXcmOpal}, runtime_features {opal-runtime}40 network {opal}, relay_branch {${{ env.UNIQUEWEST_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.WESTMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, hydradx_version {${{ env.HYDRADX_BUILD_BRANCH }}}, runtest {testXcmOpal}, runtime_features {opal-runtime}
41 network {quartz}, relay_branch {${{ env.KUSAMA_MAINNET_BRANCH }}}, acala_version {${{ env.KARURA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONRIVER_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINE_BUILD_BRANCH }}}, astar_version {${{ env.SHIDEN_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testFullXcmQuartz}, runtime_features {quartz-runtime}41 network {quartz}, relay_branch {${{ env.KUSAMA_MAINNET_BRANCH }}}, acala_version {${{ env.KARURA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONRIVER_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINE_BUILD_BRANCH }}}, astar_version {${{ env.SHIDEN_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, hydradx_version {${{ env.HYDRADX_BUILD_BRANCH }}}, runtest {testFullXcmQuartz}, runtime_features {quartz-runtime}
42 network {unique}, relay_branch {${{ env.POLKADOT_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, runtest {testFullXcmUnique}, runtime_features {unique-runtime}42 network {unique}, relay_branch {${{ env.POLKADOT_MAINNET_BRANCH }}}, acala_version {${{ env.ACALA_BUILD_BRANCH }}}, moonbeam_version {${{ env.MOONBEAM_BUILD_BRANCH }}}, cumulus_version {${{ env.STATEMINT_BUILD_BRANCH }}}, astar_version {${{ env.ASTAR_BUILD_BRANCH }}}, polkadex_version {${{ env.POLKADEX_BUILD_BRANCH }}}, hydradx_version {${{ env.HYDRADX_BUILD_BRANCH }}}, runtest {testFullXcmUnique}, runtime_features {unique-runtime}
4343
44 xcm:44 xcm:
45 needs: prepare-execution-marix45 needs: prepare-execution-marix
280 fi280 fi
281 shell: bash281 shell: bash
282
283 # Check Hydradx version and build it if it doesn't exist in repository
284 - name: Generate ENV related extend Dockerfile file for Hydradx
285 uses: cuchi/jinja2-action@v1.2.0
286 with:
287 template: .docker/Dockerfile-hydradx.j2
288 output_file: .docker/Dockerfile-hydradx.${{ matrix.hydradx_version }}.yml
289 variables: |
290 RUST_TOOLCHAIN=${{ env.RUST_TOOLCHAIN }}
291 HYDRADX_BUILD_BRANCH=${{ matrix.hydradx_version }}
292
293 - name: Check if the dockerhub repository contains the needed HYDRADX version
294 run: |
295 # aquire token
296 TOKEN=$(curl -s -H "Content-Type: application/json" -X POST -d '{"username": "'${{ secrets.CORE_DOCKERHUB_USERNAME }}'", "password": "'${{ secrets.CORE_DOCKERHUB_TOKEN }}'"}' https://hub.docker.com/v2/users/login/ | jq -r .token)
297 export TOKEN=$TOKEN
298
299 # Get TAGS from DOCKERHUB repository
300 HYDRADX_TAGS=$(curl -s -H "Authorization: JWT ${TOKEN}" https://hub.docker.com/v2/repositories/uniquenetwork/builder-hydradx/tags/?page_size=100 | jq -r '."results"[]["name"]')
301 # Show TAGS
302 echo "HYDRADX TAGS:"
303 echo $HYDRADX_TAGS
304 # Check correct version HYDRADX and build it if it doesn't exist in HYDRADX TAGS
305 if [[ ${HYDRADX_TAGS[*]} =~ (^|[[:space:]])"${{ matrix.hydradx_version }}"($|[[:space:]]) ]]; then
306 echo "Repository has needed HYDRADX version";
307 docker pull uniquenetwork/builder-hydradx:${{ matrix.hydradx_version }}
308 else
309 echo "Repository has not needed HYDRADX version, so build it";
310 cd .docker/ && docker build --file ./Dockerfile-hydradx.${{ matrix.hydradx_version }}.yml --tag uniquenetwork/builder-hydradx:${{ matrix.hydradx_version }} .
311 echo "Push needed HYDRADX version to the repository";
312 docker push uniquenetwork/builder-hydradx:${{ matrix.hydradx_version }}
313 fi
314 shell: bash
315
282316
283 - name: Build unique-chain317 - name: Build unique-chain
309 .baedeker/vendor343 .baedeker/vendor
310 tla-str: |344 tla-str: |
311 relay_spec=${{ env.RELAY_CHAIN_TYPE }}-local345 relay_spec=${{ env.RELAY_CHAIN_TYPE }}-local
312 inputs: |346 inputs: |
313 .baedeker/xcm-${{ matrix.network }}.jsonnet347 .baedeker/xcm-${{ matrix.network }}.jsonnet
314 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/polkadot':{dockerImage:'uniquenetwork/builder-polkadot:${{ matrix.relay_branch }}'}})348 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/polkadot':{dockerImage:'uniquenetwork/builder-polkadot:${{ matrix.relay_branch }}'}})
315 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/unique':{dockerImage:'uniquenetwork/ci-xcm-local:${{ matrix.network }}-${{ env.REF_SLUG }}-${{ env.BUILD_SHA }}'}})349 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/unique':{dockerImage:'uniquenetwork/ci-xcm-local:${{ matrix.network }}-${{ env.REF_SLUG }}-${{ env.BUILD_SHA }}'}})
316 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/acala':{dockerImage:'uniquenetwork/builder-acala:${{ matrix.acala_version }}'}})350 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/acala':{dockerImage:'uniquenetwork/builder-acala:${{ matrix.acala_version }}'}})
317 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/moonbeam':{dockerImage:'uniquenetwork/builder-moonbeam:${{ matrix.moonbeam_version }}'}})351 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/moonbeam':{dockerImage:'uniquenetwork/builder-moonbeam:${{ matrix.moonbeam_version }}'}})
318 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/cumulus':{dockerImage:'uniquenetwork/builder-cumulus:${{ matrix.cumulus_version }}'}})352 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/cumulus':{dockerImage:'uniquenetwork/builder-cumulus:${{ matrix.cumulus_version }}'}})
319 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/astar':{dockerImage:'uniquenetwork/builder-astar:${{ matrix.astar_version }}'}})353 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/astar':{dockerImage:'uniquenetwork/builder-astar:${{ matrix.astar_version }}'}})
320 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/polkadex':{dockerImage:'uniquenetwork/builder-polkadex:${{ matrix.polkadex_version }}'}})354 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/polkadex':{dockerImage:'uniquenetwork/builder-polkadex:${{ matrix.polkadex_version }}'}})
355 snippet:(import 'baedeker-library/ops/rewrites.libsonnet').rewriteNodePaths({'bin/hydradx':{dockerImage:'uniquenetwork/builder-hydradx:${{ matrix.hydradx_version }}'}})
321356
322 - name: Upload network config357 - name: Upload network config
323 uses: actions/upload-artifact@v3358 uses: actions/upload-artifact@v3
modified.vscode/settings.jsondiffbeforeafterboth
10 "SKIP_WASM_BUILD": "1"10 "SKIP_WASM_BUILD": "1"
11 },11 },
12 "rust-analyzer.cargo.features": ["runtime-benchmarks", "try-runtime"],12 "rust-analyzer.cargo.features": ["runtime-benchmarks", "try-runtime"],
13 "solidity.packageDefaultDependenciesDirectory": "tests/node_modules"13 "solidity.packageDefaultDependenciesDirectory": "js-packages/node_modules"
14}14}
1515
modifiedjs-packages/.vscode/settings.jsondiffbeforeafterboth
3 "RUN_GOV_TESTS": "1",3 "RUN_GOV_TESTS": "1",
4 "RUN_XCM_TESTS": "1"4 "RUN_XCM_TESTS": "1"
5 },5 },
6 "mochaExplorer.files": "src/**/*.test.ts",6 "mochaExplorer.files": "tests/**/*.test.ts",
7 "mochaExplorer.require": "ts-node/register",7 "mochaExplorer.require": "ts-node/register",
8 "eslint.format.enable": true,8 "eslint.format.enable": true,
9 "[javascript]": {9 "[javascript]": {
modifiedjs-packages/playgrounds/unique.dev.tsdiffbeforeafterboth
17import type {FrameSystemEventRecord, StagingXcmV2TraitsError, StagingXcmV3TraitsOutcome} from '@polkadot/types/lookup';17import type {FrameSystemEventRecord, StagingXcmV2TraitsError, StagingXcmV3TraitsOutcome} from '@polkadot/types/lookup';
18import type {SignerOptions, VoidFn} from '@polkadot/api/types';18import type {SignerOptions, VoidFn} from '@polkadot/api/types';
19import {spawnSync} from 'child_process';19import {spawnSync} from 'child_process';
20import {AcalaHelper, AstarHelper, MoonbeamHelper, PolkadexHelper, RelayHelper, WestmintHelper, ForeignAssetsGroup, XcmGroup, XTokensGroup, TokensGroup} from './unique.xcm.js';20import {AcalaHelper, AstarHelper, MoonbeamHelper, PolkadexHelper, RelayHelper, WestmintHelper, ForeignAssetsGroup, XcmGroup, XTokensGroup, TokensGroup, HydraDxHelper} from './unique.xcm.js';
21import {CollectiveGroup, CollectiveMembershipGroup, DemocracyGroup, RankedCollectiveGroup, ReferendaGroup} from './unique.governance.js';21import {CollectiveGroup, CollectiveMembershipGroup, DemocracyGroup, RankedCollectiveGroup, ReferendaGroup} from './unique.governance.js';
22import type {ICollectiveGroup, IFellowshipGroup} from './unique.governance.js';22import type {ICollectiveGroup, IFellowshipGroup} from './unique.governance.js';
2323
667 }667 }
668}668}
669
670export class DevHydraDxHelper extends HydraDxHelper {
671 wait: WaitGroup;
672 fastDemocracy: HydraFastDemocracyGroup;
673
674 constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
675 options.helperBase = options.helperBase ?? DevHydraDxHelper;
676
677 super(logger, options);
678
679 this.wait = new WaitGroup(this);
680 this.fastDemocracy = new HydraFastDemocracyGroup(this);
681 }
682}
669683
670export class DevKaruraHelper extends DevAcalaHelper {}684export class DevKaruraHelper extends DevAcalaHelper {}
671685
1150 }1164 }
1151}1165}
1166
1167class HydraFastDemocracyGroup {
1168 helper: DevHydraDxHelper;
1169
1170 constructor(helper: DevHydraDxHelper) {
1171 this.helper = helper;
1172 }
1173
1174 async executeProposal(proposalDesciption: string, encodedProposal: string) {
1175 const proposalHash = blake2AsHex(encodedProposal);
1176 const aliceAccount = this.helper.util.fromSeed('//Alice');
1177 const bobAccount = this.helper.util.fromSeed('//Bob');
1178 const eveAccount = this.helper.util.fromSeed('//Eve');
1179
1180 const councilVotingThreshold = 1;
1181 const technicalCommitteeThreshold = 3;
1182 const fastTrackVotingPeriod = 3;
1183 const fastTrackDelayPeriod = 0;
1184
1185 console.log(`[democracy] executing '${proposalDesciption}' proposal`);
1186
1187 // >>> Propose external motion through council >>>
1188 console.log('\t* Propose external motion through council.......');
1189 const externalMotion = this.helper.democracy.externalProposeMajority({Inline: encodedProposal});
1190 const encodedMotion = externalMotion?.method.toHex() || '';
1191 const motionHash = blake2AsHex(encodedMotion);
1192 console.log('\t* Motion hash is %s', motionHash);
1193
1194 await this.helper.collective.council.propose(
1195 aliceAccount,
1196 councilVotingThreshold,
1197 externalMotion,
1198 externalMotion.encodedLength,
1199 );
1200
1201 console.log('\t* Propose external motion through council.......DONE');
1202 // <<< Propose external motion through council <<<
1203
1204 // >>> Fast track proposal through technical committee >>>
1205 console.log('\t* Fast track proposal through technical committee.......');
1206 const fastTrack = this.helper.democracy.fastTrack(proposalHash, fastTrackVotingPeriod, fastTrackDelayPeriod);
1207 const encodedFastTrack = fastTrack?.method.toHex() || '';
1208 const fastTrackHash = blake2AsHex(encodedFastTrack);
1209 console.log('\t* FastTrack hash is %s', fastTrackHash);
1210
1211 await this.helper.collective.techCommittee.propose(aliceAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);
1212
1213 const techProposalIdx = await this.helper.collective.techCommittee.proposalCount() - 1;
1214 await this.helper.collective.techCommittee.vote(aliceAccount, fastTrackHash, techProposalIdx, true);
1215 await this.helper.collective.techCommittee.vote(bobAccount, fastTrackHash, techProposalIdx, true);
1216 await this.helper.collective.techCommittee.vote(eveAccount, fastTrackHash, techProposalIdx, true);
1217
1218 await this.helper.collective.techCommittee.close(
1219 bobAccount,
1220 fastTrackHash,
1221 techProposalIdx,
1222 {
1223 refTime: 1_000_000_000,
1224 proofSize: 1_000_000,
1225 },
1226 fastTrack.encodedLength,
1227 );
1228 console.log('\t* Fast track proposal through technical committee.......DONE');
1229 // <<< Fast track proposal through technical committee <<<
1230
1231 const democracyStarted = await this.helper.wait.expectEvent(3, Event.Democracy.Started);
1232 const referendumIndex = democracyStarted.referendumIndex;
1233
1234 // >>> Referendum voting >>>
1235 console.log(`\t* Referendum #${referendumIndex} voting.......`);
1236 await this.helper.democracy.referendumVote(eveAccount, referendumIndex, {
1237 balance: 10_000_000_000_000_000_000n,
1238 vote: {aye: true, conviction: 1},
1239 });
1240 console.log(`\t* Referendum #${referendumIndex} voting.......DONE`);
1241 // <<< Referendum voting <<<
1242
1243 // Wait the proposal to pass
1244 await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => event.referendumIndex == referendumIndex);
1245
1246 await this.helper.wait.newBlocks(1);
1247
1248 console.log(`[democracy] executing '${proposalDesciption}' proposal.......DONE`);
1249 }
1250}
11521251
1153class WaitGroup {1252class WaitGroup {
1154 helper: ChainHelperBase;1253 helper: ChainHelperBase;
modifiedjs-packages/playgrounds/unique.xcm.tsdiffbeforeafterboth
71 }71 }
72}72}
73
74class DemocracyGroup<T extends ChainHelperBase> extends HelperGroup<T> {
75 notePreimagePallet: string;
76
77 constructor(helper: T, options: { [key: string]: any } = {}) {
78 super(helper);
79 this.notePreimagePallet = options.notePreimagePallet;
80 }
81
82 async notePreimage(signer: TSigner, encodedProposal: string) {
83 await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);
84 }
85
86 externalProposeMajority(proposal: any) {
87 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);
88 }
89
90 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {
91 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);
92 }
93
94 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {
95 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);
96 }
97}
7398
74class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {99class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {
75 collective: string;100 collective: string;
97 }122 }
98}123}
99124
125class CollectiveGroup<T extends ChainHelperBase> extends HelperGroup<T> {
126 collective: string;
127
128 constructor(helper: T, palletName: string) {
129 super(helper);
130
131 this.collective = palletName;
132 }
133
134 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {
135 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);
136 }
137
138 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {
139 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);
140 }
141
142 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {
143 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);
144 }
145
146 async proposalCount() {
147 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));
148 }
149}
100class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {150class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {
101 async whitelistToken(signer: TSigner, assetId: any) {151 async whitelistToken(signer: TSigner, assetId: any) {
102 await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);152 await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);
372 }422 }
373}423}
424
425export class HydraDxHelper extends XcmChainHelper {
426 balance: SubstrateBalanceGroup<HydraDxHelper>;
427 xcm: XcmGroup<HydraDxHelper>;
428 xTokens: XTokensGroup<HydraDxHelper>;
429 democracy: DemocracyGroup<HydraDxHelper>;
430 collective: {
431 council: CollectiveGroup<HydraDxHelper>,
432 techCommittee: CollectiveGroup<HydraDxHelper>,
433 };
434
435 constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
436 super(logger, options.helperBase ?? HydraDxHelper);
437 options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';
438
439 this.balance = new SubstrateBalanceGroup(this);
440 this.xcm = new XcmGroup(this, 'polkadotXcm');
441 this.xTokens = new XTokensGroup(this);
442 this.democracy = new DemocracyGroup(this, options);
443 this.collective = {
444 council: new CollectiveGroup(this, 'council'),
445 techCommittee: new CollectiveGroup(this, 'technicalCommittee'),
446 };
447 }
448}
374449
375450
modifiedjs-packages/tests/config.tsdiffbeforeafterboth
29 statemineUrl: process.env.RELAY_STATEMINE_URL || 'ws://127.0.0.1:9948',29 statemineUrl: process.env.RELAY_STATEMINE_URL || 'ws://127.0.0.1:9948',
30 statemintUrl: process.env.RELAY_STATEMINT_URL || 'ws://127.0.0.1:9948',30 statemintUrl: process.env.RELAY_STATEMINT_URL || 'ws://127.0.0.1:9948',
31 polkadexUrl: process.env.RELAY_POLKADEX_URL || 'ws://127.0.0.1:9950',31 polkadexUrl: process.env.RELAY_POLKADEX_URL || 'ws://127.0.0.1:9950',
32 hydraDxUrl: process.env.RELAY_HYDRADX_URL || 'ws://127.0.0.1:9951',
32};33};
3334
34export default config;35export default config;
modifiedjs-packages/tests/util/createHrmp.tsdiffbeforeafterboth
27 await bidirOpen(1001, 1004);27 await bidirOpen(1001, 1004);
28 await bidirOpen(1001, 1005);28 await bidirOpen(1001, 1005);
29 await bidirOpen(1001, 1006);29 await bidirOpen(1001, 1006);
30 await bidirOpen(1001, 1007);
30 break;31 break;
31 default:32 default:
32 throw new Error(`unknown hrmp config profile: ${profile}`);33 throw new Error(`unknown hrmp config profile: ${profile}`);
modifiedjs-packages/tests/util/index.tsdiffbeforeafterboth
11import config from '../config.js';11import config from '../config.js';
12import {ChainHelperBase} from '@unique/playgrounds/unique.js';12import {ChainHelperBase} from '@unique/playgrounds/unique.js';
13import type {ILogger} from '@unique/playgrounds/types.js';13import type {ILogger} from '@unique/playgrounds/types.js';
14import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper, DevPolkadexHelper} from '@unique/playgrounds/unique.dev.js';14import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper, DevStatemineHelper, DevStatemintHelper, DevAstarHelper, DevShidenHelper, DevPolkadexHelper, DevHydraDxHelper} from '@unique/playgrounds/unique.dev.js';
15import {dirname} from 'path';15import {dirname} from 'path';
16import {fileURLToPath} from 'url';16import {fileURLToPath} from 'url';
1717
9191
92export const usingPolkadexPlaygrounds = (url: string, code: (helper: DevPolkadexHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevPolkadexHelper>(DevPolkadexHelper, url, code);92export const usingPolkadexPlaygrounds = (url: string, code: (helper: DevPolkadexHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevPolkadexHelper>(DevPolkadexHelper, url, code);
93
94export const usingHydraDxPlaygrounds = (url: string, code: (helper: DevHydraDxHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => usingPlaygroundsGeneral<DevHydraDxHelper>(DevHydraDxHelper, url, code);
9395
94export const MINIMUM_DONOR_FUND = 4_000_000n;96export const MINIMUM_DONOR_FUND = 4_000_000n;
95export const DONOR_FUNDING = 4_000_000n;97export const DONOR_FUNDING = 4_000_000n;
modifiedjs-packages/tests/xcm/lowLevelXcmUnique.test.tsdiffbeforeafterboth
1616
17import type {IKeyringPair} from '@polkadot/types/types';17import type {IKeyringPair} from '@polkadot/types/types';
18import config from '../config.js';18import config from '../config.js';
19import {itSub, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds} from '../util/index.js';19import {itSub, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingMoonbeamPlaygrounds, usingAstarPlaygrounds, usingPolkadexPlaygrounds, usingHydraDxPlaygrounds} from '../util/index.js';
20import {nToBigInt} from '@polkadot/util';20import {nToBigInt} from '@polkadot/util';
21import {hexToString} from '@polkadot/util';21import {hexToString} from '@polkadot/util';
22import {ASTAR_DECIMALS, SAFE_XCM_VERSION, SENDER_BUDGET, UNIQUE_CHAIN, UNQ_DECIMALS, XcmTestHelper, acalaUrl, astarUrl, moonbeamUrl, polkadexUrl, relayUrl, uniqueAssetId} from './xcm.types.js';22import {ASTAR_DECIMALS, SAFE_XCM_VERSION, SENDER_BUDGET, UNIQUE_CHAIN, UNQ_DECIMALS, XcmTestHelper, acalaUrl, astarUrl, hydraDxUrl, moonbeamUrl, polkadexUrl, uniqueAssetId} from './xcm.types.js';
2323
24const testHelper = new XcmTestHelper('unique');24const testHelper = new XcmTestHelper('unique');
2525
365 });365 });
366});366});
367367
368describeXCM('[XCMLL] Integration test: Exchanging tokens with HydraDx', () => {
369 let alice: IKeyringPair;
370 let randomAccount: IKeyringPair;
371
372 before(async () => {
373 await usingPlaygrounds(async (helper, privateKey) => {
374 alice = await privateKey('//Alice');
375 console.log(config.acalaUrl);
376 randomAccount = helper.arrange.createEmptyAccount();
377
378 // Set the default version to wrap the first message to other chains.
379 await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
380 await helper.balance.transferToSubstrate(alice, randomAccount.address, SENDER_BUDGET);
381 });
382
383 await usingHydraDxPlaygrounds(hydraDxUrl, async (helper) => {
384 await helper.balance.transferToSubstrate(alice, randomAccount.address, 10000000000000n);
385 });
386 });
387
388 itSub('Should connect and send UNQ to HydraDx', async () => {
389 await testHelper.sendUnqTo('hydraDx', randomAccount);
390 });
391
392 itSub('Should connect to HydraDx and send UNQ back', async () => {
393 await testHelper.sendUnqBack('hydraDx', alice, randomAccount);
394 });
395
396 itSub('HydraDx can send only up to its balance', async () => {
397 await testHelper.sendOnlyOwnedBalance('hydraDx', alice);
398 });
399
400 itSub('Should not accept reserve transfer of UNQ from HydraDx', async () => {
401 await testHelper.rejectReserveTransferUNQfrom('hydraDx', alice);
402 });
403});
modifiedjs-packages/tests/xcm/xcm.types.tsdiffbeforeafterboth
1import type {IKeyringPair} from '@polkadot/types/types';1import type {IKeyringPair} from '@polkadot/types/types';
2import {hexToString} from '@polkadot/util';2import {hexToString} from '@polkadot/util';
3import {expect, usingAcalaPlaygrounds, usingAstarPlaygrounds, usingKaruraPlaygrounds, usingMoonbeamPlaygrounds, usingMoonriverPlaygrounds, usingPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds, usingShidenPlaygrounds} from '../util/index.js';3import {expect, usingAcalaPlaygrounds, usingAstarPlaygrounds, usingHydraDxPlaygrounds, usingKaruraPlaygrounds, usingMoonbeamPlaygrounds, usingMoonriverPlaygrounds, usingPlaygrounds, usingPolkadexPlaygrounds, usingRelayPlaygrounds, usingShidenPlaygrounds} from '../util/index.js';
4import {DevUniqueHelper, Event} from '@unique/playgrounds/unique.dev.js';4import {DevUniqueHelper, Event} from '@unique/playgrounds/unique.dev.js';
5import config from '../config.js';5import config from '../config.js';
66
10export const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);10export const MOONBEAM_CHAIN = +(process.env.RELAY_MOONBEAM_ID || 2004);
11export const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);11export const ASTAR_CHAIN = +(process.env.RELAY_ASTAR_ID || 2006);
12export const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);12export const POLKADEX_CHAIN = +(process.env.RELAY_POLKADEX_ID || 2040);
13export const HYDRADX_CHAIN = +(process.env.RELAY_HYDRADX_ID || 2034);
1314
14export const QUARTZ_CHAIN = +(process.env.RELAY_QUARTZ_ID || 2095);15export const QUARTZ_CHAIN = +(process.env.RELAY_QUARTZ_ID || 2095);
15export const STATEMINE_CHAIN = +(process.env.RELAY_STATEMINE_ID || 1000);16export const STATEMINE_CHAIN = +(process.env.RELAY_STATEMINE_ID || 1000);
25export const moonbeamUrl = config.moonbeamUrl;26export const moonbeamUrl = config.moonbeamUrl;
26export const astarUrl = config.astarUrl;27export const astarUrl = config.astarUrl;
27export const polkadexUrl = config.polkadexUrl;28export const polkadexUrl = config.polkadexUrl;
29export const hydraDxUrl = config.hydraDxUrl;
2830
29export const karuraUrl = config.karuraUrl;31export const karuraUrl = config.karuraUrl;
30export const moonriverUrl = config.moonriverUrl;32export const moonriverUrl = config.moonriverUrl;
87 moonriver: usingMoonriverPlaygrounds,89 moonriver: usingMoonriverPlaygrounds,
88 karura: usingKaruraPlaygrounds,90 karura: usingKaruraPlaygrounds,
89 shiden: usingShidenPlaygrounds,91 shiden: usingShidenPlaygrounds,
92 hydraDx: usingHydraDxPlaygrounds,
90} as const;93} as const;
91type NetworkNames = keyof typeof NETWORKS;94type NetworkNames = keyof typeof NETWORKS;
9295
108 return KARURA_CHAIN;111 return KARURA_CHAIN;
109 case 'shiden':112 case 'shiden':
110 return SHIDEN_CHAIN;113 return SHIDEN_CHAIN;
114 case 'hydraDx':
115 return HYDRADX_CHAIN;
111 }116 }
112}117}
113118
127 return karuraUrl;132 return karuraUrl;
128 case 'shiden':133 case 'shiden':
129 return shidenUrl;134 return shidenUrl;
135 case 'hydraDx':
136 return hydraDxUrl;
130 }137 }
131}138}
132139
277 since the hash is being checked to ensure284 since the hash is being checked to ensure
278 it matches what was sent.285 it matches what was sent.
279 */286 */
280 if(networkName == 'polkadex') {287 if(networkName == 'polkadex' || networkName =='hydraDx') {
281 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);288 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Fail, event => event.messageHash == messageSent.messageHash);
282 } else {289 } else {
283 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == messageSent.messageHash);290 await helper.wait.expectEvent(maxWaitBlocks, Event.XcmpQueue.Success, event => event.messageHash == messageSent.messageHash);