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

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

@@ -1,46 +1,51 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
-const cli_options_1 = require("../../cli-options");
-const dry_run_extrinsic_1 = require("./dry-run-extrinsic");
-const dry_run_preimage_1 = require("./dry-run-preimage");
-const cli = (y) => {
-    y.command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
-        ...cli_options_1.defaultOptions,
-        ...cli_options_1.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) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cli", {
+    enumerable: true,
+    get: function() {
+        return cli;
+    }
+});
+const _clioptions = require("../../cli-options.js");
+const _dryrunextrinsic = require("./dry-run-extrinsic.js");
+const _dryrunpreimage = require("./dry-run-preimage.js");
+const cli = (y)=>{
+    y.command('dry-run', 'Dry run an extrinsic', (yargs)=>yargs.options({
+            ..._clioptions.defaultOptions,
+            ..._clioptions.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 (0, dry_run_preimage_1.dryRunPreimage)(argv);
-        }
-        else {
-            await (0, dry_run_extrinsic_1.dryRunExtrinsic)(argv);
+            await (0, _dryrunpreimage.dryRunPreimage)(argv);
+        } else {
+            await (0, _dryrunextrinsic.dryRunExtrinsic)(argv);
         }
     });
 };
-exports.cli = cli;

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

@@ -1,33 +1,49 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dryRunExtrinsic = void 0;
-const util_crypto_1 = require("@polkadot/util-crypto");
-const node_fs_1 = require("node:fs");
-const logger_1 = require("../../logger");
-const generate_html_diff_1 = require("../../utils/generate-html-diff");
-const open_html_1 = require("../../utils/open-html");
-const context_1 = require("../../context");
-const dryRunExtrinsic = async (argv) => {
-    const context = await (0, context_1.setupContext)(argv);
-    const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dryRunExtrinsic", {
+    enumerable: true,
+    get: function() {
+        return dryRunExtrinsic;
+    }
+});
+const _utilcrypto = require("@polkadot/util-crypto");
+const _nodefs = require("node:fs");
+const _logger = require("../../logger.js");
+const _generatehtmldiff = require("../../utils/generate-html-diff.js");
+const _openhtml = require("../../utils/open-html.js");
+const _context = require("../../context.js");
+const dryRunExtrinsic = async (argv)=>{
+    const context = await (0, _context.setupContext)(argv);
+    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());
     }
-    logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+    _logger.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
     if (argv['html']) {
-        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
+        const filePath = await (0, _generatehtmldiff.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, _utilcrypto.blake2AsHex)(argv['extrinsic'], 256));
         console.log(`Generated preview ${filePath}`);
         if (argv['open']) {
-            (0, open_html_1.openHtml)(filePath);
+            (0, _openhtml.openHtml)(filePath);
         }
