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

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

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "SetValidationData", {
         return SetValidationData;
     }
 });
-const _types = require("@polkadot/types");
 const _util = require("@polkadot/util");
+const _types = require("@polkadot/types");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 const _proof = require("../../../utils/proof.js");
 const _utilcrypto = require("@polkadot/util-crypto");
@@ -88,11 +88,13 @@ class SetValidationData {
         const hrmpIngressChannelIndexKey = (0, _proof.hrmpIngressChannelIndex)(paraId);
         const hrmpEgressChannelIndexKey = (0, _proof.hrmpEgressChannelIndex)(paraId);
         const decoded = await (0, _index1.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(_proof.WELL_KNOWN_KEYS)){
             if (key === _proof.WELL_KNOWN_KEYS.CURRENT_SLOT) {
                 // increment current slot
-                const currentSlot = decoded[key] ? meta.registry.createType('Slot', (0, _util.hexToU8a)(decoded[key])).toNumber() : await (0, _index.getCurrentSlot)(parent.chain) * 2;
-                const newSlot = meta.registry.createType('Slot', currentSlot + 2);
+                const relayCurrentSlot = decoded[key] ? meta.registry.createType('Slot', (0, _util.hexToU8a)(decoded[key])).toNumber() : await (0, _index.getCurrentSlot)(parent.chain) * slotIncrease;
+                const newSlot = meta.registry.createType('Slot', relayCurrentSlot + slotIncrease);
                 newEntries.push([
                     key,
                     (0, _util.u8aToHex)(newSlot.toU8a())
@@ -232,7 +234,7 @@ class SetValidationData {
             validationData: {
                 ...extrinsic.validationData,
                 relayParentStorageRoot: trieRootHash,
-                relayParentNumber: extrinsic.validationData.relayParentNumber + 2
+                relayParentNumber: extrinsic.validationData.relayParentNumber + slotIncrease
             },
             relayChainState: {
                 trieNodes: nodes

package/dist/cjs/chopsticks-provider.js

@@ -66,11 +66,7 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const providerHandlers = {
-    ..._index.allHandlers,
-    dev_newBlock: async (context, _params, _subscriptionManager)=>{
-        const block = await context.chain.newBlock();
-        return block.hash;
-    }
+    ..._index.allHandlers
 };
 const logger = _logger.defaultLogger.child({
     name: '[Chopsticks provider]'

package/dist/cjs/genesis-provider.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "GenesisProvider", {
 const _eventemitter3 = require("eventemitter3");
 const _index = require("./schema/index.js");
 const _index1 = require("./wasm-executor/index.js");
+const _index2 = require("./index.js");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -86,13 +87,29 @@ class GenesisProvider {
         return {
             ..._index1.emptyTaskHandler,
             getStorage: async function(key) {
+                if ((0, _index2.isPrefixedChildKey)(key)) {
+                    _index2.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 ((0, _index2.isPrefixedChildKey)(key)) {
+                    _index2.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;
+                });
             }
         };
     }
@@ -177,10 +194,25 @@ class GenesisProvider {
                     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 _class_private_field_get(this, _genesis).genesis.raw.top[params[0]];
+                    {
+                        if (params.length < 1) throw Error('invalid params');
+                        return _class_private_field_get(this, _genesis).genesis.raw.top[params[0]];
+                    }
                 default:
                     throw Error(`${method} not implemented`);
             }

package/dist/cjs/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/cjs/rpc/dev/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _newblock = _export_star(require("./new-block.js"), exports);
+const _setblockbuildmode = _export_star(require("./set-block-build-mode.js"), exports);
+const _sethead = _export_star(require("./set-head.js"), exports);
+const _setruntimeloglevel = _export_star(require("./set-runtime-log-level.js"), exports);
+const _setstorage = _export_star(require("./set-storage.js"), exports);
+const _timetravel = _export_star(require("./time-travel.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+const handlers = {
+    dev_newBlock: _newblock.dev_newBlock,
+    dev_setBlockBuildMode: _setblockbuildmode.dev_setBlockBuildMode,
+    dev_setHead: _sethead.dev_setHead,
+    dev_setRuntimeLogLevel: _setruntimeloglevel.dev_setRuntimeLogLevel,
+    dev_setStorage: _setstorage.dev_setStorage,
+    dev_timeTravel: _timetravel.dev_timeTravel
+};
+const _default = handlers;

package/dist/cjs/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/cjs/rpc/dev/new-block.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_newBlock", {
+    enumerable: true,
+    get: function() {
+        return dev_newBlock;
+    }
+});
+const _shared = require("../shared.js");
+const _zod = require("zod");
+const _logger = require("../../logger.js");
+const schema = _zod.z.object({
+    count: _zod.z.number().optional(),
+    to: _zod.z.number().optional(),
+    dmp: _zod.z.array(_zod.z.object({
+        sentAt: _zod.z.number(),
+        msg: _shared.zHex
+    })).min(1).optional(),
+    ump: _zod.z.record(_zod.z.number(), _zod.z.array(_shared.zHex).min(1)).optional(),
+    hrmp: _zod.z.record(_zod.z.union([
+        _zod.z.number(),
+        _zod.z.string()
+    ]), _zod.z.array(_zod.z.object({
+        sentAt: _zod.z.number(),
+        data: _shared.zHex
+    })).min(1)).optional(),
+    transactions: _zod.z.array(_shared.zHex).min(1).optional(),
+    unsafeBlockHeight: _zod.z.number().optional()
+});
+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 _shared.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 _shared.ResponseError(1, error.toString());
+        });
+        _logger.defaultLogger.debug({
+            hash: block.hash
+        }, 'dev_newBlock');
+        finalHash = block.hash;
+    }
+    return finalHash;
+};

package/dist/cjs/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/cjs/rpc/dev/set-block-build-mode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_setBlockBuildMode", {
+    enumerable: true,
+    get: function() {
+        return dev_setBlockBuildMode;
+    }
+});
+const _txpool = require("../../blockchain/txpool.js");
+const _shared = require("../shared.js");
+const _logger = require("../../logger.js");
+const dev_setBlockBuildMode = async (context, [mode])=>{
+    _logger.defaultLogger.debug({
+        mode: _txpool.BuildBlockMode[mode]
+    }, 'dev_setBlockBuildMode');
+    if (_txpool.BuildBlockMode[mode] === undefined) {
+        throw new _shared.ResponseError(1, `Invalid mode ${mode}`);
+    }
+    context.chain.txPool.mode = mode;
+};

package/dist/cjs/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/cjs/rpc/dev/set-head.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_setHead", {
+    enumerable: true,
+    get: function() {
+        return dev_setHead;
+    }
+});
+const _shared = require("../shared.js");
+const _zod = require("zod");
+const schema = _shared.zHash.or(_zod.z.number());
+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 _shared.ResponseError(1, `Block not found ${hashOrNumber}`);
+    }
+    await context.chain.setHead(block);
+    return block.hash;
+};

