@acala-network/chopsticks 0.8.1 → 0.8.2

package/lib/rpc/substrate/author.js

@@ -1,63 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.author_pendingExtrinsics = exports.author_unwatchExtrinsic = exports.author_submitAndWatchExtrinsic = exports.author_submitExtrinsic = void 0;
 const chopsticks_core_1 = require("@acala-network/chopsticks-core");
 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 shared_1.ResponseError(code, error.toString());
-        });
-    },
-    author_submitAndWatchExtrinsic: async (context, [extrinsic], { subscribe, unsubscribe }) => {
-        let update = (_block) => { };
-        const id = context.chain.headState.subscribeHead((block) => update(block));
-        const callback = subscribe('author_extrinsicUpdate', id, () => context.chain.headState.unsubscribeHead(id));
-        const onExtrinsicFail = ([failedExtrinsic, error]) => {
-            if (failedExtrinsic === extrinsic) {
-                callback(error.toJSON());
-                done(id);
-            }
-        };
-        context.chain.txPool.event.on(chopsticks_core_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
-        const done = (id) => {
-            context.chain.txPool.event.removeListener(chopsticks_core_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
-            unsubscribe(id);
-        };
-        update = async (block) => {
-            const extrisnics = await block.extrinsics;
-            if (!extrisnics.includes(extrinsic))
-                return;
-            logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
-            callback({
-                InBlock: block.hash,
-            });
-            callback({
-                Finalized: block.hash,
-            });
-            done(id);
-        };
-        try {
-            await context.chain.submitExtrinsic(extrinsic);
-            callback({
-                Ready: null,
-            });
-        }
-        catch (error) {
-            logger.error({ error }, 'ExtrinsicFailed');
-            const code = error.isInvalid ? 1010 : 1011;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+const author_submitExtrinsic = async (context, [extrinsic]) => {
+    return context.chain.submitExtrinsic(extrinsic).catch((error) => {
+        const code = error.isInvalid ? 1010 : 1011;
+        throw new shared_1.ResponseError(code, error.toString());
+    });
+};
+exports.author_submitExtrinsic = author_submitExtrinsic;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+const author_submitAndWatchExtrinsic = async (context, [extrinsic], { subscribe, unsubscribe }) => {
+    let update = (_block) => { };
+    const id = context.chain.headState.subscribeHead((block) => update(block));
+    const callback = subscribe('author_extrinsicUpdate', id, () => context.chain.headState.unsubscribeHead(id));
+    const onExtrinsicFail = ([failedExtrinsic, error]) => {
+        if (failedExtrinsic === extrinsic) {
+            callback(error.toJSON());
             done(id);
-            throw new shared_1.ResponseError(code, error.toString());
         }
-        return id;
-    },
-    author_unwatchExtrinsic: async (_context, [subid], { unsubscribe }) => {
-        unsubscribe(subid);
-    },
-    author_pendingExtrinsics: async (context) => {
-        return context.chain.txPool.pendingExtrinsics;
-    },
+    };
+    context.chain.txPool.event.on(chopsticks_core_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+    const done = (id) => {
+        context.chain.txPool.event.removeListener(chopsticks_core_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        unsubscribe(id);
+    };
+    update = async (block) => {
+        const extrisnics = await block.extrinsics;
+        if (!extrisnics.includes(extrinsic))
+            return;
+        logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
+        callback({
+            inBlock: block.hash,
+        });
+        callback({
+            finalized: block.hash,
+        });
+        done(id);
+    };
+    try {
+        await context.chain.submitExtrinsic(extrinsic);
+        callback({
+            ready: null,
+        });
+    }
+    catch (error) {
+        logger.error({ error }, 'ExtrinsicFailed');
+        const code = error.isInvalid ? 1010 : 1011;
+        done(id);
+        throw new shared_1.ResponseError(code, error.toString());
+    }
+    return id;
+};
+exports.author_submitAndWatchExtrinsic = author_submitAndWatchExtrinsic;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+const author_unwatchExtrinsic = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+exports.author_unwatchExtrinsic = author_unwatchExtrinsic;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+const author_pendingExtrinsics = async (context) => {
+    return context.chain.txPool.pendingExtrinsics;
 };
-exports.default = handlers;
+exports.author_pendingExtrinsics = author_pendingExtrinsics;

package/lib/rpc/substrate/chain.d.ts

@@ -1,6 +1,44 @@
-declare const _default: {
-    chain_subscribeNewHeads: import("../shared").Handler;
-    chain_unsubscribeNewHeads: import("../shared").Handler;
-    chain_unsubscribeFinalizedHeads: import("../shared").Handler;
-};
-export default _default;
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`blockNumber`]
+ *
+ * @return Block hash
+ */
+export declare const chain_getBlockHash: Handler<[number], HexString>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+export declare const chain_getHeader: Handler<[HexString], Header>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+export declare const chain_getBlock: Handler<[
+    HexString
+], {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications: null;
+}>;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+export declare const chain_getFinalizedHead: Handler<void, HexString>;
+export declare const chain_subscribeNewHead: Handler<void, string>;
+export declare const chain_subscribeFinalizedHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHead: Handler<[string], void>;
+export declare const chain_subscribeNewHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHeads: Handler<[string], void>;
+export declare const chain_unsubscribeFinalizedHeads: Handler<[string], void>;

package/lib/rpc/substrate/chain.js

@@ -1,72 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain_unsubscribeFinalizedHeads = exports.chain_unsubscribeNewHeads = exports.chain_subscribeNewHeads = exports.chain_unsubscribeNewHead = exports.chain_subscribeFinalizedHeads = exports.chain_subscribeNewHead = exports.chain_getFinalizedHead = exports.chain_getBlock = exports.chain_getHeader = exports.chain_getBlockHash = void 0;
 const shared_1 = require("../shared");
 const processHeader = (header) => {
     const res = header.toJSON();
     res.number = '0x' + res.number.toString(16); // number is hex format
     return res;
 };
-const handlers = {
-    chain_getBlockHash: async (context, [blockNumber]) => {
-        const block = await context.chain.getBlockAt(blockNumber);
-        if (!block) {
-            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 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 shared_1.ResponseError(1, `Block ${hash} not found`);
-        }
-        return {
-            block: {
-                header: await block.header,
-                extrinsics: await block.extrinsics,
-            },
-            justifications: null,
-        };
-    },
-    chain_getFinalizedHead: async (context) => {
-        return context.chain.head.hash;
-    },
-    chain_subscribeNewHead: async (context, _params, { subscribe }) => {
-        let update = () => { };
-        const id = context.chain.headState.subscribeHead(() => update());
-        const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
-        update = async () => {
-            callback(processHeader(await context.chain.head.header));
-        };
-        update();
-        return id;
-    },
-    chain_subscribeFinalizedHeads: async (context, _params, { subscribe }) => {
-        let update = () => { };
-        const id = context.chain.headState.subscribeHead(() => update());
-        const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
-        update = async () => {
-            callback(processHeader(await context.chain.head.header));
-        };
-        update();
-        return id;
-    },
-    chain_unsubscribeNewHead: async (_context, [subid], { unsubscribe }) => {
-        unsubscribe(subid);
-    },
+/**
+ * @param context
+ * @param params - [`blockNumber`]
+ *
+ * @return Block hash
+ */
+const chain_getBlockHash = async (context, [blockNumber]) => {
+    const block = await context.chain.getBlockAt(blockNumber);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block #${blockNumber} not found`);
+    }
+    return block.hash;
 };
-const alias = {
-    chain_subscribeNewHeads: handlers.chain_subscribeNewHead,
-    chain_unsubscribeNewHeads: handlers.chain_unsubscribeNewHead,
-    chain_unsubscribeFinalizedHeads: handlers.chain_unsubscribeNewHead,
+exports.chain_getBlockHash = chain_getBlockHash;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+const chain_getHeader = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return processHeader(await block.header);
 };
-exports.default = {
-    ...handlers,
-    ...alias,
+exports.chain_getHeader = chain_getHeader;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+const chain_getBlock = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return {
+        block: {
+            header: await block.header,
+            extrinsics: await block.extrinsics,
+        },
+        justifications: null,
+    };
 };
+exports.chain_getBlock = chain_getBlock;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+const chain_getFinalizedHead = async (context) => {
+    return context.chain.head.hash;
+};
+exports.chain_getFinalizedHead = chain_getFinalizedHead;
+const chain_subscribeNewHead = async (context, _params, { subscribe }) => {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = async () => {
+        callback(processHeader(await context.chain.head.header));
+    };
+    update();
+    return id;
+};
+exports.chain_subscribeNewHead = chain_subscribeNewHead;
+const chain_subscribeFinalizedHeads = async (context, _params, { subscribe }) => {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = async () => {
+        callback(processHeader(await context.chain.head.header));
+    };
+    update();
+    return id;
+};
+exports.chain_subscribeFinalizedHeads = chain_subscribeFinalizedHeads;
+const chain_unsubscribeNewHead = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+exports.chain_unsubscribeNewHead = chain_unsubscribeNewHead;
+exports.chain_subscribeNewHeads = exports.chain_subscribeNewHead;
+exports.chain_unsubscribeNewHeads = exports.chain_unsubscribeNewHead;
+exports.chain_unsubscribeFinalizedHeads = exports.chain_unsubscribeNewHead;

package/lib/rpc/substrate/index.d.ts

@@ -1,3 +1,65 @@
-import { Handlers } from '../shared';
-declare const handlers: Handlers;
+import * as AuthorRPC from './author';
+import * as ChainRPC from './chain';
+import * as PaymentRPC from './payment';
+import * as StateRPC from './state';
+import * as SystemRPC from './system';
+export { AuthorRPC };
+export { ChainRPC };
+export { PaymentRPC };
+export { StateRPC };
+export { SystemRPC };
+declare const handlers: {
+    system_localPeerId: () => Promise<string>;
+    system_nodeRoles: () => Promise<string[]>;
+    system_localListenAddresses: () => Promise<never[]>;
+    system_chain: import("../shared").Handler<void, string>;
+    system_properties: import("../shared").Handler<void, import("@acala-network/chopsticks-core").ChainProperties>;
+    system_name: import("../shared").Handler<void, string>;
+    system_version: import("../shared").Handler<void, string>;
+    system_chainType: import("../shared").Handler<void, string>;
+    system_health: () => Promise<{
+        peers: number;
+        isSyncing: boolean;
+        shouldHavePeers: boolean;
+    }>;
+    system_dryRun: import("../shared").Handler<[`0x${string}`, `0x${string}`], string>;
+    system_accountNextIndex: import("../shared").Handler<[`0x${string}`], number>;
+    state_getRuntimeVersion: import("../shared").Handler<[`0x${string}`], import("@acala-network/chopsticks-core").RuntimeVersion | undefined>;
+    state_getMetadata: import("../shared").Handler<[`0x${string}`], `0x${string}` | undefined>;
+    state_getStorage: import("../shared").Handler<[`0x${string}`, `0x${string}`], string | undefined>;
+    state_getKeysPaged: import("../shared").Handler<[string, number, string, `0x${string}`], string[] | undefined>;
+    state_queryStorageAt: import("../shared").Handler<[string[], `0x${string}`], [] | [{
+        block: `0x${string}`;
+        changes: (string | undefined)[][];
+    }]>;
+    state_call: import("../shared").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
+    state_subscribeRuntimeVersion: import("../shared").Handler<[], string>;
+    state_unsubscribeRuntimeVersion: import("../shared").Handler<[`0x${string}`], void>;
+    state_subscribeStorage: import("../shared").Handler<[string[]], string>;
+    state_unsubscribeStorage: import("../shared").Handler<[string], void>;
+    childstate_getStorage: import("../shared").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | undefined>;
+    childstate_getKeysPaged: import("../shared").Handler<[`0x${string}`, `0x${string}`, number, `0x${string}`, `0x${string}`], `0x${string}`[] | undefined>;
+    payment_queryFeeDetails: import("../shared").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    payment_queryInfo: import("../shared").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    chain_getBlockHash: import("../shared").Handler<[number], `0x${string}`>;
+    chain_getHeader: import("../shared").Handler<[`0x${string}`], import("@polkadot/types/interfaces").Header>;
+    chain_getBlock: import("../shared").Handler<[`0x${string}`], {
+        block: {
+            header: import("@polkadot/types/interfaces").Header;
+            extrinsics: `0x${string}`[];
+        };
+        justifications: null;
+    }>;
+    chain_getFinalizedHead: import("../shared").Handler<void, `0x${string}`>;
+    chain_subscribeNewHead: import("../shared").Handler<void, string>;
+    chain_subscribeFinalizedHeads: import("../shared").Handler<void, string>;
+    chain_unsubscribeNewHead: import("../shared").Handler<[string], void>;
+    chain_subscribeNewHeads: import("../shared").Handler<void, string>;
+    chain_unsubscribeNewHeads: import("../shared").Handler<[string], void>;
+    chain_unsubscribeFinalizedHeads: import("../shared").Handler<[string], void>;
+    author_submitExtrinsic: import("../shared").Handler<[`0x${string}`], `0x${string}`>;
+    author_submitAndWatchExtrinsic: import("../shared").Handler<[`0x${string}`], string>;
+    author_unwatchExtrinsic: import("../shared").Handler<[string], void>;
+    author_pendingExtrinsics: import("../shared").Handler<void, `0x${string}`[]>;
+};
 export default handlers;

package/lib/rpc/substrate/index.js

@@ -1,18 +1,44 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 __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;
 };
 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"));
+exports.SystemRPC = exports.StateRPC = exports.PaymentRPC = exports.ChainRPC = exports.AuthorRPC = void 0;
+const AuthorRPC = __importStar(require("./author"));
+exports.AuthorRPC = AuthorRPC;
+const ChainRPC = __importStar(require("./chain"));
+exports.ChainRPC = ChainRPC;
+const PaymentRPC = __importStar(require("./payment"));
+exports.PaymentRPC = PaymentRPC;
+const StateRPC = __importStar(require("./state"));
+exports.StateRPC = StateRPC;
+const SystemRPC = __importStar(require("./system"));
+exports.SystemRPC = SystemRPC;
 const handlers = {
-    ...author_1.default,
-    ...chain_1.default,
-    ...state_1.default,
-    ...system_1.default,
-    ...payment_1.default,
+    ...AuthorRPC,
+    ...ChainRPC,
+    ...PaymentRPC,
+    ...StateRPC,
+    ...SystemRPC,
 };
 exports.default = handlers;

package/lib/rpc/substrate/payment.d.ts

@@ -1,3 +1,16 @@
-import { Handlers } from '../shared';
-declare const handlers: Handlers;
-export default handlers;
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryFeeDetails: Handler<[HexString, HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryInfo: Handler<[HexString, HexString], HexString>;

package/lib/rpc/substrate/payment.js

@@ -1,33 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const shared_1 = require("../shared");
+exports.payment_queryInfo = exports.payment_queryFeeDetails = void 0;
 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 shared_1.ResponseError(1, `Block ${hash} not found`);
-        }
-        const registry = await block.registry;
-        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(),
-        ]);
-        return resp.result;
-    },
-    payment_queryInfo: async (context, [extrinsic, hash]) => {
-        const block = await context.chain.getBlock(hash);
-        if (!block) {
-            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
-        }
-        const registry = await block.registry;
-        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(),
-        ]);
-        return resp.result;
-    },
+const shared_1 = require("../shared");
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryFeeDetails = async (context, [extrinsic, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = await block.registry;
+    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(),
+    ]);
+    return resp.result;
+};
+exports.payment_queryFeeDetails = payment_queryFeeDetails;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryInfo = async (context, [extrinsic, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = await block.registry;
+    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(),
+    ]);
+    return resp.result;
 };
-exports.default = handlers;
+exports.payment_queryInfo = payment_queryInfo;