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

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

@@ -1,44 +1,58 @@
 import { u8aToHex } from '@polkadot/util';
 import { writeFileSync } from 'node:fs';
 import { z } from 'zod';
-import { Block, compactHex, decodeKeyValue, printRuntimeLogs, runTask, taskHandler, } from '@acala-network/chopsticks-core';
-import { defaultOptions, mockOptions } from '../../cli-options';
-import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
-import { openHtml } from '../../utils/open-html';
-import { setupContext } from '../../context';
-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) => {
+import { Block, compactHex, decodeKeyValue, printRuntimeLogs, 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');
+        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', []]);
+        calls.push([
+            'BlockBuilder_finalize_block',
+            []
+        ]);
         const result = await runTask({
             wasm,
             calls,
             mockSignatureHost: false,
             allowUnresolvedImports: false,
-            runtimeLogLevel: argv.runtimeLogLevel || 0,
+            runtimeLogLevel: argv.runtimeLogLevel || 0
         }, taskHandler(parent));
         if ('Error' in result) {
             throw new Error(result.Error);
@@ -50,17 +64,18 @@ export const cli = (y) => {
             if (argv.open) {
                 openHtml(filePath);
             }
-        }
-        else if (argv.outputPath) {
+        } else if (argv.outputPath) {
             writeFileSync(argv.outputPath, JSON.stringify(result, null, 2));
-        }
-        else {
-            console.dir(result, { depth: null, colors: false });
+        } else {
+            console.dir(result, {
+                depth: null,
+                colors: false
+            });
         }
         process.exit(0);
     });
 };