-    }
-    else if (argv['output-path']) {
-        (0, node_fs_1.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']) {
+        (0, _nodefs.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);
 };
-exports.dryRunExtrinsic = dryRunExtrinsic;

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

@@ -1,40 +1,61 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dryRunPreimage = void 0;
-const util_crypto_1 = require("@polkadot/util-crypto");
-const util_1 = require("@polkadot/util");
-const logger_1 = require("../../logger");
-const generate_html_diff_1 = require("../../utils/generate-html-diff");
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const open_html_1 = require("../../utils/open-html");
-const context_1 = require("../../context");
-const dryRunPreimage = async (argv) => {
-    const context = await (0, context_1.setupContext)(argv);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dryRunPreimage", {
+    enumerable: true,
+    get: function() {
+        return dryRunPreimage;
+    }
+});
+const _utilcrypto = require("@polkadot/util-crypto");
+const _util = require("@polkadot/util");
+const _logger = require("../../logger.js");
+const _generatehtmldiff = require("../../utils/generate-html-diff.js");
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _openhtml = require("../../utils/open-html.js");
+const _context = require("../../context.js");
+const dryRunPreimage = async (argv)=>{
+    const context = await (0, _context.setupContext)(argv);
     const extrinsic = argv['preimage'];
     const block = context.chain.head;
     const registry = await block.registry;
-    const header = await (0, chopsticks_core_1.newHeader)(block);
-    const data = (0, util_1.hexToU8a)(extrinsic);
-    const hash = (0, util_crypto_1.blake2AsHex)(data, 256);
-    await (0, chopsticks_core_1.setStorage)(context.chain, {
+    const header = await (0, _chopstickscore.newHeader)(block);
+    const data = (0, _util.hexToU8a)(extrinsic);
+    const hash = (0, _utilcrypto.blake2AsHex)(data, 256);
+    await (0, _chopstickscore.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',
@@ -42,55 +63,88 @@ 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', []]);
-    logger_1.defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
-    const result = await (0, chopsticks_core_1.runTask)({
+    calls.push([
+        'BlockBuilder_finalize_block',
+        []
+    ]);
+    _logger.defaultLogger.info({
+        preimage: registry.createType('Call', data).toHuman()
+    }, 'Dry run preimage');
+    const result = await (0, _chopstickscore.runTask)({
         wasm: await block.wasm,
         calls,
         mockSignatureHost: false,
         allowUnresolvedImports: false,
-        runtimeLogLevel: argv['runtime-log-level'] || 0,
-    }, (0, chopsticks_core_1.taskHandler)(block));
+        runtimeLogLevel: argv['runtime-log-level'] || 0
+    }, (0, _chopstickscore.taskHandler)(block));
     if ('Error' in result) {
         throw new Error(result.Error);
     }
-    (0, chopsticks_core_1.printRuntimeLogs)(result.Call.runtimeLogs);
-    const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, hash);
+    (0, _chopstickscore.printRuntimeLogs)(result.Call.runtimeLogs);
+    const filePath = await (0, _generatehtmldiff.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, hash);
     console.log(`Generated preview ${filePath}`);
     if (argv['open']) {
-        (0, open_html_1.openHtml)(filePath);
+        (0, _openhtml.openHtml)(filePath);
     }
     // if dry-run preimage has extrinsic arguments then dry-run extrinsic
-    // this is usefull to test something after preimage is applied
+    // this is useful 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());
         }
-        logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
-        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
+        _logger.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+        const filePath = await (0, _generatehtmldiff.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, _utilcrypto.blake2AsHex)(argv['extrinsic'], 256));
         console.log(`Generated preview ${filePath}`);
         if (argv['open']) {
-            (0, open_html_1.openHtml)(filePath);
+            (0, _openhtml.openHtml)(filePath);
         }
     }
     process.exit(0);
 };
-exports.dryRunPreimage = dryRunPreimage;

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

