@acala-network/chopsticks 0.9.4-5 → 0.9.4

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

@@ -1,49 +1,48 @@
 import { Block, defaultLogger, runTask, taskHandler } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
 import _ from 'lodash';
+import { configSchema, getYargsOptions } from '../../schema/index.js';
 import { createServer } from '../../server.js';
-import { defaultOptions } from '../../cli-options.js';
 import { handler } from '../../rpc/index.js';
 import { setupContext } from '../../context.js';
 const logger = defaultLogger.child({
     name: 'follow-chain'
 });
-const options = _.pick(defaultOptions, [
-    'endpoint',
-    'wasm-override',
-    'runtime-log-level',
-    'offchain-worker'
-]);
+var HeadMode;
+(function(HeadMode) {
+    HeadMode["Latest"] = "Latest";
+    HeadMode["Finalized"] = "Finalized";
+})(HeadMode || (HeadMode = {}));
+const schema = z.object({
+    ..._.pick(configSchema.shape, [
+        'endpoint',
+        'port',
+        'wasm-override',
+        'runtime-log-level',
+        'offchain-worker'
+    ]),
+    'head-mode': z.nativeEnum(HeadMode).default("Latest")
+});
 export 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(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 setupContext(argv, true);
-        const { close, port: listenPort } = await createServer(handler(context), port);
+        });
+        const context = await setupContext(config, true);
+        const { close, port: listenPort } = await createServer(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;
@@ -76,7 +75,7 @@ export const cli = (y)=>{
                     calls,
                     mockSignatureHost: false,
                     allowUnresolvedImports: false,
-                    runtimeLogLevel: argv.runtimeLogLevel || 0
+                    runtimeLogLevel: config['runtime-log-level'] || 0
                 }, taskHandler(parent));
                 if ('Error' in result) {
                     throw new Error(result.Error);

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

@@ -1,25 +1,25 @@
 import { writeFileSync } from 'node:fs';
+import { z } from 'zod';
 import { runTask, taskHandler } from '@acala-network/chopsticks-core';
-import { defaultOptions, mockOptions } from '../../cli-options.js';
+import { configSchema, getYargsOptions } from '../../schema/index.js';
 import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff.js';
 import { openHtml } from '../../utils/open-html.js';
 import { setupContext } from '../../context.js';
+const schema = z.object({
+    ...configSchema.shape,
+    ['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('run-block', 'Replay a block', (yargs)=>yargs.options({
-            ...defaultOptions,
-            ...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 setupContext(argv, true);
+    y.command('run-block', 'Replay a block', (yargs)=>yargs.options(getYargsOptions(schema.shape)), async (argv)=>{
+        const context = await setupContext(schema.parse(argv), true);
         const header = await context.chain.head.header;
         const block = context.chain.head;
         const parent = await block.parentBlock;

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

@@ -1,30 +1,32 @@
 import { writeFileSync } from 'node:fs';
-import { defaultOptions } from '../../cli-options.js';
+import { z } from 'zod';
+import { configSchema, getYargsOptions } from '../../schema/index.js';
 import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff.js';
 import { openHtml } from '../../utils/open-html.js';
 import { setupContext } from '../../context.js';
+const schema = z.object({
+    endpoint: configSchema.shape.endpoint,
+    port: configSchema.shape.port,
+    ['build-block-mode']: configSchema.shape['build-block-mode'],
+    block: configSchema.shape.block,
+    db: configSchema.shape.db,
+    ['runtime-log-level']: configSchema.shape['runtime-log-level'],
+    ['wasm-override']: z.string({
+        description: 'Path to WASM built with feature `try-runtime` enabled'
+    }),
+    ['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('try-runtime', 'Runs runtime upgrade', (yargs)=>yargs.options({
-            ...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 setupContext(argv);
+    y.command('try-runtime', 'Runs runtime upgrade', (yargs)=>yargs.options(getYargsOptions(schema.shape)), async (argv)=>{
+        const context = await setupContext(schema.parse(argv));
         const block = context.chain.head;
         const registry = await block.registry;
         registry.register({

package/dist/esm/rpc/index.js

@@ -1,5 +1,8 @@
-import { ResponseError, logger, substrate } from '@acala-network/chopsticks-core';
+import { ResponseError, defaultLogger, substrate } from '@acala-network/chopsticks-core';
 import { loadRpcPlugin, rpcPluginMethods } from '../plugins/index.js';
+const rpcLogger = defaultLogger.child({
+    module: 'rpc'
+});
 const allHandlers = {
     ...substrate,
     rpc_methods: async ()=>Promise.resolve({
@@ -19,10 +22,10 @@ const getHandler = async (method)=>{
     return handler;
 };
 export const handler = (context)=>async ({ method, params }, subscriptionManager)=>{
-        logger.trace('Handling %s', method);
+        rpcLogger.trace('Handling %s', method);
         const handler = await getHandler(method);
         if (!handler) {
-            logger.warn('Method not found %s', method);
+            rpcLogger.warn('Method not found %s', method);
             throw new ResponseError(-32601, `Method not found: ${method}`);
         }
         return handler(context, params, subscriptionManager);

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

@@ -1,13 +1,14 @@
 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>;
     'max-memory-block-count': z.ZodOptional<z.ZodNumber>;
     db: z.ZodOptional<z.ZodString>;
@@ -19,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;
@@ -31,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>;
             };
@@ -45,7 +46,7 @@ export declare const configSchema: z.ZodObject<{
                 top: Record<string, string>;
             };
         }>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strip", ZodTypeAny, {
         name: string;
         id: string;
         properties: {
@@ -76,13 +77,14 @@ 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;
     'max-memory-block-count'?: number | undefined;
     db?: string | undefined;
@@ -105,13 +107,14 @@ 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;
     'mock-signature-host'?: boolean | undefined;
     'max-memory-block-count'?: number | undefined;
     db?: string | undefined;
@@ -134,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/esm/schema/index.js

@@ -1,43 +1,110 @@
 import { BuildBlockMode, defaultLogger, genesisSchema, isUrl } from '@acala-network/chopsticks-core';
+import { ZodNativeEnum, z } from 'zod';
 import { basename, extname } from 'node:path';
 import { readFileSync } from 'node:fs';
-import { z } from 'zod';
 import _ from 'lodash';
 import axios from 'axios';
 import yaml from 'js-yaml';
 export const zHex = z.custom((val)=>/^0x\w+$/.test(val));
 export const zHash = z.string().length(66).and(zHex);
 export const configSchema = z.object({
-    port: z.number().optional(),
+    port: z.number({
+        description: 'Port to listen on'
+    }).default(8000),
     endpoint: z.union([
         z.string(),
         z.array(z.string())
-    ]).optional(),
+    ], {
+        description: 'Endpoint to connect to'
+    }).optional(),
     block: z.union([
-        z.string().length(66).startsWith('0x'),
+        zHash,
         z.number(),
         z.null()
-    ]).optional(),
-    'build-block-mode': z.nativeEnum(BuildBlockMode).optional(),
-    'import-storage': z.any().optional(),
-    'mock-signature-host': z.boolean().optional(),
+    ], {
+        description: 'Block hash or block number. Default to latest block'
+    }).optional(),
+    'build-block-mode': z.nativeEnum(BuildBlockMode).default(BuildBlockMode.Batch),
+    'import-storage': z.any({
+        description: 'Pre-defined JSON/YAML storage file path'
+    }).optional(),
+    'allow-unresolved-imports': z.boolean().optional(),
+    'mock-signature-host': z.boolean({
+        description: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid'
+    }).optional(),
     'max-memory-block-count': z.number().optional(),
-    db: z.string().optional(),
-    'wasm-override': z.string().optional(),
+    db: z.string({
+        description: 'Path to database'
+    }).optional(),
+    'wasm-override': z.string({
+        description: 'Path to wasm override'
+    }).optional(),
     genesis: z.union([
         z.string(),
         genesisSchema
     ]).optional(),
     timestamp: z.number().optional(),
     'registered-types': z.any().optional(),
-    'runtime-log-level': z.number().min(0).max(5).optional(),
-    'offchain-worker': z.boolean().optional(),
+    'runtime-log-level': 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': z.boolean({
+        description: 'Enable offchain worker'
+    }).optional(),
     resume: z.union([
-        z.string().length(66).startsWith('0x'),
+        zHash,
         z.number(),
         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 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;
+};
+export const getYargsOptions = (zodShape)=>{
+    return _.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/';
 export const fetchConfig = async (path)=>{
     let file;
@@ -67,5 +134,5 @@ export const fetchConfig = async (path)=>{
     const config = yaml.load(_.template(file, {
         variable: 'env'
     })(process.env));
-    return configSchema.parse(config);
+    return configSchema.strict().parse(config);
 };

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

@@ -1,16 +1,15 @@
 import { createServer } from './server.js';
+import { defaultLogger } from '@acala-network/chopsticks-core';
 import { handler } from './rpc/index.js';
-import { logger } from '@acala-network/chopsticks-core';
 import { setupContext } from './context.js';
 export const setupWithServer = async (argv)=>{
     const context = await 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 createServer(handler(context), port);
-    logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    const { close, port: listenPort } = await createServer(handler(context), argv.port);
+    defaultLogger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
     return {
         ...context,
         listenPort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.9.4-5",
+  "version": "0.9.4",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.cjs",
@@ -13,8 +13,8 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-core": "0.9.4-5",
-    "@acala-network/chopsticks-db": "0.9.4-5",
+    "@acala-network/chopsticks-core": "0.9.4",
+    "@acala-network/chopsticks-db": "0.9.4",
     "@pnpm/npm-conf": "^2.2.2",
     "@polkadot/api-augment": "^10.10.1",
     "@polkadot/types": "^10.10.1",

package/dist/cjs/cli-options.d.ts

@@ -1,40 +0,0 @@
-export declare const defaultOptions: {
-    endpoint: {
-        desc: string;
-        string: boolean;
-    };
-    block: {
-        desc: string;
-        string: boolean;
-    };
-    'wasm-override': {
-        desc: string;
-        string: boolean;
-    };
-    db: {
-        desc: string;
-        string: boolean;
-    };
-    config: {
-        desc: string;
-        string: boolean;
-    };
-    'runtime-log-level': {
-        desc: string;
-        number: boolean;
-    };
-    'offchain-worker': {
-        desc: string;
-        boolean: boolean;
-    };
-};
-export declare const mockOptions: {
-    'import-storage': {
-        desc: string;
-        string: boolean;
-    };
-    'mock-signature-host': {
-        desc: string;
-        boolean: boolean;
-    };
-};

package/dist/cjs/cli-options.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    defaultOptions: function() {
-        return defaultOptions;
-    },
-    mockOptions: function() {
-        return mockOptions;
-    }
-});
-const defaultOptions = {
-    endpoint: {
-        desc: 'Endpoint to connect to',
-        string: true
-    },
-    block: {
-        desc: 'Block hash or block number. Default to latest block',
-        string: true
-    },
-    'wasm-override': {
-        desc: 'Path to wasm override',
-        string: true
-    },
-    db: {
-        desc: 'Path to database',
-        string: true
-    },
-    config: {
-        desc: 'Path to config file with default options',
-        string: true
-    },
-    'runtime-log-level': {
-        desc: 'Runtime maximum log level [off = 0; error = 1; warn = 2; info = 3; debug = 4; trace = 5]',
-        number: true
-    },
-    'offchain-worker': {
-        desc: 'Enable offchain worker',
-        boolean: true
-    }
-};
-const mockOptions = {
-    'import-storage': {
-        desc: 'Pre-defined JSON/YAML storage file path',
-        string: true
-    },
-    'mock-signature-host': {
-        desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
-        boolean: true
-    }
-};

package/dist/esm/cli-options.d.ts

@@ -1,40 +0,0 @@
-export declare const defaultOptions: {
-    endpoint: {
-        desc: string;
-        string: boolean;
-    };
-    block: {
-        desc: string;
-        string: boolean;
-    };
-    'wasm-override': {
-        desc: string;
-        string: boolean;
-    };
-    db: {
-        desc: string;
-        string: boolean;
-    };
-    config: {
-        desc: string;
-        string: boolean;
-    };
-    'runtime-log-level': {
-        desc: string;
-        number: boolean;
-    };
-    'offchain-worker': {
-        desc: string;
-        boolean: boolean;
-    };
-};
-export declare const mockOptions: {
-    'import-storage': {
-        desc: string;
-        string: boolean;
-    };
-    'mock-signature-host': {
-        desc: string;
-        boolean: boolean;
-    };
-};

package/dist/esm/cli-options.js

@@ -1,40 +0,0 @@
-export const defaultOptions = {
-    endpoint: {
-        desc: 'Endpoint to connect to',
-        string: true
-    },
-    block: {
-        desc: 'Block hash or block number. Default to latest block',
-        string: true
-    },
-    'wasm-override': {
-        desc: 'Path to wasm override',
-        string: true
-    },
-    db: {
-        desc: 'Path to database',
-        string: true
-    },
-    config: {
-        desc: 'Path to config file with default options',
-        string: true
-    },
-    'runtime-log-level': {
-        desc: 'Runtime maximum log level [off = 0; error = 1; warn = 2; info = 3; debug = 4; trace = 5]',
-        number: true
-    },
-    'offchain-worker': {
-        desc: 'Enable offchain worker',
-        boolean: true
-    }
-};
-export const mockOptions = {
-    'import-storage': {
-        desc: 'Pre-defined JSON/YAML storage file path',
-        string: true
-    },
-    'mock-signature-host': {
-        desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
-        boolean: true
-    }
-};