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

package/dist/cjs/utils/key-cache.js

@@ -2,17 +2,9 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    PREFIX_LENGTH: function() {
-        return PREFIX_LENGTH;
-    },
-    default: function() {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
         return KeyCache;
     }
 });
@@ -35,21 +27,20 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-const PREFIX_LENGTH = 66;
 class KeyCache {
     feed(keys) {
-        const _keys = keys.filter((key)=>key.length >= PREFIX_LENGTH);
+        const _keys = keys.filter((key)=>key.length >= this.prefixLength);
         if (_keys.length === 0) return;
-        const startKey = _keys[0].slice(PREFIX_LENGTH);
-        const endKey = _keys[_keys.length - 1].slice(PREFIX_LENGTH);
-        const grouped = _lodash.default.groupBy(_keys, (key)=>key.slice(0, PREFIX_LENGTH));
+        const startKey = _keys[0].slice(this.prefixLength);
+        const endKey = _keys[_keys.length - 1].slice(this.prefixLength);
+        const grouped = _lodash.default.groupBy(_keys, (key)=>key.slice(0, this.prefixLength));
         for (const [prefix, keys] of Object.entries(grouped)){
             const ranges = this.ranges.filter((range)=>range.prefix === prefix);
             if (ranges.length === 0) {
                 // no existing range with prefix
                 this.ranges.push({
                     prefix,
-                    keys: keys.map((i)=>i.slice(PREFIX_LENGTH))
+                    keys: keys.map((i)=>i.slice(this.prefixLength))
                 });
                 continue;
             }
@@ -58,14 +49,14 @@ class KeyCache {
                 const startPosition = _lodash.default.sortedIndex(range.keys, startKey);
                 if (startPosition >= 0 && range.keys[startPosition] === startKey) {
                     // found existing range with prefix
-                    range.keys.splice(startPosition, keys.length, ...keys.map((i)=>i.slice(PREFIX_LENGTH)));
+                    range.keys.splice(startPosition, keys.length, ...keys.map((i)=>i.slice(this.prefixLength)));
                     merged = true;
                     break;
                 }
                 const endPosition = _lodash.default.sortedIndex(range.keys, endKey);
                 if (endPosition >= 0 && range.keys[endPosition] === endKey) {
                     // found existing range with prefix
-                    range.keys.splice(0, endPosition + 1, ...keys.map((i)=>i.slice(PREFIX_LENGTH)));
+                    range.keys.splice(0, endPosition + 1, ...keys.map((i)=>i.slice(this.prefixLength)));
                     merged = true;
                     break;
                 }
@@ -74,17 +65,25 @@ class KeyCache {
             if (!merged) {
                 this.ranges.push({
                     prefix,
-                    keys: keys.map((i)=>i.slice(PREFIX_LENGTH))
+                    keys: keys.map((i)=>i.slice(this.prefixLength))
                 });
             }
         }
     // TODO: merge ranges if they overlap
     }
     async next(startKey) {
-        if (startKey.length < PREFIX_LENGTH) return;
-        const prefix = startKey.slice(0, PREFIX_LENGTH);
-        const key = startKey.slice(PREFIX_LENGTH);
+        if (startKey.length < this.prefixLength) return;
+        const prefix = startKey.slice(0, this.prefixLength);
+        const key = startKey.slice(this.prefixLength);
         for (const range of this.ranges.filter((range)=>range.prefix === prefix)){
+            if (key.length === 0) {
+                // if key is empty then find the range with first key empty
+                if (range.keys[0] !== '') continue;
+                return [
+                    prefix,
+                    range.keys[1]
+                ].join('');
+            }
             const index = _lodash.default.sortedIndex(range.keys, key);
             if (range.keys[index] !== key) continue;
             const nextKey = range.keys[index + 1];
@@ -96,7 +95,10 @@ class KeyCache {
             }
         }
     }
-    constructor(){
-        _define_property(this, "ranges", []);
+    constructor(prefixLength){
+        _define_property(this, "prefixLength", void 0);
+        _define_property(this, "ranges", void 0);
+        this.prefixLength = prefixLength;
+        this.ranges = [];
     }
 }

package/dist/cjs/utils/time-travel.d.ts

@@ -1,5 +1,2 @@
 import { Blockchain } from '../blockchain/index.js';
-export declare const getCurrentSlot: (chain: Blockchain) => Promise<number>;
-export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<bigint>;
-export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;
 export declare const timeTravel: (chain: Blockchain, timestamp: number) => Promise<void>;

package/dist/cjs/utils/time-travel.js

@@ -2,51 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getCurrentSlot: function() {
-        return getCurrentSlot;
-    },
-    getCurrentTimestamp: function() {
-        return getCurrentTimestamp;
-    },
-    getSlotDuration: function() {
-        return getSlotDuration;
-    },
-    timeTravel: function() {
+Object.defineProperty(exports, "timeTravel", {
+    enumerable: true,
+    get: function() {
         return timeTravel;
     }
 });
 const _util = require("@polkadot/util");
 const _index = require("./index.js");
-const _index1 = require("../wasm-executor/index.js");
 const _setstorage = require("./set-storage.js");
-const getCurrentSlot = async (chain)=>{
-    const meta = await chain.head.meta;
-    // use raw key here because some chain did not expose those storage to metadata
-    const slotRaw = meta.consts.babe ? await chain.head.get('0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed') // babe.currentSlot
-     : await chain.head.get('0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed') // aura.currentSlot
-    ;
-    if (!slotRaw) throw new Error('Cannot find current slot');
-    return meta.registry.createType('Slot', (0, _util.hexToU8a)(slotRaw)).toNumber();
-};
-const getCurrentTimestamp = async (chain)=>{
-    const meta = await chain.head.meta;
-    const timestamp = await chain.head.read('u64', meta.query.timestamp.now);
-    return timestamp?.toBigInt() ?? 0n;
-};
-const getSlotDuration = async (chain)=>{
-    const meta = await chain.head.meta;
-    return meta.consts.babe ? meta.consts.babe.expectedBlockTime.toNumber() : meta.query.aura ? (0, _index1.getAuraSlotDuration)(await chain.head.wasm) : 12_000;
-};
 const timeTravel = async (chain, timestamp)=>{
     const meta = await chain.head.meta;
-    const slotDuration = await getSlotDuration(chain);
+    const slotDuration = await (0, _index.getSlotDuration)(chain);
     const newSlot = Math.floor(timestamp / slotDuration);
     // new timestamp
     const storage = [

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

@@ -44,9 +44,8 @@ const _comlink = /*#__PURE__*/ _interop_require_wildcard(require("comlink"));
 const _util = require("@polkadot/util");
 const _utilcrypto = require("@polkadot/util-crypto");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
-const _keycache = require("../utils/key-cache.js");
-const _logger = require("../logger.js");
 const _index = require("../utils/index.js");
+const _logger = require("../logger.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -160,7 +159,7 @@ const taskHandler = (block)=>{
         },
         getNextKey: async function(prefix, key) {
             const [nextKey] = await block.getKeysPaged({
-                prefix: prefix.length === 2 /** 0x */  ? key.slice(0, _keycache.PREFIX_LENGTH) : prefix,
+                prefix: prefix.length === 2 /** 0x */  ? key.slice(0, _index.PREFIX_LENGTH) : prefix,
                 pageSize: 1,
                 startKey: key
             });

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

@@ -1,9 +1,4 @@
 import { Blockchain } from '../blockchain/index.js';
-export declare const xcmLogger: import("pino").default.Logger<{
-    level: string;
-    transport: {
-        target: string;
-    };
-}>;
+export declare const xcmLogger: import("pino").default.Logger<never>;
 export declare const connectVertical: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
 export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/dist/esm/api.d.ts

@@ -50,6 +50,7 @@ export declare class Api {
     getBlock(hash?: string): Promise<SignedBlock | null>;
     getStorage(key: string, hash?: string): Promise<`0x${string}` | null>;
     getKeysPaged(prefix: string, pageSize: number, startKey: string, hash?: string): Promise<string[]>;
+    getStorageBatch(prefix: HexString, keys: HexString[], hash?: HexString): Promise<[`0x${string}`, `0x${string}` | null][]>;
     subscribeRemoteNewHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
     subscribeRemoteFinalizedHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
 }

package/dist/esm/api.js

@@ -1,4 +1,5 @@
 import { prefixedChildKey, splitChildKey, stripChildPrefix } from './utils/index.js';
+import _ from 'lodash';
 /**
  * API class. Calls provider to get on-chain data.
  * Either `endpoint` or `genesis` porvider must be provided.
@@ -119,6 +120,26 @@ import { prefixedChildKey, splitChildKey, stripChildPrefix } from './utils/index
             return this.#provider.send('state_getKeysPaged', params, !!hash);
         }
     }
+    async getStorageBatch(prefix, keys, hash) {
+        const [child] = splitChildKey(prefix);
+        if (child) {
+            // child storage key, use childstate_getStorageEntries
+            // strip child prefix from keys
+            const params = [
+                child,
+                keys.map((key)=>stripChildPrefix(key))
+            ];
+            if (hash) params.push(hash);
+            return this.#provider.send('childstate_getStorageEntries', params, !!hash).then((values)=>_.zip(keys, values));
+        } else {
+            // main storage key, use state_getStorageAt
+            const params = [
+                keys
+            ];
+            if (hash) params.push(hash);
+            return this.#provider.send('state_queryStorageAt', params, !!hash).then((result)=>result[0]?.['changes'] || []);
+        }
+    }
     async subscribeRemoteNewHeads(cb) {
         if (!this.#provider.hasSubscriptions) {
             throw new Error('subscribeRemoteNewHeads only works with subscriptions');

package/dist/esm/blockchain/block-builder.d.ts

@@ -1,15 +1,17 @@
 import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
 import { Block } from './block.js';
+import { BuildBlockParams } from './txpool.js';
 import { HexString } from '@polkadot/util/types';
+import { InherentProvider } from './inherent/index.js';
 import { TaskCallResponse } from '../wasm-executor/index.js';
 export declare const newHeader: (head: Block, unsafeBlockHeight?: number) => Promise<Header>;
 export type BuildBlockCallbacks = {
     onApplyExtrinsicError?: (extrinsic: HexString, error: TransactionValidityError) => void;
     onPhaseApplied?: (phase: 'initialize' | 'finalize' | number, resp: TaskCallResponse) => void;
 };
-export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, callbacks?: BuildBlockCallbacks, unsafeBlockHeight?: number) => Promise<[Block, HexString[]]>;
-export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
+export declare const buildBlock: (head: Block, inherentProviders: InherentProvider[], params: BuildBlockParams, callbacks?: BuildBlockCallbacks) => Promise<[Block, HexString[]]>;
+export declare const dryRunExtrinsic: (head: Block, inherentProviders: InherentProvider[], extrinsic: HexString | {
     call: HexString;
     address: string;
-}) => Promise<TaskCallResponse>;
-export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;
+}, params: BuildBlockParams) => Promise<TaskCallResponse>;
+export declare const dryRunInherents: (head: Block, inherentProviders: InherentProvider[], params: BuildBlockParams) => Promise<[HexString, HexString | null][]>;

package/dist/esm/blockchain/block-builder.js

@@ -1,9 +1,8 @@
 import { Block } from './block.js';
 import { StorageLayer, StorageValueKind } from './storage-layer.js';
 import { compactAddLength, hexToU8a, stringToHex, u8aConcat } from '@polkadot/util';
-import { compactHex } from '../utils/index.js';
+import { compactHex, getCurrentSlot } from '../utils/index.js';
 import { defaultLogger, truncate } from '../logger.js';
-import { getCurrentSlot } from '../utils/time-travel.js';
 const logger = defaultLogger.child({
     name: 'block-builder'
 });
@@ -103,7 +102,7 @@ export const newHeader = async (head, unsafeBlockHeight)=>{
     });
     return header;
 };
-const initNewBlock = async (head, header, inherents, storageLayer, callback)=>{
+const initNewBlock = async (head, header, inherentProviders, params, storageLayer, callback)=>{
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000).toString(16).padEnd(64, '0')}`;
     const newBlock = new Block(head.chain, blockNumber, hash, head, {
@@ -131,16 +130,20 @@ const initNewBlock = async (head, header, inherents, storageLayer, callback)=>{
         }
         callback?.onPhaseApplied?.('initialize', resp);
     }
+    const inherents = [];
     const layers = [];
     // apply inherents
-    for (const extrinsic of inherents){
+    for (const inherentProvider of inherentProviders){
         try {
-            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', [
-                extrinsic
-            ]);
+            const extrinsics = await inherentProvider.createInherents(newBlock, params);
+            if (extrinsics.length === 0) {
+                continue;
+            }
+            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsics);
             const layer = newBlock.pushStorageLayer();
             layer.setAll(resp.storageDiff);
             layers.push(layer);
+            inherents.push(...extrinsics);
             callback?.onPhaseApplied?.(layers.length - 1, resp);
         } catch (e) {
             logger.warn('Failed to apply inherents %o %s', e, e);
@@ -149,18 +152,20 @@ const initNewBlock = async (head, header, inherents, storageLayer, callback)=>{
     }
     return {
         block: newBlock,
-        layers: layers
+        layers,
+        inherents
     };
 };
-export const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight)=>{
+export const buildBlock = async (head, inherentProviders, params, callbacks)=>{
+    const { transactions: extrinsics, upwardMessages: ump, unsafeBlockHeight } = params;
     const registry = await head.registry;
     const header = await newHeader(head, unsafeBlockHeight);
     const newBlockNumber = header.number.toNumber();
     logger.info({
         number: newBlockNumber,
-        extrinsicsCount: extrinsics.length,
+        extrinsics: extrinsics.map(truncate),
         umpCount: Object.keys(ump).length
-    }, `Try building block #${newBlockNumber.toLocaleString()}`);
+    }, `${await head.chain.api.getSystemChain()} building #${newBlockNumber.toLocaleString()}`);
     let layer;
     // apply ump via storage override hack
     if (Object.keys(ump).length > 0) {
@@ -249,7 +254,7 @@ export const buildBlock = async (head, inherents, extrinsics, ump, callbacks, un
             layer.set(compactHex(meta.query.ump.needsDispatch()), needsDispatch.toHex());
         }
     }
-    const { block: newBlock } = await initNewBlock(head, header, inherents, layer);
+    const { block: newBlock, inherents } = await initNewBlock(head, header, inherentProviders, params, layer);
     const pendingExtrinsics = [];
     const includedExtrinsic = [];
     // apply extrinsics
@@ -298,21 +303,21 @@ export const buildBlock = async (head, inherents, extrinsics, ump, callbacks, un
         storageDiff
     });
     logger.info({
-        number: newBlock.number,
+        number: finalBlock.number,
         hash: finalBlock.hash,
         extrinsics: truncate(includedExtrinsic),
-        pendingExtrinsicsCount: pendingExtrinsics.length,
+        pendingExtrinsics: pendingExtrinsics.map(truncate),
         ump: truncate(ump)
-    }, 'Block built');
+    }, `${await head.chain.api.getSystemChain()} new head #${finalBlock.number.toLocaleString()}`);
     return [
         finalBlock,
         pendingExtrinsics
     ];
 };
-export const dryRunExtrinsic = async (head, inherents, extrinsic)=>{
+export const dryRunExtrinsic = async (head, inherentProviders, extrinsic, params)=>{
     const registry = await head.registry;
     const header = await newHeader(head);
-    const { block: newBlock } = await initNewBlock(head, header, inherents);
+    const { block: newBlock } = await initNewBlock(head, header, inherentProviders, params);
     if (typeof extrinsic !== 'string') {
         if (!head.chain.mockSignatureHost) {
             throw new Error('Cannot fake signature because mock signature host is not enabled. Start chain with `mockSignatureHost: true`');
@@ -351,9 +356,9 @@ export const dryRunExtrinsic = async (head, inherents, extrinsic)=>{
         extrinsic
     ]);
 };
-export const dryRunInherents = async (head, inherents)=>{
+export const dryRunInherents = async (head, inherentProviders, params)=>{
     const header = await newHeader(head);
-    const { layers } = await initNewBlock(head, header, inherents);
+    const { layers } = await initNewBlock(head, header, inherentProviders, params);
     const storage = {};
     for (const layer of layers){
         await layer.mergeInto(storage);

package/dist/esm/blockchain/block.js

@@ -129,12 +129,10 @@ import { getRuntimeVersion, runTask, taskHandler } from '../wasm-executor/index.
     /**
    * Get paged storage keys.
    */ async getKeysPaged(options) {
-        const layer = new StorageLayer(this.storage);
-        await layer.fold();
         const prefix = options.prefix ?? '0x';
         const startKey = options.startKey ?? '0x';
         const pageSize = options.pageSize;
-        return layer.getKeysPaged(prefix, pageSize, startKey);
+        return this.storage.getKeysPaged(prefix, pageSize, startKey);
     }
     /**
    * Push a layer to the storage stack.

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

@@ -17,7 +17,7 @@ export interface Options {
     /** Build block mode. Default to Batch. */
     buildBlockMode?: BuildBlockMode;
     /** Inherent provider, for creating inherents. */
-    inherentProvider: InherentProvider;
+    inherentProviders: InherentProvider[];
     /** Datasource for caching storage and blocks data. */
     db?: Database;
     /** Used to create the initial head. */
@@ -48,7 +48,7 @@ export interface Options {
  * const chain = new Blockchain({
  *  api,
  *  buildBlockMode: BuildBlockMode.Manual,
- *  inherentProvider: inherents,
+ *  inherentProviders,
  *  header: {
  *    hash: blockHash,
  *    number: Number(header.number),
@@ -79,7 +79,7 @@ export declare class Blockchain {
     /**
      * @param options - Options for instantiating the blockchain
      */
-    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, maxMemoryBlockCount, }: Options);
+    constructor({ api, buildBlockMode, inherentProviders, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, maxMemoryBlockCount, }: Options);
     get head(): Block;
     get txPool(): TxPool;
     get runtimeLogLevel(): number;
@@ -163,7 +163,7 @@ export declare class Blockchain {
     /**
      * Get inherents of head.
      */
-    getInherents(): Promise<HexString[]>;
+    getInherents(): InherentProvider[];
     /**
      * Close the db and disconnect api.
      */

package/dist/esm/blockchain/index.js

@@ -23,7 +23,7 @@ const logger = defaultLogger.child({
  * const chain = new Blockchain({
  *  api,
  *  buildBlockMode: BuildBlockMode.Manual,
- *  inherentProvider: inherents,
+ *  inherentProviders,
  *  header: {
  *    hash: blockHash,
  *    number: Number(header.number),
@@ -43,7 +43,7 @@ const logger = defaultLogger.child({
     #runtimeLogLevel;
     /** Polkadot.js custom types registration. */ registeredTypes;
     #txpool;
-    #inherentProvider;
+    #inherentProviders;
     #head;
     #blocksByNumber = new Map();
     #blocksByHash = new Map();
@@ -65,7 +65,7 @@ const logger = defaultLogger.child({
     });
     /**
    * @param options - Options for instantiating the blockchain
-   */ constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, maxMemoryBlockCount = 500 }){
+   */ constructor({ api, buildBlockMode, inherentProviders, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, maxMemoryBlockCount = 500 }){
         this.api = api;
         this.db = db;
         this.mockSignatureHost = mockSignatureHost;
@@ -74,8 +74,8 @@ const logger = defaultLogger.child({
         this.registeredTypes = registeredTypes;
         this.#head = new Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
-        this.#txpool = new TxPool(this, inherentProvider, buildBlockMode);
-        this.#inherentProvider = inherentProvider;
+        this.#txpool = new TxPool(this, inherentProviders, buildBlockMode);
+        this.#inherentProviders = inherentProviders;
         this.headState = new HeadState(this.#head);
         if (offchainWorker) {
             this.offchainWorker = new OffchainWorker();
@@ -311,13 +311,13 @@ const logger = defaultLogger.child({
             throw new Error(`Cannot find block ${at}`);
         }
         const registry = await head.registry;
-        const inherents = await this.#inherentProvider.createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        const { result, storageDiff } = await dryRunExtrinsic(head, inherents, extrinsic);
+        };
+        const { result, storageDiff } = await dryRunExtrinsic(head, this.#inherentProviders, extrinsic, params);
         const outcome = registry.createType('ApplyExtrinsicResult', result);
         return {
             outcome,
@@ -333,13 +333,13 @@ const logger = defaultLogger.child({
         if (!head) {
             throw new Error(`Cannot find block ${at}`);
         }
-        const inherents = await this.#inherentProvider.createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: hrmp
-        });
-        return dryRunInherents(head, inherents);
+        };
+        return dryRunInherents(head, this.#inherentProviders, params);
     }
     /**
    * Dry run dmp messages in block `at`.
@@ -350,13 +350,13 @@ const logger = defaultLogger.child({
         if (!head) {
             throw new Error(`Cannot find block ${at}`);
         }
-        const inherents = await this.#inherentProvider.createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: dmp,
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        return dryRunInherents(head, inherents);
+        };
+        return dryRunInherents(head, this.#inherentProviders, params);
     }
     /**
    * Dry run ump messages in block `at`.
@@ -392,25 +392,18 @@ const logger = defaultLogger.child({
             ]);
         }
         head.pushStorageLayer().setAll(storageValues);
-        const inherents = await this.#inherentProvider.createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        return dryRunInherents(head, inherents);
+        };
+        return dryRunInherents(head, this.#inherentProviders, params);
     }
     /**
    * Get inherents of head.
-   */ async getInherents() {
-        await this.api.isReady;
-        const inherents = await this.#inherentProvider.createInherents(this.head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: {}
-        });
-        return inherents;
+   */ getInherents() {
+        return this.#inherentProviders;
     }
     /**
    * Close the db and disconnect api.

package/dist/esm/blockchain/inherent/index.d.ts

@@ -1,19 +1,12 @@
 import { Block } from '../block.js';
 import { BuildBlockParams } from '../txpool.js';
 import { HexString } from '@polkadot/util/types';
-export { SetValidationData } from './parachain/validation-data.js';
-export { ParaInherentEnter } from './para-enter.js';
-export { SetBabeRandomness } from './parachain/babe-randomness.js';
-export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent.js';
-export interface CreateInherents {
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
-}
-export type InherentProvider = CreateInherents;
-export declare class SetTimestamp implements InherentProvider {
-    createInherents(parent: Block): Promise<HexString[]>;
-}
-export declare class InherentProviders implements InherentProvider {
-    #private;
-    constructor(base: InherentProvider, providers: CreateInherents[]);
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
+import { ParaInherentEnter } from './para-enter.js';
+import { SetBabeRandomness } from './parachain/babe-randomness.js';
+import { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent.js';
+import { SetTimestamp } from './timestamp.js';
+import { SetValidationData } from './parachain/validation-data.js';
+export interface InherentProvider {
+    createInherents(newBlock: Block, params: BuildBlockParams): Promise<HexString[]>;
 }
+export declare const inherentProviders: (ParaInherentEnter | SetBabeRandomness | SetNimbusAuthorInherent | SetTimestamp | SetValidationData)[];

package/dist/esm/blockchain/inherent/index.js

@@ -1,32 +1,12 @@
-import { GenericExtrinsic } from '@polkadot/types';
-import { getCurrentTimestamp, getSlotDuration } from '../../utils/time-travel.js';
-export { SetValidationData } from './parachain/validation-data.js';
-export { ParaInherentEnter } from './para-enter.js';
-export { SetBabeRandomness } from './parachain/babe-randomness.js';
-export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent.js';
-export class SetTimestamp {
-    async createInherents(parent) {
-        const meta = await parent.meta;
-        const slotDuration = await getSlotDuration(parent.chain);
-        const currentTimestamp = await getCurrentTimestamp(parent.chain);
-        return [
-            new GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + BigInt(slotDuration))).toHex()
-        ];
-    }
-}
-export class InherentProviders {
-    #base;
-    #providers;
-    constructor(base, providers){
-        this.#base = base;
-        this.#providers = providers;
-    }
-    async createInherents(parent, params) {
-        const base = await this.#base.createInherents(parent, params);
-        const extra = await Promise.all(this.#providers.map((provider)=>provider.createInherents(parent, params)));
-        return [
-            ...base,
-            ...extra.flat()
-        ];
-    }
-}
+import { ParaInherentEnter } from './para-enter.js';
+import { SetBabeRandomness } from './parachain/babe-randomness.js';
+import { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent.js';
+import { SetTimestamp } from './timestamp.js';
+import { SetValidationData } from './parachain/validation-data.js';
+export const inherentProviders = [
+    new SetTimestamp(),
+    new SetValidationData(),
+    new ParaInherentEnter(),
+    new SetNimbusAuthorInherent(),
+    new SetBabeRandomness()
+];

package/dist/esm/blockchain/inherent/para-enter.d.ts

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

package/dist/esm/blockchain/inherent/para-enter.js

@@ -1,6 +1,8 @@
 import { GenericExtrinsic } from '@polkadot/types';
 export class ParaInherentEnter {
-    async createInherents(parent, _params) {
+    async createInherents(newBlock, _params) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
         const meta = await parent.meta;
         if (!meta.tx.paraInherent?.enter) {
             return [];