@acala-network/chopsticks 0.3.0 → 0.3.1

package/README.md

@@ -26,7 +26,13 @@ Make sure you have setup Rust environment (>= 1.64).
 - Replay latest block
   - `yarn start run-block --endpoint=wss://acala-rpc-2.aca-api.network/ws`
   - This will replay the last block and print out the changed storages
+  - Use option `--block` to replay certain block hash
   - Use option `--output-path=<file_path>` to print out JSON file
+  - 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`
+
 - Run a test node
   - `yarn start dev --endpoint=wss://acala-rpc-2.aca-api.network/ws`
   - You have a test node running at `ws://localhost:8000`
@@ -34,7 +40,6 @@ Make sure you have setup Rust environment (>= 1.64).
   - Submit any transaction to produce a new block in the in parallel reality
   - (Optional) Pre-define/override storage using option `--import-storage=storage.[json/yaml]`. See example storage below.
   ```json5
-  // prettier-ignore
   {
     "Sudo": {
       "Key": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"

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

@@ -1,4 +1,5 @@
-import { Block } from './block';
-import { Header } from '@polkadot/types/interfaces';
+import { Block, TaskCallResponse } from './block';
 import { HexString } from '@polkadot/util/types';
-export declare const buildBlock: (head: Block, header: Header, inherents: HexString[], extrinsics: HexString[]) => Promise<[Block, HexString[]]>;
+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 dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/dist/blockchain/block-builder.js

@@ -1,27 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBlock = void 0;
+exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = void 0;
 const block_1 = require("./block");
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
 const logger_1 = require("../logger");
+const time_travel_1 = require("../utils/time-travel");
 const logger = logger_1.defaultLogger.child({ name: 'block-builder' });
-const buildBlock = async (head, header, inherents, extrinsics) => {
-    const registry = await head.registry;
-    const pendingExtrinsics = [];
+const getConsensus = (header) => {
+    if (header.digest.logs.length === 0)
+        return;
+    const preRuntime = header.digest.logs[0].asPreRuntime;
+    const [consensusEngine, slot] = preRuntime;
+    return { consensusEngine, slot, rest: header.digest.logs.slice(1) };
+};
+const getNewSlot = (digest, slotNumber) => {
+    if (digest.isPrimary) {
+        return {
+            primary: {
+                ...digest.asPrimary.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryPlain) {
+        return {
+            secondaryPlain: {
+                ...digest.asSecondaryPlain.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryVRF) {
+        return {
+            secondaryVRF: {
+                ...digest.asSecondaryVRF.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    return digest.toJSON();
+};
+const newHeader = async (head) => {
+    const meta = await head.meta;
+    const parentHeader = await head.header;
+    let newLogs = parentHeader.digest.logs;
+    const consensus = getConsensus(parentHeader);
+    if (consensus?.consensusEngine.isAura) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
+        const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine.isBabe) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
+        const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
+        const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine?.toString() == 'nmbs') {
+        const nmbsKey = (0, util_1.stringToHex)('nmbs');
+        newLogs = [
+            {
+                // Using previous block author
+                PreRuntime: [
+                    consensus.consensusEngine,
+                    parentHeader.digest.logs
+                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)
+                        ?.asPreRuntime[1].toHex(),
+                ],
+            },
+            ...consensus.rest,
+            head.pushStorageLayer().set((0, utils_1.compactHex)(meta.query.randomness.notFirstBlock()), "Deleted" /* StorageValueKind.Deleted */),
+        ];
+    }
+    const header = meta.registry.createType('Header', {
+        parentHash: head.hash,
+        number: head.number + 1,
+        stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        digest: {
+            logs: newLogs,
+        },
+    });
+    return header;
+};
+const initNewBlock = async (head, header, inherents) => {
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000)
         .toString(16)
         .padEnd(64, '0')}`;
     const newBlock = new block_1.Block(head.chain, blockNumber, hash, head, { header, extrinsics: [], storage: head.storage });
-    logger.info({
-        number: blockNumber,
-        extrinsicsCount: extrinsics.length,
-        tempHash: newBlock.hash,
-    }, `Building block #${blockNumber.toLocaleString()}`);
     {
         // initialize block
         const { storageDiff } = await newBlock.call('Core_initialize_block', header.toHex());
-        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Initialize block');
         newBlock.pushStorageLayer().setAll(storageDiff);
+        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Initialize block');
     }
     // apply inherents
     for (const extrinsic of inherents) {
@@ -35,6 +108,18 @@ const buildBlock = async (head, header, inherents, extrinsics) => {
             throw new Error('Failed to apply inherents');
         }
     }
