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

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

@@ -1,70 +1,103 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const lodash_1 = __importDefault(require("lodash"));
-const server_1 = require("../../server");
-const cli_options_1 = require("../../cli-options");
-const rpc_1 = require("../../rpc");
-const context_1 = require("../../context");
-const logger = chopsticks_core_1.defaultLogger.child({ name: 'follow-chain' });
-const options = lodash_1.default.pick(cli_options_1.defaultOptions, ['endpoint', 'wasm-override', 'runtime-log-level', 'offchain-worker']);
-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) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cli", {
+    enumerable: true,
+    get: function() {
+        return cli;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _server = require("../../server");
+const _clioptions = require("../../cli-options");
+const _rpc = require("../../rpc");
+const _context = require("../../context");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const logger = _chopstickscore.defaultLogger.child({
+    name: 'follow-chain'
+});
+const options = _lodash.default.pick(_clioptions.defaultOptions, [
+    'endpoint',
+    'wasm-override',
+    'runtime-log-level',
+    'offchain-worker'
+]);
+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 || '')) {
             throw Error('http provider is not supported');
         }
-        const context = await (0, context_1.setupContext)(argv, true);
-        const { close, port: listenPort } = await (0, server_1.createServer)((0, rpc_1.handler)(context), port);
+        const context = await (0, _context.setupContext)(argv, true);
+        const { close, port: listenPort } = await (0, _server.createServer)((0, _rpc.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 chopsticks_core_1.Block(chain, header.number.toNumber(), header.hash.toHex(), parent);
+                const block = new _chopstickscore.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', []]);
-                const result = await (0, chopsticks_core_1.runTask)({
+                calls.push([
+                    'BlockBuilder_finalize_block',
+                    []
+                ]);
+                const result = await (0, _chopstickscore.runTask)({
                     wasm,
                     calls,
                     mockSignatureHost: false,
                     allowUnresolvedImports: false,
-                    runtimeLogLevel: argv.runtimeLogLevel || 0,
-                }, (0, chopsticks_core_1.taskHandler)(parent));
+                    runtimeLogLevel: argv.runtimeLogLevel || 0
+                }, (0, _chopstickscore.taskHandler)(parent));
                 if ('Error' in result) {
                     throw new Error(result.Error);
                 }
-                (0, chopsticks_core_1.printRuntimeLogs)(result.Call.runtimeLogs);
-            }
-            catch (e) {
+                (0, _chopstickscore.printRuntimeLogs)(result.Call.runtimeLogs);
+            } catch (e) {
                 logger.error(e, 'Error when processing new head');
                 await close();
                 process.exit(1);
@@ -72,4 +105,3 @@ const cli = (y) => {
         });
     });
 };
-exports.cli = cli;

package/dist/cjs/plugins/index.js

@@ -1,36 +1,73 @@
 "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(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    pluginExtendCli: function() {
+        return pluginExtendCli;
+    },
+    pluginHandlers: function() {
+        return pluginHandlers;
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginExtendCli = exports.pluginHandlers = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'plugin' });
-exports.pluginHandlers = {};
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _logger = require("../logger");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const logger = _logger.defaultLogger.child({
+    name: 'plugin'
+});
+const pluginHandlers = {};
 const plugins = [
     'decode-key',
     'dry-run',
@@ -42,25 +79,24 @@ const plugins = [
     'set-runtime-log-level',
     'set-storage',
     'time-travel',
-    'try-runtime',
+    'try-runtime'
 ];
-(async () => {
-    for (const plugin of plugins) {
-        const { rpc, name } = await Promise.resolve(`${`./${plugin}`}`).then(s => __importStar(require(s)));
+(async ()=>{
+    for (const plugin of plugins){
+        const { rpc, name } = await Promise.resolve(`./${plugin}`).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
         if (rpc) {
-            const methodName = name || lodash_1.default.camelCase(plugin);
-            exports.pluginHandlers[`dev_${methodName}`] = rpc;
+            const methodName = name || _lodash.default.camelCase(plugin);
+            pluginHandlers[`dev_${methodName}`] = rpc;
             logger.debug(`Registered plugin ${plugin} RPC`);
         }
     }
 })();
-const pluginExtendCli = async (y) => {
-    for (const plugin of plugins) {
-        const { cli } = await Promise.resolve(`${`./${plugin}`}`).then(s => __importStar(require(s)));
+const pluginExtendCli = async (y)=>{
+    for (const plugin of plugins){
+        const { cli } = await Promise.resolve(`./${plugin}`).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
         if (cli) {
             cli(y);
             logger.debug(`Registered plugin ${plugin} CLI`);
         }
     }
 };
-exports.pluginExtendCli = pluginExtendCli;

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

@@ -1,47 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = void 0;
-const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const logger_1 = require("../../logger");
-/**
- * Build new blocks.
- *
- * This function is a dev rpc handler. Use `dev_newBlock` 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 Build 2 blocks
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [{ count: 2 }])
- * ```
- * @example Build a block with upward messages
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [
- *  {
- *    ump: {
- *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
- *      2000: [
- *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
- *      ],
- *    }
- *  }
- * ])
- * ```
- *
- * @example Build two blocks with unsafeBlockHeight
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * // this will create two blocks with block height 100000001 and 100000002
- * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
- * ```
- */
-const rpc = async (context, params) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rpc", {
+    enumerable: true,
+    get: function() {
+        return rpc;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _logger = require("../../logger");
+const rpc = async (context, params)=>{
     const [param] = params;
     const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
     const now = context.chain.head.number;
@@ -49,23 +18,22 @@ const rpc = async (context, params) => {
     const finalCount = diff > 0 ? diff : 1;
     let finalHash;
     if (unsafeBlockHeight < now) {
-        throw new chopsticks_core_1.ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
+        throw new _chopstickscore.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) => {
-            throw new chopsticks_core_1.ResponseError(1, error.toString());
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+        }).catch((error)=>{
+            throw new _chopstickscore.ResponseError(1, error.toString());
         });
-        logger_1.defaultLogger.debug({ hash: block.hash }, 'dev_newBlock');
+        _logger.defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
         finalHash = block.hash;
     }
     return finalHash;
 };
-exports.rpc = rpc;