@acala-network/chopsticks 0.3.1 → 0.3.3

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/head-state.js

@@ -46,15 +46,23 @@ class HeadState {
     async setHead(head) {
         this.#head = head;
         for (const cb of Object.values(this.#headListeners)) {
-            cb(head);
+            try {
+                cb(head);
+            }
+            catch (error) {
+                logger.error(error, 'callback');
+            }
         }
         const diff = await this.#head.storageDiff();
         for (const [keys, cb] of Object.values(this.#storageListeners)) {
             const changed = keys.filter((key) => diff[key]).map((key) => [key, diff[key]]);
             if (changed.length > 0) {
-                await Promise.resolve(cb(head, changed)).catch((error) => {
+                try {
+                    cb(head, changed);
+                }
+                catch (error) {
                     logger.error(error, 'callback');
-                });
+                }
             }
         }
         Object.assign(this.#oldValues, diff);

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,11 @@ export declare class Blockchain {
     setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
     newBlock(params?: BuildBlockParams): Promise<Block>;
-    dryRunExtrinsic(extrinsic: HexString): Promise<{
+    upcomingBlock(count?: number): Promise<Block>;
+    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,15 @@ class Blockchain {
         await this.#txpool.buildBlock(params);
         return this.#head;
     }
-    async dryRunExtrinsic(extrinsic) {
+    async upcomingBlock(count = 1) {
+        return this.#txpool.upcomingBlock(count);
+    }
+    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/blockchain/txpool.d.ts

@@ -1,4 +1,5 @@
 import { HexString } from '@polkadot/util/types';
+import { Block } from './block';
 import { Blockchain } from '.';
 import { InherentProvider } from './inherent';
 export declare enum BuildBlockMode {
@@ -26,4 +27,5 @@ export declare class TxPool {
     get pendingExtrinsics(): HexString[];
     submitExtrinsic(extrinsic: HexString): void;
     buildBlock(params?: BuildBlockParams): Promise<void>;
+    upcomingBlock(count?: number): Promise<Block>;
 }

package/dist/blockchain/txpool.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxPool = exports.BuildBlockMode = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
 const lodash_1 = __importDefault(require("lodash"));
 const block_builder_1 = require("./block-builder");
 var BuildBlockMode;
@@ -18,6 +20,8 @@ class TxPool {
     #mode;
     #inherentProvider;
     #lastBuildBlockPromise = Promise.resolve();
+    #last = new rxjs_1.ReplaySubject(1);
+    #upcoming = this.#last.pipe((0, rxjs_1.share)());
     constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
         this.#chain = chain;
         this.#mode = mode;
@@ -45,6 +49,17 @@ class TxPool {
         const last = this.#lastBuildBlockPromise;
         this.#lastBuildBlockPromise = this.#buildBlock(last, params);
         await this.#lastBuildBlockPromise;
+        this.#last.next(this.#chain.head);
+    }
+    async upcomingBlock(count = 1) {
+        if (count < 1)
+            throw new Error('count needs to be greater than 0');
+        return new Promise((resolve) => {
+            const sub = this.#upcoming.pipe((0, operators_1.skip)(count - 1)).subscribe((block) => {
+                sub.unsubscribe();
+                resolve(block);
+            });
+        });
     }
     async #buildBlock(wait, params) {
         await this.#chain.api.isReady;

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.d.ts

@@ -1,6 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from './blockchain/block';
 import { Registry } from '@polkadot/types-codec/types';
+import _ from 'lodash';
 interface JsCallback {
     getStorage: (key: HexString) => Promise<string | undefined>;
     getPrefixKeys: (key: HexString) => Promise<string[]>;
@@ -36,5 +37,5 @@ export declare const emptyTaskHandler: {
     getPrefixKeys: (_key: HexString) => Promise<never>;
     getNextKey: (_key: HexString) => Promise<never>;
 };
-export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & import("lodash").MemoizedFunction;
+export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & _.MemoizedFunction;
 export {};

package/dist/executor.js

@@ -1,12 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
-const ws_1 = require("ws");
 const util_1 = require("@polkadot/util");
-global.WebSocket = ws_1.WebSocket;
 const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
 const logger_1 = require("./logger");
-const lodash_1 = require("lodash");
+const lodash_1 = __importDefault(require("lodash"));
 const logger = logger_1.defaultLogger.child({ name: 'executor' });
 const getRuntimeVersion = async (code) => {
     return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
@@ -38,10 +39,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 +59,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];
         },
     };
@@ -75,7 +76,7 @@ exports.emptyTaskHandler = {
         throw new Error('Method not implemented');
     },
 };
-exports.getAuraSlotDuration = (0, lodash_1.memoize)(async (wasm, registry) => {
+exports.getAuraSlotDuration = lodash_1.default.memoize(async (wasm, registry) => {
     const result = await (0, exports.runTask)({
         wasm,
         calls: [['AuraApi_slot_duration', '0x']],

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/index.js

@@ -10,6 +10,10 @@ const substrate_1 = __importDefault(require("./substrate"));
 const allHandlers = {
     ...substrate_1.default,
     ...dev_1.default,
+    rpc_methods: async () => Promise.resolve({
+        version: 1,
+        methods: Object.keys(allHandlers),
+    }),
 };
 const handler = (context) => ({ method, params }, subscriptionManager) => {
     shared_1.logger.trace('Handling %s', method);

package/dist/rpc/substrate/chain.js

@@ -10,7 +10,11 @@ const handlers = {
         return block.hash;
     },
     chain_getHeader: async (context, [hash]) => {
-        return (await context.chain.getBlock(hash))?.header;
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+        }
+        return await block.header;
     },
     chain_getBlock: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);

package/dist/rpc/substrate/index.js

@@ -12,9 +12,5 @@ const handlers = {
     ...chain_1.default,
     ...state_1.default,
     ...system_1.default,
-    rpc_methods: async () => ({
-        version: 1,
-        methods: Object.keys(handlers),
-    }),
 };
 exports.default = handlers;

package/dist/rpc/substrate/system.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@polkadot/util");
+const node_fs_1 = require("node:fs");
 const handlers = {
     system_chain: async (context) => {
         return context.chain.api.getSystemChain();
@@ -11,7 +13,8 @@ const handlers = {
         return context.chain.api.getSystemName();
     },
     system_version: async (_context) => {
-        return 'chopsticks-1.1.0';
+        const { version } = JSON.parse((0, node_fs_1.readFileSync)('package.json', 'utf-8'));
+        return `chopsticks-v${version}`;
     },
     system_chainType: async (_context) => {
         return 'Development';
@@ -23,5 +26,16 @@ const handlers = {
             shouldhVePeers: false,
         };
     },
+    system_dryRun: async (context, [extrinsic, at]) => {
+        const { outcome } = await context.chain.dryRunExtrinsic(extrinsic, at);
+        return outcome.toHex();
+    },
+    system_accountNextIndex: async (context, [address]) => {
+        const head = context.chain.head;
+        const registry = await head.registry;
+        const account = registry.createType('AccountId', address);
+        const result = await head.call('AccountNonceApi_account_nonce', account.toHex());
+        return registry.createType('Index', (0, util_1.hexToU8a)(result.result)).toNumber();
+    },
 };
 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/schema/index.d.ts

@@ -35,12 +35,12 @@ export declare const genesisSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
+    id: string;
     properties: {
         ss58Format?: number | undefined;
         tokenDecimals?: number | number[] | undefined;
         tokenSymbol?: string | string[] | undefined;
     };
-    id: string;
     genesis: {
         raw: {
             top: Record<string, string>;
@@ -48,12 +48,12 @@ export declare const genesisSchema: z.ZodObject<{
     };
 }, {
     name: string;
+    id: string;
     properties: {
         ss58Format?: number | undefined;
         tokenDecimals?: number | number[] | undefined;
         tokenSymbol?: string | string[] | undefined;
     };
-    id: string;
     genesis: {
         raw: {
             top: Record<string, string>;
@@ -105,12 +105,12 @@ export declare const configSchema: z.ZodObject<{
         }>;
     }, "strip", z.ZodTypeAny, {
         name: string;
+        id: string;
         properties: {
             ss58Format?: number | undefined;
             tokenDecimals?: number | number[] | undefined;
             tokenSymbol?: string | string[] | undefined;
         };
-        id: string;
         genesis: {
             raw: {
                 top: Record<string, string>;
@@ -118,12 +118,12 @@ export declare const configSchema: z.ZodObject<{
         };
     }, {
         name: string;
+        id: string;
         properties: {
             ss58Format?: number | undefined;
             tokenDecimals?: number | number[] | undefined;
             tokenSymbol?: string | string[] | undefined;
         };
-        id: string;
         genesis: {
             raw: {
                 top: Record<string, string>;
@@ -136,12 +136,12 @@ export declare const configSchema: z.ZodObject<{
     db?: string | undefined;
     genesis?: string | {
         name: string;
+        id: string;
         properties: {
             ss58Format?: number | undefined;
             tokenDecimals?: number | number[] | undefined;
             tokenSymbol?: string | string[] | undefined;
         };
-        id: string;
         genesis: {
             raw: {
                 top: Record<string, string>;
@@ -160,12 +160,12 @@ export declare const configSchema: z.ZodObject<{
     db?: string | undefined;
     genesis?: string | {
         name: string;
+        id: string;
         properties: {
             ss58Format?: number | undefined;
             tokenDecimals?: number | number[] | undefined;
             tokenSymbol?: string | string[] | undefined;
         };
-        id: string;
         genesis: {
             raw: {
                 top: Record<string, string>;

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,29 @@
+"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();
+        if (downwardMessages.length === 0)
+            return;
+        _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));
+        if (upwardMessages.length === 0)
+            return;
+        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().setAll([
+            [(0, utils_1.compactHex)(relaychainMeta.query.ump.needsDispatch()), needsDispatch.toHex()],
+            [(0, utils_1.compactHex)(relaychainMeta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex()],
+            [(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.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
@@ -16,7 +16,7 @@
     "fix": "eslint . --ext .js,.ts --fix && prettier -w .",
     "prepare": "husky install",
     "start": "ts-node --transpile-only src/index.ts",
-    "build": "rimraf dist && tsc -p tsconfig.prod.json",
+    "build": "rm -rf dist && tsc -p tsconfig.prod.json",
     "build-wasm": "wasm-pack build executor --target nodejs --scope acala-network",
     "build-wasm-logging": "yarn build-wasm --features=logging",
     "check": "cd executor && cargo check --locked",
@@ -30,47 +30,45 @@
   },
   "dependencies": {
     "@acala-network/chopsticks-executor": "0.3.0",
-    "@polkadot/api": "^9.10.1",
-    "@polkadot/rpc-provider": "^9.10.1",
-    "@polkadot/types": "^9.10.1",
-    "@polkadot/types-codec": "^9.10.1",
-    "@polkadot/types-known": "^9.10.1",
-    "@polkadot/util": "^10.2.1",
-    "@polkadot/util-crypto": "^10.2.1",
-    "axios": "^1.2.2",
+    "@polkadot/api": "^9.11.3",
+    "@polkadot/rpc-provider": "^9.11.3",
+    "@polkadot/types": "^9.11.3",
+    "@polkadot/types-codec": "^9.11.3",
+    "@polkadot/types-known": "^9.11.3",
+    "@polkadot/util": "^10.2.6",
+    "@polkadot/util-crypto": "^10.2.6",
+    "axios": "^1.2.3",
     "js-yaml": "^4.1.0",
     "jsondiffpatch": "^0.4.1",
     "lodash": "^4.17.21",
-    "pino": "^8.7.0",
+    "pino": "^8.8.0",
     "pino-pretty": "^9.1.1",
     "reflect-metadata": "^0.1.13",
-    "sqlite3": "^5.1.2",
+    "sqlite3": "^5.1.4",
     "typeorm": "^0.3.11",
-    "typescript": "^4.9.3",
-    "ws": "^8.11.0",
+    "typescript": "^4.9.4",
+    "ws": "^8.12.0",
     "yargs": "^17.6.2",
-    "zod": "^3.19.1"
+    "zod": "^3.20.2"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.191",
     "@types/node": "^18.11.18",
-    "@types/rimraf": "^3",
-    "@types/ws": "^8.5.3",
-    "@types/yargs": "^17.0.18",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "eslint": "^8.31.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.26.0",
+    "@types/ws": "^8.5.4",
+    "@types/yargs": "^17.0.19",
+    "@typescript-eslint/eslint-plugin": "^5.48.2",
+    "@typescript-eslint/parser": "^5.48.2",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-sort-imports-es6-autofix": "^0.6.0",
-    "husky": "^8.0.2",
+    "husky": "^8.0.3",
     "lint-staged": "^13.1.0",
-    "prettier": "^2.8.0",
-    "rimraf": "^3.0.2",
+    "prettier": "^2.8.3",
     "ts-node": "^10.9.1",
     "ts-node-dev": "^2.0.0",
-    "vitest": "^0.25.3",
+    "vitest": "^0.27.2",
     "wasm-pack": "^0.10.3"
   },
   "files": [