@acala-network/chopsticks 0.9.4-2 → 0.9.4-3

package/dist/esm/cli-options.d.ts

@@ -0,0 +1,40 @@
+export declare const defaultOptions: {
+    endpoint: {
+        desc: string;
+        string: boolean;
+    };
+    block: {
+        desc: string;
+        string: boolean;
+    };
+    'wasm-override': {
+        desc: string;
+        string: boolean;
+    };
+    db: {
+        desc: string;
+        string: boolean;
+    };
+    config: {
+        desc: string;
+        string: boolean;
+    };
+    'runtime-log-level': {
+        desc: string;
+        number: boolean;
+    };
+    'offchain-worker': {
+        desc: string;
+        boolean: boolean;
+    };
+};
+export declare const mockOptions: {
+    'import-storage': {
+        desc: string;
+        string: boolean;
+    };
+    'mock-signature-host': {
+        desc: string;
+        boolean: boolean;
+    };
+};

package/dist/esm/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/context.d.ts

@@ -0,0 +1,7 @@
+import './utils/tunnel.js';
+import { GenesisProvider } from '@acala-network/chopsticks-core';
+import { Config } from './schema/index.js';
+export declare const genesisFromUrl: (url: string) => Promise<GenesisProvider>;
+export declare const setupContext: (argv: Config, overrideParent?: boolean) => Promise<{
+    chain: import("@acala-network/chopsticks-core").Blockchain;
+}>;

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import '@polkadot/api-augment';
+export * from '@acala-network/chopsticks-core';
+export { setupWithServer } from './setup-with-server.js';
+export { fetchConfig } from './schema/index.js';

package/dist/esm/logger.d.ts

@@ -0,0 +1 @@
+export { defaultLogger, truncate } from '@acala-network/chopsticks-core';

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

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

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

@@ -0,0 +1 @@
+export * from './cli.js';

package/dist/esm/plugins/dry-run/cli.d.ts

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

package/dist/esm/plugins/dry-run/dry-run-extrinsic.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../../schema/index.js';
+export declare const dryRunExtrinsic: (argv: Config) => Promise<never>;

package/dist/esm/plugins/dry-run/dry-run-preimage.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../../schema/index.js';
+export declare const dryRunPreimage: (argv: Config) => Promise<never>;

package/dist/esm/plugins/dry-run/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cli.js';
+export * from './rpc.js';

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

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import { Context } from '@acala-network/chopsticks-core';
+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;
+}>;
+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/rpc-provider'
+ * 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/dist/esm/plugins/follow-chain/cli.d.ts

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

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

@@ -0,0 +1 @@
+export * from './cli.js';

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

@@ -0,0 +1,6 @@
+import { Handlers } from '@acala-network/chopsticks-core';
+import type { Argv } from 'yargs';
+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/esm/plugins/new-block/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/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/esm/plugins/run-block/cli.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from './cli.js';
+export * from './rpc.js';

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

@@ -0,0 +1,140 @@
+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;
+            signer: string | null;
+        }[];
+    };
+}
+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/esm/plugins/set-block-build-mode/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/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/esm/plugins/set-head/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/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/esm/plugins/set-runtime-log-level/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/plugins/set-runtime-log-level/rpc.d.ts

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

package/dist/esm/plugins/set-storage/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/plugins/set-storage/rpc.d.ts

