@acala-network/chopsticks 0.3.0 → 0.3.2

package/dist/index.js

@@ -10,8 +10,10 @@ const yargs_1 = __importDefault(require("yargs"));
 const txpool_1 = require("./blockchain/txpool");
 const schema_1 = require("./schema");
 const xcm_1 = require("./xcm");
-const decode_key_1 = require("./decode-key");
+const decoder_1 = require("./utils/decoder");
+const dry_run_1 = require("./dry-run");
 const run_block_1 = require("./run-block");
+const setup_1 = require("./setup");
 const setup_with_server_1 = require("./setup-with-server");
 const processConfig = (path) => {
     const configFile = (0, node_fs_1.readFileSync)(path, 'utf8');
@@ -31,7 +33,6 @@ const defaultOptions = {
     },
     block: {
         desc: 'Block hash or block number. Default to latest block',
-        string: true,
     },
     'wasm-override': {
         desc: 'Path to wasm override',
@@ -58,8 +59,42 @@ const defaultOptions = {
         desc: 'File path to print output',
         string: true,
     },
+    html: {
+        desc: 'Generate html with storage diff',
+    },
+    open: {
+        desc: 'Open generated html',
+    },
 }), async (argv) => {
     await (0, run_block_1.runBlock)(processArgv(argv));
+})
+    .command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
+    ...defaultOptions,
+    extrinsic: {
+        desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
+        string: true,
+        required: true,
+    },
+    address: {
+        desc: 'Address to fake sign extrinsic',
+        string: true,
+    },
+    at: {
+        desc: 'Block hash to dry run',
+        string: true,
+    },
+    'output-path': {
+        desc: 'File path to print output',
+        string: true,
+    },
+    html: {
+        desc: 'Generate html with storage diff',
+    },
+    open: {
+        desc: 'Open generated html',
+    },
+}), async (argv) => {
+    await (0, dry_run_1.dryRun)(processArgv(argv));
 })
     .command('dev', 'Dev mode', (yargs) => yargs.options({
     ...defaultOptions,
@@ -79,6 +114,10 @@ const defaultOptions = {
         desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
         boolean: true,
     },
+    'allow-unresolved-imports': {
+        desc: 'Allow wasm unresolved imports',
+        boolean: true,
+    },
 }), async (argv) => {
     await (0, setup_with_server_1.setupWithServer)(processArgv(argv));
 })