@@ -1,18 +1,19 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./cli"), exports);
-__exportStar(require("./rpc"), exports);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./cli.js"), exports);
+_export_star(require("./rpc.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -1,79 +1,54 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = exports.name = void 0;
-const zod_1 = require("zod");
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const decoder_1 = require("../../utils/decoder");
-const generate_html_diff_1 = require("../../utils/generate-html-diff");
-const zHex = zod_1.z.custom((val) => /^0x\w+$/.test(val));
-const zHash = zod_1.z.string().length(66).and(zHex);
-const zParaId = zod_1.z.string().regex(/^\d+$/).transform(Number);
-const schema = zod_1.z.object({
-    raw: zod_1.z.boolean().optional(),
-    html: zod_1.z.boolean().optional(),
-    extrinsic: zHex
-        .or(zod_1.z.object({
-        call: zHex,
-        address: zHex,
-    }))
-        .optional(),
-    hrmp: zod_1.z
-        .record(zParaId, zod_1.z
-        .array(zod_1.z.object({
-        sentAt: zod_1.z.number(),
-        data: zHex,
-    }))
-        .min(1))
-        .optional(),
-    dmp: zod_1.z
-        .array(zod_1.z.object({
-        sentAt: zod_1.z.number(),
-        msg: zHex,
-    }))
-        .min(1)
-        .optional(),
-    ump: zod_1.z.record(zParaId, zod_1.z.array(zHex).min(1)).optional(),
-    at: zHash.optional(),
+Object.defineProperty(exports, "__esModule", {
+    value: true
 });
-// custom rpc name (optional). e.g. dryRun will be called as dev_dryRun
-exports.name = 'dryRun';
-/**
- * Dry run an extrinsic or messages.
- * If `html` is true, return the generated storage diff html string.
- * If `raw` is true, return the raw storage diff.
- * Otherwise, return `{ oldState, newState, delta }`.
- *
- * This function is a dev rpc handler. Use `dev_dryRun` 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 Dry run an dmp
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * const params = [
-    {
-      raw: false,
-      dmp: [
-        // https://acala.subscan.io/xcm_message/polkadot-2ab22918c567455af3563989d852f307f4cc1250
-        {
-          sentAt: 14471353,
-          msg: '0x02100104000100000b00280b9bba030a13000100000b00280b9bba03010300286bee0d0100040001010070c53d8e216f9c0f2e3b11c53f5f4bf3e078b995d5f0ed590f889f41e20e6531',
-        },
-      ],
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    name: function() {
+        return name;
     },
-  ]
- * await ws.send('dev_dryRun', params)
- * ```
- */
-const rpc = async (context, [params]) => {
+    rpc: function() {
+        return rpc;
+    }
+});
+const _zod = require("zod");
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _decoder = require("../../utils/decoder.js");
+const _generatehtmldiff = require("../../utils/generate-html-diff.js");
+const zHex = _zod.z.custom((val)=>/^0x\w+$/.test(val));
+const zHash = _zod.z.string().length(66).and(zHex);
+const zParaId = _zod.z.string().regex(/^\d+$/).transform(Number);
+const schema = _zod.z.object({
+    raw: _zod.z.boolean().optional(),
+    html: _zod.z.boolean().optional(),
+    extrinsic: zHex.or(_zod.z.object({
+        call: zHex,
+        address: zHex
+    })).optional(),
+    hrmp: _zod.z.record(zParaId, _zod.z.array(_zod.z.object({
+        sentAt: _zod.z.number(),
+        data: zHex
+    })).min(1)).optional(),
+    dmp: _zod.z.array(_zod.z.object({
+        sentAt: _zod.z.number(),
+        msg: zHex
+    })).min(1).optional(),
+    ump: _zod.z.record(zParaId, _zod.z.array(zHex).min(1)).optional(),
+    at: zHash.optional()
+});
+const name = 'dryRun';
+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) {
-                throw new chopsticks_core_1.ResponseError(1, outcome.asErr.toString());
+                throw new _chopstickscore.ResponseError(1, outcome.asErr.toString());
             }
             return storageDiff;
         }
@@ -86,20 +61,19 @@ const rpc = async (context, [params]) => {
         if (ump) {
             return context.chain.dryRunUmp(ump, at);
         }
-        throw new chopsticks_core_1.ResponseError(1, 'No extrinsic to run');
+        throw new _chopstickscore.ResponseError(1, 'No extrinsic to run');
     };
     const storageDiff = await dryRun();
     if (html) {
-        return (0, generate_html_diff_1.generateHtmlDiff)(context.chain.head, storageDiff);
+        return (0, _generatehtmldiff.generateHtmlDiff)(context.chain.head, storageDiff);
     }
     if (raw) {
         return storageDiff;
     }
-    const { oldState, newState, delta } = await (0, decoder_1.decodeStorageDiff)(context.chain.head, storageDiff);
+    const { oldState, newState, delta } = await (0, _decoder.decodeStorageDiff)(context.chain.head, storageDiff);
     return {
         old: oldState,
         new: newState,
-        delta,
+        delta
     };
 };
-exports.rpc = rpc;