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

package/dist/{types → cjs}/plugins/run-block/rpc.d.ts

@@ -123,6 +123,7 @@ export interface RunBlockResponse {
             method: string;
             args: any[];
             success: boolean;
+            signer: string | null;
         }[];
     };
 }

package/dist/cjs/plugins/run-block/rpc.js

@@ -142,11 +142,13 @@ const rpc = async ({ chain }, [params])=>{
         const extrinsics = block.extrinsics.map((extrinsic, idx)=>{
             const parsed = registry.createType('GenericExtrinsic', extrinsic);
             const resultEvent = events?.find(({ event, phase })=>event.section === 'system' && (event.method === 'ExtrinsicSuccess' || event.method === 'ExtrinsicFailed') && phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(idx));
+            const signer = parsed.signer.isEmpty ? null : parsed.signer.toHex();
             return {
                 section: parsed.method.section,
                 method: parsed.method.method,
                 args: parsed.method.args.map((arg)=>arg.toJSON()),
-                success: resultEvent?.event.method === 'ExtrinsicSuccess'
+                success: resultEvent?.event.method === 'ExtrinsicSuccess',
+                signer
             };
         });
         resp.blockDetails = {

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 {};