@acala-network/chopsticks 0.3.10 → 0.3.12

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

@@ -1,6 +1,8 @@
+import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
 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 newHeader: (head: Block) => Promise<Header>;
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void) => Promise<[Block, HexString[]]>;
 export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
     call: HexString;
     address: string;

package/dist/blockchain/block-builder.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = void 0;
+exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = exports.newHeader = void 0;
 const block_1 = require("./block");
+const util_crypto_1 = require("@polkadot/util-crypto");
 const util_1 = require("@polkadot/util");
 const utils_1 = require("../utils");
 const logger_1 = require("../logger");
@@ -84,6 +85,7 @@ const newHeader = async (head) => {
     });
     return header;
 };
+exports.newHeader = newHeader;
 const initNewBlock = async (head, header, inherents) => {
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000)
@@ -110,22 +112,34 @@ const initNewBlock = async (head, header, inherents) => {
     }
     return newBlock;
 };
-const buildBlock = async (head, inherents, extrinsics) => {
+const buildBlock = async (head, inherents, extrinsics, onApplyExtrinsicError) => {
     const registry = await head.registry;
-    const header = await newHeader(head);
+    const header = await (0, exports.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()}`);
+    }, `Try building block #${newBlock.number.toLocaleString()}`);
     const pendingExtrinsics = [];
+    const includedExtrinsic = [];
     // apply extrinsics
     for (const extrinsic of extrinsics) {
         try {
-            const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const { result, storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const outcome = registry.createType('ApplyExtrinsicResult', result);
+            if (outcome.isErr) {
+                if (outcome.asErr.isInvalid && outcome.asErr.asInvalid.isFuture) {
+                    pendingExtrinsics.push(extrinsic);
+                }
+                else {
+                    onApplyExtrinsicError(extrinsic, outcome.asErr);
+                }
+                continue;
+            }
             newBlock.pushStorageLayer().setAll(storageDiff);
             logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
+            includedExtrinsic.push(extrinsic);
         }
         catch (e) {
             logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -140,23 +154,28 @@ const buildBlock = async (head, inherents, extrinsics) => {
     }
     const blockData = registry.createType('Block', {
         header,
-        extrinsics,
+        extrinsics: includedExtrinsic,
     });
     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, newBlock.number, blockData.hash.toHex(), head, {
         header,
-        extrinsics: [...inherents, ...extrinsics],
+        extrinsics: [...inherents, ...includedExtrinsic],
         storage: head.storage,
         storageDiff,
     });
-    logger.info({ hash: finalBlock.hash, number: newBlock.number }, `Block built #${newBlock.number.toLocaleString()} hash ${finalBlock.hash}`);
+    logger.info({
+        hash: finalBlock.hash,
+        extrinsics: includedExtrinsic.map((x) => (0, util_crypto_1.blake2AsHex)(x, 256)),
+        pendingExtrinsics: pendingExtrinsics.length,
+        number: newBlock.number,
+    }, `Block built #${newBlock.number.toLocaleString()} hash ${finalBlock.hash}`);
     return [finalBlock, pendingExtrinsics];
 };
 exports.buildBlock = buildBlock;
 const dryRunExtrinsic = async (head, inherents, extrinsic) => {
     const registry = await head.registry;
-    const header = await newHeader(head);
+    const header = await (0, exports.newHeader)(head);
     const newBlock = await initNewBlock(head, header, inherents);
     if (typeof extrinsic !== 'string') {
         if (!head.chain.mockSignatureHost) {
@@ -185,7 +204,7 @@ const dryRunExtrinsic = async (head, inherents, extrinsic) => {
 };
 exports.dryRunExtrinsic = dryRunExtrinsic;
 const dryRunInherents = async (head, inherents) => {
-    const header = await newHeader(head);
+    const header = await (0, exports.newHeader)(head);
     const newBlock = await initNewBlock(head, header, inherents);
     return Object.entries(await newBlock.storageDiff());
 };

package/dist/blockchain/index.d.ts

@@ -4,7 +4,7 @@ import { HexString } from '@polkadot/util/types';
 import { RegisteredTypes } from '@polkadot/types/types';
 import { Api } from '../api';
 import { Block } from './block';
-import { BuildBlockMode, BuildBlockParams, HorizontalMessage } from './txpool';
+import { BuildBlockMode, BuildBlockParams, HorizontalMessage, TxPool } from './txpool';
 import { HeadState } from './head-state';
 import { InherentProvider } from './inherent';
 export interface Options {
@@ -31,7 +31,7 @@ export declare class Blockchain {
     readonly headState: HeadState;
     constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, registeredTypes, }: Options);
     get head(): Block;
-    get pendingExtrinsics(): HexString[];
+    get txPool(): TxPool;
     getBlockAt(number?: number): Promise<Block | undefined>;
     getBlock(hash?: HexString): Promise<Block | undefined>;
     unregisterBlock(block: Block): void;
@@ -47,4 +47,5 @@ export declare class Blockchain {
         storageDiff: [HexString, HexString | null][];
     }>;
     dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>): Promise<[HexString, HexString | null][]>;
+    getInherents(): Promise<HexString[]>;
 }

package/dist/blockchain/index.js

@@ -42,8 +42,8 @@ class Blockchain {
     get head() {
         return this.#head;
     }
-    get pendingExtrinsics() {
-        return this.#txpool.pendingExtrinsics;
+    get txPool() {
+        return this.#txpool;
     }
     async getBlockAt(number) {
         if (number === undefined) {
@@ -115,7 +115,7 @@ class Blockchain {
             this.#txpool.submitExtrinsic(extrinsic);
             return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
         }
-        throw new Error(`Extrinsic is invalid: ${validity.asErr.toString()}`);
+        throw validity.asErr;
     }
     async newBlock(params) {
         await this.#txpool.buildBlock(params);
@@ -142,5 +142,10 @@ class Blockchain {
         const inherents = await this.#inherentProvider.createInherents(head, { horizontalMessages: hrmp });
         return (0, block_builder_1.dryRunInherents)(head, inherents);
     }
+    async getInherents() {
+        await this.api.isReady;
+        const inherents = await this.#inherentProvider.createInherents(this.head);
+        return inherents;
+    }
 }
 exports.Blockchain = Blockchain;

package/dist/blockchain/txpool.d.ts

@@ -1,7 +1,10 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:stream';
 import { HexString } from '@polkadot/util/types';
 import { Block } from './block';
 import { Blockchain } from '.';
 import { InherentProvider } from './inherent';
+export declare const APPLY_EXTRINSIC_ERROR = "TxPool::ApplyExtrinsicError";
 export declare enum BuildBlockMode {
     Batch = 0,
     Instant = 1,
@@ -23,6 +26,7 @@ export interface BuildBlockParams {
 }
 export declare class TxPool {
     #private;
+    readonly event: EventEmitter;
     constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
     get pendingExtrinsics(): HexString[];
     submitExtrinsic(extrinsic: HexString): void;

package/dist/blockchain/txpool.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxPool = exports.BuildBlockMode = void 0;
+exports.TxPool = exports.BuildBlockMode = exports.APPLY_EXTRINSIC_ERROR = void 0;
 const rxjs_1 = require("rxjs");
+const node_stream_1 = require("node:stream");
 const operators_1 = require("rxjs/operators");
 const lodash_1 = __importDefault(require("lodash"));
 const block_builder_1 = require("./block-builder");
+exports.APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
 var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
@@ -19,6 +21,7 @@ class TxPool {
     #pool = [];
     #mode;
     #inherentProvider;
+    event = new node_stream_1.EventEmitter();
     #last;
     #lastBuildBlockPromise = Promise.resolve();
     constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
@@ -62,7 +65,9 @@ class TxPool {
         const head = this.#chain.head;
         const extrinsics = this.#pool.splice(0);
         const inherents = await this.#inherentProvider.createInherents(head, params?.inherent);
-        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, extrinsics);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, extrinsics, (extrinsic, error) => {
+            this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+        });
         this.#pool.push(...pendingExtrinsics);
         await this.#chain.setHead(newBlock);
     }

package/dist/cli.js

@@ -12,6 +12,7 @@ const _1 = require(".");
 const schema_1 = require("./schema");
 const decoder_1 = require("./utils/decoder");
 const dry_run_1 = require("./dry-run");
+const dry_run_preimage_1 = require("./dry-run-preimage");
 const utils_1 = require("./utils");
 const run_block_1 = require("./run-block");
 const processConfig = async (path) => {
@@ -78,12 +79,15 @@ const defaultOptions = {
     extrinsic: {
         desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
         string: true,
-        required: true,
     },
     address: {
         desc: 'Address to fake sign extrinsic',
         string: true,
     },
+    preimage: {
+        desc: 'Preimage to dry run',
+        string: true,
+    },
     at: {
         desc: 'Block hash to dry run',
         string: true,
@@ -99,7 +103,13 @@ const defaultOptions = {
         desc: 'Open generated html',
     },
 }), async (argv) => {
-    await (0, dry_run_1.dryRun)(await processArgv(argv));
+    const config = await processArgv(argv);
+    if (config.preimage) {
+        await (0, dry_run_preimage_1.dryRunPreimage)(config);
+    }
+    else {
+        await (0, dry_run_1.dryRun)(config);
+    }
 })
     .command('dev', 'Dev mode', (yargs) => yargs.options({
     ...defaultOptions,

package/dist/dry-run-preimage.d.ts

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

package/dist/dry-run-preimage.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRunPreimage = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const logger_1 = require("./logger");
+const generate_html_diff_1 = require("./utils/generate-html-diff");
+const block_builder_1 = require("./blockchain/block-builder");
+const open_html_1 = require("./utils/open-html");
+const executor_1 = require("./executor");
+const set_storage_1 = require("./utils/set-storage");
+const setup_1 = require("./setup");
+const dryRunPreimage = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
+    const extrinsic = argv['preimage'];
+    const block = context.chain.head;
+    const registry = await block.registry;
+    const header = await (0, block_builder_1.newHeader)(block);
+    const data = (0, util_1.hexToU8a)(extrinsic);
+    const hash = (0, util_crypto_1.blake2AsHex)(data, 256);
+    await (0, set_storage_1.setStorage)(context.chain, {
+        Preimage: {
+            PreimageFor: [[[[hash, data.byteLength]], extrinsic]],
+            StatusFor: [
+                [
+                    [hash],
+                    {
+                        Requested: {
+                            count: 1,
+                            len: data.byteLength,
+                        },
+                    },
+                ],
+            ],
+        },
+        Scheduler: {
+            Agenda: [
+                [
+                    [block.number + 1],
+                    [
+                        {
+                            maybeId: '0x64656d6f637261633a0000000000000000000000000000000000000000000000',
+                            priority: 63,
+                            call: {
+                                Lookup: {
+                                    hash: hash,
+                                    len: data.byteLength,
+                                },
+                            },
+                            origin: { system: { Root: null } },
+                        },
+                    ],
+                ],
+            ],
+            Lookup: [[['0x64656d6f637261633a0000000000000000000000000000000000000000000000'], [block.number + 1, 0]]],
+        },
+    });
+    const calls = [['Core_initialize_block', [header.toHex()]]];
+    for (const inherent of await block.chain.getInherents()) {
+        calls.push(['BlockBuilder_apply_extrinsic', [inherent]]);
+    }
+    calls.push(['BlockBuilder_finalize_block', []]);
+    logger_1.defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
+    const result = await (0, executor_1.runTask)({
+        wasm: await block.wasm,
+        calls,
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+    }, (0, executor_1.taskHandler)(block));
+    if (result.Error) {
+        throw new Error(result.Error);
+    }
+    const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, hash);
+    console.log(`Generated preview ${filePath}`);
+    if (argv['open']) {
+        (0, open_html_1.openHtml)(filePath);
+    }
+    // if dry-run preimage has extrinsic arguments then dry-run extrinsic
+    // this is usefull to test something after preimage is applied
+    if (argv['extrinsic']) {
+        await context.chain.newBlock();
+        const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+        const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input);
+        if (outcome.isErr) {
+            throw new Error(outcome.asErr.toString());
+        }
+        else {
+            logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+        }
+        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);
+        }
+    }
+    process.exit(0);
+};
+exports.dryRunPreimage = dryRunPreimage;

package/dist/logger.js

@@ -11,10 +11,13 @@ exports.defaultLogger = (0, pino_1.default)({
         target: 'pino-pretty',
     },
 });
-const truncate = (val) => {
+const innerTruncate = (level = 0) => (val) => {
     if (val == null) {
         return val;
     }
+    if (level > 5) {
+        return '( Too Deep )';
+    }
     switch (typeof val) {
         case 'string':
             if (val.length > 66) {
@@ -25,11 +28,12 @@ const truncate = (val) => {
             }
         case 'object':
             if (Array.isArray(val)) {
-                return val.map(exports.truncate);
+                return val.map(innerTruncate(level + 1));
             }
-            return Object.fromEntries(Object.entries(val).map(([k, v]) => [k, (0, exports.truncate)(v)]));
+            return Object.fromEntries(Object.entries(val.toJSON ? val.toJSON() : val).map(([k, v]) => [k, innerTruncate(level + 1)(v)]));
         default:
             return val;
     }
 };
+const truncate = (val) => innerTruncate(0)(val);
 exports.truncate = truncate;

package/dist/rpc/substrate/author.js

@@ -1,19 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const txpool_1 = require("../../blockchain/txpool");
 const shared_1 = require("../../rpc/shared");
 const logger_1 = require("../../logger");
 const logger = logger_1.defaultLogger.child({ name: 'rpc-author' });
 const handlers = {
     author_submitExtrinsic: async (context, [extrinsic]) => {
         return context.chain.submitExtrinsic(extrinsic).catch((error) => {
-            throw new shared_1.ResponseError(1, error.toString());
+            const code = error.isInvalid ? 1010 : 1011;
+            throw new shared_1.ResponseError(code, error.toString());
         });
     },
     author_submitAndWatchExtrinsic: async (context, [extrinsic], { subscribe, unsubscribe }) => {
         let update = (_block) => { };
         const id = context.chain.headState.subscribeHead((block) => update(block));
         const callback = subscribe('author_extrinsicUpdate', id, () => context.chain.headState.unsubscribeHead(id));
+        const onExtrinsicFail = ([failedExtrinsic, error]) => {
+            if (failedExtrinsic === extrinsic) {
+                callback(error.toJSON());
+                done(id);
+            }
+        };
+        context.chain.txPool.event.on(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        const done = (id) => {
+            context.chain.txPool.event.removeListener(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+            unsubscribe(id);
+        };
         update = async (block) => {
+            const extrisnics = await block.extrinsics;
+            if (!extrisnics.includes(extrinsic))
+                return;
             logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
             // for now just assume tx is always included on next block
             callback({
@@ -22,7 +38,7 @@ const handlers = {
             callback({
                 Finalized: block.hash,
             });
-            unsubscribe(id);
+            done(id);
         };
         context.chain
             .submitExtrinsic(extrinsic)
@@ -33,8 +49,8 @@ const handlers = {
         })
             .catch((error) => {
             logger.error({ error }, 'ExtrinsicFailed');
-            callback({ Invalid: null });
-            unsubscribe(id);
+            callback(error.toJSON());
+            done(id);
         });
         return id;
     },
@@ -42,7 +58,7 @@ const handlers = {
         unsubscribe(subid);
     },
     author_pendingExtrinsics: async (context) => {
-        return context.chain.pendingExtrinsics;
+        return context.chain.txPool.pendingExtrinsics;
     },
 };
 exports.default = handlers;

package/dist/rpc/substrate/chain.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     chain_subscribeNewHeads: import("../shared").Handler;
     chain_unsubscribeNewHeads: import("../shared").Handler;
+    chain_unsubscribeFinalizedHeads: import("../shared").Handler;
 };
 export default _default;

package/dist/rpc/substrate/chain.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("../shared");
+const processHeader = (header) => {
+    const res = header.toJSON();
+    res.number = '0x' + res.number.toString(16); // number is hex format
+    return res;
+};
 const handlers = {
     chain_getBlockHash: async (context, [blockNumber]) => {
         const block = await context.chain.getBlockAt(blockNumber);
@@ -14,7 +19,7 @@ const handlers = {
         if (!block) {
             throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
-        return await block.header;
+        return processHeader(await block.header);
     },
     chain_getBlock: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);
@@ -37,7 +42,7 @@ const handlers = {
         const id = context.chain.headState.subscribeHead(() => update());
         const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
         update = async () => {
-            callback(await context.chain.head.header);
+            callback(processHeader(await context.chain.head.header));
         };
         update();
         return id;
@@ -45,9 +50,9 @@ const handlers = {
     chain_subscribeFinalizedHeads: async (context, _params, { subscribe }) => {
         let update = () => { };
         const id = context.chain.headState.subscribeHead(() => update());
-        const callback = subscribe('chain_newFinalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+        const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
         update = async () => {
-            callback(await context.chain.head.header);
+            callback(processHeader(await context.chain.head.header));
         };
         update();
         return id;
@@ -59,6 +64,7 @@ const handlers = {
 const alias = {
     chain_subscribeNewHeads: handlers.chain_subscribeNewHead,
     chain_unsubscribeNewHeads: handlers.chain_unsubscribeNewHead,
+    chain_unsubscribeFinalizedHeads: handlers.chain_unsubscribeNewHead,
 };
 exports.default = {
     ...handlers,

package/dist/server.js

@@ -76,6 +76,7 @@ const createServer = async (handler, port) => {
                 subscriptions[subid] = onCancel;
                 return (data) => {
                     if (subscriptions[subid]) {
+                        logger.trace({ method, subid, data: (0, logger_1.truncate)(data) }, 'Subscription notification');
                         send({
                             jsonrpc: '2.0',
                             method,
@@ -128,7 +129,11 @@ const createServer = async (handler, port) => {
             }, 'Received message');
             try {
                 const resp = await handler(req, subscriptionManager);
-                logger.trace('Sending response for request %o %o', req.id, req.method);
+                logger.trace({
+                    id: req.id,
+                    method: req.method,
+                    result: (0, logger_1.truncate)(resp),
+                }, 'Sending response for request');
                 send({
                     id: req.id,
                     jsonrpc: '2.0',

package/dist/utils/decoder.js

@@ -100,6 +100,10 @@ const decodeStorageDiff = async (block, diff) => {
         lodash_1.default.merge(oldState, await (0, exports.decodeKeyValue)(block, key, (await block.get(key))));
         lodash_1.default.merge(newState, await (0, exports.decodeKeyValue)(block, key, value));
     }
-    return [oldState, newState, diffPatcher.diff(oldState, newState)];
+    const oldStateWithoutEvents = lodash_1.default.cloneDeep(oldState);
+    if (oldStateWithoutEvents['system']?.['events']) {
+        oldStateWithoutEvents['system']['events'] = [];
+    }
+    return [oldState, newState, diffPatcher.diff(oldStateWithoutEvents, newState)];
 };
 exports.decodeStorageDiff = decodeStorageDiff;

package/dist/utils/set-storage.js

@@ -28,12 +28,14 @@ function objectToStorageItems(meta, storage) {
                 throw Error(`Cannot find storage ${storageName} in pallet ${sectionName}`);
             if (storageEntry.meta.type.isPlain) {
                 const key = new types_1.StorageKey(meta.registry, [storageEntry]);
-                storageItems.push([key.toHex(), storage ? meta.registry.createType(key.outputType, storage).toHex(true) : null]);
+                const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
+                storageItems.push([key.toHex(), storage ? meta.registry.createType(type, storage).toHex() : null]);
             }
             else {
                 for (const [keys, value] of storage) {
                     const key = new types_1.StorageKey(meta.registry, [storageEntry, keys]);
-                    storageItems.push([key.toHex(), value ? meta.registry.createType(key.outputType, value).toHex(true) : null]);
+                    const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
+                    storageItems.push([key.toHex(), value ? meta.registry.createType(type, value).toHex() : null]);
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
@@ -29,7 +29,7 @@
     "dev:moonbeam": "ts-node-dev --transpile-only --inspect --notify=false src/cli.ts -- dev --config=configs/moonbeam.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.3.7",
+    "@acala-network/chopsticks-executor": "0.3.12",
     "@polkadot/api": "^9.12.1",
     "@polkadot/rpc-provider": "^9.12.1",
     "@polkadot/types": "^9.12.1",
@@ -57,8 +57,8 @@
     "@types/node": "^18.11.18",
     "@types/ws": "^8.5.4",
     "@types/yargs": "^17.0.20",
-    "@typescript-eslint/eslint-plugin": "^5.49.0",
-    "@typescript-eslint/parser": "^5.49.0",
+    "@typescript-eslint/eslint-plugin": "^5.50.0",
+    "@typescript-eslint/parser": "^5.50.0",
     "eslint": "^8.32.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-import": "^2.27.5",

package/template/diff.html

@@ -13,7 +13,7 @@
 
 			div#app {
 				margin: 0 !important;
-				padding: 10px !important;
+				padding: 0 !important;
 			}
 
 			.diff {
@@ -24,6 +24,36 @@
 				line-height: 150%;
 			}
 
+			.diff > button {
+				position: absolute;
+				display: none;
+				left: 50%;
+				top: 50%;
+				translate: -50% -50%;
+				background: #fff;
+				border: none;
+				border-radius: 50%;
+				padding: 10px;
+				cursor: pointer;
+				cursor: pointer;
+				opacity: 80%;
+				width: 40px;
+				height: 40px;
+			}
+
+			.diff > button > img {
+				width: 100%;
+				height: 100%;
+			}
+
+			.diff > button:hover {
+				opacity: 100%;
+			}
+
+			.diff:hover > button {
+				display: block;
+			}
+
 			.diffWrap {
 				position: relative;
 				z-index: 1;
@@ -37,30 +67,36 @@
 
 			.diffAdd {
 				color: darkseagreen;
+				display: inline-flex;
 			}
 
 			.diffRemove {
 				text-decoration: line-through;
 				text-decoration-thickness: 1px;
 				color: red;
+				display: inline-flex;
 			}
 
 			.diffUpdateFrom {
 				text-decoration: line-through;
 				text-decoration-thickness: 1px;
 				color: red;
+				display: inline-flex;
 			}
 
 			.diffUpdateTo {
 				color: darkseagreen;
+				display: inline-flex;
 			}
 
 			.diffUpdateArrow {
 				color: #ccc;
 			}
+
 			.unchanged {
 				color: #666;
 			}
+
 			.delta {
 				color: #ccc;
 				font-size: 12px;
@@ -94,76 +130,82 @@
 				return { className: className.join(' ') }
 			}
 
-			function valueRenderer(raw, value, ...keys) {
-				const modifyPath = keys.reverse().join('.')
-				const removePath = keys.map(x => Number.isInteger(parseInt(x)) ? '_' + x : x).join('.')
-				const isDelta = _.has(delta, modifyPath) || _.has(delta, removePath)
+			function valueRenderer(viewPartial) {
+				return function (raw, value, ...keys) {
+					const modifyPath = keys.reverse().join('.')
+					const removePath = keys.map(x => Number.isInteger(parseInt(x)) ? '_' + x : x).join('.')
+					const isDelta = _.has(delta, modifyPath) || _.has(delta, removePath)
 
-				function renderSpan(name, body) {
-					return (
-						<span key={name} {...styling(['diff', name])}>
-							{body}
-						</span>
-					);
-				}
+					function renderSpan(name, body, raw) {
+						return (
+							<span key={name} {...styling(['diff', name])}>
+								{body}
+								{_.isObjectLike(raw) ? <button onClick={() => viewPartial({ [modifyPath]: raw })}><img src='data:image/svg+xml;base64,PCFET0NUWVBFIHN2ZyBQVUJMSUMgIi0vL1czQy8vRFREIFNWRyAxLjEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvR3JhcGhpY3MvU1ZHLzEuMS9EVEQvc3ZnMTEuZHRkIj4KDTwhLS0gVXBsb2FkZWQgdG86IFNWRyBSZXBvLCB3d3cuc3ZncmVwby5jb20sIFRyYW5zZm9ybWVkIGJ5OiBTVkcgUmVwbyBNaXhlciBUb29scyAtLT4KPHN2ZyBmaWxsPSIjMDAwMDAwIiBoZWlnaHQ9IjY0cHgiIHdpZHRoPSI2NHB4IiB2ZXJzaW9uPSIxLjEiIGlkPSJMYXllcl8xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMjQyLjEzMyAyNDIuMTMzIiB4bWw6c3BhY2U9InByZXNlcnZlIiBzdHJva2U9IiMwMDAwMDAiPgoNPGcgaWQ9IlNWR1JlcG9fYmdDYXJyaWVyIiBzdHJva2Utd2lkdGg9IjAiLz4KDTxnIGlkPSJTVkdSZXBvX3RyYWNlckNhcnJpZXIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgoNPGcgaWQ9IlNWR1JlcG9faWNvbkNhcnJpZXIiPiA8ZyBpZD0iWE1MSURfMjVfIj4gPHBhdGggaWQ9IlhNTElEXzI2XyIgZD0iTTg5LjI0NywxMzEuNjczbC00Ny43MzIsNDcuNzNsLTE1LjkwOS0xNS45MWMtNC4yOS00LjI5MS0xMC43NDItNS41NzItMTYuMzQ3LTMuMjUyIEMzLjY1NCwxNjIuNTYzLDAsMTY4LjAzMywwLDE3NC4xdjUzLjAzMmMwLDguMjg0LDYuNzE2LDE1LDE1LDE1bDUzLjAzMywwLjAwMWMwLjAwNy0wLjAwMSwwLjAxMi0wLjAwMSwwLjAxOSwwIGM4LjI4NSwwLDE1LTYuNzE2LDE1LTE1YzAtNC4zNzctMS44NzUtOC4zMTYtNC44NjUtMTEuMDU5bC0xNS40NTgtMTUuNDU4bDQ3LjczLTQ3LjcyOWM1Ljg1OC01Ljg1OCw1Ljg1OC0xNS4zNTUsMC0yMS4yMTMgQzEwNC42MDMsMTI1LjgxNSw5NS4xMDQsMTI1LjgxNiw4OS4yNDcsMTMxLjY3M3oiLz4gPHBhdGggaWQ9IlhNTElEXzI4XyIgZD0iTTIyNy4xMzMsMEgxNzQuMWMtNi4wNjcsMC0xMS41MzYsMy42NTUtMTMuODU4LDkuMjZjLTIuMzIxLDUuNjA1LTEuMDM4LDEyLjA1NywzLjI1MiwxNi4zNDdsMTUuOTExLDE1LjkxMSBsLTQ3LjcyOSw0Ny43M2MtNS44NTgsNS44NTgtNS44NTgsMTUuMzU1LDAsMjEuMjEzYzIuOTI5LDIuOTI5LDYuNzY4LDQuMzkzLDEwLjYwNiw0LjM5M2MzLjgzOSwwLDcuNjc4LTEuNDY0LDEwLjYwNi00LjM5NCBsNDcuNzMtNDcuNzNsMTUuOTA5LDE1LjkxYzIuODY5LDIuODcsNi43MDYsNC4zOTQsMTAuNjA5LDQuMzk0YzEuOTMzLDAsMy44ODItMC4zNzMsNS43MzctMS4xNDIgYzUuNjA1LTIuMzIyLDkuMjYtNy43OTIsOS4yNi0xMy44NThWMTVDMjQyLjEzMyw2LjcxNiwyMzUuNDE3LDAsMjI3LjEzMywweiIvPiA8L2c+IDwvZz4KDTwvc3ZnPg==' /></button> : null}
+							</span>
+						);
+					}
 
-				function renderDelta(value) {
-					if (/^\d+(,\d+)*$/.test(value[0]) && /^\d+(,\d+)*$/.test(value[1])) {
-						const oldValue = parseInt(value[0].replace(/,/g, ''))
-						const newValue = parseInt(value[1].replace(/,/g, ''))
-						if (oldValue > 0 && newValue > 0) {
-							const delta = Number(newValue - oldValue)
-							return (<span className="delta" >{delta > 0 ? '+' : ''}{delta.toLocaleString()}</span>)
+					function renderDelta(value) {
+						if (/^\d+(,\d+)*$/.test(value[0]) && /^\d+(,\d+)*$/.test(value[1])) {
+							const oldValue = parseInt(value[0].replace(/,/g, ''))
+							const newValue = parseInt(value[1].replace(/,/g, ''))
+							if (oldValue > 0 && newValue > 0) {
+								const delta = Number(newValue - oldValue)
+								return (<span className="delta" >{delta > 0 ? '+' : ''}{delta.toLocaleString()}</span>)
+							}
 						}
 					}
-				}
 
-				if (isDelta && Array.isArray(value)) {
-					switch (value.length) {
-						case 0:
-						return (
-							<span {...styling('diffWrap')}>
-							{renderSpan('diff', '[]')}
-							</span>
-						)
-						case 1:
-						return (
-							<span {...styling('diffWrap')}>
-							{renderSpan(
-								'diffAdd',
-								stringifyAndShrink(value[0])
-							)}
-							</span>
-						);
-						case 2:
-						return (
-							<span {...styling('diffWrap')}>
-							{renderSpan(
-								'diffUpdateFrom',
-								stringifyAndShrink(value[0])
-							)}
-							{renderSpan('diffUpdateArrow', ' => ')}
-							{renderSpan(
-								'diffUpdateTo',
-								stringifyAndShrink(value[1])
-							)}
-							{renderDelta(value)}
-							</span>
-						);
-						case 3:
-						return (
-							<span {...styling('diffWrap')}>
-							{renderSpan('diffRemove', stringifyAndShrink(value[0]))}
-							</span>
-						);
+					if (isDelta && Array.isArray(value)) {
+						switch (value.length) {
+							case 0:
+								return (
+									<span {...styling('diffWrap')}>
+										{renderSpan('diff', '[]')}
+									</span>
+								)
+							case 1:
+								return (
+									<span {...styling('diffWrap')}>
+										{renderSpan(
+											'diffAdd',
+											stringifyAndShrink(value[0]),
+											value[0]
+										)}
+									</span>
+								);
+							case 2:
+								return (
+									<span {...styling('diffWrap')}>
+										{renderSpan(
+											'diffUpdateFrom',
+											stringifyAndShrink(value[0]),
+											value[0]
+										)}
+										{renderSpan('diffUpdateArrow', ' => ')}
+										{renderSpan(
+											'diffUpdateTo',
+											stringifyAndShrink(value[1]),
+											value[1]
+										)}
+										{renderDelta(value)}
+									</span>
+								);
+							case 3:
+								return (
+									<span {...styling('diffWrap')}>
+										{renderSpan('diffRemove', stringifyAndShrink(value[0]), value[0])}
+									</span>
+								);
+						}
 					}
-				}
 
-				return (
-					<span {...styling('diffWrap')}>
-						{renderSpan('unchanged', stringifyAndShrink(value))}
-					</span>
-				);
+					return (
+						<span {...styling('diffWrap')}>
+							{renderSpan('unchanged', stringifyAndShrink(value), value)}
+						</span>
+					);
+				}
 			};
 
 			function prepareDelta(value) {
@@ -208,30 +250,49 @@
 			class App extends React.Component {
 				constructor(props) {
 					super(props);
-					this.state = { showUnchanged: false };
+					this.state = { showUnchanged: false, partial: null };
 				}
 
 				toggle = (e) => {
 					this.setState(state => {
-						return { showUnchanged: !state.showUnchanged }
+						return { ...state, showUnchanged: !state.showUnchanged }
+					})
+				}
+
+				viewPartial = (value) => {
+					this.setState(state => {
+						return { ...state, partial: _.isEqual(state.partial, value) ? null : value }
 					})
 				}
 
 				render() {
 					return (
 						<div>
-							<input type="checkbox" onChange={this.toggle} id="show_unchanged" />
-							<label for="show_unchanged" style={{fontSize: '12px', color: 'white'}}>Show Unchanged</label>
-							<ReactJsonTree.JSONTree
-								theme={theme}
-								invertTheme={false}
-								data={this.state.showUnchanged ? _.merge(_.cloneDeep(left), delta): delta}
-								valueRenderer={valueRenderer}
-								postprocessValue={prepareDelta}
-								isCustomNode={Array.isArray}
-								shouldExpandNodeInitially={expandFirstLevel}
-								hideRoot
-							/>
+							<div style={{ display: 'flex', flexDirection: 'row' }}>
+								<div style={{ flex: 1, padding: '0 10px', overflow: 'hidden', overflowY: 'scroll', height: '100vh' }}>
+									<input type="checkbox" onChange={this.toggle} id="show_unchanged" />
+									<label for="show_unchanged" style={{ fontSize: '12px', color: 'white' }}>Show Unchanged</label>
+									<ReactJsonTree.JSONTree
+										theme={theme}
+										invertTheme={false}
+										data={this.state.showUnchanged ? _.merge(_.cloneDeep(left), delta) : delta}
+										valueRenderer={valueRenderer(this.viewPartial)}
+										postprocessValue={prepareDelta}
+										isCustomNode={Array.isArray}
+										shouldExpandNodeInitially={expandFirstLevel}
+										hideRoot
+									/>
+								</div>
+								{this.state.partial ? <div style={{ flex: 1, padding: '0 10px', overflow: 'hidden', overflowY: 'scroll', height: '100vh' }}>
+									<ReactJsonTree.JSONTree
+										theme={theme}
+										invertTheme={false}
+										data={this.state.partial}
+										shouldExpandNodeInitially={() => true}
+										hideRoot
+									/>
+								</div> : null}
+							</div>
 						</div>
 					);
 				}