@acala-network/chopsticks 0.9.4-6 → 0.9.4

package/dist/cjs/cli.js

@@ -8,7 +8,6 @@ const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 const _yargs = /*#__PURE__*/ _interop_require_default(require("yargs"));
 const _chopstickscore = require("@acala-network/chopsticks-core");
 const _index = require("./schema/index.js");
-const _clioptions = require("./cli-options.js");
 const _index1 = require("./plugins/index.js");
 const _index2 = require("./index.js");
 function _interop_require_default(obj) {
@@ -21,39 +20,12 @@ const processArgv = async (argv)=>{
     if (argv.config) {
         Object.assign(argv, _lodash.default.defaults(argv, await (0, _index.fetchConfig)(argv.config)));
     }
-    argv.port = argv.port ?? (process.env.PORT ? Number(process.env.PORT) : 8000);
+    if (process.env.PORT) {
+        argv.port = Number(process.env.PORT);
+    }
 };
-const commands = (0, _yargs.default)((0, _helpers.hideBin)(process.argv)).scriptName('chopsticks').middleware(processArgv, false).command('*', 'Dev mode, fork off a chain', (yargs)=>yargs.options({
-        ..._clioptions.defaultOptions,
-        ..._clioptions.mockOptions,
-        port: {
-            desc: 'Port to listen on',
-            number: true
-        },
-        'build-block-mode': {
-            desc: 'Build block mode. Default to Batch',
-            enum: [
-                _chopstickscore.BuildBlockMode.Batch,
-                _chopstickscore.BuildBlockMode.Manual,
-                _chopstickscore.BuildBlockMode.Instant
-            ]
-        },
-        'allow-unresolved-imports': {
-            desc: 'Allow wasm unresolved imports',
-            boolean: true
-        },
-        'max-memory-block-count': {
-            desc: 'Max memory block count',
-            number: true
-        },
-        resume: {
-            desc: `Resume from the specified block hash or block number in db.
-                 If true, it will resume from the latest block in db.
-                 Note this will override the block option`,
-            string: true
-        }
-    }), async (argv)=>{
-    await (0, _index2.setupWithServer)(argv);
+const commands = (0, _yargs.default)((0, _helpers.hideBin)(process.argv)).scriptName('chopsticks').middleware(processArgv, false).command('*', 'Dev mode, fork off a chain', (yargs)=>yargs.config('config', 'Path to config file with default options', ()=>({})).options((0, _index.getYargsOptions)(_index.configSchema.shape)), async (argv)=>{
+    await (0, _index2.setupWithServer)(_index.configSchema.parse(argv));
 }).command('xcm', 'XCM setup with relaychain and parachains', (yargs)=>yargs.options({
         relaychain: {
             desc: 'Relaychain config file path',
@@ -82,7 +54,7 @@ const commands = (0, _yargs.default)((0, _helpers.hideBin)(process.argv)).script
     }
 }).strict().help().alias('help', 'h').alias('version', 'v').alias('config', 'c').alias('endpoint', 'e').alias('port', 'p').alias('block', 'b').alias('import-storage', 's').alias('wasm-override', 'w').usage('Usage: $0 <command> [options]').example('$0', '-c acala');
 if (!process.env.DISABLE_PLUGINS) {
-    (0, _index1.pluginExtendCli)(commands).then(()=>commands.parse());
+    (0, _index1.pluginExtendCli)(commands.config('config', 'Path to config file with default options', ()=>({}))).then(()=>commands.parse());
 } else {
     commands.parse();
 }

package/dist/cjs/context.js

@@ -112,10 +112,10 @@ const setupContext = async (argv, overrideParent = false)=>{
             let blockData = null;
             if (typeof argv.resume === 'string' && argv.resume.startsWith('0x')) {
                 blockData = await chain.db.queryBlock(argv.resume);
-            } else if (typeof argv.resume === 'boolean' || argv.resume === 'true') {
+            } else if (typeof argv.resume === 'number') {
+                blockData = await chain.db.queryBlockByNumber(argv.resume);
+            } else if (argv.resume === true) {
                 blockData = await chain.db.queryHighestBlock();
-            } else if (Number.isInteger(+argv.resume)) {
-                blockData = await chain.db.queryBlockByNumber(+argv.resume);
             } else {
                 throw new Error(`Resume failed. Invalid resume option ${argv.resume}`);
             }

package/dist/cjs/plugins/decode-key/cli.js

@@ -8,17 +8,15 @@ Object.defineProperty(exports, "cli", {
         return cli;
     }
 });
+const _index = require("../../schema/index.js");
 const _chopstickscore = require("@acala-network/chopsticks-core");
-const _clioptions = require("../../cli-options.js");
 const _context = require("../../context.js");
 const cli = (y)=>{
-    y.command('decode-key <key>', 'Deocde a key', (yargs)=>yargs.positional('key', {
+    y.command('decode-key <key>', 'Deocde a key', (yargs)=>yargs.options((0, _index.getYargsOptions)(_index.configSchema.shape)).positional('key', {
             desc: 'Key to decode',
             type: 'string'
-        }).options({
-            ..._clioptions.defaultOptions
         }), async (argv)=>{
-        const context = await (0, _context.setupContext)(argv);
+        const context = await (0, _context.setupContext)(_index.configSchema.parse(argv));
         const { storage, decodedKey } = (0, _chopstickscore.decodeKey)(await context.chain.head.meta, context.chain.head, argv.key);
         if (storage && decodedKey) {
             console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x)=>JSON.stringify(x.toHuman())).join(', '));

package/dist/cjs/plugins/dry-run/cli.js

@@ -8,44 +8,41 @@ Object.defineProperty(exports, "cli", {
         return cli;
     }
 });
-const _clioptions = require("../../cli-options.js");
+const _index = require("../../schema/index.js");
 const _dryrunextrinsic = require("./dry-run-extrinsic.js");
 const _dryrunpreimage = require("./dry-run-preimage.js");
+const _zod = require("zod");
+const schema = _zod.z.object({
+    ..._index.configSchema.shape,
+    extrinsic: _zod.z.string({
+        description: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature'
+    }),
+    address: _zod.z.string({
+        description: 'Address to fake sign extrinsic'
+    }).optional(),
+    preimage: _zod.z.string({
+        description: 'Preimage to dry run'
+    }).optional(),
+    at: _zod.z.string({
+        description: 'Block hash to dry run'
+    }).optional(),
+    ['output-path']: _zod.z.string({
+        description: 'File path to print output'
+    }).optional(),
+    html: _zod.z.boolean({
+        description: 'Generate html with storage diff'
+    }).optional(),
+    open: _zod.z.boolean({
+        description: 'Open generated html'
+    }).optional()
+});
 const cli = (y)=>{
-    y.command('dry-run', 'Dry run an extrinsic', (yargs)=>yargs.options({
-            ..._clioptions.defaultOptions,
-            ..._clioptions.mockOptions,
-            extrinsic: {
-                desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
-                string: 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
-            },
-            'output-path': {
-                desc: 'File path to print output',
-                string: true
-            },
-            html: {
-                desc: 'Generate html with storage diff'
-            },
-            open: {
-                desc: 'Open generated html'
-            }
-        }), async (argv)=>{
-        if (argv.preimage) {
-            await (0, _dryrunpreimage.dryRunPreimage)(argv);
+    y.command('dry-run', 'Dry run an extrinsic', (yargs)=>yargs.options((0, _index.getYargsOptions)(schema.shape)), async (argv)=>{
+        const config = schema.parse(argv);
+        if (config.preimage) {
+            await (0, _dryrunpreimage.dryRunPreimage)(config);
         } else {
-            await (0, _dryrunextrinsic.dryRunExtrinsic)(argv);
+            await (0, _dryrunextrinsic.dryRunExtrinsic)(config);
         }
     });
 };

package/dist/cjs/plugins/dry-run/dry-run-extrinsic.d.ts

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

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

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

package/dist/cjs/plugins/dry-run/index.d.ts

@@ -1,2 +1,162 @@
+import { z } from 'zod';
+export declare const dryRunSchema: z.ZodObject<{
+    extrinsic: z.ZodString;
+    address: z.ZodOptional<z.ZodString>;
+    preimage: z.ZodOptional<z.ZodString>;
+    at: z.ZodOptional<z.ZodString>;
+    "output-path": z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodBoolean>;
+    open: z.ZodOptional<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    endpoint: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    block: z.ZodOptional<z.ZodUnion<[z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>, z.ZodNumber, z.ZodNull]>>;
+    'build-block-mode': z.ZodDefault<z.ZodNativeEnum<typeof import("@acala-network/chopsticks-core").BuildBlockMode>>;
+    'import-storage': z.ZodOptional<z.ZodAny>;
+    'allow-unresolved-imports': z.ZodOptional<z.ZodBoolean>;
+    'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
+    'max-memory-block-count': z.ZodOptional<z.ZodNumber>;
+    db: z.ZodOptional<z.ZodString>;
+    'wasm-override': z.ZodOptional<z.ZodString>;
+    genesis: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        properties: z.ZodObject<{
+            ss58Format: z.ZodOptional<z.ZodNumber>;
+            tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+            tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }>;
+        genesis: z.ZodObject<{
+            raw: z.ZodObject<{
+                top: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                top: Record<string, string>;
+            }, {
+                top: Record<string, string>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }, {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }>]>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    'registered-types': z.ZodOptional<z.ZodAny>;
+    'runtime-log-level': z.ZodOptional<z.ZodNumber>;
+    'offchain-worker': z.ZodOptional<z.ZodBoolean>;
+    resume: z.ZodOptional<z.ZodUnion<[z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>, z.ZodNumber, z.ZodBoolean]>>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    'build-block-mode': import("@acala-network/chopsticks-core").BuildBlockMode;
+    extrinsic: string;
+    address?: string | undefined;
+    preimage?: string | undefined;
+    at?: string | undefined;
+    "output-path"?: string | undefined;
+    html?: boolean | undefined;
+    open?: boolean | undefined;
+    endpoint?: string | string[] | undefined;
+    block?: number | `0x${string}` | null | undefined;
+    'import-storage'?: any;
+    'allow-unresolved-imports'?: boolean | undefined;
+    'mock-signature-host'?: boolean | undefined;
+    'max-memory-block-count'?: number | undefined;
+    db?: string | undefined;
+    'wasm-override'?: string | undefined;
+    genesis?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    timestamp?: number | undefined;
+    'registered-types'?: any;
+    'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
+    resume?: number | boolean | `0x${string}` | undefined;
+}, {
+    extrinsic: string;
+    address?: string | undefined;
+    preimage?: string | undefined;
+    at?: string | undefined;
+    "output-path"?: string | undefined;
+    html?: boolean | undefined;
+    open?: boolean | undefined;
+    port?: number | undefined;
+    endpoint?: string | string[] | undefined;
+    block?: number | `0x${string}` | null | undefined;
+    'build-block-mode'?: import("@acala-network/chopsticks-core").BuildBlockMode | undefined;
+    'import-storage'?: any;
+    'allow-unresolved-imports'?: boolean | undefined;
+    'mock-signature-host'?: boolean | undefined;
+    'max-memory-block-count'?: number | undefined;
+    db?: string | undefined;
+    'wasm-override'?: string | undefined;
+    genesis?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    timestamp?: number | undefined;
+    'registered-types'?: any;
+    'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
+    resume?: number | boolean | `0x${string}` | undefined;
+}>;
+export type DryRunSchemaType = z.infer<typeof dryRunSchema>;
 export * from './cli.js';
 export * from './rpc.js';

package/dist/cjs/plugins/dry-run/index.js

@@ -2,6 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+Object.defineProperty(exports, "dryRunSchema", {
+    enumerable: true,
+    get: function() {
+        return dryRunSchema;
+    }
+});
+const _index = require("../../schema/index.js");
+const _zod = require("zod");
 _export_star(require("./cli.js"), exports);
 _export_star(require("./rpc.js"), exports);
 function _export_star(from, to) {
@@ -17,3 +25,27 @@ function _export_star(from, to) {
     });
     return from;
 }
+const dryRunSchema = _zod.z.object({
+    ..._index.configSchema.shape,
+    extrinsic: _zod.z.string({
+        description: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature'
+    }),
+    address: _zod.z.string({
+        description: 'Address to fake sign extrinsic'
+    }).optional(),
+    preimage: _zod.z.string({
+        description: 'Preimage to dry run'
+    }).optional(),
+    at: _zod.z.string({
+        description: 'Block hash to dry run'
+    }).optional(),
+    ['output-path']: _zod.z.string({
+        description: 'File path to print output'
+    }).optional(),
+    html: _zod.z.boolean({
+        description: 'Generate html with storage diff'
+    }).optional(),
+    open: _zod.z.boolean({
+        description: 'Open generated html'
+    }).optional()
+});

package/dist/cjs/plugins/follow-chain/cli.js

@@ -9,10 +9,11 @@ Object.defineProperty(exports, "cli", {
     }
 });
 const _chopstickscore = require("@acala-network/chopsticks-core");
+const _zod = require("zod");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _index = require("../../schema/index.js");
 const _server = require("../../server.js");
-const _clioptions = require("../../cli-options.js");
-const _index = require("../../rpc/index.js");
+const _index1 = require("../../rpc/index.js");
 const _context = require("../../context.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -22,43 +23,41 @@ function _interop_require_default(obj) {
 const logger = _chopstickscore.defaultLogger.child({
     name: 'follow-chain'
 });
-const options = _lodash.default.pick(_clioptions.defaultOptions, [
-    'endpoint',
-    'wasm-override',
-    'runtime-log-level',
-    'offchain-worker'
-]);
+var HeadMode;
+(function(HeadMode) {
+    HeadMode["Latest"] = "Latest";
+    HeadMode["Finalized"] = "Finalized";
+})(HeadMode || (HeadMode = {}));
+const schema = _zod.z.object({
+    ..._lodash.default.pick(_index.configSchema.shape, [
+        'endpoint',
+        'port',
+        'wasm-override',
+        'runtime-log-level',
+        'offchain-worker'
+    ]),
+    'head-mode': _zod.z.nativeEnum(HeadMode).default("Latest")
+});
 const cli = (y)=>{
-    y.command('follow-chain', 'Always follow the latest block on upstream', (yargs)=>yargs.options({
-            ...options,
-            port: {
-                desc: 'Port to listen on',
-                number: true
-            },
-            'head-mode': {
-                desc: 'Head mode',
-                choices: [
-                    'latest',
-                    'finalized'
-                ],
-                default: 'finalized'
+    y.command('follow-chain', 'Always follow the latest block on upstream', (yargs)=>yargs.options((0, _index.getYargsOptions)(schema.shape)), async (argv)=>{
+        const config = schema.parse(argv);
+        Array.isArray(config.endpoint) ? config.endpoint : [
+            config.endpoint || ''
+        ].forEach((endpoint)=>{
+            if (/^(https|http):\/\//.test(endpoint)) {
+                throw Error('http provider is not supported');
             }
-        }), async (argv)=>{
-        const port = argv.port ?? 8000;
-        const endpoint = argv.endpoint;
-        if (/^(https|http):\/\//.test(endpoint || '')) {
-            throw Error('http provider is not supported');
-        }
-        const context = await (0, _context.setupContext)(argv, true);
-        const { close, port: listenPort } = await (0, _server.createServer)((0, _index.handler)(context), port);
+        });
+        const context = await (0, _context.setupContext)(config, true);
+        const { close, port: listenPort } = await (0, _server.createServer)((0, _index1.handler)(context), config.port);
         logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
         const chain = context.chain;
-        chain.api[argv.headMode === 'latest' ? 'subscribeRemoteNewHeads' : 'subscribeRemoteFinalizedHeads'](async (error, data)=>{
+        chain.api[config['head-mode'] === "Latest" ? 'subscribeRemoteNewHeads' : 'subscribeRemoteFinalizedHeads'](async (error, data)=>{
             try {
                 if (error) throw error;
                 logger.info({
                     header: data
-                }, `Follow ${argv.headMode} head from upstream`);
+                }, `Follow ${config['head-mode']} head from upstream`);
                 const parent = await chain.getBlock(data.parentHash);
                 if (!parent) throw Error(`Cannot find parent', ${data.parentHash}`);
                 const registry = await parent.registry;
@@ -91,7 +90,7 @@ const cli = (y)=>{
                     calls,
                     mockSignatureHost: false,
                     allowUnresolvedImports: false,
-                    runtimeLogLevel: argv.runtimeLogLevel || 0
+                    runtimeLogLevel: config['runtime-log-level'] || 0
                 }, (0, _chopstickscore.taskHandler)(parent));
                 if ('Error' in result) {
                     throw new Error(result.Error);

package/dist/cjs/plugins/run-block/cli.js

@@ -9,27 +9,27 @@ Object.defineProperty(exports, "cli", {
     }
 });
 const _nodefs = require("node:fs");
+const _zod = require("zod");
 const _chopstickscore = require("@acala-network/chopsticks-core");
-const _clioptions = require("../../cli-options.js");
+const _index = require("../../schema/index.js");
 const _generatehtmldiff = require("../../utils/generate-html-diff.js");
 const _openhtml = require("../../utils/open-html.js");
 const _context = require("../../context.js");
+const schema = _zod.z.object({
+    ..._index.configSchema.shape,
+    ['output-path']: _zod.z.string({
+        description: 'File path to print output'
+    }).optional(),
+    html: _zod.z.boolean({
+        description: 'Generate html with storage diff'
+    }).optional(),
+    open: _zod.z.boolean({
+        description: 'Open generated html'
+    }).optional()
+});
 const cli = (y)=>{
-    y.command('run-block', 'Replay a block', (yargs)=>yargs.options({
-            ..._clioptions.defaultOptions,
-            ..._clioptions.mockOptions,
-            'output-path': {
-                desc: 'File path to print output',
-                string: true
-            },
-            html: {
-                desc: 'Generate html with storage diff'
-            },
-            open: {
-                desc: 'Open generated html'
-            }
-        }), async (argv)=>{
-        const context = await (0, _context.setupContext)(argv, true);
+    y.command('run-block', 'Replay a block', (yargs)=>yargs.options((0, _index.getYargsOptions)(schema.shape)), async (argv)=>{
+        const context = await (0, _context.setupContext)(schema.parse(argv), true);
         const header = await context.chain.head.header;
         const block = context.chain.head;
         const parent = await block.parentBlock;

package/dist/cjs/plugins/try-runtime/index.js

@@ -9,32 +9,34 @@ Object.defineProperty(exports, "cli", {
     }
 });
 const _nodefs = require("node:fs");
-const _clioptions = require("../../cli-options.js");
+const _zod = require("zod");
+const _index = require("../../schema/index.js");
 const _generatehtmldiff = require("../../utils/generate-html-diff.js");
 const _openhtml = require("../../utils/open-html.js");
 const _context = require("../../context.js");
+const schema = _zod.z.object({
+    endpoint: _index.configSchema.shape.endpoint,
+    port: _index.configSchema.shape.port,
+    ['build-block-mode']: _index.configSchema.shape['build-block-mode'],
+    block: _index.configSchema.shape.block,
+    db: _index.configSchema.shape.db,
+    ['runtime-log-level']: _index.configSchema.shape['runtime-log-level'],
+    ['wasm-override']: _zod.z.string({
+        description: 'Path to WASM built with feature `try-runtime` enabled'
+    }),
+    ['output-path']: _zod.z.string({
+        description: 'File path to print output'
+    }).optional(),
+    html: _zod.z.boolean({
+        description: 'Generate html with storage diff'
+    }).optional(),
+    open: _zod.z.boolean({
+        description: 'Open generated html'
+    }).optional()
+});
 const cli = (y)=>{
-    y.command('try-runtime', 'Runs runtime upgrade', (yargs)=>yargs.options({
-            ..._clioptions.defaultOptions,
-            'wasm-override': {
-                desc: 'Path to WASM built with feature `try-runtime` enabled',
-                string: true,
-                required: true
-            },
-            'output-path': {
-                desc: 'File path to print output',
-                string: true
-            },
-            html: {
-                desc: 'Generate html with storage diff',
-                boolean: true
-            },
-            open: {
-                desc: 'Open generated html',
-                boolean: true
-            }
-        }), async (argv)=>{
-        const context = await (0, _context.setupContext)(argv);
+    y.command('try-runtime', 'Runs runtime upgrade', (yargs)=>yargs.options((0, _index.getYargsOptions)(schema.shape)), async (argv)=>{
+        const context = await (0, _context.setupContext)(schema.parse(argv));
         const block = context.chain.head;
         const registry = await block.registry;
         registry.register({

package/dist/cjs/rpc/index.js

@@ -10,6 +10,9 @@ Object.defineProperty(exports, "handler", {
 });
 const _chopstickscore = require("@acala-network/chopsticks-core");
 const _index = require("../plugins/index.js");
+const rpcLogger = _chopstickscore.defaultLogger.child({
+    module: 'rpc'
+});
 const allHandlers = {
     ..._chopstickscore.substrate,
     rpc_methods: async ()=>Promise.resolve({
@@ -29,10 +32,10 @@ const getHandler = async (method)=>{
     return handler;
 };
 const handler = (context)=>async ({ method, params }, subscriptionManager)=>{
-        _chopstickscore.logger.trace('Handling %s', method);
+        rpcLogger.trace('Handling %s', method);
         const handler = await getHandler(method);
         if (!handler) {
-            _chopstickscore.logger.warn('Method not found %s', method);
+            rpcLogger.warn('Method not found %s', method);
             throw new _chopstickscore.ResponseError(-32601, `Method not found: ${method}`);
         }
         return handler(context, params, subscriptionManager);