@acala-network/chopsticks 0.9.2-2 → 0.9.2-3

package/dist/cjs/plugins/time-travel/index.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "rpc", {
-    enumerable: true,
-    get: function() {
-        return rpc;
-    }
-});
-const _chopstickscore = require("@acala-network/chopsticks-core");
-const rpc = async (context, [date])=>{
-    const timestamp = typeof date === 'string' ? Date.parse(date) : date;
-    if (Number.isNaN(timestamp)) throw new _chopstickscore.ResponseError(1, 'Invalid date');
-    await (0, _chopstickscore.timeTravel)(context.chain, timestamp);
-    return timestamp;
-};
+_export_star(require("./rpc.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/plugins/time-travel/rpc.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rpc", {
+    enumerable: true,
+    get: function() {
+        return rpc;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const rpc = async (context, [date])=>{
+    const timestamp = typeof date === 'string' ? Date.parse(date) : date;
+    if (Number.isNaN(timestamp)) throw new _chopstickscore.ResponseError(1, 'Invalid date');
+    await (0, _chopstickscore.timeTravel)(context.chain, timestamp);
+    return timestamp;
+};

package/dist/cjs/rpc/index.js

@@ -16,21 +16,21 @@ const allHandlers = {
             version: 1,
             methods: [
                 ...Object.keys(allHandlers),
-                ...Object.keys(_index.pluginHandlers)
+                ..._index.rpcPluginMethods
             ]
         })
 };
-const getHandler = (method)=>{
+const getHandler = async (method)=>{
     const handler = allHandlers[method];
     if (!handler) {
         // no handler for this method, check if it's a plugin
-        return _index.pluginHandlers[method];
+        return (0, _index.loadRpcPlugin)(method);
     }
     return handler;
 };
-const handler = (context)=>({ method, params }, subscriptionManager)=>{
+const handler = (context)=>async ({ method, params }, subscriptionManager)=>{
         _chopstickscore.logger.trace('Handling %s', method);
-        const handler = getHandler(method);
+        const handler = await getHandler(method);
         if (!handler) {
             _chopstickscore.logger.warn('Method not found %s', method);
             throw new _chopstickscore.ResponseError(-32601, `Method not found: ${method}`);

package/dist/cjs/schema/index.js

@@ -14,6 +14,12 @@ _export(exports, {
     },
     fetchConfig: function() {
         return fetchConfig;
+    },
+    zHash: function() {
+        return zHash;
+    },
+    zHex: function() {
+        return zHex;
     }
 });
 const _chopstickscore = require("@acala-network/chopsticks-core");
@@ -28,6 +34,8 @@ function _interop_require_default(obj) {
         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(),
     endpoint: _zod.z.string().optional(),

package/dist/esm/context.js

@@ -1,7 +1,6 @@
 import './utils/tunnel.js';
 import { GenesisProvider, defaultLogger, isUrl, setup, timeTravel } from '@acala-network/chopsticks-core';
 import { SqliteDatabase } from '@acala-network/chopsticks-db';
-import { loadRPCPlugins } from './plugins/index.js';
 import { overrideStorage, overrideWasm } from './utils/override.js';
 import axios from 'axios';
 const logger = defaultLogger.child({
@@ -77,9 +76,6 @@ export const setupContext = async (argv, overrideParent = false)=>{
     // added that have storage imports
     await overrideWasm(chain, argv['wasm-override'], at);
     await overrideStorage(chain, argv['import-storage'], at);
-    if (!process.env.DISABLE_PLUGINS) {
-        await loadRPCPlugins();
-    }
     return {
         chain
     };

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

@@ -0,0 +1,20 @@
+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', {
+            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);
+        if (storage && decodedKey) {
+            console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x)=>JSON.stringify(x.toHuman())).join(', '));
+        } else {
+            console.log('Unknown');
+        }
+        process.exit(0);
+    });
+};

package/dist/esm/plugins/decode-key/index.js

@@ -1,20 +1 @@
-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', {
-            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);
-        if (storage && decodedKey) {
-            console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x)=>JSON.stringify(x.toHuman())).join(', '));
-        } else {
-            console.log('Unknown');
-        }
-        process.exit(0);
-    });
-};
+export * from './cli.js';

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