@@ -90,7 +129,15 @@ const defaultOptions = {
     .options({
     ...defaultOptions,
 }), async (argv) => {
-    await (0, decode_key_1.decodeKey)(processArgv(argv));
+    const context = await (0, setup_1.setup)(processArgv(argv));
+    const { storage, decodedKey } = await (0, decoder_1.decodeKey)(context.chain.head, argv.key);
+    if (storage && decodedKey) {
+        console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
+    }
+    else {
+        console.log('Unknown');
+    }
+    process.exit(0);
 })
     .command('xcm', 'XCM setup with relaychain and parachains', (yargs) => yargs.options({
     relaychain: {
@@ -115,7 +162,7 @@ const defaultOptions = {
     if (argv.relaychain) {
         const { chain: relaychain } = await (0, setup_with_server_1.setupWithServer)(processConfig(argv.relaychain));
         for (const parachain of parachains) {
-            await (0, xcm_1.connectDownward)(relaychain, parachain);
+            await (0, xcm_1.connectVertical)(relaychain, parachain);
         }
     }
 })

package/dist/logger.d.ts

@@ -1,9 +1,7 @@
-import { HexString } from '@polkadot/util/types';
 export declare const defaultLogger: import("pino").Logger<{
     level: string;
     transport: {
         target: string;
     };
 }>;
-export declare const truncate: (str: string | null) => string | null;
-export declare const truncateStorageDiff: (diff: [HexString, HexString | null][]) => [HexString, string | null][];
+export declare const truncate: (val: any) => any;

package/dist/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncateStorageDiff = exports.truncate = exports.defaultLogger = void 0;
+exports.truncate = exports.defaultLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 exports.defaultLogger = (0, pino_1.default)({
     level: process.env.LOG_LEVEL || 'info',
@@ -11,19 +11,25 @@ exports.defaultLogger = (0, pino_1.default)({
         target: 'pino-pretty',
     },
 });
-const truncate = (str) => {
-    if (str == null) {
-        return str;
+const truncate = (val) => {
+    if (val == null) {
+        return val;
     }
-    if (str.length > 66) {
-        return str.slice(0, 34) + '…' + str.slice(-32);
-    }
-    else {
-        return str;
+    switch (typeof val) {
+        case 'string':
+            if (val.length > 66) {
+                return val.slice(0, 34) + '…' + val.slice(-32);
+            }
+            else {
+                return val;
+            }
+        case 'object':
+            if (Array.isArray(val)) {
+                return val.map(exports.truncate);
+            }
+            return Object.fromEntries(Object.entries(val).map(([k, v]) => [k, (0, exports.truncate)(v)]));
+        default:
+            return val;
     }
 };
 exports.truncate = truncate;
-const truncateStorageDiff = (diff) => {
-    return diff.map(([key, value]) => [key, (0, exports.truncate)(value)]);
-};
-exports.truncateStorageDiff = truncateStorageDiff;

package/dist/rpc/dev.js

@@ -2,18 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const set_storage_1 = require("../utils/set-storage");
+const decoder_1 = require("../utils/decoder");
 const logger_1 = require("../logger");
+const generate_html_diff_1 = require("../utils/generate-html-diff");
 const time_travel_1 = require("../utils/time-travel");
 const logger = logger_1.defaultLogger.child({ name: 'rpc-dev' });
 const handlers = {
     dev_newBlock: async (context, [param]) => {
-        const { count, to } = param || {};
+        const { count, to, hrmp } = param || {};
         const now = context.chain.head.number;
         const diff = to ? to - now : count;
         const finalCount = diff > 0 ? diff : 1;
         let finalHash;
         for (let i = 0; i < finalCount; i++) {
-            const block = await context.chain.newBlock().catch((error) => {
+            const block = await context.chain.newBlock({ inherent: { horizontalMessages: hrmp } }).catch((error) => {
                 throw new shared_1.ResponseError(1, error.toString());
             });
             logger.debug({ hash: block.hash }, 'dev_newBlock');
@@ -39,5 +41,45 @@ const handlers = {
         await (0, time_travel_1.timeTravel)(context.chain, timestamp);
         return timestamp;
     },
+    dev_dryRun: async (context, [{ html, extrinsic, hrmp, raw }]) => {
+        const dryRun = async () => {
+            if (extrinsic) {
+                const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(extrinsic);
+                if (outcome.isErr) {
+                    throw new Error(outcome.asErr.toString());
+                }
+                return storageDiff;
+            }
+            return context.chain.dryRunHrmp(hrmp);
+        };
+        const storageDiff = await dryRun();
+        if (html) {
+            return (0, generate_html_diff_1.generateHtmlDiff)(context.chain.head, storageDiff);
+        }
+        if (raw) {
+            return storageDiff;
+        }
+        const [oldData, newData, delta] = await (0, decoder_1.decodeStorageDiff)(context.chain.head, storageDiff);
+        return {
+            old: oldData,
+            new: newData,
+            delta,
+        };
+    },
+    dev_setHead: async (context, [hashOrNumber]) => {
+        let block;
+        if (typeof hashOrNumber === 'number') {
+            const blockNumber = hashOrNumber > 0 ? hashOrNumber : context.chain.head.number + hashOrNumber;
+            block = await context.chain.getBlockAt(blockNumber);
+        }
+        else {
+            block = await context.chain.getBlock(hashOrNumber);
+        }
+        if (!block) {
+            throw new shared_1.ResponseError(1, `Block not found ${hashOrNumber}`);
+        }
+        await context.chain.setHead(block);
+        return block.hash;
+    },
 };
 exports.default = handlers;

package/dist/rpc/substrate/system.js

@@ -23,5 +23,9 @@ const handlers = {
             shouldhVePeers: false,
         };
     },
+    system_dryRun: async (context, [extrinsic, at]) => {
+        const { outcome } = await context.chain.dryRunExtrinsic(extrinsic, at);
+        return outcome.toHex();
+    },
 };
 exports.default = handlers;

package/dist/run-block.d.ts

@@ -1,2 +1,2 @@
 import { Config } from './schema';
-export declare const runBlock: (argv: Config) => Promise<void>;
+export declare const runBlock: (argv: Config) => Promise<never>;

package/dist/run-block.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runBlock = void 0;
 const node_fs_1 = require("node:fs");
+const generate_html_diff_1 = require("./utils/generate-html-diff");
+const open_html_1 = require("./utils/open-html");
 const executor_1 = require("./executor");
-const setup_with_server_1 = require("./setup-with-server");
+const setup_1 = require("./setup");
 const runBlock = async (argv) => {
-    const context = await (0, setup_with_server_1.setupWithServer)(argv);
+    const context = await (0, setup_1.setup)(argv);
     const header = await context.chain.head.header;
     const wasm = await context.chain.head.wasm;
     const block = context.chain.head;
@@ -24,13 +26,22 @@ const runBlock = async (argv) => {
         mockSignatureHost: false,
         allowUnresolvedImports: false,
     }, (0, executor_1.taskHandler)(parent));
-    if (argv['output-path']) {
+    if (result.Error) {
+        throw new Error(result.Error);
+    }
+    if (argv['html']) {
+        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
+        console.log(`Generated preview ${filePath}`);
+        if (argv['open']) {
+            (0, open_html_1.openHtml)(filePath);
+        }
+    }
+    else if (argv['output-path']) {
         (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(result, null, 2));
     }
     else {
         console.dir(result, { depth: null, colors: false });
     }
-    await context.close();
-    setTimeout(() => process.exit(0), 50);
+    process.exit(0);
 };
 exports.runBlock = runBlock;

package/dist/setup.js

@@ -30,7 +30,7 @@ const setup = async (argv) => {
     if (argv.block == null) {
         blockHash = await api.getBlockHash();
     }
-    else if (Number.isInteger(argv.block)) {
+    else if (Number.isInteger(+argv.block)) {
         blockHash = await api.getBlockHash(Number(argv.block));
     }
     else {
@@ -42,7 +42,12 @@ const setup = async (argv) => {
         db = await (0, db_1.openDb)(argv.db);
     }
     const header = await api.getHeader(blockHash);
-    const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [new inherent_1.SetValidationData(), new inherent_1.ParaInherentEnter()]);
+    const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [
+        new inherent_1.SetValidationData(),
+        new inherent_1.ParaInherentEnter(),
+        new inherent_1.SetNimbusAuthorInherent(),
+        new inherent_1.SetBabeRandomness(),
+    ]);
     const chain = new blockchain_1.Blockchain({
         api,
         buildBlockMode: argv['build-block-mode'],
@@ -52,6 +57,8 @@ const setup = async (argv) => {
             hash: blockHash,
             number: Number(header.number),
         },
+        mockSignatureHost: argv['mock-signature-host'],
+        allowUnresolvedImports: argv['allow-unresolved-imports'],
     });
     if (argv.timestamp)
         await (0, time_travel_1.timeTravel)(chain, argv.timestamp);

package/dist/utils/decoder.d.ts

@@ -0,0 +1,17 @@
+import '@polkadot/types-codec';
+import { Block } from '../blockchain/block';
+import { HexString } from '@polkadot/util/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
+import { StorageKey } from '@polkadot/types';
+export declare const decodeKey: (block: Block, key: HexString) => Promise<{
+    storage?: StorageEntry | undefined;
+    decodedKey?: StorageKey<import("@polkadot/types-codec/types").AnyTuple> | undefined;
+}>;
+export declare const decodeKeyValue: (block: Block, key: HexString, value?: HexString | null) => Promise<{
+    [x: string]: `0x${string}` | null | undefined;
+} | {
+    [x: string]: {
+        [x: string]: import("@polkadot/types-codec/types").AnyJson;
+    };
+}>;
+export declare const decodeStorageDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<({} | undefined)[]>;

package/dist/utils/decoder.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeStorageDiff = exports.decodeKeyValue = exports.decodeKey = void 0;
+require("@polkadot/types-codec");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const jsondiffpatch_1 = require("jsondiffpatch");
+const util_1 = require("@polkadot/util");
+const lodash_1 = __importDefault(require("lodash"));
+const diffPatcher = (0, jsondiffpatch_1.create)({
+    array: { detectMove: false },
+    textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
+});
+const _CACHE = {};
+const getCache = (uid) => {
+    if (!_CACHE[uid]) {
+        _CACHE[uid] = {};
+    }
+    return _CACHE[uid];
+};
+const getStorageEntry = async (block, key) => {
+    const cache = getCache(block.chain.uid);
+    for (const [prefix, storageEntry] of Object.entries(cache)) {
+        if (key.startsWith(prefix))
+            return storageEntry;
+    }
+    const meta = await block.meta;
+    for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                cache[keyPrefix] = storage;
+                return storage;
+            }
+        }
+    }
+    throw new Error(`Cannot find key ${key}`);
+};
+const decodeKey = async (block, key) => {
+    const meta = await block.meta;
+    const storage = await getStorageEntry(block, key).catch(() => undefined);
+    const decodedKey = meta.registry.createType('StorageKey', key);
+    if (storage) {
+        decodedKey.setMeta(storage.meta);
+        return { storage, decodedKey };
+    }
+    return {};
+};
+exports.decodeKey = decodeKey;
+const decodeKeyValue = async (block, key, value) => {
+    const meta = await block.meta;
+    const { storage, decodedKey } = await (0, exports.decodeKey)(block, key);
+    if (!storage || !decodedKey) {
+        return { [key]: value };
+    }
+    const decodeValue = () => {
+        if (!value)
+            return null;
+        if (storage.section === 'substrate' && storage.method === 'code') {
+            return `:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${(0, util_1.hexToU8a)(value).length} bytes)`;
+        }
+        return meta.registry.createType(decodedKey.outputType, (0, util_1.hexToU8a)(value)).toHuman();
+    };
+    switch (decodedKey.args.length) {
+        case 2: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: {
+                            [decodedKey.args[1].toString()]: decodeValue(),
+                        },
+                    },
+                },
+            };
+        }
+        case 1: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: decodeValue(),
+                    },
+                },
+            };
+        }
+        default:
+            return {
+                [storage.section]: {
+                    [storage.method]: decodeValue(),
+                },
+            };
+    }
+};
+exports.decodeKeyValue = decodeKeyValue;
+const decodeStorageDiff = async (block, diff) => {
+    const oldState = {};
+    const newState = {};
+    for (const [key, value] of diff) {
+        lodash_1.default.merge(oldState, await (0, exports.decodeKeyValue)(block, key, (await block.get(key))));
+        lodash_1.default.merge(newState, await (0, exports.decodeKeyValue)(block, key, value));
+    }
+    return [oldState, newState, diffPatcher.diff(oldState, newState)];
+};
+exports.decodeStorageDiff = decodeStorageDiff;

