@acala-network/chopsticks 0.8.1 → 0.8.3

package/lib/plugins/dry-run/rpc.d.ts

@@ -1,3 +1,140 @@
-import { Handler } from '../../rpc/shared';
+import { z } from 'zod';
+import { Context } from '../../rpc/shared';
+declare const schema: z.ZodObject<{
+    raw: z.ZodOptional<z.ZodBoolean>;
+    html: z.ZodOptional<z.ZodBoolean>;
+    extrinsic: z.ZodOptional<z.ZodUnion<[z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodObject<{
+        call: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        address: `0x${string}`;
+        call: `0x${string}`;
+    }, {
+        address: `0x${string}`;
+        call: `0x${string}`;
+    }>]>>;
+    hrmp: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, number, string>, z.ZodArray<z.ZodObject<{
+        sentAt: z.ZodNumber;
+        data: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        data: `0x${string}`;
+        sentAt: number;
+    }, {
+        data: `0x${string}`;
+        sentAt: number;
+    }>, "many">>>;
+    dmp: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sentAt: z.ZodNumber;
+        msg: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    }, "strip", z.ZodTypeAny, {
+        sentAt: number;
+        msg: `0x${string}`;
+    }, {
+        sentAt: number;
+        msg: `0x${string}`;
+    }>, "many">>;
+    ump: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, number, string>, z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">>>;
+    at: z.ZodOptional<z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>>;
+}, "strip", z.ZodTypeAny, {
+    raw?: boolean | undefined;
+    html?: boolean | undefined;
+    extrinsic?: `0x${string}` | {
+        address: `0x${string}`;
+        call: `0x${string}`;
+    } | undefined;
+    hrmp?: Record<number, {
+        data: `0x${string}`;
+        sentAt: number;
+    }[]> | undefined;
+    dmp?: {
+        sentAt: number;
+        msg: `0x${string}`;
+    }[] | undefined;
+    ump?: Record<number, `0x${string}`[]> | undefined;
+    at?: `0x${string}` | undefined;
+}, {
+    raw?: boolean | undefined;
+    html?: boolean | undefined;
+    extrinsic?: `0x${string}` | {
+        address: `0x${string}`;
+        call: `0x${string}`;
+    } | undefined;
+    hrmp?: Record<string, {
+        data: `0x${string}`;
+        sentAt: number;
+    }[]> | undefined;
+    dmp?: {
+        sentAt: number;
+        msg: `0x${string}`;
+    }[] | undefined;
+    ump?: Record<string, `0x${string}`[]> | undefined;
+    at?: `0x${string}` | undefined;
+}>;
 export declare const name = "dryRun";
-export declare const rpc: Handler;
+type Params = z.infer<typeof schema>;
+export interface DryRunParams {
+    /**
+     * Return the raw storage diff
+     */
+    raw: Params['raw'];
+    /**
+     * Return the html storage diff
+     */
+    html: Params['html'];
+    /**
+     * The extrinsic to run
+     */
+    extrinsic: Params['extrinsic'];
+    /**
+     * The horizontal messages to run
+     */
+    hrmp: Params['hrmp'];
+    /**
+     * The downward messages to run
+     */
+    dmp: Params['dmp'];
+    /**
+     * The upward messages to run
+     */
+    ump: Params['ump'];
+    /**
+     * The block hash or number to run the extrinsic at
+     */
+    at: Params['at'];
+}
+/**
+ * Dry run an extrinsic or messages.
+ * If `html` is true, return the generated storage diff html string.
+ * If `raw` is true, return the raw storage diff.
+ * Otherwise, return `{ oldState, newState, delta }`.
+ *
+ * This function is a dev rpc handler. Use `dev_dryRun` 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 Dry run an dmp
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const params = [
+    {
+      raw: false,
+      dmp: [
+        // https://acala.subscan.io/xcm_message/polkadot-2ab22918c567455af3563989d852f307f4cc1250
+        {
+          sentAt: 14471353,
+          msg: '0x02100104000100000b00280b9bba030a13000100000b00280b9bba03010300286bee0d0100040001010070c53d8e216f9c0f2e3b11c53f5f4bf3e078b995d5f0ed590f889f41e20e6531',
+        },
+      ],
+    },
+  ]
+ * await ws.send('dev_dryRun', params)
+ * ```
+ */
+export declare const rpc: (context: Context, [params]: [DryRunParams]) => Promise<string | [`0x${string}`, `0x${string}` | null][] | {
+    old: {};
+    new: {};
+    delta: import("jsondiffpatch").Delta | undefined;
+}>;
+export {};

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

