@acala-network/chopsticks 0.9.4-6 → 0.9.5-1

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/run-block/rpc.js

@@ -78,6 +78,7 @@ const rpc = async ({ chain }, [params])=>{
         const raw = result.Call.storageDiff;
         const previousLayer = newBlock.storage;
         newBlock.pushStorageLayer().setAll(raw);
+        const newBlockMeta = await newBlock.meta;
         for (const [key, value] of raw){
             if (key === systemEventsKey) {
                 continue;
@@ -97,7 +98,7 @@ const rpc = async ({ chain }, [params])=>{
                 };
             }
             if (includeParsed) {
-                const decoded = (0, _chopstickscore.decodeKeyValue)(await newBlock.meta, newBlock, key, value, false);
+                const decoded = (0, _chopstickscore.decodeKeyValue)(newBlockMeta, key, value, false);
                 if (decoded) {
                     obj.parsed = {
                         section: decoded.section,

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

package/dist/cjs/schema/index.d.ts

@@ -1,12 +1,12 @@
 import { BuildBlockMode } from '@acala-network/chopsticks-core';
-import { z } from 'zod';
+import { ZodNativeEnum, ZodRawShape, ZodTypeAny, z } from 'zod';
 export declare const zHex: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
 export declare const zHash: z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
 export declare const configSchema: z.ZodObject<{
-    port: z.ZodOptional<z.ZodNumber>;
+    port: z.ZodDefault<z.ZodNumber>;
     endpoint: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
-    block: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
-    'build-block-mode': z.ZodOptional<z.ZodNativeEnum<typeof BuildBlockMode>>;
+    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<ZodNativeEnum<typeof BuildBlockMode>>;
     'import-storage': z.ZodOptional<z.ZodAny>;
     'allow-unresolved-imports': z.ZodOptional<z.ZodBoolean>;
     'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
@@ -20,7 +20,7 @@ export declare const configSchema: 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, {
+        }, "strip", ZodTypeAny, {
             ss58Format?: number | undefined;
             tokenDecimals?: number | number[] | undefined;
             tokenSymbol?: string | string[] | undefined;
@@ -32,12 +32,12 @@ export declare const configSchema: z.ZodObject<{
         genesis: z.ZodObject<{
             raw: z.ZodObject<{
                 top: z.ZodRecord<z.ZodString, z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
+            }, "strip", ZodTypeAny, {
                 top: Record<string, string>;
             }, {
                 top: Record<string, string>;
             }>;
-        }, "strip", z.ZodTypeAny, {
+        }, "strip", ZodTypeAny, {
             raw: {
                 top: Record<string, string>;
             };
@@ -46,7 +46,7 @@ export declare const configSchema: z.ZodObject<{
                 top: Record<string, string>;
             };
         }>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strip", ZodTypeAny, {
         name: string;
         id: string;
         properties: {
@@ -77,12 +77,12 @@ export declare const configSchema: z.ZodObject<{
     '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.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-}, "strict", z.ZodTypeAny, {
-    port?: number | undefined;
+    resume: z.ZodOptional<z.ZodUnion<[z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>, z.ZodNumber, z.ZodBoolean]>>;
+}, "strip", ZodTypeAny, {
+    port: number;
+    'build-block-mode': BuildBlockMode;
     endpoint?: string | string[] | undefined;
-    block?: string | number | null | undefined;
-    'build-block-mode'?: BuildBlockMode | undefined;
+    block?: number | `0x${string}` | null | undefined;
     'import-storage'?: any;
     'allow-unresolved-imports'?: boolean | undefined;
     'mock-signature-host'?: boolean | undefined;
@@ -107,11 +107,11 @@ export declare const configSchema: z.ZodObject<{
     'registered-types'?: any;
     'runtime-log-level'?: number | undefined;
     'offchain-worker'?: boolean | undefined;
-    resume?: string | number | boolean | undefined;
+    resume?: number | boolean | `0x${string}` | undefined;
 }, {
     port?: number | undefined;
     endpoint?: string | string[] | undefined;
-    block?: string | number | null | undefined;
+    block?: number | `0x${string}` | null | undefined;
     'build-block-mode'?: BuildBlockMode | undefined;
     'import-storage'?: any;
     'allow-unresolved-imports'?: boolean | undefined;
@@ -137,7 +137,15 @@ export declare const configSchema: z.ZodObject<{
     'registered-types'?: any;
     'runtime-log-level'?: number | undefined;
     'offchain-worker'?: boolean | undefined;
-    resume?: string | number | boolean | undefined;
+    resume?: number | boolean | `0x${string}` | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
+export declare const getYargsOptions: (zodShape: ZodRawShape) => {
+    [x: string]: {
+        demandOption: boolean;
+        description: any;
+        type: any;
+        choices: any;
+    };
+};
 export declare const fetchConfig: (path: string) => Promise<Config>;

package/dist/cjs/schema/index.js

@@ -15,6 +15,9 @@ _export(exports, {
     fetchConfig: function() {
         return fetchConfig;
     },
+    getYargsOptions: function() {
+        return getYargsOptions;
+    },
     zHash: function() {
         return zHash;
     },
@@ -23,9 +26,9 @@ _export(exports, {
     }
 });
 const _chopstickscore = require("@acala-network/chopsticks-core");
+const _zod = require("zod");
 const _nodepath = require("node:path");
 const _nodefs = require("node:fs");
-const _zod = require("zod");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 const _axios = /*#__PURE__*/ _interop_require_default(require("axios"));
 const _jsyaml = /*#__PURE__*/ _interop_require_default(require("js-yaml"));
@@ -37,37 +40,103 @@ function _interop_require_default(obj) {
 const zHex = _zod.z.custom((val)=>/^0x\w+$/.test(val));
 const zHash = _zod.z.string().length(66).and(zHex);
 const configSchema = _zod.z.object({
-    port: _zod.z.number().optional(),
+    port: _zod.z.number({
+        description: 'Port to listen on'
+    }).default(8000),
     endpoint: _zod.z.union([
         _zod.z.string(),
         _zod.z.array(_zod.z.string())
-    ]).optional(),
+    ], {
+        description: 'Endpoint to connect to'
+    }).optional(),
     block: _zod.z.union([
-        _zod.z.string().length(66).startsWith('0x'),
+        zHash,
         _zod.z.number(),
         _zod.z.null()
-    ]).optional(),
-    'build-block-mode': _zod.z.nativeEnum(_chopstickscore.BuildBlockMode).optional(),
-    'import-storage': _zod.z.any().optional(),
+    ], {
+        description: 'Block hash or block number. Default to latest block'
+    }).optional(),
+    'build-block-mode': _zod.z.nativeEnum(_chopstickscore.BuildBlockMode).default(_chopstickscore.BuildBlockMode.Batch),
+    'import-storage': _zod.z.any({
+        description: 'Pre-defined JSON/YAML storage file path'
+    }).optional(),
     'allow-unresolved-imports': _zod.z.boolean().optional(),
-    'mock-signature-host': _zod.z.boolean().optional(),
+    'mock-signature-host': _zod.z.boolean({
+        description: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid'
+    }).optional(),
     'max-memory-block-count': _zod.z.number().optional(),
-    db: _zod.z.string().optional(),
-    'wasm-override': _zod.z.string().optional(),
+    db: _zod.z.string({
+        description: 'Path to database'
+    }).optional(),
+    'wasm-override': _zod.z.string({
+        description: 'Path to wasm override'
+    }).optional(),
     genesis: _zod.z.union([
         _zod.z.string(),
         _chopstickscore.genesisSchema
     ]).optional(),
     timestamp: _zod.z.number().optional(),
     'registered-types': _zod.z.any().optional(),
-    'runtime-log-level': _zod.z.number().min(0).max(5).optional(),
-    'offchain-worker': _zod.z.boolean().optional(),
+    'runtime-log-level': _zod.z.number({
+        description: 'Runtime maximum log level [off = 0; error = 1; warn = 2; info = 3; debug = 4; trace = 5]'
+    }).min(0).max(5).optional(),
+    'offchain-worker': _zod.z.boolean({
+        description: 'Enable offchain worker'
+    }).optional(),
     resume: _zod.z.union([
-        _zod.z.string().length(66).startsWith('0x'),
+        zHash,
         _zod.z.number(),
         _zod.z.boolean()
-    ]).optional()
-}).strict();
+    ], {
+        description: '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'
+    }).optional()
+});
+const getZodType = (option)=>{
+    switch(option._def.typeName){
+        case 'ZodString':
+            return 'string';
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        default:
+            break;
+    }
+    if (option._def.innerType) {
+        return getZodType(option._def.innerType);
+    }
+    return undefined;
+};
+const getZodChoices = (option)=>{
+    if (option._def.innerType instanceof _zod.ZodNativeEnum) {
+        return Object.values(option._def.innerType._def.values).filter((x)=>typeof x === 'string');
+    }
+    if (option._def.innerType) {
+        return getZodChoices(option._def.innerType);
+    }
+    return undefined;
+};
+const getZodFirstOption = (option)=>{
+    const options = option._def.options;
+    if (options) {
+        for (const option of options){
+            const type = getZodType(option);
+            if (type) return type;
+        }
+    }
+    if (option._def.innerType) {
+        return getZodFirstOption(option._def.innerType);
+    }
+    return undefined;
+};
+const getYargsOptions = (zodShape)=>{
+    return _lodash.default.mapValues(zodShape, (option)=>({
+            demandOption: !option.isOptional(),
+            description: option._def.description,
+            type: getZodType(option) || getZodFirstOption(option),
+            choices: getZodChoices(option)
+        }));
+};
 const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
 const fetchConfig = async (path)=>{
     let file;
@@ -97,5 +166,5 @@ const fetchConfig = async (path)=>{
     const config = _jsyaml.default.load(_lodash.default.template(file, {
         variable: 'env'
     })(process.env));
-    return configSchema.parse(config);
+    return configSchema.strict().parse(config);
 };

package/dist/cjs/setup-with-server.js

@@ -9,18 +9,17 @@ Object.defineProperty(exports, "setupWithServer", {
     }
 });
 const _server = require("./server.js");
-const _index = require("./rpc/index.js");
 const _chopstickscore = require("@acala-network/chopsticks-core");
+const _index = require("./rpc/index.js");
 const _context = require("./context.js");
 const setupWithServer = async (argv)=>{
     const context = await (0, _context.setupContext)(argv);
-    const port = argv.port ?? 8000;
     if (argv.genesis) {
         // mine 1st block when starting from genesis to set some mock validation data
         await context.chain.newBlock();
     }
-    const { close, port: listenPort } = await (0, _server.createServer)((0, _index.handler)(context), port);
-    _chopstickscore.logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    const { close, port: listenPort } = await (0, _server.createServer)((0, _index.handler)(context), argv.port);
+    _chopstickscore.defaultLogger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
     return {
         ...context,
         listenPort,

package/dist/esm/cli.js

@@ -2,9 +2,8 @@ import { config as dotenvConfig } from 'dotenv';
 import { hideBin } from 'yargs/helpers';
 import _ from 'lodash';
 import yargs from 'yargs';
-import { BuildBlockMode, connectParachains, connectVertical } from '@acala-network/chopsticks-core';
-import { fetchConfig } from './schema/index.js';
-import { defaultOptions, mockOptions } from './cli-options.js';
+import { connectParachains, connectVertical } from '@acala-network/chopsticks-core';
+import { configSchema, fetchConfig, getYargsOptions } from './schema/index.js';
 import { pluginExtendCli } from './plugins/index.js';
 import { setupWithServer } from './index.js';
 dotenvConfig();
@@ -12,39 +11,12 @@ const processArgv = async (argv)=>{
     if (argv.config) {
         Object.assign(argv, _.defaults(argv, await 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 = yargs(hideBin(process.argv)).scriptName('chopsticks').middleware(processArgv, false).command('*', 'Dev mode, fork off a chain', (yargs)=>yargs.options({
-        ...defaultOptions,
-        ...mockOptions,
-        port: {
-            desc: 'Port to listen on',
-            number: true
-        },
-        'build-block-mode': {
-            desc: 'Build block mode. Default to Batch',
-            enum: [
-                BuildBlockMode.Batch,
-                BuildBlockMode.Manual,
-                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 setupWithServer(argv);
+const commands = yargs(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(getYargsOptions(configSchema.shape)), async (argv)=>{
+    await setupWithServer(configSchema.parse(argv));
 }).command('xcm', 'XCM setup with relaychain and parachains', (yargs)=>yargs.options({
         relaychain: {
             desc: 'Relaychain config file path',
@@ -73,7 +45,7 @@ const commands = yargs(hideBin(process.argv)).scriptName('chopsticks').middlewar
     }
 }).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) {
-    pluginExtendCli(commands).then(()=>commands.parse());
+    pluginExtendCli(commands.config('config', 'Path to config file with default options', ()=>({}))).then(()=>commands.parse());
 } else {
     commands.parse();
 }

package/dist/esm/context.js

@@ -48,10 +48,10 @@ export 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/esm/plugins/decode-key/cli.js

@@ -1,15 +1,13 @@
+import { configSchema, getYargsOptions } from '../../schema/index.js';
 import { decodeKey } from '@acala-network/chopsticks-core';
-import { defaultOptions } from '../../cli-options.js';
 import { setupContext } from '../../context.js';
 export 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(getYargsOptions(configSchema.shape)).positional('key', {
             desc: 'Key to decode',
             type: 'string'
-        }).options({
-            ...defaultOptions
         }), async (argv)=>{
-        const context = await setupContext(argv);
-        const { storage, decodedKey } = decodeKey(await context.chain.head.meta, context.chain.head, argv.key);
+        const context = await setupContext(configSchema.parse(argv));
+        const { storage, decodedKey } = decodeKey(await context.chain.head.meta, argv.key);
         if (storage && decodedKey) {
             console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x)=>JSON.stringify(x.toHuman())).join(', '));
         } else {

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

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

package/dist/esm/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/esm/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>;