@acala-network/chopsticks 0.5.5 → 0.5.7

package/lib/executor.js

@@ -1,41 +1,52 @@
-import { hexToString, hexToU8a } from '@polkadot/util';
-import { calculate_state_root, create_proof, decode_proof, get_runtime_version, run_task, } from '@acala-network/chopsticks-executor';
-import { defaultLogger, truncate } from './logger';
-import _ from 'lodash';
-const logger = defaultLogger.child({ name: 'executor' });
-export const getRuntimeVersion = async (code) => {
-    return get_runtime_version(code).then((version) => {
-        version.specName = hexToString(version.specName);
-        version.implName = hexToString(version.implName);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
+const util_1 = require("@polkadot/util");
+const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
+const logger_1 = require("./logger");
+const lodash_1 = __importDefault(require("lodash"));
+const logger = logger_1.defaultLogger.child({ name: 'executor' });
+const getRuntimeVersion = async (code) => {
+    return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
+        version.specName = (0, util_1.hexToString)(version.specName);
+        version.implName = (0, util_1.hexToString)(version.implName);
         return version;
     });
 };
-export const calculateStateRoot = async (entries) => {
-    return calculate_state_root(entries);
+exports.getRuntimeVersion = getRuntimeVersion;
+const calculateStateRoot = async (entries) => {
+    return (0, chopsticks_executor_1.calculate_state_root)(entries);
 };
-export const decodeProof = async (trieRootHash, keys, nodes) => {
-    const decoded = await decode_proof(trieRootHash, keys, nodes);
+exports.calculateStateRoot = calculateStateRoot;
+const decodeProof = async (trieRootHash, keys, nodes) => {
+    const decoded = await (0, chopsticks_executor_1.decode_proof)(trieRootHash, keys, nodes);
     return decoded.reduce((accum, [key, value]) => {
         accum[key] = value;
         return accum;
     }, {});
 };
-export const createProof = async (trieRootHash, nodes, entries) => {
-    const result = await create_proof(trieRootHash, nodes, entries);
+exports.decodeProof = decodeProof;
+const createProof = async (trieRootHash, nodes, entries) => {
+    const result = await (0, chopsticks_executor_1.create_proof)(trieRootHash, nodes, entries);
     return { trieRootHash: result[0], nodes: result[1] };
 };
-export const runTask = async (task, callback = emptyTaskHandler) => {
-    logger.trace(truncate(task), 'taskRun');
-    const response = await run_task(task, callback);
+exports.createProof = createProof;
+const runTask = async (task, callback = exports.emptyTaskHandler) => {
+    logger.trace((0, logger_1.truncate)(task), 'taskRun');
+    const response = await (0, chopsticks_executor_1.run_task)(task, callback);
     if (response.Call) {
-        logger.trace(truncate(response.Call), 'taskResponse');
+        logger.trace((0, logger_1.truncate)(response.Call), 'taskResponse');
     }
     else {
         logger.trace({ response }, 'taskResponse');
     }
     return response;
 };
-export const taskHandler = (block) => {
+exports.runTask = runTask;
+const taskHandler = (block) => {
     return {
         getStorage: async function (key) {
             return block.get(key);
@@ -49,7 +60,8 @@ export const taskHandler = (block) => {
         },
     };
 };
-export const emptyTaskHandler = {
+exports.taskHandler = taskHandler;
+exports.emptyTaskHandler = {
     getStorage: async function (_key) {
         throw new Error('Method not implemented');
     },
@@ -60,8 +72,8 @@ export const emptyTaskHandler = {
         throw new Error('Method not implemented');
     },
 };
-export const getAuraSlotDuration = _.memoize(async (wasm, registry) => {
-    const result = await runTask({
+exports.getAuraSlotDuration = lodash_1.default.memoize(async (wasm, registry) => {
+    const result = await (0, exports.runTask)({
         wasm,
         calls: [['AuraApi_slot_duration', []]],
         storage: [],
@@ -70,6 +82,6 @@ export const getAuraSlotDuration = _.memoize(async (wasm, registry) => {
     });
     if (!result.Call)
         throw new Error(result.Error);
-    const slotDuration = registry.createType('u64', hexToU8a(result.Call.result)).toNumber();
+    const slotDuration = registry.createType('u64', (0, util_1.hexToU8a)(result.Call.result)).toNumber();
     return slotDuration;
 });

package/lib/genesis-provider.js

@@ -1,11 +1,17 @@
-import { EventEmitter } from 'node:events';
-import { lstatSync, readFileSync } from 'node:fs';
-import { stringToHex } from '@polkadot/util';
-import axios from 'axios';
-import { genesisSchema } from './schema';
-import { calculateStateRoot, runTask } from './executor';
-import { isUrl } from './utils';
-export class GenesisProvider {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisProvider = void 0;
+const node_events_1 = require("node:events");
+const node_fs_1 = require("node:fs");
+const util_1 = require("@polkadot/util");
+const axios_1 = __importDefault(require("axios"));
+const schema_1 = require("./schema");
+const executor_1 = require("./executor");
+const utils_1 = require("./utils");
+class GenesisProvider {
     #isConnected = false;
     stats;
     #eventemitter;
@@ -14,11 +20,11 @@ export class GenesisProvider {
     #stateRoot;
     constructor(genesis) {
         this.#genesis = genesis;
-        this.#stateRoot = calculateStateRoot(Object.entries(this.#genesis.genesis.raw.top).reduce((accu, item) => {
+        this.#stateRoot = (0, executor_1.calculateStateRoot)(Object.entries(this.#genesis.genesis.raw.top).reduce((accu, item) => {
             accu.push(item);
             return accu;
         }, []));
-        this.#eventemitter = new EventEmitter();
+        this.#eventemitter = new node_events_1.EventEmitter();
         this.#isReadyPromise = new Promise((resolve, reject) => {
             this.#eventemitter.once('connected', () => {
                 resolve();
@@ -28,16 +34,16 @@ export class GenesisProvider {
     }
     static fromUrl = async (url) => {
         let file;
-        if (isUrl(url)) {
-            file = await axios.get(url).then((x) => x.data);
+        if ((0, utils_1.isUrl)(url)) {
+            file = await axios_1.default.get(url).then((x) => x.data);
         }
-        else if (lstatSync(url).isFile()) {
-            file = JSON.parse(String(readFileSync(url)));
+        else if ((0, node_fs_1.lstatSync)(url).isFile()) {
+            file = JSON.parse(String((0, node_fs_1.readFileSync)(url)));
         }
         else {
             throw Error(`invalid genesis path or url ${url}`);
         }
-        return new GenesisProvider(genesisSchema.parse(file));
+        return new GenesisProvider(schema_1.genesisSchema.parse(file));
     };
     get isClonable() {
         return true;
@@ -114,8 +120,8 @@ export class GenesisProvider {
             case 'system_name':
                 return this.#genesis.name;
             case 'state_getMetadata': {
-                const code = this.#genesis.genesis.raw.top[stringToHex(':code')];
-                return runTask({
+                const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
+                return (0, executor_1.runTask)({
                     wasm: code,
                     calls: [['Metadata_metadata', []]],
                     storage: [],
@@ -145,3 +151,4 @@ export class GenesisProvider {
         throw Error('unimplemented');
     };
 }
+exports.GenesisProvider = GenesisProvider;

package/lib/index.js

@@ -1,7 +1,31 @@
-export { Api } from './api';
-export { Blockchain } from './blockchain';
-export { BuildBlockMode } from './blockchain/txpool';
-export { connectParachains, connectVertical } from './xcm';
-export { setup } from './setup';
-export { setupWithServer } from './setup-with-server';
-export * from './blockchain/inherent';
+"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 });
+exports.setupWithServer = exports.setup = exports.connectVertical = exports.connectParachains = exports.BuildBlockMode = exports.Blockchain = exports.Api = void 0;
+var api_1 = require("./api");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return api_1.Api; } });
+var blockchain_1 = require("./blockchain");
+Object.defineProperty(exports, "Blockchain", { enumerable: true, get: function () { return blockchain_1.Blockchain; } });
+var txpool_1 = require("./blockchain/txpool");
+Object.defineProperty(exports, "BuildBlockMode", { enumerable: true, get: function () { return txpool_1.BuildBlockMode; } });
+var xcm_1 = require("./xcm");
+Object.defineProperty(exports, "connectParachains", { enumerable: true, get: function () { return xcm_1.connectParachains; } });
+Object.defineProperty(exports, "connectVertical", { enumerable: true, get: function () { return xcm_1.connectVertical; } });
+var setup_1 = require("./setup");
+Object.defineProperty(exports, "setup", { enumerable: true, get: function () { return setup_1.setup; } });
+var setup_with_server_1 = require("./setup-with-server");
+Object.defineProperty(exports, "setupWithServer", { enumerable: true, get: function () { return setup_with_server_1.setupWithServer; } });
+__exportStar(require("./blockchain/inherent"), exports);

package/lib/logger.js

@@ -1,5 +1,11 @@
-import createLogger from 'pino';
-export const defaultLogger = createLogger({
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncate = exports.defaultLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+exports.defaultLogger = (0, pino_1.default)({
     level: process.env.LOG_LEVEL || 'info',
     transport: {
         target: 'pino-pretty',
@@ -29,4 +35,5 @@ const innerTruncate = (level = 0) => (val) => {
             return val;
     }
 };
-export const truncate = (val) => innerTruncate(0)(val);
+const truncate = (val) => innerTruncate(0)(val);
+exports.truncate = truncate;

package/lib/rpc/dev/dry-run.js

@@ -1,37 +1,43 @@
-import z from 'zod';
-import { decodeStorageDiff } from '../../utils/decoder';
-import { generateHtmlDiff } from '../../utils/generate-html-diff';
-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 dryRunSchema = z.object({
-    raw: z.boolean().optional(),
-    html: z.boolean().optional(),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev_dryRun = void 0;
+const zod_1 = __importDefault(require("zod"));
+const decoder_1 = require("../../utils/decoder");
+const generate_html_diff_1 = require("../../utils/generate-html-diff");
+const zHex = zod_1.default.custom((val) => /^0x\w+$/.test(val));
+const zHash = zod_1.default.string().length(66).and(zHex);
+const zParaId = zod_1.default.string().regex(/^\d+$/).transform(Number);
+const dryRunSchema = zod_1.default.object({
+    raw: zod_1.default.boolean().optional(),
+    html: zod_1.default.boolean().optional(),
     extrinsic: zHex
-        .or(z.object({
+        .or(zod_1.default.object({
         call: zHex,
         address: zHex,
     }))
         .optional(),
-    hrmp: z
-        .record(zParaId, z
-        .array(z.object({
-        sentAt: z.number(),
+    hrmp: zod_1.default
+        .record(zParaId, zod_1.default
+        .array(zod_1.default.object({
+        sentAt: zod_1.default.number(),
         data: zHex,
     }))
         .min(1))
         .optional(),
-    dmp: z
-        .array(z.object({
-        sentAt: z.number(),
+    dmp: zod_1.default
+        .array(zod_1.default.object({
+        sentAt: zod_1.default.number(),
         msg: zHex,
     }))
         .min(1)
         .optional(),
-    ump: z.record(zParaId, z.array(zHex).min(1)).optional(),
+    ump: zod_1.default.record(zParaId, zod_1.default.array(zHex).min(1)).optional(),
     at: zHash.optional(),
 });
-export const dev_dryRun = async (context, [params]) => {
+const dev_dryRun = async (context, [params]) => {
     const { html, extrinsic, hrmp, dmp, ump, raw, at } = dryRunSchema.parse(params);
     const dryRun = async () => {
         if (extrinsic) {
@@ -54,15 +60,16 @@ export const dev_dryRun = async (context, [params]) => {
     };
     const storageDiff = await dryRun();
     if (html) {
-        return generateHtmlDiff(context.chain.head, storageDiff);
+        return (0, generate_html_diff_1.generateHtmlDiff)(context.chain.head, storageDiff);
     }
     if (raw) {
         return storageDiff;
     }
-    const [oldData, newData, delta] = await decodeStorageDiff(context.chain.head, storageDiff);
+    const [oldData, newData, delta] = await (0, decoder_1.decodeStorageDiff)(context.chain.head, storageDiff);
     return {
         old: oldData,
         new: newData,
         delta,
     };
 };
+exports.dev_dryRun = dev_dryRun;

package/lib/rpc/dev/index.js

@@ -1,9 +1,11 @@
-import { ResponseError } from '../shared';
-import { setStorage } from '../../utils/set-storage';
-import { defaultLogger } from '../../logger';
-import { dev_dryRun } from './dry-run';
-import { timeTravel } from '../../utils/time-travel';
-const logger = defaultLogger.child({ name: 'rpc-dev' });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
+const set_storage_1 = require("../../utils/set-storage");
+const logger_1 = require("../../logger");
+const dry_run_1 = require("./dry-run");
+const time_travel_1 = require("../../utils/time-travel");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-dev' });
 const handlers = {
     dev_newBlock: async (context, [param]) => {
         const { count, to, hrmp, ump, dmp, transactions } = param || {};
@@ -20,7 +22,7 @@ const handlers = {
                 downwardMessages: dmp,
             })
                 .catch((error) => {
-                throw new ResponseError(1, error.toString());
+                throw new shared_1.ResponseError(1, error.toString());
             });
             logger.debug({ hash: block.hash }, 'dev_newBlock');
             finalHash = block.hash;
@@ -29,8 +31,8 @@ const handlers = {
     },
     dev_setStorage: async (context, params) => {
         const [values, blockHash] = params;
-        const hash = await setStorage(context.chain, values, blockHash).catch((error) => {
-            throw new ResponseError(1, error.toString());
+        const hash = await (0, set_storage_1.setStorage)(context.chain, values, blockHash).catch((error) => {
+            throw new shared_1.ResponseError(1, error.toString());
         });
         logger.debug({
             hash,
@@ -41,8 +43,8 @@ const handlers = {
     dev_timeTravel: async (context, [date]) => {
         const timestamp = typeof date === 'string' ? Date.parse(date) : date;
         if (Number.isNaN(timestamp))
-            throw new ResponseError(1, 'Invalid date');
-        await timeTravel(context.chain, timestamp);
+            throw new shared_1.ResponseError(1, 'Invalid date');
+        await (0, time_travel_1.timeTravel)(context.chain, timestamp);
         return timestamp;
     },
     dev_setHead: async (context, [hashOrNumber]) => {
@@ -55,11 +57,11 @@ const handlers = {
             block = await context.chain.getBlock(hashOrNumber);
         }
         if (!block) {
-            throw new ResponseError(1, `Block not found ${hashOrNumber}`);
+            throw new shared_1.ResponseError(1, `Block not found ${hashOrNumber}`);
         }
         await context.chain.setHead(block);
         return block.hash;
     },
-    dev_dryRun,
+    dev_dryRun: dry_run_1.dev_dryRun,
 };
-export default handlers;
+exports.default = handlers;

package/lib/rpc/index.js

@@ -1,20 +1,27 @@
-import { ResponseError, logger } from './shared';
-import dev from './dev';
-import substrate from './substrate';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const shared_1 = require("./shared");
+const dev_1 = __importDefault(require("./dev"));
+const substrate_1 = __importDefault(require("./substrate"));
 const allHandlers = {
-    ...substrate,
-    ...dev,
+    ...substrate_1.default,
+    ...dev_1.default,
     rpc_methods: async () => Promise.resolve({
         version: 1,
         methods: Object.keys(allHandlers),
     }),
 };
-export const handler = (context) => ({ method, params }, subscriptionManager) => {
-    logger.trace('Handling %s', method);
+const handler = (context) => ({ method, params }, subscriptionManager) => {
+    shared_1.logger.trace('Handling %s', method);
     const handler = allHandlers[method];
     if (!handler) {
-        logger.warn('Method not found %s', method);
-        throw new ResponseError(-32601, `Method not found: ${method}`);
+        shared_1.logger.warn('Method not found %s', method);
+        throw new shared_1.ResponseError(-32601, `Method not found: ${method}`);
     }
     return handler(context, params, subscriptionManager);
 };
+exports.handler = handler;

package/lib/rpc/shared.js

@@ -1,6 +1,9 @@
-import { defaultLogger } from '../logger';
-export const logger = defaultLogger.child({ name: 'rpc' });
-export class ResponseError extends Error {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.logger = void 0;
+const logger_1 = require("../logger");
+exports.logger = logger_1.defaultLogger.child({ name: 'rpc' });
+class ResponseError extends Error {
     code;
     constructor(code, message) {
         super(message);
@@ -14,3 +17,4 @@ export class ResponseError extends Error {
         };
     }
 }
+exports.ResponseError = ResponseError;

package/lib/rpc/substrate/author.js

@@ -1,12 +1,14 @@
-import { APPLY_EXTRINSIC_ERROR } from '../../blockchain/txpool';
-import { ResponseError } from '../shared';
-import { defaultLogger } from '../../logger';
-const logger = defaultLogger.child({ name: 'rpc-author' });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const txpool_1 = require("../../blockchain/txpool");
+const shared_1 = require("../shared");
+const logger_1 = require("../../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-author' });
 const handlers = {
     author_submitExtrinsic: async (context, [extrinsic]) => {
         return context.chain.submitExtrinsic(extrinsic).catch((error) => {
             const code = error.isInvalid ? 1010 : 1011;
-            throw new ResponseError(code, error.toString());
+            throw new shared_1.ResponseError(code, error.toString());
         });
     },
     author_submitAndWatchExtrinsic: async (context, [extrinsic], { subscribe, unsubscribe }) => {
@@ -19,9 +21,9 @@ const handlers = {
                 done(id);
             }
         };
-        context.chain.txPool.event.on(APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        context.chain.txPool.event.on(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
         const done = (id) => {
-            context.chain.txPool.event.removeListener(APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+            context.chain.txPool.event.removeListener(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
             unsubscribe(id);
         };
         update = async (block) => {
@@ -58,4 +60,4 @@ const handlers = {
         return context.chain.txPool.pendingExtrinsics;
     },
 };
-export default handlers;
+exports.default = handlers;

package/lib/rpc/substrate/chain.js

@@ -1,4 +1,6 @@
-import { ResponseError } from '../shared';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
 const processHeader = (header) => {
     const res = header.toJSON();
     res.number = '0x' + res.number.toString(16); // number is hex format
@@ -8,21 +10,21 @@ const handlers = {
     chain_getBlockHash: async (context, [blockNumber]) => {
         const block = await context.chain.getBlockAt(blockNumber);
         if (!block) {
-            throw new ResponseError(1, `Block #${blockNumber} not found`);
+            throw new shared_1.ResponseError(1, `Block #${blockNumber} not found`);
         }
         return block.hash;
     },
     chain_getHeader: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new ResponseError(1, `Block ${hash} not found`);
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         return processHeader(await block.header);
     },
     chain_getBlock: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new ResponseError(1, `Block ${hash} not found`);
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         return {
             block: {
@@ -64,7 +66,7 @@ const alias = {
     chain_unsubscribeNewHeads: handlers.chain_unsubscribeNewHead,
     chain_unsubscribeFinalizedHeads: handlers.chain_unsubscribeNewHead,
 };
-export default {
+exports.default = {
     ...handlers,
     ...alias,
 };

package/lib/rpc/substrate/index.js

@@ -1,13 +1,18 @@
-import author from './author';
-import chain from './chain';
-import payment from './payment';
-import state from './state';
-import system from './system';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const author_1 = __importDefault(require("./author"));
+const chain_1 = __importDefault(require("./chain"));
+const payment_1 = __importDefault(require("./payment"));
+const state_1 = __importDefault(require("./state"));
+const system_1 = __importDefault(require("./system"));
 const handlers = {
-    ...author,
-    ...chain,
-    ...state,
-    ...system,
-    ...payment,
+    ...author_1.default,
+    ...chain_1.default,
+    ...state_1.default,
+    ...system_1.default,
+    ...payment_1.default,
 };
-export default handlers;
+exports.default = handlers;

package/lib/rpc/substrate/payment.js

@@ -1,13 +1,15 @@
-import { ResponseError } from '../shared';
-import { hexToU8a } from '@polkadot/util';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
+const util_1 = require("@polkadot/util");
 const handlers = {
     payment_queryFeeDetails: async (context, [extrinsic, hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new ResponseError(1, `Block ${hash} not found`);
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         const registry = await block.registry;
-        const tx = hexToU8a(extrinsic);
+        const tx = (0, util_1.hexToU8a)(extrinsic);
         const resp = await block.call('TransactionPaymentApi_query_fee_details', [
             registry.createType('Extrinsic', tx).toHex(),
             registry.createType('u32', tx.byteLength).toHex(),
@@ -17,10 +19,10 @@ const handlers = {
     payment_queryInfo: async (context, [extrinsic, hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new ResponseError(1, `Block ${hash} not found`);
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         const registry = await block.registry;
-        const tx = hexToU8a(extrinsic);
+        const tx = (0, util_1.hexToU8a)(extrinsic);
         const resp = await block.call('TransactionPaymentApi_query_info', [
             registry.createType('Extrinsic', tx).toHex(),
             registry.createType('u32', tx.byteLength).toHex(),
@@ -28,4 +30,4 @@ const handlers = {
         return resp.result;
     },
 };
-export default handlers;
+exports.default = handlers;

package/lib/rpc/substrate/state.js

@@ -1,6 +1,8 @@
-import { ResponseError } from '../shared';
-import { defaultLogger } from '../../logger';
-const logger = defaultLogger.child({ name: 'rpc-state' });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
+const logger_1 = require("../../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-state' });
 const handlers = {
     state_getRuntimeVersion: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);
@@ -34,7 +36,7 @@ const handlers = {
     state_call: async (context, [method, data, hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new ResponseError(1, `Block ${hash} not found`);
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         const resp = await block.call(method, [data]);
         return resp.result;
@@ -77,4 +79,4 @@ const handlers = {
         unsubscribe(subid);
     },
 };
-export default handlers;
+exports.default = handlers;