@acala-network/chopsticks 0.9.1-1 → 0.9.1-3

package/dist/cjs/plugins/index.js

@@ -1,52 +1,102 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+Object.defineProperty(exports, "__esModule", {
+    value: true
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginExtendCli = exports.pluginHandlers = void 0;
-const lodash_1 = require("lodash");
-const fs_1 = require("fs");
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'plugin' });
-exports.pluginHandlers = {};
-const plugins = (0, fs_1.readdirSync)(__dirname).filter((file) => (0, fs_1.lstatSync)(`${__dirname}/${file}`).isDirectory());
-(async () => {
-    for (const plugin of plugins) {
-        const { rpc, name } = await Promise.resolve(`${`./${plugin}`}`).then(s => __importStar(require(s)));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    pluginExtendCli: function() {
+        return pluginExtendCli;
+    },
+    pluginHandlers: function() {
+        return pluginHandlers;
+    }
+});
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _logger = require("../logger");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const logger = _logger.defaultLogger.child({
+    name: 'plugin'
+});
+const pluginHandlers = {};
+const plugins = [
+    'decode-key',
+    'dry-run',
+    'follow-chain',
+    'new-block',
+    'run-block',
+    'set-block-build-mode',
+    'set-head',
+    'set-runtime-log-level',
+    'set-storage',
+    'time-travel',
+    'try-runtime'
+];
+(async ()=>{
+    for (const plugin of plugins){
+        const { rpc, name } = await Promise.resolve(`./${plugin}`).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
         if (rpc) {
-            const methodName = name || (0, lodash_1.camelCase)(plugin);
-            exports.pluginHandlers[`dev_${methodName}`] = rpc;
+            const methodName = name || _lodash.default.camelCase(plugin);
+            pluginHandlers[`dev_${methodName}`] = rpc;
             logger.debug(`Registered plugin ${plugin} RPC`);
         }
     }
 })();
-const pluginExtendCli = async (y) => {
-    for (const plugin of plugins) {
-        const { cli } = await Promise.resolve(`${`./${plugin}`}`).then(s => __importStar(require(s)));
+const pluginExtendCli = async (y)=>{
+    for (const plugin of plugins){
+        const { cli } = await Promise.resolve(`./${plugin}`).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
         if (cli) {
             cli(y);
             logger.debug(`Registered plugin ${plugin} CLI`);
         }
     }
 };
-exports.pluginExtendCli = pluginExtendCli;

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

@@ -1,47 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const logger_1 = require("../../logger");
-/**
- * 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 }])
- * ```
- */
-const rpc = async (context, params) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rpc", {
+    enumerable: true,
+    get: function() {
+        return rpc;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _logger = require("../../logger");
+const rpc = async (context, params)=>{
     const [param] = params;
     const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
     const now = context.chain.head.number;
@@ -49,23 +18,22 @@ const rpc = async (context, params) => {
     const finalCount = diff > 0 ? diff : 1;
     let finalHash;
     if (unsafeBlockHeight < now) {
-        throw new chopsticks_core_1.ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
+        throw new _chopstickscore.ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
     }
-    for (let i = 0; i < finalCount; i++) {
-        const block = await context.chain
-            .newBlock({
+    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 chopsticks_core_1.ResponseError(1, error.toString());
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+        }).catch((error)=>{
+            throw new _chopstickscore.ResponseError(1, error.toString());
         });
-        logger_1.defaultLogger.debug({ hash: block.hash }, 'dev_newBlock');
+        _logger.defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
         finalHash = block.hash;
     }
     return finalHash;
 };
-exports.rpc = rpc;

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

@@ -1,91 +1,115 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = exports.name = exports.cli = void 0;
-const util_1 = require("@polkadot/util");
-const node_fs_1 = require("node:fs");
-const zod_1 = require("zod");
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const cli_options_1 = require("../../cli-options");
-const generate_html_diff_1 = require("../../utils/generate-html-diff");
-const open_html_1 = require("../../utils/open-html");
-const context_1 = require("../../context");
-const cli = (y) => {
-    y.command('run-block', 'Replay a block', (yargs) => yargs.options({
-        ...cli_options_1.defaultOptions,
-        ...cli_options_1.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_1.setupContext)(argv, true);
+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, {
+    cli: function() {
+        return cli;
+    },
+    name: function() {
+        return name;
+    },
+    rpc: function() {
+        return rpc;
+    }
+});
+const _util = require("@polkadot/util");
+const _nodefs = require("node:fs");
+const _zod = require("zod");
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _clioptions = require("../../cli-options");
+const _generatehtmldiff = require("../../utils/generate-html-diff");
+const _openhtml = require("../../utils/open-html");
+const _context = require("../../context");
+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);
         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');
+        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]]);
+        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 (0, chopsticks_core_1.runTask)({
+        calls.push([
+            'BlockBuilder_finalize_block',
+            []
+        ]);
+        const result = await (0, _chopstickscore.runTask)({
             wasm,
             calls,
             mockSignatureHost: false,
             allowUnresolvedImports: false,
-            runtimeLogLevel: argv.runtimeLogLevel || 0,
-        }, (0, chopsticks_core_1.taskHandler)(parent));
+            runtimeLogLevel: argv.runtimeLogLevel || 0
+        }, (0, _chopstickscore.taskHandler)(parent));
         if ('Error' in result) {
             throw new Error(result.Error);
         }
-        (0, chopsticks_core_1.printRuntimeLogs)(result.Call.runtimeLogs);
+        (0, _chopstickscore.printRuntimeLogs)(result.Call.runtimeLogs);
         if (argv.html) {
-            const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
+            const filePath = await (0, _generatehtmldiff.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
             console.log(`Generated preview ${filePath}`);
             if (argv.open) {
-                (0, open_html_1.openHtml)(filePath);
+                (0, _openhtml.openHtml)(filePath);
             }
-        }
-        else if (argv.outputPath) {
-            (0, node_fs_1.writeFileSync)(argv.outputPath, JSON.stringify(result, null, 2));
-        }
-        else {
-            console.dir(result, { depth: null, colors: false });
+        } else if (argv.outputPath) {
+            (0, _nodefs.writeFileSync)(argv.outputPath, JSON.stringify(result, null, 2));
+        } else {
+            console.dir(result, {
+                depth: null,
+                colors: false
+            });
         }
         process.exit(0);
     });
 };
-exports.cli = cli;
-const zHex = zod_1.z.custom((val) => /^0x\w+$/.test(val));
-const zHash = zod_1.z.string().length(66).and(zHex);
-const schema = zod_1.z.object({
-    includeRaw: zod_1.z.boolean().optional(),
-    includeParsed: zod_1.z.boolean().optional(),
-    includeBlockDetails: zod_1.z.boolean().optional(),
+const zHex = _zod.z.custom((val)=>/^0x\w+$/.test(val));
+const zHash = _zod.z.string().length(66).and(zHex);
+const schema = _zod.z.object({
+    includeRaw: _zod.z.boolean().optional(),
+    includeParsed: _zod.z.boolean().optional(),
+    includeBlockDetails: _zod.z.boolean().optional(),
     parent: zHash.optional(),
-    block: zod_1.z.object({
-        header: zod_1.z.any(),
-        extrinsics: zod_1.z.array(zHex),
-    }),
+    block: _zod.z.object({
+        header: _zod.z.any(),
+        extrinsics: _zod.z.array(zHex)
+    })
 });
-exports.name = 'runBlock';
-/**
- * Run a set of extrinsics on top of a block and get the storage diff
- * and optionally the parsed storage diff and block details.
- * NOTE: The extrinsics should include inherents or tranasctions may have unexpected results.
- * NOTE: system.events and system.extrinsicData are excluded from storage diff to reduce size.
- *
- * This function is a dev rpc handler. Use `dev_runBlock` as the method name when calling it.
- */
-const rpc = async ({ chain }, [params]) => {
+const name = 'runBlock';
+const rpc = async ({ chain }, [params])=>{
     const { includeRaw, includeParsed, includeBlockDetails, parent, block } = schema.parse(params);
     const includeRawStorage = includeRaw ?? true;
     const parentBlock = await chain.getBlock(parent);
@@ -97,36 +121,41 @@ const rpc = async ({ chain }, [params]) => {
     const wasm = await parentBlock.wasm;
     const meta = await parentBlock.meta;
     const blockNumber = parentBlock.number + 1;
-    const hash = `0x${Math.round(Math.random() * 100000000)
-        .toString(16)
-        .padEnd(64, '0')}`;
-    const newBlock = new chopsticks_core_1.Block(chain, blockNumber, hash, parentBlock, {
+    const hash = `0x${Math.round(Math.random() * 100000000).toString(16).padEnd(64, '0')}`;
+    const newBlock = new _chopstickscore.Block(chain, blockNumber, hash, parentBlock, {
         header,
         extrinsics: [],
-        storage: parentBlock.storage,
+        storage: parentBlock.storage
     });
     const resp = {
-        phases: [],
+        phases: []
     };
     // exclude system events because it can be stupidly large and redudant
-    const systemEventsKey = (0, chopsticks_core_1.compactHex)(meta.query.system.events());
+    const systemEventsKey = (0, _chopstickscore.compactHex)(meta.query.system.events());
     // large and not really useful
-    const systemExtrinsicDataKey = (0, util_1.u8aToHex)(meta.query.system.extrinsicData.keyPrefix());
-    const run = async (fn, args) => {
-        const result = await (0, chopsticks_core_1.runTask)({
+    const systemExtrinsicDataKey = (0, _util.u8aToHex)(meta.query.system.extrinsicData.keyPrefix());
+    const run = async (fn, args)=>{
+        const result = await (0, _chopstickscore.runTask)({
             wasm,
-            calls: [[fn, args]],
+            calls: [
+                [
+                    fn,
+                    args
+                ]
+            ],
             mockSignatureHost: false,
             allowUnresolvedImports: false,
-            runtimeLogLevel: 5,
-        }, (0, chopsticks_core_1.taskHandler)(newBlock));
+            runtimeLogLevel: 5
+        }, (0, _chopstickscore.taskHandler)(newBlock));
         if ('Error' in result) {
             throw new Error(result.Error);
         }
-        const resp = { storageDiff: [] };
+        const resp = {
+            storageDiff: []
+        };
         const raw = result.Call.storageDiff;
         newBlock.pushStorageLayer().setAll(raw);
-        for (const [key, value] of raw) {
+        for (const [key, value] of raw){
             if (key === systemEventsKey) {
                 continue;
             }
@@ -135,16 +164,19 @@ const rpc = async ({ chain }, [params]) => {
             }
             const obj = {};
             if (includeRawStorage) {
-                obj.raw = { key, value };
+                obj.raw = {
+                    key,
+                    value
+                };
             }
             if (includeParsed) {
-                const decoded = (0, chopsticks_core_1.decodeKeyValue)(await newBlock.meta, newBlock, key, value, false);
+                const decoded = (0, _chopstickscore.decodeKeyValue)(await newBlock.meta, newBlock, key, value, false);
                 if (decoded) {
                     obj.parsed = {
                         section: decoded.section,
                         method: decoded.method,
                         key: decoded.key,
-                        value: decoded.value,
+                        value: decoded.value
                     };
                 }
             }
@@ -153,44 +185,53 @@ const rpc = async ({ chain }, [params]) => {
         resp.logs = result.Call.runtimeLogs;
         return resp;
     };
-    const resInit = await run('Core_initialize_block', [header.toHex()]);
-    resp.phases.push({ phase: 'Initialization', ...resInit });
-    for (const extrinsic of block.extrinsics) {
-        const res = await run('BlockBuilder_apply_extrinsic', [extrinsic]);
-        resp.phases.push({ phase: resp.phases.length - 1, ...res });
+    const resInit = await run('Core_initialize_block', [
+        header.toHex()
+    ]);
+    resp.phases.push({
+        phase: 'Initialization',
+        ...resInit
+    });
+    for (const extrinsic of block.extrinsics){
+        const res = await run('BlockBuilder_apply_extrinsic', [
+            extrinsic
+        ]);
+        resp.phases.push({
+            phase: resp.phases.length - 1,
+            ...res
+        });
     }
     const resFinalize = await run('BlockBuilder_finalize_block', []);
-    resp.phases.push({ phase: 'Finalization', ...resFinalize });
+    resp.phases.push({
+        phase: 'Finalization',
+        ...resFinalize
+    });
     if (includeBlockDetails) {
         const meta = await newBlock.meta;
         const registry = await newBlock.registry;
         const timestamp = await newBlock.read('u64', meta.query.timestamp.now);
         const events = await newBlock.read('Vec<EventRecord>', meta.query.system.events);
-        const parsedEvents = events?.map((event) => ({
-            phase: event.phase.isApplyExtrinsic ? event.phase.asApplyExtrinsic.toNumber() : event.phase.toString(),
-            section: event.event.section,
-            method: event.event.method,
-            args: event.event.data.map((arg) => arg.toJSON()),
-        }));
-        const extrinsics = block.extrinsics.map((extrinsic, idx) => {
+        const parsedEvents = events?.map((event)=>({
+                phase: event.phase.isApplyExtrinsic ? event.phase.asApplyExtrinsic.toNumber() : event.phase.toString(),
+                section: event.event.section,
+                method: event.event.method,
+                args: event.event.data.map((arg)=>arg.toJSON())
+            }));
+        const extrinsics = block.extrinsics.map((extrinsic, idx)=>{
             const parsed = registry.createType('GenericExtrinsic', extrinsic);
-            const resultEvent = events?.find(({ event, phase }) => event.section === 'system' &&
-                (event.method === 'ExtrinsicSuccess' || event.method === 'ExtrinsicFailed') &&
-                phase.isApplyExtrinsic &&
-                phase.asApplyExtrinsic.eq(idx));
+            const resultEvent = events?.find(({ event, phase })=>event.section === 'system' && (event.method === 'ExtrinsicSuccess' || event.method === 'ExtrinsicFailed') && phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(idx));
             return {
                 section: parsed.method.section,
                 method: parsed.method.method,
-                args: parsed.method.args.map((arg) => arg.toJSON()),
-                success: resultEvent?.event.method === 'ExtrinsicSuccess',
+                args: parsed.method.args.map((arg)=>arg.toJSON()),
+                success: resultEvent?.event.method === 'ExtrinsicSuccess'
             };
         });
         resp.blockDetails = {
             timestamp: timestamp?.toString(),
             events: parsedEvents,
-            extrinsics,
+            extrinsics
         };
     }
     return resp;
 };
-exports.rpc = rpc;

package/dist/cjs/plugins/set-block-build-mode/index.js

@@ -1,29 +1,21 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const logger_1 = require("../../logger");
-/**
- * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
- *
- * This function is a dev rpc handler. Use `dev_setBlockBuildMode` 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 Set build block mode to instant
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * import { BuildBlockMode } from '@acala-network/chopsticks-core'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
- * ```
- */
-const rpc = async (context, [mode]) => {
-    logger_1.defaultLogger.debug({ mode }, 'dev_setBlockBuildMode');
-    if (chopsticks_core_1.BuildBlockMode[mode] === undefined) {
-        throw new chopsticks_core_1.ResponseError(1, `Invalid mode ${mode}`);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rpc", {
+    enumerable: true,
+    get: function() {
+        return rpc;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _logger = require("../../logger");
+const rpc = async (context, [mode])=>{
+    _logger.defaultLogger.debug({
+        mode
+    }, 'dev_setBlockBuildMode');
+    if (_chopstickscore.BuildBlockMode[mode] === undefined) {
+        throw new _chopstickscore.ResponseError(1, `Invalid mode ${mode}`);
     }
     context.chain.txPool.mode = mode;
 };
-exports.rpc = rpc;