+    return newBlock;
+};
+const buildBlock = async (head, inherents, extrinsics) => {
+    const registry = await head.registry;
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    logger.info({
+        number: newBlock.number,
+        extrinsicsCount: extrinsics.length,
+        tempHash: newBlock.hash,
+    }, `Building block #${newBlock.number.toLocaleString()}`);
+    const pendingExtrinsics = [];
     // apply extrinsics
     for (const extrinsic of extrinsics) {
         try {
@@ -59,13 +144,25 @@ const buildBlock = async (head, header, inherents, extrinsics) => {
     });
     const storageDiff = await newBlock.storageDiff();
     logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
-    const finalBlock = new block_1.Block(head.chain, blockNumber, blockData.hash.toHex(), head, {
+    const finalBlock = new block_1.Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
         header,
         extrinsics: [...inherents, ...extrinsics],
         storage: head.storage,
         storageDiff,
     });
-    logger.info({ hash: finalBlock.hash, number: blockNumber }, `Block built #${blockNumber.toLocaleString()} hash ${finalBlock.hash}`);
+    logger.info({ hash: finalBlock.hash, number: newBlock.number }, `Block built #${newBlock.number.toLocaleString()} hash ${finalBlock.hash}`);
     return [finalBlock, pendingExtrinsics];
 };
 exports.buildBlock = buildBlock;
+const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    return newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
+};
+exports.dryRunExtrinsic = dryRunExtrinsic;
+const dryRunInherents = async (head, inherents) => {
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    return Object.entries(await newBlock.storageDiff());
+};
+exports.dryRunInherents = dryRunInherents;

package/dist/blockchain/block.d.ts

@@ -32,7 +32,7 @@ export declare class Block {
     }): Promise<string[]>;
     pushStorageLayer(): StorageLayer;
     popStorageLayer(): void;
-    storageDiff(): Promise<Record<string, string>>;
+    storageDiff(): Promise<Record<HexString, HexString | null>>;
     get wasm(): Promise<`0x${string}`>;
     setWasm(wasm: HexString): void;
     get registry(): Promise<TypeRegistry>;

package/dist/blockchain/index.d.ts

@@ -1,8 +1,9 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
 import { DataSource } from 'typeorm';
 import { HexString } from '@polkadot/util/types';
 import { Api } from '../api';
 import { Block } from './block';
