@acala-network/chopsticks 0.3.1 → 0.3.2

package/README.md

@@ -31,7 +31,8 @@ Make sure you have setup Rust environment (>= 1.64).
   - Use option `--html` to generate storage diff preview (add `--open` to automatically open file)
 
 - Dry run extrinsic, same as `run-block`, example:
-  - `yarn start dry-run --config=configs/mandala.yml --html --open --extrinsic 0x51028400d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01a4143d076116f80a4074ed7acc90f9e1f9e2db54603900be53145a6ef5faa333f2614e687a06a9c886a909d77f3115b1a9d989afdc9fd73e5dca941bc690ae8a0000000a00008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a481b000000a1edccce1bc2d3`
+  - `yarn start dry-run --config=configs/mandala.yml --html --open --extrinsic=0x39028400d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01183abac17ff331f8b65dbeddd27f014dedd892020cfdc6c40b574f6930f8cf391bde95997ae2edc5b1192a4036ea97804956c4b5497175c8d68b630301685889450200000a00008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480284d717`
+  - Dry run call `yarn start dry-run --config=configs/mandala.yml --html --open --extrinsic=0xff00000080969800 --address=5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY --at=0x5f660b32489966cc707ecde831864aeecf9092c4983e75f9880313e9158d62b9`
 
 - Run a test node
   - `yarn start dev --endpoint=wss://acala-rpc-2.aca-api.network/ws`
@@ -63,7 +64,7 @@ Make sure you have setup Rust environment (>= 1.64).
   - Edit configs/kusama.yml if needed. (e.g. update the block number)
   - `yarn start dev --config=configs/kusama.yml`
 