package/dist/utils/generate-html-diff.d.ts

@@ -0,0 +1,4 @@
+import { Block } from '../blockchain/block';
+import { HexString } from '@polkadot/util/types';
+export declare const generateHtmlDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<string>;
+export declare const generateHtmlDiffPreviewFile: (block: Block, diff: [HexString, HexString | null][], filename: string) => Promise<string>;

package/dist/utils/generate-html-diff.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHtmlDiffPreviewFile = exports.generateHtmlDiff = void 0;
+const decoder_1 = require("./decoder");
+const node_fs_1 = require("node:fs");
+const lodash_1 = require("lodash");
+const generateHtmlDiff = async (block, diff) => {
+    const [left, _right, delta] = await (0, decoder_1.decodeStorageDiff)(block, diff);
+    const htmlTemplate = (0, node_fs_1.readFileSync)('./template/diff.html', 'utf-8');
+    return (0, lodash_1.template)(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) });
+};
+exports.generateHtmlDiff = generateHtmlDiff;
+const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
+    const html = await (0, exports.generateHtmlDiff)(block, diff);
+    (0, node_fs_1.mkdirSync)('./preview', { recursive: true });
+    const filePath = `./preview/${filename}.html`;
+    (0, node_fs_1.writeFileSync)(filePath, html);
+    return filePath;
+};
+exports.generateHtmlDiffPreviewFile = generateHtmlDiffPreviewFile;

