@acala-network/chopsticks 0.9.1-2 → 0.9.1-4

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.js");
+const _generatehtmldiff = require("../../utils/generate-html-diff.js");
+const _openhtml = require("../../utils/open-html.js");
+const _context = require("../../context.js");
+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.js");
+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;

package/dist/cjs/plugins/set-head/index.js

@@ -1,35 +1,25 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-/**
- * Set head.
- *
- * This function is a dev rpc handler. Use `dev_setHead` as the method name when calling it.
- *
- * @param context - The context object of the rpc handler
- * @param hashOrNumber - The block hash or number to set as head
- *
- * @example Set head to block 1000000
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_setHead', [1000000])
- * ```
- */
-const rpc = async (context, [hashOrNumber]) => {
+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, [hashOrNumber])=>{
     let block;
     if (typeof hashOrNumber === 'number') {
         const blockNumber = hashOrNumber > 0 ? hashOrNumber : context.chain.head.number + hashOrNumber;
         block = await context.chain.getBlockAt(blockNumber);
-    }
-    else {
+    } else {
         block = await context.chain.getBlock(hashOrNumber);
     }
     if (!block) {
-        throw new chopsticks_core_1.ResponseError(1, `Block not found ${hashOrNumber}`);
+        throw new _chopstickscore.ResponseError(1, `Block not found ${hashOrNumber}`);
     }
     await context.chain.setHead(block);
     return block.hash;
 };
-exports.rpc = rpc;

package/dist/cjs/plugins/set-runtime-log-level/index.js

@@ -1,28 +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 runtime log level.
- *
- * This function is a dev rpc handler. Use `dev_setRuntimeLogLevel` as the method name when calling it.
- *
- * @param context - The context object of the rpc handler
- * @param runtimeLogLevel - The runtime log level to set
- *
- * @example Set runtime log level to 1
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_setRuntimeLogLevel', [1])
- * ```
- */
-const rpc = async (context, [runtimeLogLevel]) => {
-    logger_1.defaultLogger.debug({ runtimeLogLevel }, 'dev_setRuntimeLogLevel');
+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.js");
+const rpc = async (context, [runtimeLogLevel])=>{
+    _logger.defaultLogger.debug({
+        runtimeLogLevel
+    }, 'dev_setRuntimeLogLevel');
     if (typeof runtimeLogLevel !== 'number') {
-        throw new chopsticks_core_1.ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
+        throw new _chopstickscore.ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
     }
     context.chain.runtimeLogLevel = runtimeLogLevel;
 };
-exports.rpc = rpc;

package/dist/cjs/plugins/set-storage/index.js

@@ -1,42 +1,23 @@
 "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 storage values.
- *
- * This function is a dev rpc handler. Use `dev_setStorage` 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
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * import { Keyring } from '@polkadot/keyring'
- *
- * const ws = new WsProvider(`ws://localhost:8000`)
- * const keyring = new Keyring({ type: 'ed25519' })
- * const bob = keyring.addFromUri('//Bob')
- *
- * const storage = {
- *   System: {
- *     Account: [[[bob.address], { data: { free: 100000 }, nonce: 1 }]],
- *   },
- * }
- * await ws.send('dev_setStorage', [storage])
- * ```
- */
-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.js");
+const rpc = async (context, params)=>{
     const [values, blockHash] = params;
-    const hash = await (0, chopsticks_core_1.setStorage)(context.chain, values, blockHash).catch((error) => {
-        throw new chopsticks_core_1.ResponseError(1, error.toString());
+    const hash = await (0, _chopstickscore.setStorage)(context.chain, values, blockHash).catch((error)=>{
+        throw new _chopstickscore.ResponseError(1, error.toString());
     });
-    logger_1.defaultLogger.debug({
+    _logger.defaultLogger.debug({
         hash,
-        values,
+        values
     }, 'dev_setStorage');
     return hash;
 };
-exports.rpc = rpc;

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

@@ -1,27 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-/**
- * Travel to a specific time.
- *
- * This function is a dev rpc handler. Use `dev_timeTravel` as the method name when calling it.
- *
- * @param context - The context object of the rpc handler
- * @param date - Timestamp or date string to set
- *
- * @example
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_timeTravel', ['Jan 1, 2023'])
- * ```
- */
-const rpc = async (context, [date]) => {
+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 chopsticks_core_1.ResponseError(1, 'Invalid date');
-    await (0, chopsticks_core_1.timeTravel)(context.chain, timestamp);
+    if (Number.isNaN(timestamp)) throw new _chopstickscore.ResponseError(1, 'Invalid date');
+    await (0, _chopstickscore.timeTravel)(context.chain, timestamp);
     return timestamp;
 };
-exports.rpc = rpc;