package/dist/cjs/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/cjs/rpc/dev/set-runtime-log-level.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_setRuntimeLogLevel", {
+    enumerable: true,
+    get: function() {
+        return dev_setRuntimeLogLevel;
+    }
+});
+const _shared = require("../shared.js");
+const _logger = require("../../logger.js");
+const dev_setRuntimeLogLevel = async (context, [runtimeLogLevel])=>{
+    _logger.defaultLogger.debug({
+        runtimeLogLevel
+    }, 'dev_setRuntimeLogLevel');
+    if (typeof runtimeLogLevel !== 'number') {
+        throw new _shared.ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
+    }
+    context.chain.runtimeLogLevel = runtimeLogLevel;
+};

package/dist/cjs/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/cjs/rpc/dev/set-storage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_setStorage", {
+    enumerable: true,
+    get: function() {
+        return dev_setStorage;
+    }
+});
+const _shared = require("../shared.js");
+const _setstorage = require("../../utils/set-storage.js");
+const _logger = require("../../logger.js");
+const dev_setStorage = async (context, params)=>{
+    const [values, blockHash] = params;
+    const hash = await (0, _setstorage.setStorage)(context.chain, values, blockHash).catch((error)=>{
+        throw new _shared.ResponseError(1, error.toString());
+    });
+    _logger.defaultLogger.debug({
+        hash,
+        values
+    }, 'dev_setStorage');
+    return hash;
+};

package/dist/cjs/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/cjs/rpc/dev/time-travel.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dev_timeTravel", {
+    enumerable: true,
+    get: function() {
+        return dev_timeTravel;
+    }
+});
+const _shared = require("../shared.js");
+const _timetravel = require("../../utils/time-travel.js");
+const dev_timeTravel = async (context, [date])=>{
+    const timestamp = typeof date === 'string' ? Date.parse(date) : date;
+    if (Number.isNaN(timestamp)) throw new _shared.ResponseError(1, 'Invalid date');
+    await (0, _timetravel.timeTravel)(context.chain, timestamp);
+    return timestamp;
+};

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

@@ -1,5 +1,7 @@
 import { Handlers } from './shared.js';
+import dev from './dev/index.js';
+import substrate from './substrate/index.js';
 export declare const allHandlers: Handlers;
-export { default as substrate } from './substrate/index.js';
+export { substrate, dev };
 export { ResponseError } from './shared.js';
 export type { Context, SubscriptionManager, Handler, Handlers } from './shared.js';

package/dist/cjs/rpc/index.js

@@ -15,11 +15,15 @@ _export(exports, {
     allHandlers: function() {
         return allHandlers;
     },
-    substrate: function() {
+    dev: function() {
         return _index.default;
+    },
+    substrate: function() {
+        return _index1.default;
     }
 });
-const _index = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
+const _index = /*#__PURE__*/ _interop_require_default(require("./dev/index.js"));
+const _index1 = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
 const _shared = require("./shared.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -27,11 +31,10 @@ function _interop_require_default(obj) {
     };
 }
 const allHandlers = {
+    ..._index1.default,
     ..._index.default,
     rpc_methods: async ()=>Promise.resolve({
             version: 1,
-            methods: [
-                ...Object.keys(allHandlers)
-            ]
+            methods: Object.keys(allHandlers).sort()
         })
 };

package/dist/cjs/rpc/shared.d.ts

@@ -1,5 +1,8 @@
+import { z } from 'zod';
 import { Blockchain } from '../blockchain/index.js';
 export declare const logger: import("pino").default.Logger<never>;
+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 class ResponseError extends Error {
     code: number;
     constructor(code: number, message: string);

package/dist/cjs/rpc/shared.js

@@ -14,8 +14,15 @@ _export(exports, {
     },
     logger: function() {
         return logger;
+    },
+    zHash: function() {
+        return zHash;
+    },
+    zHex: function() {
+        return zHex;
     }
 });
+const _zod = require("zod");
 const _logger = require("../logger.js");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -33,6 +40,8 @@ function _define_property(obj, key, value) {
 const logger = _logger.defaultLogger.child({
     name: 'rpc'
 });
+const zHex = _zod.z.custom((val)=>/^0x\w+$/.test(val));
+const zHash = _zod.z.string().length(66).and(zHex);
 class ResponseError extends Error {
     toJSON() {
         return {