-import { BuildBlockMode, BuildBlockParams } from './txpool';
+import { BuildBlockMode, BuildBlockParams, HorizontalMessage } from './txpool';
 import { HeadState } from './head-state';
 import { InherentProvider } from './inherent';
 export interface Options {
@@ -33,4 +34,9 @@ export declare class Blockchain {
     setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
     newBlock(params?: BuildBlockParams): Promise<Block>;
+    dryRunExtrinsic(extrinsic: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>): Promise<[HexString, HexString | null][]>;
 }

package/dist/blockchain/index.js

@@ -7,6 +7,7 @@ const block_1 = require("./block");
 const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
 const logger_1 = require("../logger");
+const block_builder_1 = require("./block-builder");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
     api;
@@ -14,6 +15,7 @@ class Blockchain {
     mockSignatureHost;
     allowUnresolvedImports;
     #txpool;
+    #inherentProvider;
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
@@ -27,6 +29,7 @@ class Blockchain {
         this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
+        this.#inherentProvider = inherentProvider;
         this.headState = new head_state_1.HeadState(this.#head);
     }
     #registerBlock(block) {
@@ -115,5 +118,20 @@ class Blockchain {
         await this.#txpool.buildBlock(params);
         return this.#head;
     }
+    async dryRunExtrinsic(extrinsic) {
+        await this.api.isReady;
+        const head = this.head;
+        const registry = await head.registry;
+        const inherents = await this.#inherentProvider.createInherents(head);
+        const { result, storageDiff } = await (0, block_builder_1.dryRunExtrinsic)(head, inherents, extrinsic);
+        const outcome = registry.createType('ApplyExtrinsicResult', result);
+        return { outcome, storageDiff };
+    }
+    async dryRunHrmp(hrmp) {
+        await this.api.isReady;
+        const head = this.head;
+        const inherents = await this.#inherentProvider.createInherents(head, { horizontalMessages: hrmp });
+        return (0, block_builder_1.dryRunInherents)(head, inherents);
+    }
 }
 exports.Blockchain = Blockchain;

package/dist/blockchain/inherent/index.d.ts

@@ -3,6 +3,8 @@ import { BuildBlockParams } from '../txpool';
 import { HexString } from '@polkadot/util/types';
 export { SetValidationData } from './parachain/validation-data';
 export { ParaInherentEnter } from './para-enter';
+export { SetBabeRandomness } from './parachain/babe-randomness';
+export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
 export interface CreateInherents {
     createInherents(parent: Block, params?: BuildBlockParams['inherent']): Promise<HexString[]>;
 }

package/dist/blockchain/inherent/index.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InherentProviders = exports.SetTimestamp = exports.ParaInherentEnter = exports.SetValidationData = void 0;
+exports.InherentProviders = exports.SetTimestamp = exports.SetNimbusAuthorInherent = exports.SetBabeRandomness = exports.ParaInherentEnter = exports.SetValidationData = void 0;
 const types_1 = require("@polkadot/types");
 const time_travel_1 = require("../../utils/time-travel");
 var validation_data_1 = require("./parachain/validation-data");
 Object.defineProperty(exports, "SetValidationData", { enumerable: true, get: function () { return validation_data_1.SetValidationData; } });
 var para_enter_1 = require("./para-enter");
 Object.defineProperty(exports, "ParaInherentEnter", { enumerable: true, get: function () { return para_enter_1.ParaInherentEnter; } });
+var babe_randomness_1 = require("./parachain/babe-randomness");
+Object.defineProperty(exports, "SetBabeRandomness", { enumerable: true, get: function () { return babe_randomness_1.SetBabeRandomness; } });
+var nimbus_author_inherent_1 = require("./parachain/nimbus-author-inherent");
+Object.defineProperty(exports, "SetNimbusAuthorInherent", { enumerable: true, get: function () { return nimbus_author_inherent_1.SetNimbusAuthorInherent; } });
 class SetTimestamp {
     async createInherents(parent) {
         const meta = await parent.meta;

package/dist/blockchain/inherent/parachain/babe-randomness.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../../blockchain/block';
+import { BuildBlockParams } from '../../txpool';
+import { CreateInherents } from '..';
+export declare class SetBabeRandomness implements CreateInherents {
+    createInherents(parent: Block, _params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/inherent/parachain/babe-randomness.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetBabeRandomness = void 0;
+const types_1 = require("@polkadot/types");
+// Support for Moonbeam pallet-randomness mandatory inherent
+class SetBabeRandomness {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.randomness?.setBabeRandomnessResults) {
+            return [];
+        }
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
+    }
+}
+exports.SetBabeRandomness = SetBabeRandomness;

package/dist/blockchain/inherent/parachain/nimbus-author-inherent.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../../blockchain/block';
+import { BuildBlockParams } from '../../txpool';
+import { CreateInherents } from '..';
+export declare class SetNimbusAuthorInherent implements CreateInherents {
+    createInherents(parent: Block, _params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetNimbusAuthorInherent = void 0;
+const types_1 = require("@polkadot/types");
+// Support for Nimbus Author Inherent
+class SetNimbusAuthorInherent {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.authorInherent?.kickOffAuthorshipValidation) {
+            return [];
+        }
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
+    }
+}
+exports.SetNimbusAuthorInherent = SetNimbusAuthorInherent;

package/dist/blockchain/txpool.js

@@ -4,50 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxPool = exports.BuildBlockMode = void 0;
-const util_1 = require("@polkadot/util");
 const lodash_1 = __importDefault(require("lodash"));
 const block_builder_1 = require("./block-builder");
-const time_travel_1 = require("../utils/time-travel");
 var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
     BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
     BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
 })(BuildBlockMode = exports.BuildBlockMode || (exports.BuildBlockMode = {}));
-const getConsensus = (header) => {
-    if (header.digest.logs.length === 0)
-        return;
-    const preRuntime = header.digest.logs[0].asPreRuntime;
-    const [consensusEngine, slot] = preRuntime;
-    return { consensusEngine, slot, rest: header.digest.logs.slice(1) };
-};
-const getNewSlot = (digest, slotNumber) => {
-    if (digest.isPrimary) {
-        return {
-            primary: {
-                ...digest.asPrimary.toJSON(),
-                slotNumber,
-            },
-        };
-    }
-    if (digest.isSecondaryPlain) {
-        return {
-            secondaryPlain: {
-                ...digest.asSecondaryPlain.toJSON(),
-                slotNumber,
-            },
-        };
-    }
-    if (digest.isSecondaryVRF) {
-        return {
-            secondaryVRF: {
-                ...digest.asSecondaryVRF.toJSON(),
-                slotNumber,
-            },
-        };
-    }
-    return digest.toJSON();
-};
 class TxPool {
     #chain;
     #pool = [];
@@ -87,33 +51,8 @@ class TxPool {
         await wait.catch(() => { }); // ignore error
         const head = this.#chain.head;
         const extrinsics = this.#pool.splice(0);
-        const meta = await head.meta;
-        const parentHeader = await head.header;
-        let newLogs = parentHeader.digest.logs;
-        const consensus = getConsensus(parentHeader);
-        if (consensus?.consensusEngine.isAura) {
-            const slot = await (0, time_travel_1.getCurrentSlot)(this.#chain);
-            const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
-            newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
-        }
-        else if (consensus?.consensusEngine.isBabe) {
-            const slot = await (0, time_travel_1.getCurrentSlot)(this.#chain);
-            const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
-            const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
-            newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
-        }
-        const registry = await head.registry;
-        const header = registry.createType('Header', {
-            parentHash: head.hash,
-            number: head.number + 1,
-            stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-            extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-            digest: {
-                logs: newLogs,
-            },
-        });
         const inherents = await this.#inherentProvider.createInherents(head, params?.inherent);
-        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, header, inherents, extrinsics);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, extrinsics);
         this.#pool.push(...pendingExtrinsics);
         await this.#chain.setHead(newBlock);
     }

package/dist/dry-run.d.ts

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

package/dist/dry-run.js

@@ -0,0 +1,30 @@
+"use strict";
+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 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']);
+    if (outcome.isErr) {
+        throw new Error(outcome.asErr.toString());
+    }
+    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}`);
+        if (argv['open']) {
+            (0, open_html_1.openHtml)(filePath);
+        }
+    }
+    else if (argv['output-path']) {
+        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
+    }
+    else {
+        console.dir({ outcome: outcome.toHuman(), storageDiff }, { depth: null, colors: false });
+    }
+    process.exit(0);
+};
+exports.dryRun = dryRun;

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,34 @@ 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 to dry run',
+        string: true,
+        required: 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,
@@ -90,7 +117,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: {

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,30 @@ 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,
+        };
+    },
 };
 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)(block, 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'],

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,101 @@
+"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 getStorageEntry = async (block, key) => {
+    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 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(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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
@@ -24,10 +24,12 @@
     "test:dev": "LOG_LEVEL=trace vitest --inspect",
     "dev": "LOG_LEVEL=trace ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/dev.yml",
     "dev:karura": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/karura.yml",
-    "dev:acala": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/acala.yml"
+    "dev:acala": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/acala.yml",
+    "dev:moonriver": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/moonriver.yml",
+    "dev:moonbeam": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/moonbeam.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.2.3",
+    "@acala-network/chopsticks-executor": "0.3.0",
     "@polkadot/api": "^9.10.1",
     "@polkadot/rpc-provider": "^9.10.1",
     "@polkadot/types": "^9.10.1",
@@ -37,6 +39,7 @@
     "@polkadot/util-crypto": "^10.2.1",
     "axios": "^1.2.2",
     "js-yaml": "^4.1.0",
+    "jsondiffpatch": "^0.4.1",
     "lodash": "^4.17.21",
     "pino": "^8.7.0",
     "pino-pretty": "^9.1.1",

package/dist/decode-key.d.ts

@@ -1,2 +0,0 @@
-import '@polkadot/types-codec';
-export declare const decodeKey: (argv: any) => Promise<void>;

package/dist/decode-key.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeKey = void 0;
-require("@polkadot/types-codec");
-const util_1 = require("@polkadot/util");
-const setup_1 = require("./setup");
-const decodeKey = async (argv) => {
-    const context = await (0, setup_1.setup)(argv);
-    const key = argv.key;
-    const meta = await context.chain.head.meta;
-    outer: 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)) {
-                const decodedKey = meta.registry.createType('StorageKey', key);
-                decodedKey.setMeta(storage.meta);
-                console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
-                break outer;
-            }
-        }
-    }
-    setTimeout(() => process.exit(0), 50);
-};
-exports.decodeKey = decodeKey;