-const zHex = z.custom((val) => /^0x\w+$/.test(val));
+const zHex = z.custom((val)=>/^0x\w+$/.test(val));
 const zHash = z.string().length(66).and(zHex);
 const schema = z.object({
     includeRaw: z.boolean().optional(),
@@ -69,8 +84,8 @@ const schema = z.object({
     parent: zHash.optional(),
     block: z.object({
         header: z.any(),
-        extrinsics: z.array(zHex),
-    }),
+        extrinsics: z.array(zHex)
+    })
 });
 export const name = 'runBlock';
 /**
@@ -80,8 +95,7 @@ export const name = 'runBlock';
  * 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.
- */
-export const rpc = async ({ chain }, [params]) => {
+ */ export const rpc = async ({ chain }, [params])=>{
     const { includeRaw, includeParsed, includeBlockDetails, parent, block } = schema.parse(params);
     const includeRawStorage = includeRaw ?? true;
     const parentBlock = await chain.getBlock(parent);
@@ -93,36 +107,41 @@ export 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 hash = `0x${Math.round(Math.random() * 100000000).toString(16).padEnd(64, '0')}`;
     const newBlock = new 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 = compactHex(meta.query.system.events());
     // large and not really useful
     const systemExtrinsicDataKey = u8aToHex(meta.query.system.extrinsicData.keyPrefix());
-    const run = async (fn, args) => {
+    const run = async (fn, args)=>{
         const result = await runTask({
             wasm,
-            calls: [[fn, args]],
+            calls: [
+                [
+                    fn,
+                    args
+                ]
+            ],
             mockSignatureHost: false,
             allowUnresolvedImports: false,
-            runtimeLogLevel: 5,
+            runtimeLogLevel: 5
         }, 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;
             }
@@ -131,7 +150,10 @@ export const rpc = async ({ chain }, [params]) => {
             }
             const obj = {};
             if (includeRawStorage) {
-                obj.raw = { key, value };
+                obj.raw = {
+                    key,
+                    value
+                };
             }
             if (includeParsed) {
                 const decoded = decodeKeyValue(await newBlock.meta, newBlock, key, value, false);
@@ -140,7 +162,7 @@ export const rpc = async ({ chain }, [params]) => {
                         section: decoded.section,
                         method: decoded.method,
                         key: decoded.key,
-                        value: decoded.value,
+                        value: decoded.value
                     };
                 }
             }
@@ -149,42 +171,52 @@ export 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;

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

@@ -1,5 +1,5 @@
 import { BuildBlockMode, ResponseError } from '@acala-network/chopsticks-core';
-import { defaultLogger } from '../../logger';
+import { defaultLogger } from '../../logger.js';
 /**
  * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
  *
@@ -15,9 +15,10 @@ import { defaultLogger } from '../../logger';
  * const ws = new WsProvider(`ws://localhost:8000`)
  * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
  * ```
- */
-export const rpc = async (context, [mode]) => {
-    defaultLogger.debug({ mode }, 'dev_setBlockBuildMode');
+ */ export const rpc = async (context, [mode])=>{
+    defaultLogger.debug({
+        mode
+    }, 'dev_setBlockBuildMode');
     if (BuildBlockMode[mode] === undefined) {
         throw new ResponseError(1, `Invalid mode ${mode}`);
     }

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

@@ -13,14 +13,12 @@ import { ResponseError } from '@acala-network/chopsticks-core';
  * const ws = new WsProvider(`ws://localhost:8000`)
  * await ws.send('dev_setHead', [1000000])
  * ```
- */
-export const rpc = async (context, [hashOrNumber]) => {
+ */ export 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) {

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

@@ -1,5 +1,5 @@
 import { ResponseError } from '@acala-network/chopsticks-core';
-import { defaultLogger } from '../../logger';
+import { defaultLogger } from '../../logger.js';
 /**
  * Set runtime log level.
  *
@@ -14,9 +14,10 @@ import { defaultLogger } from '../../logger';
  * const ws = new WsProvider(`ws://localhost:8000`)
  * await ws.send('dev_setRuntimeLogLevel', [1])
  * ```
- */
-export const rpc = async (context, [runtimeLogLevel]) => {
-    defaultLogger.debug({ runtimeLogLevel }, 'dev_setRuntimeLogLevel');
+ */ export const rpc = async (context, [runtimeLogLevel])=>{
+    defaultLogger.debug({
+        runtimeLogLevel
+    }, 'dev_setRuntimeLogLevel');
     if (typeof runtimeLogLevel !== 'number') {
         throw new ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
     }

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

@@ -1,5 +1,5 @@
 import { ResponseError, setStorage } from '@acala-network/chopsticks-core';
-import { defaultLogger } from '../../logger';
+import { defaultLogger } from '../../logger.js';
 /**
  * Set storage values.
  *
@@ -24,15 +24,14 @@ import { defaultLogger } from '../../logger';
  * }
  * await ws.send('dev_setStorage', [storage])
  * ```
- */
-export const rpc = async (context, params) => {
+ */ export const rpc = async (context, params)=>{
     const [values, blockHash] = params;
-    const hash = await setStorage(context.chain, values, blockHash).catch((error) => {
+    const hash = await setStorage(context.chain, values, blockHash).catch((error)=>{
         throw new ResponseError(1, error.toString());
     });
     defaultLogger.debug({
         hash,
-        values,
+        values
     }, 'dev_setStorage');
     return hash;
 };

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

@@ -13,11 +13,9 @@ import { ResponseError, timeTravel } from '@acala-network/chopsticks-core';
  * const ws = new WsProvider(`ws://localhost:8000`)
  * await ws.send('dev_timeTravel', ['Jan 1, 2023'])
  * ```
- */
-export const rpc = async (context, [date]) => {
+ */ export const rpc = async (context, [date])=>{
     const timestamp = typeof date === 'string' ? Date.parse(date) : date;
-    if (Number.isNaN(timestamp))
-        throw new ResponseError(1, 'Invalid date');
+    if (Number.isNaN(timestamp)) throw new ResponseError(1, 'Invalid date');
     await timeTravel(context.chain, timestamp);
     return timestamp;
 };

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

@@ -1,53 +1,56 @@
 import { writeFileSync } from 'node:fs';
-import { defaultOptions } from '../../cli-options';
-import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
-import { openHtml } from '../../utils/open-html';
-import { setupContext } from '../../context';
-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) => {
+import { defaultOptions } 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('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);
         const block = context.chain.head;
         const registry = await block.registry;
         registry.register({
             UpgradeCheckSelect: {
                 _enum: {
-                    None: null,
-                },
-            },
+                    None: null
+                }
+            }
         });
         const select_none = registry.createType('UpgradeCheckSelect', 'None');
-        const result = await block.call('TryRuntime_on_runtime_upgrade', [select_none.toHex()]);
+        const result = await block.call('TryRuntime_on_runtime_upgrade', [
+            select_none.toHex()
+        ]);
         if (argv.html) {
             const filePath = await generateHtmlDiffPreviewFile(block, result.storageDiff, block.hash);
             console.log(`Generated preview ${filePath}`);
             if (argv.open) {
                 openHtml(filePath);
             }
-        }
-        else if (argv.outputPath) {
+        } else if (argv.outputPath) {
             writeFileSync(argv.outputPath, JSON.stringify(result, null, 2));
-        }
-        else {
-            console.dir(result, { depth: null, colors: false });
+        } else {
+            console.dir(result, {
+                depth: null,
+                colors: false
+            });
         }
         process.exit(0);
     });

package/dist/esm/plugins/types.js

@@ -1,8 +1,8 @@
-export { rpc as newBlock } from './new-block';
-export { rpc as dryRun } from './dry-run';
-export { rpc as setBlockBuildMode } from './set-block-build-mode';
-export { rpc as setHead } from './set-head';
-export { rpc as setRuntimeLogLevel } from './set-runtime-log-level';
-export { rpc as setStorage } from './set-storage';
-export { rpc as timeTravel } from './time-travel';
-export { rpc as runBlock } from './run-block';
+export { rpc as newBlock } from './new-block/index.js';
+export { rpc as dryRun } from './dry-run/index.js';
+export { rpc as setBlockBuildMode } from './set-block-build-mode/index.js';
+export { rpc as setHead } from './set-head/index.js';
+export { rpc as setRuntimeLogLevel } from './set-runtime-log-level/index.js';
+export { rpc as setStorage } from './set-storage/index.js';
+export { rpc as timeTravel } from './time-travel/index.js';
+export { rpc as runBlock } from './run-block/index.js';

package/dist/esm/rpc/index.js

@@ -1,13 +1,16 @@
-import { ResponseError, logger, substrate, } from '@acala-network/chopsticks-core';
-import { pluginHandlers } from '../plugins';
+import { ResponseError, logger, substrate } from '@acala-network/chopsticks-core';
+import { pluginHandlers } from '../plugins/index.js';
 const allHandlers = {
     ...substrate,
-    rpc_methods: async () => Promise.resolve({
-        version: 1,
-        methods: [...Object.keys(allHandlers), ...Object.keys(pluginHandlers)],
-    }),
+    rpc_methods: async ()=>Promise.resolve({
+            version: 1,
+            methods: [
+                ...Object.keys(allHandlers),
+                ...Object.keys(pluginHandlers)
+            ]
+        })
 };
-const getHandler = (method) => {
+const getHandler = (method)=>{
     const handler = allHandlers[method];
     if (!handler) {
         // no handler for this method, check if it's a plugin
@@ -15,12 +18,12 @@ const getHandler = (method) => {
     }
     return handler;
 };
-export const handler = (context) => ({ method, params }, subscriptionManager) => {
-    logger.trace('Handling %s', method);
-    const handler = getHandler(method);
-    if (!handler) {
-        logger.warn('Method not found %s', method);
-        throw new ResponseError(-32601, `Method not found: ${method}`);
-    }
-    return handler(context, params, subscriptionManager);
-};
+export const handler = (context)=>({ method, params }, subscriptionManager)=>{
+        logger.trace('Handling %s', method);
+        const handler = getHandler(method);
+        if (!handler) {
+            logger.warn('Method not found %s', method);
+            throw new ResponseError(-32601, `Method not found: ${method}`);
+        }
+        return handler(context, params, subscriptionManager);
+    };

package/dist/esm/schema/index.js

@@ -5,49 +5,62 @@ import { z } from 'zod';
 import _ from 'lodash';
 import axios from 'axios';
 import yaml from 'js-yaml';
-export const configSchema = z
-    .object({
+export const configSchema = z.object({
     port: z.number().optional(),
     endpoint: z.string().optional(),
-    block: z.union([z.string().length(66).startsWith('0x'), z.number(), z.null()]).optional(),
+    block: z.union([
+        z.string().length(66).startsWith('0x'),
+        z.number(),
+        z.null()
+    ]).optional(),
     'build-block-mode': z.nativeEnum(BuildBlockMode).optional(),
     'import-storage': z.any().optional(),
     'mock-signature-host': z.boolean().optional(),
     'max-memory-block-count': z.number().optional(),
     db: z.string().optional(),
     'wasm-override': z.string().optional(),
-    genesis: z.union([z.string(), genesisSchema]).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(),
-    resume: z.union([z.string().length(66).startsWith('0x'), z.number(), z.boolean()]).optional(),
-})
-    .strict();
+    resume: z.union([
+        z.string().length(66).startsWith('0x'),
+        z.number(),
+        z.boolean()
+    ]).optional()
+}).strict();
 const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
-export const fetchConfig = async (path) => {
+export const fetchConfig = async (path)=>{
     let file;
     if (isUrl(path)) {
-        file = await axios.get(path).then((x) => x.data);
-    }
-    else {
+        file = await axios.get(path).then((x)=>x.data);
+    } else {
         try {
             file = readFileSync(path, 'utf8');
-        }
-        catch (err) {
-            if (basename(path) === path && ['', '.yml', '.yaml', '.json'].includes(extname(path))) {
+        } catch (err) {
+            if (basename(path) === path && [
+                '',
+                '.yml',
+                '.yaml',
+                '.json'
+            ].includes(extname(path))) {
                 if (extname(path) === '') {
                     path += '.yml';
                 }
                 const url = CONFIGS_BASE_URL + path;
                 defaultLogger.info(`Loading config file ${url}`);
-                file = await axios.get(url).then((x) => x.data);
-            }
-            else {
+                file = await axios.get(url).then((x)=>x.data);
+            } else {
                 throw err;
             }
         }
     }
-    const config = yaml.load(_.template(file, { variable: 'env' })(process.env));
+    const config = yaml.load(_.template(file, {
+        variable: 'env'
+    })(process.env));
     return configSchema.parse(config);
 };