package/dist/utils/open-html.d.ts

@@ -0,0 +1 @@
+export declare const openHtml: (filePath: string) => void;

package/dist/utils/open-html.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openHtml = void 0;
+const node_child_process_1 = require("node:child_process");
+const openHtml = (filePath) => {
+    const start = process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open';
+    (0, node_child_process_1.execSync)(start + ' ' + filePath);
+};
+exports.openHtml = openHtml;

package/dist/xcm/downward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;

package/dist/xcm/downward.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectDownward = void 0;
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const _1 = require(".");
+const set_storage_1 = require("../utils/set-storage");
+const connectDownward = async (relaychain, parachain) => {
+    const meta = await relaychain.head.meta;
+    const paraId = await (0, utils_1.getParaId)(parachain);
+    const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+    await relaychain.headState.subscribeStorage([downwardMessageQueuesKey], async (head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = await relaychain.head.meta;
+        const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+        // clear relaychain message queue
+        await (0, set_storage_1.setStorage)(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        const downwardMessages = meta.registry
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', (0, util_1.hexToU8a)(value))
+            .toJSON();
+        _1.logger.debug({ downwardMessages }, 'downward_message');
+        await parachain.newBlock({ inherent: { downwardMessages } });
+    });
+};
+exports.connectDownward = connectDownward;

package/dist/xcm/horizontal.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectHorizontal: (parachains: Record<number, Blockchain>) => Promise<void>;

package/dist/xcm/horizontal.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectHorizontal = void 0;
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const _1 = require(".");
+const set_storage_1 = require("../utils/set-storage");
+const connectHorizontal = async (parachains) => {
+    for (const [id, chain] of Object.entries(parachains)) {
+        const meta = await chain.head.meta;
+        const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+        await chain.headState.subscribeStorage([hrmpOutboundMessagesKey], async (head, pairs) => {
+            const value = pairs[0][1];
+            if (!value)
+                return;
+            const meta = await chain.head.meta;
+            const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+            // clear sender message queue
+            await (0, set_storage_1.setStorage)(chain, [[hrmpOutboundMessagesKey, null]], head.hash);
+            const outboundHrmpMessage = meta.registry
+                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', (0, util_1.hexToU8a)(value))
+                .toJSON();
+            _1.logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
+            for (const { recipient, data } of outboundHrmpMessage) {
+                const horizontalMessages = {
+                    [Number(id)]: [{ sentAt: chain.head.number, data }],
+                };
+                const receiver = parachains[recipient];
+                if (receiver) {
+                    await receiver.newBlock({ inherent: { horizontalMessages } });
+                }
+            }
+        });
+    }
+};
+exports.connectHorizontal = connectHorizontal;

package/dist/xcm/index.d.ts

@@ -1,3 +1,9 @@
 import { Blockchain } from '../blockchain';
-export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+} & import("pino").default.ChildLoggerOptions>;
+export declare const connectVertical: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
 export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/dist/xcm/index.js

