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

package/dist/cjs/blockchain/inherent/parachain/nimbus-author-inherent.d.ts

@@ -1,6 +1,6 @@
-import { HexString } from '@polkadot/util/types';
 import { Block } from '../../block.js';
 import { BuildBlockParams } from '../../txpool.js';
+import { HexString } from '@polkadot/util/types';
 import { InherentProvider } from '../index.js';
 export declare class SetNimbusAuthorInherent implements InherentProvider {
     createInherents(newBlock: Block, _params: BuildBlockParams): Promise<HexString[]>;

package/dist/cjs/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -34,6 +34,23 @@ class SetNimbusAuthorInherent {
                 alice
             ]).toHex());
         }
+        if (meta.query.authorityAssignment && meta.query.session) {
+            const session = await newBlock.chain.head.read('u32', meta.query.session.currentIndex);
+            if (session) {
+                // We need to set both the assignemnt for current and next sessions
+                layer.set((0, _index.compactHex)(meta.query.authorityAssignment.collatorContainerChain(session)), meta.registry.createType(`DpCollatorAssignmentAssignedCollatorsPublic`, {
+                    orchestratorChain: [
+                        alice
+                    ]
+                }).toHex());
+                layer.set((0, _index.compactHex)(meta.query.authorityAssignment.collatorContainerChain(session.toBigInt() + 1n)), meta.registry.createType(`DpCollatorAssignmentAssignedCollatorsPublic`, {
+                    orchestratorChain: [
+                        alice
+                    ]
+                }).toHex());
+            }
+            layer.set((0, _index.compactHex)(meta.query.authorNoting.didSetContainerAuthorData()), meta.registry.createType('bool', true).toHex());
+        }
         return [
             new _types.GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()
         ];

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())
@@ -104,13 +106,28 @@ class SetValidationData {
                 ]);
             }
         }
+        // inject missing hrmpIngressChannel and hrmpEgressChannel
+        const hrmpIngressChannels = meta.registry.createType('Vec<u32>', (0, _util.hexToU8a)(decoded[hrmpIngressChannelIndexKey]));
+        const hrmpEgressChannels = meta.registry.createType('Vec<u32>', (0, _util.hexToU8a)(decoded[hrmpEgressChannelIndexKey]));
+        for(const key in params.horizontalMessages){
+            // order is important
+            const sender = meta.registry.createType('u32', key);
+            if (!hrmpIngressChannels.some((x)=>x.eq(sender))) {
+                const idx = _lodash.default.sortedIndexBy(hrmpIngressChannels, sender, (x)=>x.toNumber());
+                hrmpIngressChannels.splice(idx, 0, sender);
+            }
+            if (!hrmpEgressChannels.some((x)=>x.eq(sender))) {
+                const idx = _lodash.default.sortedIndexBy(hrmpEgressChannels, sender, (x)=>x.toNumber());
+                hrmpEgressChannels.splice(idx, 0, sender);
+            }
+        }
         newEntries.push([
             hrmpIngressChannelIndexKey,
-            decoded[hrmpIngressChannelIndexKey]
+            hrmpIngressChannels.toHex()
         ]);
         newEntries.push([
             hrmpEgressChannelIndexKey,
-            decoded[hrmpEgressChannelIndexKey]
+            hrmpEgressChannels.toHex()
         ]);
         // inject paraHead
         const headData = meta.registry.createType('HeadData', (await parent.header).toHex());
@@ -132,25 +149,26 @@ class SetValidationData {
             dmqMqcHeadKey,
             dmqMqcHeadHash
         ]);
-        const hrmpIngressChannels = meta.registry.createType('Vec<ParaId>', decoded[hrmpIngressChannelIndexKey]).toJSON();
-        const hrmpEgressChannels = meta.registry.createType('Vec<ParaId>', decoded[hrmpEgressChannelIndexKey]).toJSON();
-        const hrmpMessages = {
-            // reset values, we just need the keys
-            ..._lodash.default.mapValues(extrinsic.horizontalMessages, ()=>[]),
-            ...params.horizontalMessages
-        };
         // inject horizontal messages
-        for (const id of hrmpIngressChannels){
-            const messages = hrmpMessages[id];
-            const sender = Number(id);
+        for (const sender of hrmpIngressChannels){
+            // search by number and string just in case key is not a number
+            const messages = params.horizontalMessages[sender.toNumber()] || params.horizontalMessages[sender.toString()] || [];
             const channelId = meta.registry.createType('HrmpChannelId', {
                 sender,
                 receiver: paraId.toNumber()
             });
             const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
             const abridgedHrmpRaw = decoded[hrmpChannelKey];
-            if (!abridgedHrmpRaw) throw new Error('Canoot find hrmp channels from validation data');
-            const abridgedHrmp = meta.registry.createType('AbridgedHrmpChannel', (0, _util.hexToU8a)(abridgedHrmpRaw)).toJSON();
+            const abridgedHrmp = abridgedHrmpRaw ? meta.registry.createType('AbridgedHrmpChannel', (0, _util.hexToU8a)(abridgedHrmpRaw)).toJSON() : {
+                maxCapacity: 1000,
+                maxTotalSize: 102400,
+                maxMessageSize: 102400,
+                msgCount: 0,
+                totalSize: 0,
+                mqcHead: 0x0000000000000000000000000000000000000000000000000000000000000000,
+                senderDeposit: 5000000000000,
+                recipientDeposit: 5000000000000
+            };
             const paraMessages = [];
             for (const { data, sentAt: _unused } of messages){
                 // fake relaychain sentAt to make validationData think this msg was sent at previous block
@@ -165,24 +183,31 @@ class SetValidationData {
                     sentAt
                 });
             }
-            horizontalMessages[sender] = paraMessages;
+            horizontalMessages[sender.toNumber()] = paraMessages;
             newEntries.push([
                 hrmpChannelKey,
                 meta.registry.createType('AbridgedHrmpChannel', abridgedHrmp).toHex()
             ]);
         }
         // inject hrmpEgressChannels proof
-        for (const id of hrmpEgressChannels){
-            // const messages = hrmpMessages[id]
-            const receiver = Number(id);
+        for (const receiver of hrmpEgressChannels){
             const channelId = meta.registry.createType('HrmpChannelId', {
                 sender: paraId.toNumber(),
                 receiver
             });
             const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
+            const abridgedHrmpRaw = decoded[hrmpChannelKey];
+            const abridgedHrmp = abridgedHrmpRaw ? meta.registry.createType('AbridgedHrmpChannel', (0, _util.hexToU8a)(abridgedHrmpRaw)).toJSON() : {
+                maxCapacity: 1000,
+                maxTotalSize: 102400,
+                maxMessageSize: 102400,
+                msgCount: 0,
+                totalSize: 0,
+                mqcHead: 0x0000000000000000000000000000000000000000000000000000000000000000
+            };
             newEntries.push([
                 hrmpChannelKey,
-                decoded[hrmpChannelKey]
+                meta.registry.createType('AbridgedHrmpChannel', abridgedHrmp).toHex()
             ]);
         }
         const upgradeKey = (0, _proof.upgradeGoAheadSignal)(paraId);
@@ -209,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}`>;