@acala-network/chopsticks 0.9.2-2 → 0.9.2-4

package/dist/esm/rpc/index.js

@@ -1,26 +1,26 @@
 import { ResponseError, logger, substrate } from '@acala-network/chopsticks-core';
-import { pluginHandlers } from '../plugins/index.js';
+import { loadRpcPlugin, rpcPluginMethods } from '../plugins/index.js';
 const allHandlers = {
     ...substrate,
     rpc_methods: async ()=>Promise.resolve({
             version: 1,
             methods: [
                 ...Object.keys(allHandlers),
-                ...Object.keys(pluginHandlers)
+                ...rpcPluginMethods
             ]
         })
 };
-const getHandler = (method)=>{
+const getHandler = async (method)=>{
     const handler = allHandlers[method];
     if (!handler) {
         // no handler for this method, check if it's a plugin
-        return pluginHandlers[method];
+        return loadRpcPlugin(method);
     }
     return handler;
 };
-export const handler = (context)=>({ method, params }, subscriptionManager)=>{
+export const handler = (context)=>async ({ method, params }, subscriptionManager)=>{
         logger.trace('Handling %s', method);
-        const handler = getHandler(method);
+        const handler = await getHandler(method);
         if (!handler) {
             logger.warn('Method not found %s', method);
             throw new ResponseError(-32601, `Method not found: ${method}`);

package/dist/esm/schema/index.js

@@ -5,6 +5,8 @@ import { z } from 'zod';
 import _ from 'lodash';
 import axios from 'axios';
 import yaml from 'js-yaml';
+export const zHex = z.custom((val)=>/^0x\w+$/.test(val));
+export const zHash = z.string().length(66).and(zHex);
 export const configSchema = z.object({
     port: z.number().optional(),
     endpoint: z.string().optional(),

package/dist/types/plugins/decode-key/cli.d.ts

@@ -0,0 +1,2 @@
+import type { Argv } from 'yargs';
+export declare const cli: (y: Argv) => void;

package/dist/types/plugins/decode-key/index.d.ts

@@ -1,2 +1 @@
-import type { Argv } from 'yargs';
-export declare const cli: (y: Argv) => void;
+export * from './cli.js';

package/dist/types/plugins/dry-run/rpc.d.ts

@@ -70,7 +70,6 @@ declare const schema: z.ZodObject<{
     ump?: Record<string, `0x${string}`[]> | undefined;
     at?: `0x${string}` | undefined;
 }>;
-export declare const name = "dryRun";
 type Params = z.infer<typeof schema>;
 export interface DryRunParams {
     /**

package/dist/types/plugins/follow-chain/cli.d.ts

@@ -0,0 +1,2 @@
+import type { Argv } from 'yargs';
+export declare const cli: (y: Argv) => void;

package/dist/types/plugins/follow-chain/index.d.ts

@@ -1,2 +1 @@
-import type { Argv } from 'yargs';
-export declare const cli: (y: Argv) => void;
+export * from './cli.js';

package/dist/types/plugins/index.d.ts

@@ -1,5 +1,6 @@
 import { Handlers } from '@acala-network/chopsticks-core';
 import type { Argv } from 'yargs';
-export declare const pluginHandlers: Handlers;
-export declare const loadRPCPlugins: () => Promise<void>;
+export declare const rpcPluginHandlers: Handlers;
+export declare const rpcPluginMethods: string[];
+export declare const loadRpcPlugin: (method: string) => Promise<any>;
 export declare const pluginExtendCli: (y: Argv) => Promise<void>;

package/dist/types/plugins/new-block/index.d.ts

@@ -1,71 +1 @@
-import { Context, 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/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [{ count: 2 }])
- * ```
- * @example Build a block with upward messages
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_newBlock', [
- *  {
- *    ump: {
- *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
- *      2000: [
- *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
- *      ],
- *    }
- *  }
- * ])
- * ```
- *
- * @example Build two blocks with unsafeBlockHeight
- * ```ts
- * import { WsProvider } from '@polkadot/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * // this will create two blocks with block height 100000001 and 100000002
- * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
- * ```
- */
-export declare const rpc: (context: Context, params: [NewBlockParams]) => Promise<string | undefined>;
+export * from './rpc.js';

package/dist/types/plugins/new-block/rpc.d.ts

@@ -0,0 +1,128 @@
+import { Context } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+declare const schema: z.ZodObject<{
+    count: z.ZodOptional<z.ZodNumber>;
+    to: z.ZodOptional<z.ZodNumber>;
+    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.ZodNumber, z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">>>;
+    hrmp: z.ZodOptional<z.ZodRecord<z.ZodNumber, 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">>>;
+    transactions: z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">>;
+    unsafeBlockHeight: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    count?: number | undefined;
+    to?: number | undefined;
+    dmp?: {
+        sentAt: number;
+        msg: `0x${string}`;
+    }[] | undefined;
+    ump?: Record<number, `0x${string}`[]> | undefined;
+    hrmp?: Record<number, {
+        data: `0x${string}`;
+        sentAt: number;
+    }[]> | undefined;
+    transactions?: `0x${string}`[] | undefined;
+    unsafeBlockHeight?: number | undefined;
+}, {
+    count?: number | undefined;
+    to?: number | undefined;
+    dmp?: {
+        sentAt: number;
+        msg: `0x${string}`;
+    }[] | undefined;
+    ump?: Record<number, `0x${string}`[]> | undefined;
+    hrmp?: Record<number, {
+        data: `0x${string}`;
+        sentAt: number;
+    }[]> | undefined;
+    transactions?: `0x${string}`[] | undefined;
+    unsafeBlockHeight?: number | undefined;
+}>;
+type Params = z.infer<typeof schema>;
+export interface NewBlockParams {
+    /**
+     * The number of blocks to build
+     */
+    count: Params['count'];
+    /**
+     * The block number to build to
+     */
+    to: Params['to'];
+    /**
+     * The downward messages to include in the block
+     */
+    dmp: Params['dmp'];
+    /**
+     * The upward messages to include in the block
+     */
+    ump: Params['ump'];
+    /**
+     * The horizontal messages to include in the block
+     */
+    hrmp: Params['hrmp'];
+    /**
+     * The transactions to include in the block
+     */
+    transactions: Params['transactions'];
+    /**
+     * Build block using a specific block height (unsafe)
+     */
+    unsafeBlockHeight: Params['unsafeBlockHeight'];
+}
+/**
+ * Build new blocks.
+ *
+ * This function is a dev rpc handler. Use `dev_newBlock` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param params - The parameters of the rpc handler
+ *
+ * @example Build 2 blocks
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [{ count: 2 }])
+ * ```
+ * @example Build a block with upward messages
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [
+ *  {
+ *    ump: {
+ *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
+ *      2000: [
+ *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
+ *      ],
+ *    }
+ *  }
+ * ])
+ * ```
+ *
+ * @example Build two blocks with unsafeBlockHeight
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * // this will create two blocks with block height 100000001 and 100000002
+ * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
+ * ```
+ */
+export declare const rpc: (context: Context, [params]: [NewBlockParams]) => Promise<string | undefined>;
+export {};

package/dist/types/plugins/run-block/cli.d.ts

@@ -0,0 +1,2 @@
+import type { Argv } from 'yargs';
+export declare const cli: (y: Argv) => void;

package/dist/types/plugins/run-block/index.d.ts

@@ -1,141 +1,2 @@
-import { HexString } from '@polkadot/util/types';
-import { z } from 'zod';
-import type { Argv } from 'yargs';
-import { Context, RuntimeLog } from '@acala-network/chopsticks-core';
-export declare const cli: (y: Argv) => void;
-declare const schema: z.ZodObject<{
-    includeRaw: z.ZodOptional<z.ZodBoolean>;
-    includeParsed: z.ZodOptional<z.ZodBoolean>;
-    includeBlockDetails: z.ZodOptional<z.ZodBoolean>;
-    parent: z.ZodOptional<z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>>;
-    block: z.ZodObject<{
-        header: z.ZodAny;
-        extrinsics: z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        extrinsics: `0x${string}`[];
-        header?: any;
-    }, {
-        extrinsics: `0x${string}`[];
-        header?: any;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    block: {
-        extrinsics: `0x${string}`[];
-        header?: any;
-    };
-    includeRaw?: boolean | undefined;
-    includeParsed?: boolean | undefined;
-    includeBlockDetails?: boolean | undefined;
-    parent?: `0x${string}` | undefined;
-}, {
-    block: {
-        extrinsics: `0x${string}`[];
-        header?: any;
-    };
-    includeRaw?: boolean | undefined;
-    includeParsed?: boolean | undefined;
-    includeBlockDetails?: boolean | undefined;
-    parent?: `0x${string}` | undefined;
-}>;
-type Params = z.infer<typeof schema>;
-export interface RunBlockParams {
-    /**
-     * Include raw storage diff. Default to true
-     */
-    includeRaw: Params['includeRaw'];
-    /**
-     * Include parsed storage diff in json format
-     */
-    includeParsed: Params['includeParsed'];
-    /**
-     * Include block details such as parsed extrinsics in json format
-     */
-    includeBlockDetails: Params['includeBlockDetails'];
-    /**
-     * The parent block hash to run on top of. Default to chain head.
-     */
-    parent: Params['parent'];
-    /**
-     * Block to run
-     */
-    block: Params['block'];
-}
-/**
- * The phase of an execution.
- * `number` means the phase is ApplyExtrinsic and the value is the extrinsic index.
- */
-export type Phase = 'Initialization' | 'Finalization' | number;
-export interface RunBlockResponse {
-    /**
-     * The storage diff of each phase.
-     */
-    phases: {
-        /**
-         * The phase of the execution. See {@link Phase}.
-         */
-        phase: Phase;
-        /**
-         * The modified storages of this phase.
-         */
-        storageDiff: {
-            /**
-             * Raw storage diff in bytes. Only available when `includeRaw` is true.
-             */
-            raw?: {
-                key: HexString;
-                value: HexString | null;
-            };
-            /**
-             * Decoded storage diff. Only available when `includeParsed` is true.
-             */
-            parsed?: {
-                method: string;
-                section: string;
-                key: any[];
-                value: any;
-            };
-        }[];
-        /**
-         * Runtime logs.
-         */
-        logs?: RuntimeLog[];
-    }[];
-    /**
-     * Block details. Only available when `includeBlockDetails` is true.
-     */
-    blockDetails?: {
-        /**
-         * Block timestamp in ms
-         */
-        timestamp?: string;
-        /**
-         * Parsed events in this block.
-         */
-        events?: {
-            phase: Phase;
-            section: string;
-            method: string;
-            args: any[];
-        }[];
-        /**
-         * Parsed extrinsics in this block.
-         */
-        extrinsics: {
-            section: string;
-            method: string;
-            args: any[];
-            success: boolean;
-        }[];
-    };
-}
-export declare const name = "runBlock";
-/**
- * Run a set of extrinsics on top of a block and get the storage diff
- * and optionally the parsed storage diff and block details.
- * NOTE: The extrinsics should include inherents or tranasctions may have unexpected results.
- * NOTE: system.events and system.extrinsicData are excluded from storage diff to reduce size.
- *
- * This function is a dev rpc handler. Use `dev_runBlock` as the method name when calling it.
- */
-export declare const rpc: ({ chain }: Context, [params]: [RunBlockParams]) => Promise<RunBlockResponse>;
-export {};
+export * from './cli.js';
+export * from './rpc.js';

package/dist/types/plugins/run-block/rpc.d.ts

@@ -0,0 +1,139 @@
+import { HexString } from '@polkadot/util/types';
+import { z } from 'zod';
+import { Context, RuntimeLog } from '@acala-network/chopsticks-core';
+declare const schema: z.ZodObject<{
+    includeRaw: z.ZodOptional<z.ZodBoolean>;
+    includeParsed: z.ZodOptional<z.ZodBoolean>;
+    includeBlockDetails: z.ZodOptional<z.ZodBoolean>;
+    parent: z.ZodOptional<z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>>;
+    block: z.ZodObject<{
+        header: z.ZodAny;
+        extrinsics: z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        extrinsics: `0x${string}`[];
+        header?: any;
+    }, {
+        extrinsics: `0x${string}`[];
+        header?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    block: {
+        extrinsics: `0x${string}`[];
+        header?: any;
+    };
+    includeRaw?: boolean | undefined;
+    includeParsed?: boolean | undefined;
+    includeBlockDetails?: boolean | undefined;
+    parent?: `0x${string}` | undefined;
+}, {
+    block: {
+        extrinsics: `0x${string}`[];
+        header?: any;
+    };
+    includeRaw?: boolean | undefined;
+    includeParsed?: boolean | undefined;
+    includeBlockDetails?: boolean | undefined;
+    parent?: `0x${string}` | undefined;
+}>;
+type Params = z.infer<typeof schema>;
+export interface RunBlockParams {
+    /**
+     * Include raw storage diff. Default to true
+     */
+    includeRaw: Params['includeRaw'];
+    /**
+     * Include parsed storage diff in json format
+     */
+    includeParsed: Params['includeParsed'];
+    /**
+     * Include block details such as parsed extrinsics in json format
+     */
+    includeBlockDetails: Params['includeBlockDetails'];
+    /**
+     * The parent block hash to run on top of. Default to chain head.
+     */
+    parent: Params['parent'];
+    /**
+     * Block to run
+     */
+    block: Params['block'];
+}
+/**
+ * The phase of an execution.
+ * `number` means the phase is ApplyExtrinsic and the value is the extrinsic index.
+ */
+export type Phase = 'Initialization' | 'Finalization' | number;
+export interface RunBlockResponse {
+    /**
+     * The storage diff of each phase.
+     */
+    phases: {
+        /**
+         * The phase of the execution. See {@link Phase}.
+         */
+        phase: Phase;
+        /**
+         * The modified storages of this phase.
+         */
+        storageDiff: {
+            /**
+             * Raw storage diff in bytes. Only available when `includeRaw` is true.
+             */
+            raw?: {
+                key: HexString;
+                value: HexString | null;
+            };
+            /**
+             * Decoded storage diff. Only available when `includeParsed` is true.
+             */
+            parsed?: {
+                method: string;
+                section: string;
+                key: any[];
+                value: any;
+            };
+        }[];
+        /**
+         * Runtime logs.
+         */
+        logs?: RuntimeLog[];
+    }[];
+    /**
+     * Block details. Only available when `includeBlockDetails` is true.
+     */
+    blockDetails?: {
+        /**
+         * Block timestamp in ms
+         */
+        timestamp?: string;
+        /**
+         * Parsed events in this block.
+         */
+        events?: {
+            phase: Phase;
+            section: string;
+            method: string;
+            args: any[];
+        }[];
+        /**
+         * Parsed extrinsics in this block.
+         */
+        extrinsics: {
+            section: string;
+            method: string;
+            args: any[];
+            success: boolean;
+        }[];
+    };
+}
+export declare const name = "runBlock";
+/**
+ * Run a set of extrinsics on top of a block and get the storage diff
+ * and optionally the parsed storage diff and block details.
+ * NOTE: The extrinsics should include inherents or tranasctions may have unexpected results.
+ * NOTE: system.events and system.extrinsicData are excluded from storage diff to reduce size.
+ *
+ * This function is a dev rpc handler. Use `dev_runBlock` as the method name when calling it.
+ */
+export declare const rpc: ({ chain }: Context, [params]: [RunBlockParams]) => Promise<RunBlockResponse>;
+export {};

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

@@ -1,18 +1 @@
-import { BuildBlockMode, Context } from '@acala-network/chopsticks-core';
-/**
- * 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/rpc-provider'
- * import { BuildBlockMode } from '@acala-network/chopsticks-core'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
- * ```
- */
-export declare const rpc: (context: Context, [mode]: [BuildBlockMode]) => Promise<void>;
+export * from './rpc.js';

package/dist/types/plugins/set-block-build-mode/rpc.d.ts

@@ -0,0 +1,20 @@
+import { BuildBlockMode, Context } from '@acala-network/chopsticks-core';
+/**
+ * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
+ *
+ * 1 - Batch, 2 - Instant, 3 - Manual
+ *
+ * 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/rpc-provider'
+ * import { BuildBlockMode } from '@acala-network/chopsticks-core'
+ * 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/dist/types/plugins/set-head/index.d.ts

@@ -1,18 +1 @@
-import { Context } from '@acala-network/chopsticks-core';
-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/rpc-provider'
- * 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}`>;
+export * from './rpc.js';

package/dist/types/plugins/set-head/rpc.d.ts

@@ -0,0 +1,21 @@
+import { Context } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+declare const schema: z.ZodUnion<[z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>, z.ZodNumber]>;
+type Params = z.infer<typeof schema>;
+/**
+ * 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/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setHead', [1000000])
+ * ```
+ */
+export declare const rpc: (context: Context, [params]: [Params]) => Promise<`0x${string}`>;
+export {};

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

@@ -1,17 +1 @@
-import { Context } from '@acala-network/chopsticks-core';
-/**
- * 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/rpc-provider'
- * const ws = new WsProvider(`ws://localhost:8000`)
- * await ws.send('dev_setRuntimeLogLevel', [1])
- * ```
- */
-export declare const rpc: (context: Context, [runtimeLogLevel]: [number]) => Promise<void>;
+export * from './rpc.js';