-- Setup XCM multichain (UpwardMessages not yet supported)
+- Setup XCM multichain
 **_NOTE:_** You can also connect multiple parachains without a relaychain
 ```bash
 yarn start xcm --relaychain=configs/kusama.yml --parachain=configs/karura.yml --parachain=configs/statemine.yml

package/dist/blockchain/block-builder.d.ts

@@ -1,5 +1,8 @@
 import { Block, TaskCallResponse } from './block';
 import { HexString } from '@polkadot/util/types';
 export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[]) => Promise<[Block, HexString[]]>;
-export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString) => Promise<TaskCallResponse>;
+export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
+    call: HexString;
+    address: string;
+}) => Promise<TaskCallResponse>;
 export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/dist/blockchain/block-builder.js

@@ -94,14 +94,14 @@ const initNewBlock = async (head, header, inherents) => {
         // initialize block
         const { storageDiff } = await newBlock.call('Core_initialize_block', header.toHex());
         newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Initialize block');
+        logger.trace((0, logger_1.truncate)(storageDiff), 'Initialize block');
     }
     // apply inherents
     for (const extrinsic of inherents) {
         try {
             const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
             newBlock.pushStorageLayer().setAll(storageDiff);
-            logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Applied inherent');
+            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied inherent');
         }
         catch (e) {
             logger.warn('Failed to apply inherents %o %s', e, e);
@@ -125,7 +125,7 @@ const buildBlock = async (head, inherents, extrinsics) => {
         try {
             const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
             newBlock.pushStorageLayer().setAll(storageDiff);
-            logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Applied extrinsic');
+            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
         }
         catch (e) {
             logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -136,7 +136,7 @@ const buildBlock = async (head, inherents, extrinsics) => {
         // finalize block
         const { storageDiff } = await newBlock.call('BlockBuilder_finalize_block', '0x');
         newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Finalize block');
+        logger.trace((0, logger_1.truncate)(storageDiff), 'Finalize block');
     }
     const blockData = registry.createType('Block', {
         header,
@@ -155,8 +155,32 @@ const buildBlock = async (head, inherents, extrinsics) => {
 };
 exports.buildBlock = buildBlock;
 const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+    const registry = await head.registry;
     const header = await newHeader(head);
     const newBlock = await initNewBlock(head, header, inherents);
+    if (typeof extrinsic !== 'string') {
+        if (!head.chain.mockSignatureHost) {
+            throw new Error('Cannot fake signature because mock signature host is not enabled. Start chain with `mockSignatureHost: true`');
+        }
+        const meta = await head.meta;
+        const call = registry.createType('Call', (0, util_1.hexToU8a)(extrinsic.call));
+        const generic = registry.createType('GenericExtrinsic', call);
+        const accountRaw = await head.get((0, utils_1.compactHex)(meta.query.system.account(extrinsic.address)));
+        const account = registry.createType('AccountInfo', (0, util_1.hexToU8a)(accountRaw));
+        generic.signFake(extrinsic.address, {
+            blockHash: head.hash,
+            genesisHash: head.hash,
+            runtimeVersion: await head.runtimeVersion,
+            nonce: account.nonce,
+        });
+        const mockSignature = new Uint8Array(64);
+        mockSignature.fill(0xcd);
+        mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
+        generic.signature.set(mockSignature);
+        logger_1.defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
+        return newBlock.call('BlockBuilder_apply_extrinsic', generic.toHex());
+    }
+    logger_1.defaultLogger.info({ call: registry.createType('GenericExtrinsic', (0, util_1.hexToU8a)(extrinsic)).toHuman() }, 'dry_run_extrinsic');
     return newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
 };
 exports.dryRunExtrinsic = dryRunExtrinsic;

package/dist/blockchain/index.d.ts

@@ -20,6 +20,7 @@ export interface Options {
 }
 export declare class Blockchain {
     #private;
+    readonly uid: string;
     readonly api: Api;
     readonly db: DataSource | undefined;
     readonly mockSignatureHost: boolean;
@@ -34,7 +35,10 @@ export declare class Blockchain {
     setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
     newBlock(params?: BuildBlockParams): Promise<Block>;
-    dryRunExtrinsic(extrinsic: HexString): Promise<{
+    dryRunExtrinsic(extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString): Promise<{
         outcome: ApplyExtrinsicResult;
         storageDiff: [HexString, HexString | null][];
     }>;

package/dist/blockchain/index.js

@@ -10,6 +10,7 @@ const logger_1 = require("../logger");
 const block_builder_1 = require("./block-builder");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
+    uid = Math.random().toString(36).substring(2);
     api;
     db;
     mockSignatureHost;
@@ -118,9 +119,12 @@ class Blockchain {
         await this.#txpool.buildBlock(params);
         return this.#head;
     }
-    async dryRunExtrinsic(extrinsic) {
+    async dryRunExtrinsic(extrinsic, at) {
         await this.api.isReady;
-        const head = this.head;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
         const registry = await head.registry;
         const inherents = await this.#inherentProvider.createInherents(head);
         const { result, storageDiff } = await (0, block_builder_1.dryRunExtrinsic)(head, inherents, extrinsic);

package/dist/dry-run.js

@@ -3,15 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dryRun = void 0;
 const util_crypto_1 = require("@polkadot/util-crypto");
 const node_fs_1 = require("node:fs");
+const logger_1 = require("./logger");
 const generate_html_diff_1 = require("./utils/generate-html-diff");
 const open_html_1 = require("./utils/open-html");
 const setup_1 = require("./setup");
 const dryRun = async (argv) => {
     const context = await (0, setup_1.setup)(argv);
-    const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(argv['extrinsic']);
+    const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+    const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input, argv['at']);
     if (outcome.isErr) {
         throw new Error(outcome.asErr.toString());
     }
+    else {
+        logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+    }
     if (argv['html']) {
         const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
         console.log(`Generated preview ${filePath}`);

package/dist/executor.js

@@ -38,10 +38,10 @@ const createProof = async (trieRootHash, nodes, entries) => {
 };
 exports.createProof = createProof;
 const runTask = async (task, callback = exports.emptyTaskHandler) => {
-    logger.trace({ task: { ...task, wasm: (0, logger_1.truncate)(task.wasm) } }, 'taskRun');
+    logger.trace((0, logger_1.truncate)(task), 'taskRun');
     const response = await (0, chopsticks_executor_1.run_task)(task, callback);
     if (response.Call) {
-        logger.trace({ result: (0, logger_1.truncate)(response.Call.result), storageDiff: (0, logger_1.truncateStorageDiff)(response.Call.storageDiff) }, 'taskResponse');
+        logger.trace((0, logger_1.truncate)(response.Call), 'taskResponse');
     }
     else {
         logger.trace({ response }, 'taskResponse');
@@ -58,7 +58,7 @@ const taskHandler = (block) => {
             return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
         },
         getNextKey: async function (key) {
-            const keys = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+            const keys = await block.getKeysPaged({ prefix: '0x', pageSize: 1, startKey: key });
             return keys[0];
         },
     };

package/dist/index.js

@@ -71,10 +71,18 @@ const defaultOptions = {
     .command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
     ...defaultOptions,
     extrinsic: {
-        desc: 'Extrinsic to dry run',
+        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,
@@ -106,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));
 })
@@ -150,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

@@ -66,5 +66,20 @@ const handlers = {
             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.js

@@ -30,7 +30,7 @@ const runBlock = async (argv) => {
         throw new Error(result.Error);
     }
     if (argv['html']) {
-        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, block.hash);
+        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);

package/dist/setup.js

@@ -57,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.js

@@ -13,8 +13,15 @@ const diffPatcher = (0, jsondiffpatch_1.create)({
     array: { detectMove: false },
     textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
 });
-const cache = {};
+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;
@@ -87,13 +94,10 @@ const decodeKeyValue = async (block, key, value) => {
 };
 exports.decodeKeyValue = decodeKeyValue;
 const decodeStorageDiff = async (block, diff) => {
-    const parent = await block.parentBlock;
-    if (!parent)
-        throw new Error('Cannot find parent block');
     const oldState = {};
     const newState = {};
     for (const [key, value] of diff) {
-        lodash_1.default.merge(oldState, await (0, exports.decodeKeyValue)(parent, key, (await parent.get(key))));
+        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)];

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>;

package/dist/xcm/upward.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectUpward = 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 connectUpward = async (parachain, relaychain) => {
+    const meta = await parachain.head.meta;
+    const paraId = await (0, utils_1.getParaId)(parachain);
+    const upwardMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.upwardMessages());
+    await parachain.headState.subscribeStorage([upwardMessagesKey], async (head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const parachainMeta = await parachain.head.meta;
+        const upwardMessagesKey = (0, utils_1.compactHex)(parachainMeta.query.parachainSystem.upwardMessages());
+        // clear parachain message queue
+        await (0, set_storage_1.setStorage)(parachain, [[upwardMessagesKey, null]], head.hash);
+        const relaychainMeta = await relaychain.head.meta;
+        const upwardMessages = parachainMeta.registry.createType('Vec<Bytes>', (0, util_1.hexToU8a)(value));
+        const queueSize = parachainMeta.registry.createType('(u32, u32)', [
+            upwardMessages.length,
+            upwardMessages.map((x) => x.byteLength).reduce((s, i) => s + i, 0),
+        ]);
+        const needsDispatch = parachainMeta.registry.createType('Vec<u32>', [paraId]);
+        _1.logger.debug({ [paraId.toNumber()]: upwardMessages.toJSON(), queueSize: queueSize.toJSON() }, 'upward_message');
+        // TODO: make sure we append instead of replace
+        relaychain.head.pushStorageLayer().set((0, utils_1.compactHex)(relaychainMeta.query.ump.needsDispatch()), needsDispatch.toHex());
+        relaychain.head
+            .pushStorageLayer()
+            .set((0, utils_1.compactHex)(relaychainMeta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex());
+        relaychain.head
+            .pushStorageLayer()
+            .set((0, utils_1.compactHex)(relaychainMeta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex());
+        await relaychain.newBlock();
+    });
+};
+exports.connectUpward = connectUpward;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",