@@ -0,0 +1,28 @@
+import { Context, StorageValues } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+/**
+ * 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/rpc-provider'
+ * 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/dist/esm/plugins/time-travel/index.d.ts

@@ -0,0 +1 @@
+export * from './rpc.js';

package/dist/esm/plugins/time-travel/rpc.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '@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/rpc-provider'
+ * 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/dist/esm/plugins/try-runtime/index.d.ts

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

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

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

package/dist/esm/rpc/index.d.ts

@@ -0,0 +1,5 @@
+import { Context, SubscriptionManager } from '@acala-network/chopsticks-core';
+export declare const handler: (context: Context) => ({ method, params }: {
+    method: string;
+    params: any[];
+}, subscriptionManager: SubscriptionManager) => Promise<any>;

package/dist/esm/schema/index.d.ts

@@ -0,0 +1,140 @@
+import { BuildBlockMode } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+export declare const zHex: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+export declare const zHash: z.ZodIntersection<z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+export declare const configSchema: z.ZodObject<{
+    port: z.ZodOptional<z.ZodNumber>;
+    endpoint: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    block: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    'build-block-mode': z.ZodOptional<z.ZodNativeEnum<typeof BuildBlockMode>>;
+    'import-storage': z.ZodOptional<z.ZodAny>;
+    'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
+    'max-memory-block-count': z.ZodOptional<z.ZodNumber>;
+    db: z.ZodOptional<z.ZodString>;
+    'wasm-override': z.ZodOptional<z.ZodString>;
+    genesis: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        properties: z.ZodObject<{
+            ss58Format: z.ZodOptional<z.ZodNumber>;
+            tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+            tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }>;
+        genesis: z.ZodObject<{
+            raw: z.ZodObject<{
+                top: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                top: Record<string, string>;
+            }, {
+                top: Record<string, string>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }, {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }>]>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    'registered-types': z.ZodOptional<z.ZodAny>;
+    'runtime-log-level': z.ZodOptional<z.ZodNumber>;
+    'offchain-worker': z.ZodOptional<z.ZodBoolean>;
+    resume: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, "strict", z.ZodTypeAny, {
+    port?: number | undefined;
+    endpoint?: string | string[] | undefined;
+    block?: string | number | null | undefined;
+    'build-block-mode'?: BuildBlockMode | undefined;
+    'import-storage'?: any;
+    'mock-signature-host'?: boolean | undefined;
+    'max-memory-block-count'?: number | undefined;
+    db?: string | undefined;
+    'wasm-override'?: string | undefined;
+    genesis?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    timestamp?: number | undefined;
+    'registered-types'?: any;
+    'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
+    resume?: string | number | boolean | undefined;
+}, {
+    port?: number | undefined;
+    endpoint?: string | string[] | undefined;
+    block?: string | number | null | undefined;
+    'build-block-mode'?: BuildBlockMode | undefined;
+    'import-storage'?: any;
+    'mock-signature-host'?: boolean | undefined;
+    'max-memory-block-count'?: number | undefined;
+    db?: string | undefined;
+    'wasm-override'?: string | undefined;
+    genesis?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    timestamp?: number | undefined;
+    'registered-types'?: any;
+    'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
+    resume?: string | number | boolean | undefined;
+}>;
+export type Config = z.infer<typeof configSchema>;
+export declare const fetchConfig: (path: string) => Promise<Config>;

package/dist/esm/server.d.ts

@@ -0,0 +1,9 @@
+import { SubscriptionManager } from '@acala-network/chopsticks-core';
+export type Handler = (data: {
+    method: string;
+    params: string[];
+}, subscriptionManager: SubscriptionManager) => Promise<any>;
+export declare const createServer: (handler: Handler, port?: number) => Promise<{
+    port: number;
+    close: () => Promise<void>;
+}>;

package/dist/esm/setup-with-server.d.ts

@@ -0,0 +1,6 @@
+import { Config } from './schema/index.js';
+export declare const setupWithServer: (argv: Config) => Promise<{
+    listenPort: number;
+    close(): Promise<void>;
+    chain: import("@acala-network/chopsticks-core").Blockchain;
+}>;

package/dist/esm/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chopsticks JSON RPC and CLI.
+ *
+ * @remarks
+ * This package extends the `@acala-network/chopsticks-core` package a with JSON RPC server and CLI support.
+ *
+ * @privateRemarks
+ * Above is the package documentation for 'chopsticks' package.
+ * `export` below is for tsdoc.
+ *
+ * @packageDocumentation
+ */
+export type { ChainProperties, RuntimeVersion, Context, SubscriptionManager, Handler, } from '@acala-network/chopsticks-core';
+export * from '@acala-network/chopsticks-core/rpc/substrate/index.js';
+export * from './plugins/types.js';

package/dist/esm/utils/decoder.d.ts

@@ -0,0 +1,7 @@
+import { Block } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+export declare const decodeStorageDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<{
+    oldState: {};
+    newState: {};
+    delta: import("jsondiffpatch").Delta | undefined;
+}>;

package/dist/esm/utils/generate-html-diff.d.ts

@@ -0,0 +1,4 @@
+import { Block } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+export declare const generateHtmlDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<string>;
+export declare const generateHtmlDiffPreviewFile: (block: Block, diff: [HexString, HexString | null][], filename: string) => Promise<string>;

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decoder.js';
+export * from './generate-html-diff.js';
+export * from './open-html.js';
+export * from './override.js';

package/dist/esm/utils/open-html.d.ts

@@ -0,0 +1 @@
+export declare const openHtml: (filePath: string) => void;

package/dist/esm/utils/override.d.ts

@@ -0,0 +1,4 @@
+import { Blockchain, StorageValues } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+export declare const overrideStorage: (chain: Blockchain, storage?: string | StorageValues, at?: HexString) => Promise<void>;
+export declare const overrideWasm: (chain: Blockchain, wasmPath?: string, at?: HexString) => Promise<void>;

package/dist/esm/utils/tunnel.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.9.4-2",
+  "version": "0.9.4-3",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.cjs",
   "type": "module",
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
-    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs --copy-files && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
-    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm --copy-files",
-    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build": "yarn clean && yarn build:cjs && yarn build:esm",
+    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs --copy-files && tsc -p tsconfig.json --declarationDir dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm --copy-files && tsc -p tsconfig.json --declarationDir dist/esm",
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-core": "0.9.4-2",
-    "@acala-network/chopsticks-db": "0.9.4-2",
+    "@acala-network/chopsticks-core": "0.9.4-3",
+    "@acala-network/chopsticks-db": "0.9.4-3",
     "@pnpm/npm-conf": "^2.2.2",
     "@polkadot/api-augment": "^10.10.1",
     "@polkadot/types": "^10.10.1",
@@ -46,38 +45,30 @@
   "files": [
     "dist/esm/**",
     "dist/cjs/**",
-    "dist/types/**",
     "chopsticks.cjs"
   ],
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
       "require": "./dist/cjs/index.js",
       "import": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
     },
     "./*": {
-      "types": "./dist/types/*.d.ts",
       "require": "./dist/cjs/*.js",
       "import": "./dist/esm/*.js",
       "default": "./dist/esm/*.js"
     },
     "./plugins/*": {
-      "types": "./dist/types/plugins/*.d.ts",
       "require": "./dist/cjs/plugins/*.js",
       "import": "./dist/esm/plugins/*.js",
       "default": "./dist/esm/plugins/*.js"
     },
     "./utils/*": {
-      "types": "./dist/types/utils/*.d.ts",
       "require": "./dist/cjs/utils/*.js",
       "import": "./dist/esm/utils/*.js",
       "default": "./dist/esm/utils/*.js"
-    },
-    "./package.json": "./package.json",
-    "./package.cjs.json": "./dist/cjs/package.json"
+    }
   }
 }