@acala-network/chopsticks-core 0.8.2 → 0.8.4

package/lib/chopsticks-worker.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpc_1 = require("./rpc");
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const setup_1 = require("./setup");
+let chain;
+const logger = logger_1.defaultLogger.child({ name: '[Chopsticks worker]' });
+const subscriptions = {};
+const providerHandlers = Object.assign(Object.assign({}, rpc_1.allHandlers), { new_block: (context, _params, _subscriptionManager) => __awaiter(void 0, void 0, void 0, function* () {
+        const { chain } = context;
+        const block = yield chain.newBlock();
+        return block;
+    }) });
+const subscriptionManager = {
+    subscribe: (method, subid, onCancel = () => { }) => {
+        subscriptions[subid] = onCancel;
+        return (data) => {
+            postMessage({
+                type: 'subscribe-callback',
+                method,
+                subid,
+                result: JSON.stringify(data),
+            });
+        };
+    },
+    unsubscribe: (subid) => {
+        if (subscriptions[subid]) {
+            subscriptions[subid](subid); // call onCancel
+            postMessage({
+                type: 'unsubscribe-callback',
+                subid,
+            });
+        }
+    },
+};
+onmessage = (e) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    switch (e.data.type) {
+        case 'connect':
+            try {
+                logger.debug('onMessage: connect. Initializing...');
+                chain = yield (0, setup_1.setup)({
+                    endpoint: e.data.endpoint,
+                    mockSignatureHost: true,
+                    db: e.data.dbPath,
+                    block: e.data.blockHash,
+                });
+                logger.debug('onMessage: connect. Chain setup done.');
+                yield (0, utils_1.setStorage)(chain, e.data.storageValues);
+                logger.debug('onMessage: connect. Set storage done.');
+                postMessage({
+                    type: 'connection',
+                    connected: true,
+                });
+            }
+            catch (e) {
+                logger.error('onMessage: connect error.', e);
+                postMessage({
+                    type: 'connection',
+                    connected: false,
+                    message: e,
+                });
+            }
+            break;
+        case 'disconnect':
+            if (chain) {
+                yield ((_a = chain === null || chain === void 0 ? void 0 : chain.api) === null || _a === void 0 ? void 0 : _a.disconnect());
+                yield (chain === null || chain === void 0 ? void 0 : chain.close());
+            }
+            break;
+        case 'send':
+            {
+                const { method, params } = e.data;
+                const handler = providerHandlers[method];
+                if (!handler) {
+                    logger.error(`Unable to find rpc handler=${method}`);
+                    return Promise.reject(new Error(`Unable to find handler=${method}`));
+                }
+                const result = yield handler({ chain: chain }, params, subscriptionManager);
+                postMessage({
+                    type: 'send-result',
+                    id: e.data.id,
+                    method: method,
+                    result: JSON.stringify(result),
+                });
+            }
+            break;
+        default:
+            break;
+    }
+});

package/lib/genesis-provider.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
 import { Genesis } from './schema';
-import { JsCallback } from './executor';
+import { JsCallback } from './wasm-executor';
 export declare class GenesisProvider implements ProviderInterface {
     #private;
     readonly stats?: ProviderStats;

package/lib/genesis-provider.js

@@ -51,7 +51,7 @@ exports.GenesisProvider = void 0;
 const eventemitter3_1 = require("eventemitter3");
 const axios_1 = __importDefault(require("axios"));
 const schema_1 = require("./schema");
-const executor_1 = require("./executor");
+const wasm_executor_1 = require("./wasm-executor");
 const utils_1 = require("./utils");
 class GenesisProvider {
     constructor(genesis) {
@@ -127,7 +127,7 @@ class GenesisProvider {
             throw Error('unimplemented');
         });
         __classPrivateFieldSet(this, _GenesisProvider_genesis, genesis, "f");
-        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, (0, executor_1.calculateStateRoot)(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
+        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, (0, wasm_executor_1.calculateStateRoot)(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
             accu.push(item);
             return accu;
         }, []), 1), "f");