@@ -2,8 +2,7 @@ import { z } from 'zod';
 import { ResponseError } from '@acala-network/chopsticks-core';
 import { decodeStorageDiff } from '../../utils/decoder.js';
 import { generateHtmlDiff } from '../../utils/generate-html-diff.js';
-const zHex = z.custom((val)=>/^0x\w+$/.test(val));
-const zHash = z.string().length(66).and(zHex);
+import { zHash, zHex } from '../../schema/index.js';
 const zParaId = z.string().regex(/^\d+$/).transform(Number);
 const schema = z.object({
     raw: z.boolean().optional(),
@@ -23,8 +22,6 @@ const schema = z.object({
     ump: z.record(zParaId, z.array(zHex).min(1)).optional(),
     at: zHash.optional()
 });
-// custom rpc name (optional). e.g. dryRun will be called as dev_dryRun
-export const name = 'dryRun';
 /**
  * Dry run an extrinsic or messages.
  * If `html` is true, return the generated storage diff html string.

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

@@ -0,0 +1,91 @@
+import { Block, defaultLogger, runTask, taskHandler } from '@acala-network/chopsticks-core';
+import _ from 'lodash';
+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'
+]);
+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'
+            }
+        }), 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);
+        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)=>{
+            try {
+                if (error) throw error;
+                logger.info({
+                    header: data
+                }, `Follow ${argv.headMode} head from upstream`);
+                const parent = await chain.getBlock(data.parentHash);
+                if (!parent) throw Error(`Cannot find parent', ${data.parentHash}`);
+                const registry = await parent.registry;
+                const header = registry.createType('Header', data);
+                const wasm = await parent.wasm;
+                const block = new Block(chain, header.number.toNumber(), header.hash.toHex(), parent);
+                await chain.setHead(block);
+                const calls = [
+                    [
+                        'Core_initialize_block',
+                        [
+                            header.toHex()
+                        ]
+                    ]
+                ];
+                for (const extrinsic of (await block.extrinsics)){
+                    calls.push([
+                        'BlockBuilder_apply_extrinsic',
+                        [
+                            extrinsic
+                        ]
+                    ]);
+                }
+                calls.push([
+                    'BlockBuilder_finalize_block',
+                    []
+                ]);
+                const result = await runTask({
+                    wasm,
+                    calls,
+                    mockSignatureHost: false,
+                    allowUnresolvedImports: false,
+                    runtimeLogLevel: argv.runtimeLogLevel || 0
+                }, taskHandler(parent));
+                if ('Error' in result) {
+                    throw new Error(result.Error);
+                }
+            } catch (e) {
+                logger.error(e, 'Error when processing new head');
+                await close();
+                process.exit(1);
+            }
+        });
+    });
+};

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

@@ -1,91 +1 @@
-import { Block, defaultLogger, runTask, taskHandler } from '@acala-network/chopsticks-core';
-import _ from 'lodash';
-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'
-]);
-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'
-            }
-        }), 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);
-        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)=>{
-            try {
-                if (error) throw error;
-                logger.info({
-                    header: data
-                }, `Follow ${argv.headMode} head from upstream`);
-                const parent = await chain.getBlock(data.parentHash);
-                if (!parent) throw Error(`Cannot find parent', ${data.parentHash}`);
-                const registry = await parent.registry;
-                const header = registry.createType('Header', data);
-                const wasm = await parent.wasm;
-                const block = new Block(chain, header.number.toNumber(), header.hash.toHex(), parent);
-                await chain.setHead(block);
-                const calls = [
-                    [
-                        'Core_initialize_block',
-                        [
-                            header.toHex()
-                        ]
-                    ]
-                ];
-                for (const extrinsic of (await block.extrinsics)){
-                    calls.push([
-                        'BlockBuilder_apply_extrinsic',
-                        [
-                            extrinsic
-                        ]
-                    ]);
-                }
-                calls.push([
-                    'BlockBuilder_finalize_block',
-                    []
-                ]);
-                const result = await runTask({
-                    wasm,
-                    calls,
-                    mockSignatureHost: false,
-                    allowUnresolvedImports: false,
-                    runtimeLogLevel: argv.runtimeLogLevel || 0
-                }, taskHandler(parent));
-                if ('Error' in result) {
-                    throw new Error(result.Error);
-                }
-            } catch (e) {
-                logger.error(e, 'Error when processing new head');
-                await close();
-                process.exit(1);
-            }
-        });
-    });
-};
+export * from './cli.js';

package/dist/esm/plugins/index.js

@@ -4,19 +4,24 @@ import { defaultLogger } from '../logger.js';
 const logger = defaultLogger.child({
     name: 'plugin'
 });
-export const pluginHandlers = {};
+export const rpcPluginHandlers = {};
 // list of plugins directory
 const plugins = readdirSync(new URL('.', import.meta.url)).filter((file)=>lstatSync(new URL(file, import.meta.url)).isDirectory());
-export const loadRPCPlugins = async ()=>{
-    for (const plugin of plugins){
-        const location = new URL(`${plugin}/index.js`, import.meta.url);
-        const { rpc, name } = await import(location.pathname);
-        if (rpc) {
-            const methodName = name || _.camelCase(plugin);
-            pluginHandlers[`dev_${methodName}`] = rpc;
-            logger.debug(`Registered plugin RPC: ${`dev_${methodName}`}`);
-        }
+// find all rpc methods
+export const rpcPluginMethods = plugins.filter((name)=>readdirSync(new URL(name, import.meta.url)).some((file)=>file.startsWith('rpc'))).map((name)=>`dev_${_.camelCase(name)}`);
+export const loadRpcPlugin = async (method)=>{
+    if (process.env.DISABLE_PLUGINS) {
+        return undefined;
     }
+    if (rpcPluginHandlers[method]) return rpcPluginHandlers[method];
+    const plugin = _.snakeCase(method.split('dev_')[1]).replaceAll('_', '-');
+    if (!plugin) return undefined;
+    const location = new URL(`${plugin}/index.js`, import.meta.url);
+    const { rpc } = await import(location.pathname);
+    if (!rpc) return undefined;
+    rpcPluginHandlers[method] = rpc;
+    logger.debug(`Registered plugin ${plugin} RPC`);
+    return rpc;
 };
 export const pluginExtendCli = async (y)=>{
     for (const plugin of plugins){

package/dist/esm/plugins/new-block/index.js

@@ -1,66 +1 @@
-import { ResponseError } from '@acala-network/chopsticks-core';
-import { defaultLogger } from '../../logger.js';
-/**
- * Build new blocks.
- *
- * This function is a dev rpc handler. Use `dev_newBlock` as the method name when calling it.
- *
- * @param context - The context object of the rpc handler
- * @param params - The parameters of the rpc handler
- *
- * @example Build 2 blocks
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [{ count: 2 }])
- * ```
- * @example Build a block with upward messages
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [
- *  {
- *    ump: {
- *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
- *      2000: [
- *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
- *      ],
- *    }
- *  }
- * ])
- * ```
- *
- * @example Build two blocks with unsafeBlockHeight
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * // this will create two blocks with block height 100000001 and 100000002
- * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
- * ```
- */ export const rpc = async (context, params)=>{
-    const [param] = params;
-    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
-    const now = context.chain.head.number;
-    const diff = to ? to - now : count;
-    const finalCount = diff > 0 ? diff : 1;
-    let finalHash;
-    if (unsafeBlockHeight < now) {
-        throw new ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
-    }
-    for(let i = 0; i < finalCount; i++){
-        const block = await context.chain.newBlock({
-            transactions,
-            horizontalMessages: hrmp,
-            upwardMessages: ump,
-            downwardMessages: dmp,
-            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
-        }).catch((error)=>{
-            throw new ResponseError(1, error.toString());
-        });
-        defaultLogger.debug({
-            hash: block.hash
-        }, 'dev_newBlock');
-        finalHash = block.hash;
-    }
-    return finalHash;
-};
+export * from './rpc.js';

package/dist/esm/plugins/new-block/rpc.js

@@ -0,0 +1,82 @@
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+import { defaultLogger } from '../../logger.js';
+import { zHex } from '../../schema/index.js';
+const schema = z.object({
+    count: z.number().optional(),
+    to: z.number().optional(),
+    dmp: z.array(z.object({
+        sentAt: z.number(),
+        msg: zHex
+    })).min(1).optional(),
+    ump: z.record(z.number(), z.array(zHex).min(1)).optional(),
+    hrmp: z.record(z.number(), z.array(z.object({
+        sentAt: z.number(),
+        data: zHex
+    })).min(1)).optional(),
+    transactions: z.array(zHex).min(1).optional(),
+    unsafeBlockHeight: z.number().optional()
+});
+/**
+ * Build new blocks.
+ *
+ * This function is a dev rpc handler. Use `dev_newBlock` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param params - The parameters of the rpc handler
+ *
+ * @example Build 2 blocks
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [{ count: 2 }])
+ * ```
+ * @example Build a block with upward messages
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [
+ *  {
+ *    ump: {
+ *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
+ *      2000: [
+ *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
+ *      ],
+ *    }
+ *  }
+ * ])
+ * ```
+ *
+ * @example Build two blocks with unsafeBlockHeight
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * // this will create two blocks with block height 100000001 and 100000002
+ * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
+ * ```
+ */ export const rpc = async (context, [params])=>{
+    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = schema.parse(params || {});
+    const now = context.chain.head.number;
+    const diff = to ? to - now : count;
+    const finalCount = diff !== undefined ? Math.max(diff, 1) : 1;
+    let finalHash;
+    if (unsafeBlockHeight !== undefined && unsafeBlockHeight <= now) {
+        throw new ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
+    }
+    for(let i = 0; i < finalCount; i++){
+        const block = await context.chain.newBlock({
+            transactions,
+            horizontalMessages: hrmp,
+            upwardMessages: ump,
+            downwardMessages: dmp,
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+        }).catch((error)=>{
+            throw new ResponseError(1, error.toString());
+        });
+        defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
+        finalHash = block.hash;
+    }
+    return finalHash;
+};

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

@@ -0,0 +1,74 @@
+import { writeFileSync } from 'node:fs';
+import { runTask, taskHandler } from '@acala-network/chopsticks-core';
+import { defaultOptions, mockOptions } from '../../cli-options.js';
+import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff.js';
+import { openHtml } from '../../utils/open-html.js';
+import { setupContext } from '../../context.js';
+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);
+        const header = await context.chain.head.header;
+        const block = context.chain.head;
+        const parent = await block.parentBlock;
+        if (!parent) throw Error('cant find parent block');
+        const wasm = await parent.wasm;
+        const calls = [
+            [
+                'Core_initialize_block',
+                [
+                    header.toHex()
+                ]
+            ]
+        ];
+        for (const extrinsic of (await block.extrinsics)){
+            calls.push([
+                'BlockBuilder_apply_extrinsic',
+                [
+                    extrinsic
+                ]
+            ]);
+        }
+        calls.push([
+            'BlockBuilder_finalize_block',
+            []
+        ]);
+        const result = await runTask({
+            wasm,
+            calls,
+            mockSignatureHost: false,
+            allowUnresolvedImports: false,
+            runtimeLogLevel: argv.runtimeLogLevel || 0
+        }, taskHandler(parent));
+        if ('Error' in result) {
+            throw new Error(result.Error);
+        }
+        if (argv.html) {
+            const filePath = await generateHtmlDiffPreviewFile(parent, result.Call.storageDiff, block.hash);
+            console.log(`Generated preview ${filePath}`);
+            if (argv.open) {
+                openHtml(filePath);
+            }
+        } else if (argv.outputPath) {
+            writeFileSync(argv.outputPath, JSON.stringify(result, null, 2));
+        } else {
+            console.dir(result, {
+                depth: null,
+                colors: false
+            });
+        }
+        process.exit(0);
+    });
+};