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

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

@@ -1,58 +1,67 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
-const node_fs_1 = require("node:fs");
-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('try-runtime', 'Runs runtime upgrade', (yargs) => yargs.options({
-        ...cli_options_1.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 (0, context_1.setupContext)(argv);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cli", {
+    enumerable: true,
+    get: function() {
+        return cli;
+    }
+});
+const _nodefs = require("node:fs");
+const _clioptions = require("../../cli-options");
+const _generatehtmldiff = require("../../utils/generate-html-diff");
+const _openhtml = require("../../utils/open-html");
+const _context = require("../../context");
+const cli = (y)=>{
+    y.command('try-runtime', 'Runs runtime upgrade', (yargs)=>yargs.options({
+            ..._clioptions.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 (0, _context.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 (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.storageDiff, block.hash);
+            const filePath = await (0, _generatehtmldiff.generateHtmlDiffPreviewFile)(block, result.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;

package/dist/cjs/plugins/types.js

@@ -1,19 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runBlock = exports.timeTravel = exports.setStorage = exports.setRuntimeLogLevel = exports.setHead = exports.setBlockBuildMode = exports.dryRun = exports.newBlock = void 0;
-var new_block_1 = require("./new-block");
-Object.defineProperty(exports, "newBlock", { enumerable: true, get: function () { return new_block_1.rpc; } });
-var dry_run_1 = require("./dry-run");
-Object.defineProperty(exports, "dryRun", { enumerable: true, get: function () { return dry_run_1.rpc; } });
-var set_block_build_mode_1 = require("./set-block-build-mode");
-Object.defineProperty(exports, "setBlockBuildMode", { enumerable: true, get: function () { return set_block_build_mode_1.rpc; } });
-var set_head_1 = require("./set-head");
-Object.defineProperty(exports, "setHead", { enumerable: true, get: function () { return set_head_1.rpc; } });
-var set_runtime_log_level_1 = require("./set-runtime-log-level");
-Object.defineProperty(exports, "setRuntimeLogLevel", { enumerable: true, get: function () { return set_runtime_log_level_1.rpc; } });
-var set_storage_1 = require("./set-storage");
-Object.defineProperty(exports, "setStorage", { enumerable: true, get: function () { return set_storage_1.rpc; } });
-var time_travel_1 = require("./time-travel");
-Object.defineProperty(exports, "timeTravel", { enumerable: true, get: function () { return time_travel_1.rpc; } });
-var run_block_1 = require("./run-block");
-Object.defineProperty(exports, "runBlock", { enumerable: true, get: function () { return run_block_1.rpc; } });
+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, {
+    dryRun: function() {
+        return _dryrun.rpc;
+    },
+    newBlock: function() {
+        return _newblock.rpc;
+    },
+    runBlock: function() {
+        return _runblock.rpc;
+    },
+    setBlockBuildMode: function() {
+        return _setblockbuildmode.rpc;
+    },
+    setHead: function() {
+        return _sethead.rpc;
+    },
+    setRuntimeLogLevel: function() {
+        return _setruntimeloglevel.rpc;
+    },
+    setStorage: function() {
+        return _setstorage.rpc;
+    },
+    timeTravel: function() {
+        return _timetravel.rpc;
+    }
+});
+const _newblock = require("./new-block");
+const _dryrun = require("./dry-run");
+const _setblockbuildmode = require("./set-block-build-mode");
+const _sethead = require("./set-head");
+const _setruntimeloglevel = require("./set-runtime-log-level");
+const _setstorage = require("./set-storage");
+const _timetravel = require("./time-travel");
+const _runblock = require("./run-block");

package/dist/cjs/rpc/index.js

@@ -1,30 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const plugins_1 = require("../plugins");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "handler", {
+    enumerable: true,
+    get: function() {
+        return handler;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _plugins = require("../plugins");
 const allHandlers = {
-    ...chopsticks_core_1.substrate,
-    rpc_methods: async () => Promise.resolve({
-        version: 1,
-        methods: [...Object.keys(allHandlers), ...Object.keys(plugins_1.pluginHandlers)],
-    }),
+    ..._chopstickscore.substrate,
+    rpc_methods: async ()=>Promise.resolve({
+            version: 1,
+            methods: [
+                ...Object.keys(allHandlers),
+                ...Object.keys(_plugins.pluginHandlers)
+            ]
+        })
 };
-const getHandler = (method) => {
+const getHandler = (method)=>{
     const handler = allHandlers[method];
     if (!handler) {
         // no handler for this method, check if it's a plugin
-        return plugins_1.pluginHandlers[method];
+        return _plugins.pluginHandlers[method];
     }
     return handler;
 };
-const handler = (context) => ({ method, params }, subscriptionManager) => {
-    chopsticks_core_1.logger.trace('Handling %s', method);
-    const handler = getHandler(method);
-    if (!handler) {
-        chopsticks_core_1.logger.warn('Method not found %s', method);
-        throw new chopsticks_core_1.ResponseError(-32601, `Method not found: ${method}`);
-    }
-    return handler(context, params, subscriptionManager);
-};
-exports.handler = handler;
+const handler = (context)=>({ method, params }, subscriptionManager)=>{
+        _chopstickscore.logger.trace('Handling %s', method);
+        const handler = getHandler(method);
+        if (!handler) {
+            _chopstickscore.logger.warn('Method not found %s', method);
+            throw new _chopstickscore.ResponseError(-32601, `Method not found: ${method}`);
+        }
+        return handler(context, params, subscriptionManager);
+    };

package/dist/cjs/schema/index.js

@@ -1,60 +1,89 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchConfig = exports.configSchema = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const node_path_1 = require("node:path");
-const node_fs_1 = require("node:fs");
-const zod_1 = require("zod");
-const lodash_1 = __importDefault(require("lodash"));
-const axios_1 = __importDefault(require("axios"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-exports.configSchema = zod_1.z
-    .object({
-    port: zod_1.z.number().optional(),
-    endpoint: zod_1.z.string().optional(),
-    block: zod_1.z.union([zod_1.z.string().length(66).startsWith('0x'), zod_1.z.number(), zod_1.z.null()]).optional(),
-    'build-block-mode': zod_1.z.nativeEnum(chopsticks_core_1.BuildBlockMode).optional(),
-    'import-storage': zod_1.z.any().optional(),
-    'mock-signature-host': zod_1.z.boolean().optional(),
-    'max-memory-block-count': zod_1.z.number().optional(),
-    db: zod_1.z.string().optional(),
-    'wasm-override': zod_1.z.string().optional(),
-    genesis: zod_1.z.union([zod_1.z.string(), chopsticks_core_1.genesisSchema]).optional(),
-    timestamp: zod_1.z.number().optional(),
-    'registered-types': zod_1.z.any().optional(),
-    'runtime-log-level': zod_1.z.number().min(0).max(5).optional(),
-    'offchain-worker': zod_1.z.boolean().optional(),
-    resume: zod_1.z.union([zod_1.z.string().length(66).startsWith('0x'), zod_1.z.number(), zod_1.z.boolean()]).optional(),
-})
-    .strict();
+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, {
+    configSchema: function() {
+        return configSchema;
+    },
+    fetchConfig: function() {
+        return fetchConfig;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _nodepath = require("node:path");
+const _nodefs = require("node:fs");
+const _zod = require("zod");
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _axios = /*#__PURE__*/ _interop_require_default(require("axios"));
+const _jsyaml = /*#__PURE__*/ _interop_require_default(require("js-yaml"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const configSchema = _zod.z.object({
+    port: _zod.z.number().optional(),
+    endpoint: _zod.z.string().optional(),
+    block: _zod.z.union([
+        _zod.z.string().length(66).startsWith('0x'),
+        _zod.z.number(),
+        _zod.z.null()
+    ]).optional(),
+    'build-block-mode': _zod.z.nativeEnum(_chopstickscore.BuildBlockMode).optional(),
+    'import-storage': _zod.z.any().optional(),
+    'mock-signature-host': _zod.z.boolean().optional(),
+    'max-memory-block-count': _zod.z.number().optional(),
+    db: _zod.z.string().optional(),
+    'wasm-override': _zod.z.string().optional(),
+    genesis: _zod.z.union([
+        _zod.z.string(),
+        _chopstickscore.genesisSchema
+    ]).optional(),
+    timestamp: _zod.z.number().optional(),
+    'registered-types': _zod.z.any().optional(),
+    'runtime-log-level': _zod.z.number().min(0).max(5).optional(),
+    'offchain-worker': _zod.z.boolean().optional(),
+    resume: _zod.z.union([
+        _zod.z.string().length(66).startsWith('0x'),
+        _zod.z.number(),
+        _zod.z.boolean()
+    ]).optional()
+}).strict();
 const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
-const fetchConfig = async (path) => {
+const fetchConfig = async (path)=>{
     let file;
-    if ((0, chopsticks_core_1.isUrl)(path)) {
-        file = await axios_1.default.get(path).then((x) => x.data);
-    }
-    else {
+    if ((0, _chopstickscore.isUrl)(path)) {
+        file = await _axios.default.get(path).then((x)=>x.data);
+    } else {
         try {
-            file = (0, node_fs_1.readFileSync)(path, 'utf8');
-        }
-        catch (err) {
-            if ((0, node_path_1.basename)(path) === path && ['', '.yml', '.yaml', '.json'].includes((0, node_path_1.extname)(path))) {
-                if ((0, node_path_1.extname)(path) === '') {
+            file = (0, _nodefs.readFileSync)(path, 'utf8');
+        } catch (err) {
+            if ((0, _nodepath.basename)(path) === path && [
+                '',
+                '.yml',
+                '.yaml',
+                '.json'
+            ].includes((0, _nodepath.extname)(path))) {
+                if ((0, _nodepath.extname)(path) === '') {
                     path += '.yml';
                 }
                 const url = CONFIGS_BASE_URL + path;
-                chopsticks_core_1.defaultLogger.info(`Loading config file ${url}`);
-                file = await axios_1.default.get(url).then((x) => x.data);
-            }
-            else {
+                _chopstickscore.defaultLogger.info(`Loading config file ${url}`);
+                file = await _axios.default.get(url).then((x)=>x.data);
+            } else {
                 throw err;
             }
         }
     }
-    const config = js_yaml_1.default.load(lodash_1.default.template(file, { variable: 'env' })(process.env));
-    return exports.configSchema.parse(config);
+    const config = _jsyaml.default.load(_lodash.default.template(file, {
+        variable: 'env'
+    })(process.env));
+    return configSchema.parse(config);
 };
-exports.fetchConfig = fetchConfig;

package/dist/cjs/server.js

@@ -1,43 +1,60 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServer = void 0;
-const ws_1 = require("ws");
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const zod_1 = require("zod");
-const logger_1 = require("./logger");
-const logger = logger_1.defaultLogger.child({ name: 'ws' });
-const singleRequest = zod_1.z.object({
-    id: zod_1.z.number(),
-    jsonrpc: zod_1.z.literal('2.0'),
-    method: zod_1.z.string(),
-    params: zod_1.z.array(zod_1.z.any()).default([]),
+Object.defineProperty(exports, "__esModule", {
+    value: true
 });
-const batchRequest = zod_1.z.array(singleRequest);
-const requestSchema = zod_1.z.union([singleRequest, batchRequest]);
-const parseRequest = (request) => {
+Object.defineProperty(exports, "createServer", {
+    enumerable: true,
+    get: function() {
+        return createServer;
+    }
+});
+const _ws = require("ws");
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _zod = require("zod");
+const _logger = require("./logger");
+const logger = _logger.defaultLogger.child({
+    name: 'ws'
+});
+const singleRequest = _zod.z.object({
+    id: _zod.z.number(),
+    jsonrpc: _zod.z.literal('2.0'),
+    method: _zod.z.string(),
+    params: _zod.z.array(_zod.z.any()).default([])
+});
+const batchRequest = _zod.z.array(singleRequest);
+const requestSchema = _zod.z.union([
+    singleRequest,
+    batchRequest
+]);
+const parseRequest = (request)=>{
     try {
         return JSON.parse(request);
-    }
-    catch (e) {
+    } catch (e) {
         return undefined;
     }
 };
-const createWS = async (port) => {
-    const wss = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
-    const promise = new Promise((resolve) => {
-        wss.on('listening', () => {
-            resolve([wss, wss.address().port]);
+const createWS = async (port)=>{
+    const wss = new _ws.WebSocketServer({
+        port,
+        maxPayload: 1024 * 1024 * 100
+    });
+    const promise = new Promise((resolve)=>{
+        wss.on('listening', ()=>{
+            resolve([
+                wss,
+                wss.address().port
+            ]);
         });
-        wss.on('error', (_) => {
+        wss.on('error', (_)=>{
             resolve([]);
         });
     });
     return promise;
 };
-const createServer = async (handler, port) => {
+const createServer = async (handler, port)=>{
     let wss;
     let listenPort;
-    for (let i = 0; i < 10; i++) {
+    for(let i = 0; i < 10; i++){
         const preferPort = (port ?? 0) > 0 ? (port ?? 0) + i : 0;
         logger.debug('Try starting on port %d', preferPort);
         const [maybeWss, maybeListenPort] = await createWS(preferPort);
@@ -50,80 +67,86 @@ const createServer = async (handler, port) => {
     if (!wss || !listenPort) {
         throw new Error(`Failed to create WebsocketServer at port ${port}`);
     }
-    wss.on('connection', (ws) => {
+    wss.on('connection', (ws)=>{
         logger.debug('New connection');
-        const send = (data) => {
-            if (ws.readyState === ws_1.WebSocket.OPEN) {
+        const send = (data)=>{
+            if (ws.readyState === _ws.WebSocket.OPEN) {
                 ws.send(JSON.stringify(data));
             }
         };
         const subscriptions = {};
         const subscriptionManager = {
-            subscribe: (method, subid, onCancel = () => { }) => {
+            subscribe: (method, subid, onCancel = ()=>{})=>{
                 subscriptions[subid] = onCancel;
-                return (data) => {
+                return (data)=>{
                     if (subscriptions[subid]) {
-                        logger.trace({ method, subid, data: (0, logger_1.truncate)(data) }, 'Subscription notification');
+                        logger.trace({
+                            method,
+                            subid,
+                            data: (0, _logger.truncate)(data)
+                        }, 'Subscription notification');
                         send({
                             jsonrpc: '2.0',
                             method,
                             params: {
                                 result: data,
-                                subscription: subid,
-                            },
+                                subscription: subid
+                            }
                         });
                     }
                 };
             },
-            unsubscribe: (subid) => {
+            unsubscribe: (subid)=>{
                 if (subscriptions[subid]) {
                     subscriptions[subid](subid);
                     delete subscriptions[subid];
                 }
-            },
+            }
         };
-        const processRequest = async (req) => {
+        const processRequest = async (req)=>{
             logger.trace({
                 id: req.id,
-                method: req.method,
+                method: req.method
             }, 'Received message');
             try {
                 const resp = await handler(req, subscriptionManager);
                 logger.trace({
                     id: req.id,
                     method: req.method,
-                    result: (0, logger_1.truncate)(resp),
+                    result: (0, _logger.truncate)(resp)
                 }, 'Response for request');
                 return {
                     id: req.id,
                     jsonrpc: '2.0',
-                    result: resp ?? null,
+                    result: resp ?? null
                 };
-            }
-            catch (e) {
+            } catch (e) {
                 logger.info('Error handling request: %s %o', e, e.stack);
                 return {
                     id: req.id,
                     jsonrpc: '2.0',
-                    error: e instanceof chopsticks_core_1.ResponseError ? e : { code: -32603, message: `Internal ${e}` },
+                    error: e instanceof _chopstickscore.ResponseError ? e : {
+                        code: -32603,
+                        message: `Internal ${e}`
+                    }
                 };
             }
         };
-        ws.on('close', () => {
+        ws.on('close', ()=>{
             logger.debug('Connection closed');
-            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+            for (const [subid, onCancel] of Object.entries(subscriptions)){
                 onCancel(subid);
             }
             ws.removeAllListeners();
         });
-        ws.on('error', () => {
+        ws.on('error', ()=>{
             logger.debug('Connection error');
-            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+            for (const [subid, onCancel] of Object.entries(subscriptions)){
                 onCancel(subid);
             }
             ws.removeAllListeners();
         });
-        ws.on('message', async (message) => {
+        ws.on('message', async (message)=>{
             const parsed = await requestSchema.safeParseAsync(parseRequest(message.toString()));
             if (!parsed.success) {
                 logger.info('Invalid request: %s', message);
@@ -132,19 +155,22 @@ const createServer = async (handler, port) => {
                     jsonrpc: '2.0',
                     error: {
                         code: -32600,
-                        message: 'Invalid JSON Request',
-                    },
+                        message: 'Invalid JSON Request'
+                    }
                 });
                 return;
             }
             const { data: req } = parsed;
             if (Array.isArray(req)) {
-                logger.trace({ req }, 'Received batch request');
+                logger.trace({
+                    req
+                }, 'Received batch request');
                 const resp = await Promise.all(req.map(processRequest));
                 send(resp);
-            }
-            else {
-                logger.trace({ req }, 'Received single request');
+            } else {
+                logger.trace({
+                    req
+                }, 'Received single request');
                 const resp = await processRequest(req);
                 send(resp);
             }
@@ -152,17 +178,15 @@ const createServer = async (handler, port) => {
     });
     return {
         port: listenPort,
-        close: () => new Promise((resolve, reject) => {
-            wss?.clients.forEach((socket) => socket.close());
-            wss?.close((err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        }),
+        close: ()=>new Promise((resolve, reject)=>{
+                wss?.clients.forEach((socket)=>socket.close());
+                wss?.close((err)=>{
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve();
+                    }
+                });
+            })
     };
 };
-exports.createServer = createServer;