@@ -1,67 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectParachains = exports.connectDownward = void 0;
-const util_1 = require("@polkadot/util");
-const utils_1 = require("../utils");
+exports.connectParachains = exports.connectVertical = exports.logger = void 0;
+const downward_1 = require("./downward");
+const horizontal_1 = require("./horizontal");
+const upward_1 = require("./upward");
 const logger_1 = require("../logger");
-const set_storage_1 = require("../utils/set-storage");
-const logger = logger_1.defaultLogger.child({ name: 'xcm' });
-const connectDownward = async (relaychain, parachain) => {
-    const meta = await relaychain.head.meta;
-    const paraId = await (0, utils_1.getParaId)(parachain);
-    const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
-    await relaychain.headState.subscribeStorage([downwardMessageQueuesKey], async (head, pairs) => {
-        const value = pairs[0][1];
-        if (!value)
-            return;
-        const meta = await relaychain.head.meta;
-        const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
-        // clear relaychain message queue
-        await (0, set_storage_1.setStorage)(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
-        const downwardMessages = meta.registry
-            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', (0, util_1.hexToU8a)(value))
-            .toJSON();
-        logger.debug({ downwardMessages }, 'downward_message');
-        await parachain.newBlock({ inherent: { downwardMessages } });
-    });
-    logger.info(`Connected relaychain '${await relaychain.api.getSystemChain()}' with parachain '${await parachain.api.getSystemChain()}'`);
+const utils_1 = require("../utils");
+exports.logger = logger_1.defaultLogger.child({ name: 'xcm' });
+const connectVertical = async (relaychain, parachain) => {
+    await (0, downward_1.connectDownward)(relaychain, parachain);
+    await (0, upward_1.connectUpward)(parachain, relaychain);
+    exports.logger.info(`Connected relaychain '${await relaychain.api.getSystemChain()}' with parachain '${await parachain.api.getSystemChain()}'`);
 };
-exports.connectDownward = connectDownward;
+exports.connectVertical = connectVertical;
 const connectParachains = async (parachains) => {
     const list = {};
     for (const chain of parachains) {
         const paraId = await (0, utils_1.getParaId)(chain);
         list[paraId.toNumber()] = chain;
     }
-    await connectHorizontal(list);
-    logger.info('Parachains connected');
+    await (0, horizontal_1.connectHorizontal)(list);
+    exports.logger.info(`Connected parachains [${Object.keys(list)}]`);
 };
 exports.connectParachains = connectParachains;
-const connectHorizontal = async (parachains) => {
-    for (const [id, chain] of Object.entries(parachains)) {
-        const meta = await chain.head.meta;
-        const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
-        await chain.headState.subscribeStorage([hrmpOutboundMessagesKey], async (head, pairs) => {
-            const value = pairs[0][1];
-            if (!value)
-                return;
-            const meta = await chain.head.meta;
-            const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
-            // clear sender message queue
-            await (0, set_storage_1.setStorage)(chain, [[hrmpOutboundMessagesKey, null]], head.hash);
-            const outboundHrmpMessage = meta.registry
-                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', (0, util_1.hexToU8a)(value))
-                .toJSON();
-            logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
-            for (const { recipient, data } of outboundHrmpMessage) {
-                const horizontalMessages = {
-                    [Number(id)]: [{ sentAt: chain.head.number, data }],
-                };
-                const receiver = parachains[recipient];
-                if (receiver) {
-                    await receiver.newBlock({ inherent: { horizontalMessages } });
-                }
-            }
-        });
-    }
-};

package/dist/xcm/upward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectUpward: (parachain: Blockchain, relaychain: Blockchain) => Promise<void>;