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

package/dist/esm/context.js

@@ -3,13 +3,14 @@ import { GenesisProvider, defaultLogger, isUrl, setup, timeTravel } from '@acala
 import { SqliteDatabase } from '@acala-network/chopsticks-db';
 import { overrideStorage, overrideWasm } from './utils/override';
 import axios from 'axios';
-const logger = defaultLogger.child({ name: 'setup-context' });
-export const genesisFromUrl = async (url) => {
-    const getFile = async (url) => {
+const logger = defaultLogger.child({
+    name: 'setup-context'
+});
+export const genesisFromUrl = async (url)=>{
+    const getFile = async (url)=>{
         if (isUrl(url)) {
-            return axios.get(url).then((x) => x.data);
-        }
-        else if (typeof process === 'object') {
+            return axios.get(url).then((x)=>x.data);
+        } else if (typeof process === 'object') {
             const { lstatSync, readFileSync } = await import('node:fs');
             if (lstatSync(url).isFile()) {
                 return JSON.parse(String(readFileSync(url)));
@@ -19,13 +20,12 @@ export const genesisFromUrl = async (url) => {
     };
     return new GenesisProvider(await getFile(url));
 };
-export const setupContext = async (argv, overrideParent = false) => {
+export const setupContext = async (argv, overrideParent = false)=>{
     let genesis;
     if (argv.genesis) {
         if (typeof argv.genesis === 'string') {
             genesis = await genesisFromUrl(argv.genesis);
-        }
-        else {
+        } else {
             genesis = new GenesisProvider(argv.genesis);
         }
     }
@@ -40,7 +40,7 @@ export const setupContext = async (argv, overrideParent = false) => {
         runtimeLogLevel: argv['runtime-log-level'],
         registeredTypes: argv['registered-types'],
         offchainWorker: argv['offchain-worker'],
-        maxMemoryBlockCount: argv['max-memory-block-count'],
+        maxMemoryBlockCount: argv['max-memory-block-count']
     });
     // load block from db
     if (chain.db) {
@@ -48,39 +48,35 @@ export const setupContext = async (argv, overrideParent = false) => {
             let blockData = null;
             if (typeof argv.resume === 'string' && argv.resume.startsWith('0x')) {
                 blockData = await chain.db.queryBlock(argv.resume);
-            }
-            else if (typeof argv.resume === 'boolean' || argv.resume === 'true') {
+            } else if (typeof argv.resume === 'boolean' || argv.resume === 'true') {
                 blockData = await chain.db.queryHighestBlock();
-            }
-            else if (Number.isInteger(+argv.resume)) {
+            } else if (Number.isInteger(+argv.resume)) {
                 blockData = await chain.db.queryBlockByNumber(+argv.resume);
-            }
-            else {
+            } else {
                 throw new Error(`Resume failed. Invalid resume option ${argv.resume}`);
             }
             if (blockData) {
                 const block = await chain.loadBlockFromDB(blockData.number);
-                block && (await chain.setHead(block));
+                block && await chain.setHead(block);
                 logger.info(`Resume from block ${blockData.number}, hash: ${blockData.hash}`);
-            }
-            else {
+            } else {
                 throw new Error(`Resume failed. Cannot find block ${argv.resume}`);
             }
         }
     }
-    if (argv.timestamp)
-        await timeTravel(chain, argv.timestamp);
+    if (argv.timestamp) await timeTravel(chain, argv.timestamp);
     let at;
     if (overrideParent) {
         // in case of run block we need to apply wasm-override and import-storage to parent block
         const block = await chain.head.parentBlock;
-        if (!block)
-            throw new Error('Cannot find parent block');
+        if (!block) throw new Error('Cannot find parent block');
         at = block.hash;
     }
     // override wasm before importing storage, in case new pallets have been
     // added that have storage imports
     await overrideWasm(chain, argv['wasm-override'], at);
     await overrideStorage(chain, argv['import-storage'], at);
-    return { chain };
+    return {
+        chain
+    };
 };

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

@@ -1,21 +1,18 @@
 import { decodeKey } from '@acala-network/chopsticks-core';
 import { defaultOptions } from '../../cli-options';
 import { setupContext } from '../../context';
-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) => {
+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(`${storage.section}.${storage.method}`, decodedKey.args.map((x)=>JSON.stringify(x.toHuman())).join(', '));
+        } else {
             console.log('Unknown');
         }
         process.exit(0);

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

@@ -1,41 +1,40 @@
 import { defaultOptions, mockOptions } from '../../cli-options';
 import { dryRunExtrinsic } from './dry-run-extrinsic';
 import { dryRunPreimage } from './dry-run-preimage';
-export const cli = (y) => {
-    y.command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
-        ...defaultOptions,
-        ...mockOptions,
-        extrinsic: {
-            desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
-            string: true,
-        },
-        address: {
-            desc: 'Address to fake sign extrinsic',
-            string: true,
-        },
-        preimage: {
-            desc: 'Preimage to dry run',
-            string: true,
-        },
-        at: {
-            desc: 'Block hash to dry run',
-            string: true,
-        },
-        'output-path': {
-            desc: 'File path to print output',
-            string: true,
-        },
-        html: {
-            desc: 'Generate html with storage diff',
-        },
-        open: {
-            desc: 'Open generated html',
-        },
-    }), async (argv) => {
+export const cli = (y)=>{
+    y.command('dry-run', 'Dry run an extrinsic', (yargs)=>yargs.options({
+            ...defaultOptions,
+            ...mockOptions,
+            extrinsic: {
+                desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
+                string: true
+            },
+            address: {
+                desc: 'Address to fake sign extrinsic',
+                string: true
+            },
+            preimage: {
+                desc: 'Preimage to dry run',
+                string: true
+            },
+            at: {
+                desc: 'Block hash to dry run',
+                string: true
+            },
+            'output-path': {
+                desc: 'File path to print output',
+                string: true
+            },
+            html: {
+                desc: 'Generate html with storage diff'
+            },
+            open: {
+                desc: 'Open generated html'
+            }
+        }), async (argv)=>{
         if (argv.preimage) {
             await dryRunPreimage(argv);
-        }
-        else {
+        } else {
             await dryRunExtrinsic(argv);
         }
     });

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

@@ -4,9 +4,12 @@ import { defaultLogger } from '../../logger';
 import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
 import { openHtml } from '../../utils/open-html';
 import { setupContext } from '../../context';
-export const dryRunExtrinsic = async (argv) => {
+export const dryRunExtrinsic = async (argv)=>{
     const context = await setupContext(argv);
-    const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+    const input = argv['address'] ? {
+        call: argv['extrinsic'],
+        address: argv['address']
+    } : argv['extrinsic'];
     const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input, argv['at']);
     if (outcome.isErr) {
         throw new Error(outcome.asErr.toString());
@@ -18,12 +21,19 @@ export const dryRunExtrinsic = async (argv) => {
         if (argv['open']) {
             openHtml(filePath);
         }
-    }
-    else if (argv['output-path']) {
-        writeFileSync(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
-    }
-    else {
-        console.dir({ outcome: outcome.toHuman(), storageDiff }, { depth: null, colors: false });
+    } else if (argv['output-path']) {
+        writeFileSync(argv['output-path'], JSON.stringify({
+            outcome: outcome.toHuman(),
+            storageDiff
+        }, null, 2));
+    } else {
+        console.dir({
+            outcome: outcome.toHuman(),
+            storageDiff
+        }, {
+            depth: null,
+            colors: false
+        });
     }
     process.exit(0);
 };

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

@@ -5,7 +5,7 @@ import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
 import { newHeader, printRuntimeLogs, runTask, setStorage, taskHandler } from '@acala-network/chopsticks-core';
 import { openHtml } from '../../utils/open-html';
 import { setupContext } from '../../context';
-export const dryRunPreimage = async (argv) => {
+export const dryRunPreimage = async (argv)=>{
     const context = await setupContext(argv);
     const extrinsic = argv['preimage'];
     const block = context.chain.head;
@@ -15,23 +15,37 @@ export const dryRunPreimage = async (argv) => {
     const hash = blake2AsHex(data, 256);
     await setStorage(context.chain, {
         Preimage: {
-            PreimageFor: [[[[hash, data.byteLength]], extrinsic]],
+            PreimageFor: [
+                [
+                    [
+                        [
+                            hash,
+                            data.byteLength
+                        ]
+                    ],
+                    extrinsic
+                ]
+            ],
             StatusFor: [
                 [
-                    [hash],
+                    [
+                        hash
+                    ],
                     {
                         Requested: {
                             count: 1,
-                            len: data.byteLength,
-                        },
-                    },
-                ],
-            ],
+                            len: data.byteLength
+                        }
+                    }
+                ]
+            ]
         },
         Scheduler: {
             Agenda: [
                 [
-                    [block.number + 1],
+                    [
+                        block.number + 1
+                    ],
                     [
                         {
                             maybeId: '0x64656d6f637261633a0000000000000000000000000000000000000000000000',
@@ -39,29 +53,60 @@ export const dryRunPreimage = async (argv) => {
                             call: {
                                 Lookup: {
                                     hash: hash,
-                                    len: data.byteLength,
-                                },
+                                    len: data.byteLength
+                                }
                             },
-                            origin: { system: { Root: null } },
-                        },
-                    ],
-                ],
+                            origin: {
+                                system: {
+                                    Root: null
+                                }
+                            }
+                        }
+                    ]
+                ]
             ],
-            Lookup: [[['0x64656d6f637261633a0000000000000000000000000000000000000000000000'], [block.number + 1, 0]]],
-        },
+            Lookup: [
+                [
+                    [
+                        '0x64656d6f637261633a0000000000000000000000000000000000000000000000'
+                    ],
+                    [
+                        block.number + 1,
+                        0
+                    ]
+                ]
+            ]
+        }
     });
-    const calls = [['Core_initialize_block', [header.toHex()]]];
-    for (const inherent of await block.chain.getInherents()) {
-        calls.push(['BlockBuilder_apply_extrinsic', [inherent]]);
+    const calls = [
+        [
+            'Core_initialize_block',
+            [
+                header.toHex()
+            ]
+        ]
+    ];
+    for (const inherent of (await block.chain.getInherents())){
+        calls.push([
+            'BlockBuilder_apply_extrinsic',
+            [
+                inherent
+            ]
+        ]);
     }
-    calls.push(['BlockBuilder_finalize_block', []]);
-    defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
+    calls.push([
+        'BlockBuilder_finalize_block',
+        []
+    ]);
+    defaultLogger.info({
+        preimage: registry.createType('Call', data).toHuman()
+    }, 'Dry run preimage');
     const result = await runTask({
         wasm: await block.wasm,
         calls,
         mockSignatureHost: false,
         allowUnresolvedImports: false,
-        runtimeLogLevel: argv['runtime-log-level'] || 0,
+        runtimeLogLevel: argv['runtime-log-level'] || 0
     }, taskHandler(block));
     if ('Error' in result) {
         throw new Error(result.Error);
@@ -76,7 +121,10 @@ export const dryRunPreimage = async (argv) => {
     // this is usefull to test something after preimage is applied
     if (argv['extrinsic']) {
         await context.chain.newBlock();
-        const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+        const input = argv['address'] ? {
+            call: argv['extrinsic'],
+            address: argv['address']
+        } : argv['extrinsic'];
         const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input);
         if (outcome.isErr) {
             throw new Error(outcome.asErr.toString());

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

@@ -2,35 +2,26 @@ import { z } from 'zod';
 import { ResponseError } from '@acala-network/chopsticks-core';
 import { decodeStorageDiff } from '../../utils/decoder';
 import { generateHtmlDiff } from '../../utils/generate-html-diff';
-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 zParaId = z.string().regex(/^\d+$/).transform(Number);
 const schema = z.object({
     raw: z.boolean().optional(),
     html: z.boolean().optional(),
-    extrinsic: zHex
-        .or(z.object({
+    extrinsic: zHex.or(z.object({
         call: zHex,
-        address: zHex,
-    }))
-        .optional(),
-    hrmp: z
-        .record(zParaId, z
-        .array(z.object({
+        address: zHex
+    })).optional(),
+    hrmp: z.record(zParaId, z.array(z.object({
         sentAt: z.number(),
-        data: zHex,
-    }))
-        .min(1))
-        .optional(),
-    dmp: z
-        .array(z.object({
+        data: zHex
+    })).min(1)).optional(),
+    dmp: z.array(z.object({
         sentAt: z.number(),
-        msg: zHex,
-    }))
-        .min(1)
-        .optional(),
+        msg: zHex
+    })).min(1).optional(),
     ump: z.record(zParaId, z.array(zHex).min(1)).optional(),
-    at: zHash.optional(),
+    at: zHash.optional()
 });
 // custom rpc name (optional). e.g. dryRun will be called as dev_dryRun
 export const name = 'dryRun';
@@ -63,10 +54,9 @@ export const name = 'dryRun';
   ]
  * await ws.send('dev_dryRun', params)
  * ```
- */
-export const rpc = async (context, [params]) => {
+ */ export const rpc = async (context, [params])=>{
     const { html, extrinsic, hrmp, dmp, ump, raw, at } = schema.parse(params);
-    const dryRun = async () => {
+    const dryRun = async ()=>{
         if (extrinsic) {
             const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(extrinsic, at);
             if (outcome.isErr) {
@@ -96,6 +86,6 @@ export const rpc = async (context, [params]) => {
     return {
         old: oldState,
         new: newState,
-        delta,
+        delta
     };
 };

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

@@ -4,21 +4,31 @@ import { createServer } from '../../server';
 import { defaultOptions } from '../../cli-options';
 import { handler } from '../../rpc';
 import { setupContext } from '../../context';
-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 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 || '')) {
@@ -28,37 +38,51 @@ export const cli = (y) => {
         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) => {
+        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`);
+                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}`);
+                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]]);
+                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);
                 }
                 printRuntimeLogs(result.Call.runtimeLogs);
-            }
-            catch (e) {
+            } catch (e) {
                 logger.error(e, 'Error when processing new head');
                 await close();
                 process.exit(1);

package/dist/esm/plugins/index.js

@@ -1,6 +1,8 @@
 import _ from 'lodash';
 import { defaultLogger } from '../logger';
-const logger = defaultLogger.child({ name: 'plugin' });
+const logger = defaultLogger.child({
+    name: 'plugin'
+});
 export const pluginHandlers = {};
 const plugins = [
     'decode-key',
@@ -13,10 +15,10 @@ const plugins = [
     'set-runtime-log-level',
     'set-storage',
     'time-travel',
-    'try-runtime',
+    'try-runtime'
 ];
-(async () => {
-    for (const plugin of plugins) {
+(async ()=>{
+    for (const plugin of plugins){
         const { rpc, name } = await import(`./${plugin}`);
         if (rpc) {
             const methodName = name || _.camelCase(plugin);
@@ -25,8 +27,8 @@ const plugins = [
         }
     }
 })();
-export const pluginExtendCli = async (y) => {
-    for (const plugin of plugins) {
+export const pluginExtendCli = async (y)=>{
+    for (const plugin of plugins){
         const { cli } = await import(`./${plugin}`);
         if (cli) {
             cli(y);

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

@@ -37,8 +37,7 @@ import { defaultLogger } from '../../logger';
  * // 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) => {
+ */ export const rpc = async (context, params)=>{
     const [param] = params;
     const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
     const now = context.chain.head.number;
@@ -48,19 +47,19 @@ export const rpc = async (context, params) => {
     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({
+    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) => {
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+        }).catch((error)=>{
             throw new ResponseError(1, error.toString());
         });
-        defaultLogger.debug({ hash: block.hash }, 'dev_newBlock');
+        defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
         finalHash = block.hash;
     }
     return finalHash;