@@ -157,7 +157,7 @@ class GenesisProvider {
     }
     get _jsCallback() {
         const storage = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top;
-        return Object.assign(Object.assign({}, executor_1.emptyTaskHandler), { getStorage: function (key) {
+        return Object.assign(Object.assign({}, wasm_executor_1.emptyTaskHandler), { getStorage: function (key) {
                 return __awaiter(this, void 0, void 0, function* () {
                     return storage[key];
                 });

package/lib/index.d.ts

@@ -15,10 +15,11 @@ export * from './blockchain/txpool';
 export * from './blockchain/storage-layer';
 export * from './blockchain/head-state';
 export * from './utils';
-export * from './executor';
+export * from './wasm-executor';
 export * from './schema';
 export * from './xcm';
 export * from './setup';
 export * from './blockchain/inherent';
 export * from './logger';
 export * from './offchain';
+export * from './rpc';

package/lib/index.js

@@ -31,10 +31,12 @@ __exportStar(require("./blockchain/txpool"), exports);
 __exportStar(require("./blockchain/storage-layer"), exports);
 __exportStar(require("./blockchain/head-state"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./executor"), exports);
+__exportStar(require("./wasm-executor"), exports);
 __exportStar(require("./schema"), exports);
 __exportStar(require("./xcm"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./blockchain/inherent"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./offchain"), exports);
+// export * from './chopsticks-provider'
+__exportStar(require("./rpc"), exports);

package/lib/rpc/index.d.ts

@@ -0,0 +1,5 @@
+import { Handlers } from './shared';
+export declare const allHandlers: Handlers;
+export { default as substrate } from './substrate';
+export { ResponseError } from './shared';
+export type { Context, SubscriptionManager, Handler, Handlers } from './shared';

package/lib/rpc/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.substrate = exports.allHandlers = void 0;
+const substrate_1 = __importDefault(require("./substrate"));
+exports.allHandlers = Object.assign(Object.assign({}, substrate_1.default), { rpc_methods: () => __awaiter(void 0, void 0, void 0, function* () {
+        return Promise.resolve({
+            version: 1,
+            methods: [...Object.keys(exports.allHandlers)],
+        });
+    }) });
+var substrate_2 = require("./substrate");
+Object.defineProperty(exports, "substrate", { enumerable: true, get: function () { return __importDefault(substrate_2).default; } });
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function () { return shared_1.ResponseError; } });

package/lib/rpc/shared.d.ts

@@ -0,0 +1,27 @@
+import { Blockchain } from '@acala-network/chopsticks-core';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare class ResponseError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+    toJSON(): {
+        code: number;
+        message: string;
+    };
+}
+export interface Context {
+    /**
+     * The blockchain instance
+     */
+    chain: Blockchain;
+}
+export interface SubscriptionManager {
+    subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+    unsubscribe: (subid: string) => void;
+}
+export type Handler<TParams = any, TReturn = any> = (context: Context, params: TParams, subscriptionManager: SubscriptionManager) => Promise<TReturn>;
+export type Handlers = Record<string, Handler>;

package/lib/rpc/shared.js

@@ -0,0 +1,19 @@
+"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 {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ResponseError';
+        this.code = code;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+        };
+    }
+}
+exports.ResponseError = ResponseError;

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

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+export declare const author_submitExtrinsic: Handler<[HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const author_submitAndWatchExtrinsic: Handler<[HexString], string>;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+export declare const author_unwatchExtrinsic: Handler<[string], void>;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+export declare const author_pendingExtrinsics: Handler<void, HexString[]>;

package/lib/rpc/substrate/author.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author_pendingExtrinsics = exports.author_unwatchExtrinsic = exports.author_submitAndWatchExtrinsic = exports.author_submitExtrinsic = void 0;
+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' });
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+const author_submitExtrinsic = (context, [extrinsic]) => __awaiter(void 0, void 0, void 0, function* () {
+    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 = (context, [extrinsic], { subscribe, unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    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(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+    const done = (id) => {
+        context.chain.txPool.event.removeListener(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        unsubscribe(id);
+    };
+    update = (block) => __awaiter(void 0, void 0, void 0, function* () {
+        const extrisnics = yield block.extrinsics;
+        if (!extrisnics.includes(extrinsic))
+            return;
+        logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
+        callback({
+            inBlock: block.hash,
+        });
+        // wait a bit for InBlock to be sent
+        yield new Promise((r) => setTimeout(r, 100));
+        callback({
+            finalized: block.hash,
+        });
+        done(id);
+    });
+    try {
+        yield 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 = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.author_unwatchExtrinsic = author_unwatchExtrinsic;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+const author_pendingExtrinsics = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.txPool.pendingExtrinsics;
+});
+exports.author_pendingExtrinsics = author_pendingExtrinsics;

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

@@ -0,0 +1,45 @@
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+export declare const chain_getBlockHash: Handler<[number | number[] | null], HexString | (HexString | null)[] | null>;
+/**
+ * @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_getHead: Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+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

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain_unsubscribeFinalizedHeads = exports.chain_unsubscribeNewHeads = exports.chain_subscribeNewHeads = exports.chain_getHead = 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;
+};
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+const chain_getBlockHash = (context, [blockNumber]) => __awaiter(void 0, void 0, void 0, function* () {
+    const numbers = Array.isArray(blockNumber) ? blockNumber : [blockNumber];
+    const hashes = yield Promise.all(numbers.map((n) => context.chain.getBlockAt(n))).then((blocks) => blocks.map((b) => (b === null || b === void 0 ? void 0 : b.hash) || null));
+    return Array.isArray(blockNumber) ? hashes : hashes[0];
+});
+exports.chain_getBlockHash = chain_getBlockHash;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+const chain_getHeader = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return processHeader(yield block.header);
+});
+exports.chain_getHeader = chain_getHeader;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+const chain_getBlock = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return {
+        block: {
+            header: yield block.header,
+            extrinsics: yield block.extrinsics,
+        },
+        justifications: null,
+    };
+});
+exports.chain_getBlock = chain_getBlock;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+const chain_getFinalizedHead = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.head.hash;
+});
+exports.chain_getFinalizedHead = chain_getFinalizedHead;
+const chain_subscribeNewHead = (context, _params, { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = () => __awaiter(void 0, void 0, void 0, function* () {
+        callback(processHeader(yield context.chain.head.header));
+    });
+    update();
+    return id;
+});
+exports.chain_subscribeNewHead = chain_subscribeNewHead;
+const chain_subscribeFinalizedHeads = (context, _params, { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = () => __awaiter(void 0, void 0, void 0, function* () {
+        callback(processHeader(yield context.chain.head.header));
+    });
+    update();
+    return id;
+});
+exports.chain_subscribeFinalizedHeads = chain_subscribeFinalizedHeads;
+const chain_unsubscribeNewHead = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.chain_unsubscribeNewHead = chain_unsubscribeNewHead;
+exports.chain_getHead = exports.chain_getBlockHash;
+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

@@ -0,0 +1,66 @@
+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("..").Handler<void, string>;
+    system_properties: import("..").Handler<void, import("../..").ChainProperties>;
+    system_name: import("..").Handler<void, string>;
+    system_version: import("..").Handler<void, string>;
+    system_chainType: import("..").Handler<void, string>;
+    system_health: () => Promise<{
+        peers: number;
+        isSyncing: boolean;
+        shouldHavePeers: boolean;
+    }>;
+    system_dryRun: import("..").Handler<[`0x${string}`, `0x${string}`], string>;
+    system_accountNextIndex: import("..").Handler<[`0x${string}`], number>;
+    state_getRuntimeVersion: import("..").Handler<[`0x${string}`], import("../..").RuntimeVersion | undefined>;
+    state_getMetadata: import("..").Handler<[`0x${string}`], `0x${string}` | undefined>;
+    state_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`], string | undefined>;
+    state_getKeysPaged: import("..").Handler<[string, number, string, `0x${string}`], string[] | undefined>;
+    state_queryStorageAt: import("..").Handler<[string[], `0x${string}`], [] | [{
+        block: `0x${string}`;
+        changes: (string | undefined)[][];
+    }]>;
+    state_call: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
+    state_subscribeRuntimeVersion: import("..").Handler<[], string>;
+    state_unsubscribeRuntimeVersion: import("..").Handler<[`0x${string}`], void>;
+    state_subscribeStorage: import("..").Handler<[string[]], string>;
+    state_unsubscribeStorage: import("..").Handler<[string], void>;
+    childstate_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | undefined>;
+    childstate_getKeysPaged: import("..").Handler<[`0x${string}`, `0x${string}`, number, `0x${string}`, `0x${string}`], `0x${string}`[] | undefined>;
+    payment_queryFeeDetails: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    payment_queryInfo: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    chain_getBlockHash: import("..").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_getHeader: import("..").Handler<[`0x${string}`], import("@polkadot/types/interfaces").Header>;
+    chain_getBlock: import("..").Handler<[`0x${string}`], {
+        block: {
+            header: import("@polkadot/types/interfaces").Header;
+            extrinsics: `0x${string}`[];
+        };
+        justifications: null;
+    }>;
+    chain_getFinalizedHead: import("..").Handler<void, `0x${string}`>;
+    chain_subscribeNewHead: import("..").Handler<void, string>;
+    chain_subscribeFinalizedHeads: import("..").Handler<void, string>;
+    chain_unsubscribeNewHead: import("..").Handler<[string], void>;
+    chain_getHead: import("..").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_subscribeNewHeads: import("..").Handler<void, string>;
+    chain_unsubscribeNewHeads: import("..").Handler<[string], void>;
+    chain_unsubscribeFinalizedHeads: import("..").Handler<[string], void>;
+    author_submitExtrinsic: import("..").Handler<[`0x${string}`], `0x${string}`>;
+    author_submitAndWatchExtrinsic: import("..").Handler<[`0x${string}`], string>;
+    author_unwatchExtrinsic: import("..").Handler<[string], void>;
+    author_pendingExtrinsics: import("..").Handler<void, `0x${string}`[]>;
+};
+export default handlers;

package/lib/rpc/substrate/index.js

@@ -0,0 +1,38 @@
+"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 __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 });
+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 = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, AuthorRPC), ChainRPC), PaymentRPC), StateRPC), SystemRPC);
+exports.default = handlers;

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

@@ -0,0 +1,16 @@
+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>;