@@ -37,6 +37,36 @@ const schema = zod_1.z.object({
 });
 // custom rpc name (optional). e.g. dryRun will be called as dev_dryRun
 exports.name = 'dryRun';
+/**
+ * Dry run an extrinsic or messages.
+ * If `html` is true, return the generated storage diff html string.
+ * If `raw` is true, return the raw storage diff.
+ * Otherwise, return `{ oldState, newState, delta }`.
+ *
+ * This function is a dev rpc handler. Use `dev_dryRun` 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 Dry run an dmp
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const params = [
+    {
+      raw: false,
+      dmp: [
+        // https://acala.subscan.io/xcm_message/polkadot-2ab22918c567455af3563989d852f307f4cc1250
+        {
+          sentAt: 14471353,
+          msg: '0x02100104000100000b00280b9bba030a13000100000b00280b9bba03010300286bee0d0100040001010070c53d8e216f9c0f2e3b11c53f5f4bf3e078b995d5f0ed590f889f41e20e6531',
+        },
+      ],
+    },
+  ]
+ * await ws.send('dev_dryRun', params)
+ * ```
+ */
 const rpc = async (context, [params]) => {
     const { html, extrinsic, hrmp, dmp, ump, raw, at } = schema.parse(params);
     const dryRun = async () => {

package/lib/plugins/new-block/index.d.ts

@@ -1,2 +1,72 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { Context } from '../../rpc/shared';
+import { DownwardMessage, HorizontalMessage } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+export interface NewBlockParams {
+    /**
+     * The number of blocks to build
+     */
+    count: number;
+    /**
+     * The block number to build to
+     */
+    to: number;
+    /**
+     * The downward messages to include in the block
+     */
+    dmp: DownwardMessage[];
+    /**
+     * The upward messages to include in the block
+     */
+    ump: Record<number, HexString[]>;
+    /**
+     * The horizontal messages to include in the block
+     */
+    hrmp: Record<number, HorizontalMessage[]>;
+    /**
+     * The transactions to include in the block
+     */
+    transactions: HexString[];
+    /**
+     * Build block using a specific block height (unsafe)
+     */
+    unsafeBlockHeight: number;
+}
+/**
+ * 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/api'
+ * 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/api'
+ * 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/api'
+ * 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 }])
+ * ```
+ */
+export declare const rpc: (context: Context, params: [NewBlockParams]) => Promise<string | undefined>;

package/lib/plugins/new-block/index.js

@@ -3,7 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
 const shared_1 = require("../../rpc/shared");
 const logger_1 = require("../../logger");
-const rpc = async (context, [param]) => {
+/**
+ * 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/api'
+ * 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/api'
+ * 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/api'
+ * 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) => {
+    const [param] = params;
     const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
     const now = context.chain.head.number;
     const diff = to ? to - now : count;

package/lib/plugins/set-block-build-mode/index.d.ts

@@ -1,2 +1,19 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { BuildBlockMode } from '@acala-network/chopsticks-core';
+import { Context } from '../../rpc/shared';
+/**
+ * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
+ *
+ * This function is a dev rpc handler. Use `dev_setBlockBuildMode` 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 Set build block mode to instant
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * import { BuildBlockMode } from '@acala-network/chopsticks'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
+ * ```
+ */
+export declare const rpc: (context: Context, [mode]: [BuildBlockMode]) => Promise<void>;

package/lib/plugins/set-block-build-mode/index.js

@@ -4,6 +4,22 @@ exports.rpc = void 0;
 const chopsticks_core_1 = require("@acala-network/chopsticks-core");
 const shared_1 = require("../../rpc/shared");
 const logger_1 = require("../../logger");
+/**
+ * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
+ *
+ * This function is a dev rpc handler. Use `dev_setBlockBuildMode` 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 Set build block mode to instant
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * import { BuildBlockMode } from '@acala-network/chopsticks'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
+ * ```
+ */
 const rpc = async (context, [mode]) => {
     logger_1.defaultLogger.debug({ mode }, 'dev_setBlockBuildMode');
     if (chopsticks_core_1.BuildBlockMode[mode] === undefined) {

package/lib/plugins/set-head/index.d.ts

@@ -1,2 +1,18 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { Context } from '../../rpc/shared';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Set head.
+ *
+ * This function is a dev rpc handler. Use `dev_setHead` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param hashOrNumber - The block hash or number to set as head
+ *
+ * @example Set head to block 1000000
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setHead', [1000000])
+ * ```
+ */
+export declare const rpc: (context: Context, [hashOrNumber]: [HexString | number]) => Promise<`0x${string}`>;

package/lib/plugins/set-head/index.js

@@ -2,6 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
 const shared_1 = require("../../rpc/shared");
+/**
+ * Set head.
+ *
+ * This function is a dev rpc handler. Use `dev_setHead` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param hashOrNumber - The block hash or number to set as head
+ *
+ * @example Set head to block 1000000
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setHead', [1000000])
+ * ```
+ */
 const rpc = async (context, [hashOrNumber]) => {
     let block;
     if (typeof hashOrNumber === 'number') {

package/lib/plugins/set-runtime-log-level/index.d.ts

@@ -1,2 +1,17 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { Context } from '../../rpc/shared';
+/**
+ * Set runtime log level.
+ *
+ * This function is a dev rpc handler. Use `dev_setRuntimeLogLevel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param runtimeLogLevel - The runtime log level to set
+ *
+ * @example Set runtime log level to 1
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setRuntimeLogLevel', [1])
+ * ```
+ */
+export declare const rpc: (context: Context, [runtimeLogLevel]: [number]) => Promise<void>;

package/lib/plugins/set-runtime-log-level/index.js

@@ -3,6 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
 const shared_1 = require("../../rpc/shared");
 const logger_1 = require("../../logger");
+/**
+ * Set runtime log level.
+ *
+ * This function is a dev rpc handler. Use `dev_setRuntimeLogLevel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param runtimeLogLevel - The runtime log level to set
+ *
+ * @example Set runtime log level to 1
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setRuntimeLogLevel', [1])
+ * ```
+ */
 const rpc = async (context, [runtimeLogLevel]) => {
     logger_1.defaultLogger.debug({ runtimeLogLevel }, 'dev_setRuntimeLogLevel');
     if (typeof runtimeLogLevel !== 'number') {

package/lib/plugins/set-storage/index.d.ts

@@ -1,2 +1,29 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { HexString } from '@polkadot/util/types';
+import { Context } from '../../rpc/shared';
+import { StorageValues } from '@acala-network/chopsticks-core';
+/**
+ * Set storage values.
+ *
+ * This function is a dev rpc handler. Use `dev_setStorage` 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
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * import { Keyring } from '@polkadot/keyring'
+ *
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const keyring = new Keyring({ type: 'ed25519' })
+ * const bob = keyring.addFromUri('//Bob')
+ *
+ * const storage = {
+ *   System: {
+ *     Account: [[[bob.address], { data: { free: 100000 }, nonce: 1 }]],
+ *   },
+ * }
+ * await ws.send('dev_setStorage', [storage])
+ * ```
+ */
+export declare const rpc: (context: Context, params: [StorageValues, HexString?]) => Promise<`0x${string}`>;

package/lib/plugins/set-storage/index.js

@@ -4,6 +4,31 @@ exports.rpc = void 0;
 const shared_1 = require("../../rpc/shared");
 const chopsticks_core_1 = require("@acala-network/chopsticks-core");
 const logger_1 = require("../../logger");
+/**
+ * Set storage values.
+ *
+ * This function is a dev rpc handler. Use `dev_setStorage` 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
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * import { Keyring } from '@polkadot/keyring'
+ *
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const keyring = new Keyring({ type: 'ed25519' })
+ * const bob = keyring.addFromUri('//Bob')
+ *
+ * const storage = {
+ *   System: {
+ *     Account: [[[bob.address], { data: { free: 100000 }, nonce: 1 }]],
+ *   },
+ * }
+ * await ws.send('dev_setStorage', [storage])
+ * ```
+ */
 const rpc = async (context, params) => {
     const [values, blockHash] = params;
     const hash = await (0, chopsticks_core_1.setStorage)(context.chain, values, blockHash).catch((error) => {

package/lib/plugins/time-travel/index.d.ts

@@ -1,2 +1,17 @@
-import { Handler } from '../../rpc/shared';
-export declare const rpc: Handler;
+import { Context } from '../../rpc/shared';
+/**
+ * Travel to a specific time.
+ *
+ * This function is a dev rpc handler. Use `dev_timeTravel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param date - Timestamp or date string to set
+ *
+ * @example
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_timeTravel', ['Jan 1, 2023'])
+ * ```
+ */
+export declare const rpc: (context: Context, [date]: [string | number]) => Promise<number>;

package/lib/plugins/time-travel/index.js

@@ -3,6 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = void 0;
 const shared_1 = require("../../rpc/shared");
 const chopsticks_core_1 = require("@acala-network/chopsticks-core");
+/**
+ * Travel to a specific time.
+ *
+ * This function is a dev rpc handler. Use `dev_timeTravel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param date - Timestamp or date string to set
+ *
+ * @example
+ * ```ts
+ * import { WsProvider } from '@polkadot/api'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_timeTravel', ['Jan 1, 2023'])
+ * ```
+ */
 const rpc = async (context, [date]) => {
     const timestamp = typeof date === 'string' ? Date.parse(date) : date;
     if (Number.isNaN(timestamp))

package/lib/plugins/types.d.ts

@@ -0,0 +1,7 @@
+export { rpc as newBlock, NewBlockParams } from './new-block';
+export { rpc as dryRun, DryRunParams } from './dry-run';
+export { rpc as setBlockBuildMode } from './set-block-build-mode';
+export { rpc as setHead } from './set-head';
+export { rpc as setRuntimeLogLevel } from './set-runtime-log-level';
+export { rpc as setStorage } from './set-storage';
+export { rpc as timeTravel } from './time-travel';

package/lib/plugins/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeTravel = exports.setStorage = exports.setRuntimeLogLevel = exports.setHead = exports.setBlockBuildMode = exports.dryRun = exports.newBlock = void 0;
+var new_block_1 = require("./new-block");
+Object.defineProperty(exports, "newBlock", { enumerable: true, get: function () { return new_block_1.rpc; } });
+var dry_run_1 = require("./dry-run");
+Object.defineProperty(exports, "dryRun", { enumerable: true, get: function () { return dry_run_1.rpc; } });
+var set_block_build_mode_1 = require("./set-block-build-mode");
+Object.defineProperty(exports, "setBlockBuildMode", { enumerable: true, get: function () { return set_block_build_mode_1.rpc; } });
+var set_head_1 = require("./set-head");
+Object.defineProperty(exports, "setHead", { enumerable: true, get: function () { return set_head_1.rpc; } });
+var set_runtime_log_level_1 = require("./set-runtime-log-level");
+Object.defineProperty(exports, "setRuntimeLogLevel", { enumerable: true, get: function () { return set_runtime_log_level_1.rpc; } });
+var set_storage_1 = require("./set-storage");
+Object.defineProperty(exports, "setStorage", { enumerable: true, get: function () { return set_storage_1.rpc; } });
+var time_travel_1 = require("./time-travel");
+Object.defineProperty(exports, "timeTravel", { enumerable: true, get: function () { return time_travel_1.rpc; } });

package/lib/rpc/index.d.ts

@@ -2,4 +2,4 @@ import { Context, SubscriptionManager } from './shared';
 export declare const handler: (context: Context) => ({ method, params }: {
     method: string;
     params: any[];
-}, subscriptionManager: SubscriptionManager) => Promise<string | number | void | object | null | undefined>;
+}, subscriptionManager: SubscriptionManager) => Promise<any>;

package/lib/rpc/shared.d.ts

@@ -14,11 +14,14 @@ export declare class ResponseError extends Error {
     };
 }
 export interface Context {
+    /**
+     * The blockchain instance, see `Blockchain` type in the `core` package
+     */
     chain: Blockchain;
 }
 export interface SubscriptionManager {
     subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
     unsubscribe: (subid: string) => void;
 }
-export type Handler = (context: Context, params: any[], subscriptionManager: SubscriptionManager) => Promise<object | string | number | void | undefined | null>;
+export type Handler<TParams = any, TReturn = any> = (context: Context, params: TParams, subscriptionManager: SubscriptionManager) => Promise<TReturn>;
 export type Handlers = Record<string, Handler>;

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

@@ -1,3 +1,28 @@
-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`]
+ *
+ * @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[]>;