@acala-network/chopsticks-core 0.9.9-1 → 0.9.9

package/dist/cjs/wasm-executor/index.d.ts

@@ -71,7 +71,6 @@ export declare const runTask: (task: {
 export declare const taskHandler: (block: Block) => JsCallback;
 export declare const emptyTaskHandler: {
     getStorage: (_key: HexString) => Promise<never>;
-    getStateRoot: () => Promise<never>;
     getNextKey: (_prefix: HexString, _key: HexString) => Promise<never>;
     offchainGetStorage: (_key: HexString) => Promise<never>;
     offchainTimestamp: () => Promise<never>;

package/dist/cjs/wasm-executor/index.js

@@ -153,10 +153,6 @@ const taskHandler = (block)=>{
         getStorage: async function(key) {
             return block.get(key);
         },
-        getStateRoot: async function() {
-            const header = await block.header;
-            return header.stateRoot.toHex();
-        },
         getNextKey: async function(prefix, key) {
             const [nextKey] = await block.getKeysPaged({
                 prefix: prefix.length === 2 /** 0x */  ? key.slice(0, _index.PREFIX_LENGTH) : prefix,
@@ -196,9 +192,6 @@ const emptyTaskHandler = {
     getStorage: async function(_key) {
         throw new Error('Method not implemented');
     },
-    getStateRoot: async function() {
-        throw new Error('Method not implemented');
-    },
     getNextKey: async function(_prefix, _key) {
         throw new Error('Method not implemented');
     },

package/dist/esm/blockchain/inherent/parachain/validation-data.js

@@ -1,5 +1,5 @@
-import { GenericExtrinsic } from '@polkadot/types';
 import { hexToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { GenericExtrinsic } from '@polkadot/types';
 import _ from 'lodash';
 import { WELL_KNOWN_KEYS, dmqMqcHead, hrmpChannels, hrmpEgressChannelIndex, hrmpIngressChannelIndex, paraHead, upgradeGoAheadSignal } from '../../../utils/proof.js';
 import { blake2AsHex, blake2AsU8a } from '@polkadot/util-crypto';
@@ -73,11 +73,13 @@ export class SetValidationData {
         const hrmpIngressChannelIndexKey = hrmpIngressChannelIndex(paraId);
         const hrmpEgressChannelIndexKey = hrmpEgressChannelIndex(paraId);
         const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes);
+        const slotIncrease = meta.consts.timestamp.minimumPeriod.divn(3000) // relaychain min period
+        .toNumber();
         for (const key of Object.values(WELL_KNOWN_KEYS)){
             if (key === WELL_KNOWN_KEYS.CURRENT_SLOT) {
                 // increment current slot
-                const currentSlot = decoded[key] ? meta.registry.createType('Slot', hexToU8a(decoded[key])).toNumber() : await getCurrentSlot(parent.chain) * 2;
-                const newSlot = meta.registry.createType('Slot', currentSlot + 2);
+                const relayCurrentSlot = decoded[key] ? meta.registry.createType('Slot', hexToU8a(decoded[key])).toNumber() : await getCurrentSlot(parent.chain) * slotIncrease;
+                const newSlot = meta.registry.createType('Slot', relayCurrentSlot + slotIncrease);
                 newEntries.push([
                     key,
                     u8aToHex(newSlot.toU8a())
@@ -217,7 +219,7 @@ export class SetValidationData {
             validationData: {
                 ...extrinsic.validationData,
                 relayParentStorageRoot: trieRootHash,
-                relayParentNumber: extrinsic.validationData.relayParentNumber + 2
+                relayParentNumber: extrinsic.validationData.relayParentNumber + slotIncrease
             },
             relayChainState: {
                 trieNodes: nodes

package/dist/esm/chopsticks-provider.js

@@ -3,11 +3,7 @@ import { allHandlers } from './rpc/index.js';
 import { defaultLogger } from './logger.js';
 import { setup } from './setup.js';
 const providerHandlers = {
-    ...allHandlers,
-    dev_newBlock: async (context, _params, _subscriptionManager)=>{
-        const block = await context.chain.newBlock();
-        return block.hash;
-    }
+    ...allHandlers
 };
 const logger = defaultLogger.child({
     name: '[Chopsticks provider]'

package/dist/esm/genesis-provider.js

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'eventemitter3';
 import { genesisSchema } from './schema/index.js';
 import { calculateStateRoot, emptyTaskHandler } from './wasm-executor/index.js';
+import { defaultLogger, isPrefixedChildKey } from './index.js';
 /**
  * Provider to start a chain from genesis
  */ export class GenesisProvider {
@@ -86,13 +87,29 @@ import { calculateStateRoot, emptyTaskHandler } from './wasm-executor/index.js';
         return {
             ...emptyTaskHandler,
             getStorage: async function(key) {
+                if (isPrefixedChildKey(key)) {
+                    defaultLogger.warn({
+                        key
+                    }, 'genesis child storage not supported');
+                    return undefined;
+                }
                 return storage[key];
             },
-            getStateRoot: async function() {
-                return '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1';
-            },
-            getNextKey: async function(_prefix, _key) {
-                return undefined;
+            getNextKey: async function(prefix, key) {
+                if (isPrefixedChildKey(key)) {
+                    defaultLogger.warn({
+                        prefix,
+                        key
+                    }, 'genesis child storage not supported');
+                    return undefined;
+                }
+                return Object.keys(storage).find((k)=>{
+                    if (!k.startsWith(prefix)) return false;
+                    if (key.length > prefix.length) {
+                        return k > key;
+                    }
+                    return true;
+                });
             }
         };
     }
@@ -113,10 +130,25 @@ import { calculateStateRoot, emptyTaskHandler } from './wasm-executor/index.js';
                 return this.blockHash;
             case 'state_getKeysPaged':
             case 'state_getKeysPagedAt':
-                return [];
+                {
+                    if (params.length < 2) throw Error('invalid params');
+                    const [prefix, size, start] = params;
+                    let startKey = start || prefix;
+                    const keys = [];
+                    while(keys.length < size){
+                        const nextKey = await this._jsCallback.getNextKey(prefix, startKey);
+                        if (!nextKey) break;
+                        keys.push(nextKey);
+                        startKey = nextKey;
+                    }
+                    return keys;
+                }
             case 'state_getStorage':
             case 'state_getStorageAt':
-                return this.#genesis.genesis.raw.top[params[0]];
+                {
+                    if (params.length < 1) throw Error('invalid params');
+                    return this.#genesis.genesis.raw.top[params[0]];
+                }
             default:
                 throw Error(`${method} not implemented`);
         }

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

@@ -0,0 +1,15 @@
+declare const handlers: {
+    dev_newBlock: (context: import("../shared.js").Context, [params]: [import("./new-block.js").NewBlockParams]) => Promise<`0x${string}`>;
+    dev_setBlockBuildMode: (context: import("../shared.js").Context, [mode]: [import("../../index.js").BuildBlockMode]) => Promise<void>;
+    dev_setHead: (context: import("../shared.js").Context, [params]: [number | `0x${string}`]) => Promise<`0x${string}`>;
+    dev_setRuntimeLogLevel: (context: import("../shared.js").Context, [runtimeLogLevel]: [number]) => Promise<void>;
+    dev_setStorage: (context: import("../shared.js").Context, params: [import("../../index.js").StorageValues, (`0x${string}` | undefined)?]) => Promise<`0x${string}`>;
+    dev_timeTravel: (context: import("../shared.js").Context, [date]: [string | number]) => Promise<number>;
+};
+export default handlers;
+export * from './new-block.js';
+export * from './set-block-build-mode.js';
+export * from './set-head.js';
+export * from './set-runtime-log-level.js';
+export * from './set-storage.js';
+export * from './time-travel.js';

package/dist/esm/rpc/dev/index.js

@@ -0,0 +1,21 @@
+import { dev_newBlock } from './new-block.js';
+import { dev_setBlockBuildMode } from './set-block-build-mode.js';
+import { dev_setHead } from './set-head.js';
+import { dev_setRuntimeLogLevel } from './set-runtime-log-level.js';
+import { dev_setStorage } from './set-storage.js';
+import { dev_timeTravel } from './time-travel.js';
+const handlers = {
+    dev_newBlock,
+    dev_setBlockBuildMode,
+    dev_setHead,
+    dev_setRuntimeLogLevel,
+    dev_setStorage,
+    dev_timeTravel
+};
+export default handlers;
+export * from './new-block.js';
+export * from './set-block-build-mode.js';
+export * from './set-head.js';
+export * from './set-runtime-log-level.js';
+export * from './set-storage.js';
+export * from './time-travel.js';

package/dist/esm/rpc/dev/new-block.d.ts

@@ -0,0 +1,128 @@
+import { Context } from '../shared.js';
+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, {
+        msg: `0x${string}`;
+        sentAt: number;
+    }, {
+        msg: `0x${string}`;
+        sentAt: number;
+    }>, "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.ZodUnion<[z.ZodNumber, z.ZodString]>, 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?: {
+        msg: `0x${string}`;
+        sentAt: number;
+    }[] | undefined;
+    ump?: Record<number, `0x${string}`[]> | undefined;
+    hrmp?: Record<string | number, {
+        data: `0x${string}`;
+        sentAt: number;
+    }[]> | undefined;
+    transactions?: `0x${string}`[] | undefined;
+    unsafeBlockHeight?: number | undefined;
+}, {
+    count?: number | undefined;
+    to?: number | undefined;
+    dmp?: {
+        msg: `0x${string}`;
+        sentAt: number;
+    }[] | undefined;
+    ump?: Record<number, `0x${string}`[]> | undefined;
+    hrmp?: Record<string | 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 dev_newBlock: (context: Context, [params]: [NewBlockParams]) => Promise<`0x${string}`>;
+export {};

package/dist/esm/rpc/dev/new-block.js

@@ -0,0 +1,84 @@
+import { ResponseError, zHex } from '../shared.js';
+import { z } from 'zod';
+import { defaultLogger } from '../../logger.js';
+const schema = z.object({
+    count: z.number().optional(),
+    to: z.number().optional(),
+    dmp: z.array(z.object({
+        sentAt: z.number(),
+        msg: zHex
+    })).min(1).optional(),
+    ump: z.record(z.number(), z.array(zHex).min(1)).optional(),
+    hrmp: z.record(z.union([
+        z.number(),
+        z.string()
+    ]), z.array(z.object({
+        sentAt: z.number(),
+        data: zHex
+    })).min(1)).optional(),
+    transactions: z.array(zHex).min(1).optional(),
+    unsafeBlockHeight: z.number().optional()
+});
+/**
+ * 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 const dev_newBlock = async (context, [params])=>{
+    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = schema.parse(params || {});
+    const now = context.chain.head.number;
+    const diff = to ? to - now : count;
+    const finalCount = diff !== undefined ? Math.max(diff, 1) : 1;
+    let finalHash;
+    if (unsafeBlockHeight !== undefined && unsafeBlockHeight <= now) {
+        throw new ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
+    }
+    for(let i = 0; i < finalCount; i++){
+        const block = await context.chain.newBlock({
+            transactions,
+            horizontalMessages: hrmp,
+            upwardMessages: ump,
+            downwardMessages: dmp,
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+        }).catch((error)=>{
+            throw new ResponseError(1, error.toString());
+        });
+        defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
+        finalHash = block.hash;
+    }
+    return finalHash;
+};

package/dist/esm/rpc/dev/set-block-build-mode.d.ts

@@ -0,0 +1,21 @@
+import { BuildBlockMode } from '../../blockchain/txpool.js';
+import { Context } from '../shared.js';
+/**
+ * Set block build mode.
+ *
+ * 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 dev_setBlockBuildMode: (context: Context, [mode]: [BuildBlockMode]) => Promise<void>;

package/dist/esm/rpc/dev/set-block-build-mode.js

@@ -0,0 +1,29 @@
+import { BuildBlockMode } from '../../blockchain/txpool.js';
+import { ResponseError } from '../shared.js';
+import { defaultLogger } from '../../logger.js';
+/**
+ * Set block build mode.
+ *
+ * 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 const dev_setBlockBuildMode = async (context, [mode])=>{
+    defaultLogger.debug({
+        mode: BuildBlockMode[mode]
+    }, 'dev_setBlockBuildMode');
+    if (BuildBlockMode[mode] === undefined) {
+        throw new ResponseError(1, `Invalid mode ${mode}`);
+    }
+    context.chain.txPool.mode = mode;
+};

package/dist/esm/rpc/dev/set-head.d.ts

@@ -0,0 +1,21 @@
+import { Context } from '../shared.js';
+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 dev_setHead: (context: Context, [params]: [Params]) => Promise<`0x${string}`>;
+export {};

package/dist/esm/rpc/dev/set-head.js

@@ -0,0 +1,32 @@
+import { ResponseError, zHash } from '../shared.js';
+import { z } from 'zod';
+const schema = zHash.or(z.number());
+/**
+ * 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 const dev_setHead = async (context, [params])=>{
+    const hashOrNumber = schema.parse(params);
+    let block;
+    if (typeof hashOrNumber === 'number') {
+        const blockNumber = hashOrNumber > 0 ? hashOrNumber : context.chain.head.number + hashOrNumber;
+        block = await context.chain.getBlockAt(blockNumber);
+    } else {
+        block = await context.chain.getBlock(hashOrNumber);
+    }
+    if (!block) {
+        throw new ResponseError(1, `Block not found ${hashOrNumber}`);
+    }
+    await context.chain.setHead(block);
+    return block.hash;
+};

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

@@ -0,0 +1,17 @@
+import { Context } from '../shared.js';
+/**
+ * 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 dev_setRuntimeLogLevel: (context: Context, [runtimeLogLevel]: [number]) => Promise<void>;

package/dist/esm/rpc/dev/set-runtime-log-level.js

@@ -0,0 +1,25 @@
+import { ResponseError } from '../shared.js';
+import { defaultLogger } from '../../logger.js';
+/**
+ * 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 const dev_setRuntimeLogLevel = async (context, [runtimeLogLevel])=>{
+    defaultLogger.debug({
+        runtimeLogLevel
+    }, 'dev_setRuntimeLogLevel');
+    if (typeof runtimeLogLevel !== 'number') {
+        throw new ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
+    }
+    context.chain.runtimeLogLevel = runtimeLogLevel;
+};

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

@@ -0,0 +1,29 @@
+import { Context } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+import { StorageValues } from '../../utils/set-storage.js';
+/**
+ * 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 dev_setStorage: (context: Context, params: [StorageValues, HexString?]) => Promise<`0x${string}`>;

package/dist/esm/rpc/dev/set-storage.js

@@ -0,0 +1,38 @@
+import { ResponseError } from '../shared.js';
+import { setStorage } from '../../utils/set-storage.js';
+import { defaultLogger } from '../../logger.js';
+/**
+ * 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 const dev_setStorage = async (context, params)=>{
+    const [values, blockHash] = params;
+    const hash = await setStorage(context.chain, values, blockHash).catch((error)=>{
+        throw new ResponseError(1, error.toString());
+    });
+    defaultLogger.debug({
+        hash,
+        values
+    }, 'dev_setStorage');
+    return hash;
+};

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

@@ -0,0 +1,17 @@
+import { Context } from '../shared.js';
+/**
+ * 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 dev_timeTravel: (context: Context, [date]: [string | number]) => Promise<number>;

package/dist/esm/rpc/dev/time-travel.js

@@ -0,0 +1,22 @@
+import { ResponseError } from '../shared.js';
+import { timeTravel } from '../../utils/time-travel.js';
+/**
+ * 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 const dev_timeTravel = async (context, [date])=>{
+    const timestamp = typeof date === 'string' ? Date.parse(date) : date;
+    if (Number.isNaN(timestamp)) throw new ResponseError(1, 'Invalid date');
+    await timeTravel(context.chain, timestamp);
+    return timestamp;
+};