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

package/dist/cjs/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/cjs/api.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "Api", {
     }
 });
 const _index = require("./utils/index.js");
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -62,6 +63,11 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 var _provider = /*#__PURE__*/ new WeakMap(), _ready = /*#__PURE__*/ new WeakMap(), _chain = /*#__PURE__*/ new WeakMap(), _chainProperties = /*#__PURE__*/ new WeakMap();
 class Api {
     async disconnect() {
@@ -163,6 +169,26 @@ class Api {
             return _class_private_field_get(this, _provider).send('state_getKeysPaged', params, !!hash);
         }
     }
+    async getStorageBatch(prefix, keys, hash) {
+        const [child] = (0, _index.splitChildKey)(prefix);
+        if (child) {
+            // child storage key, use childstate_getStorageEntries
+            // strip child prefix from keys
+            const params = [
+                child,
+                keys.map((key)=>(0, _index.stripChildPrefix)(key))
+            ];
+            if (hash) params.push(hash);
+            return _class_private_field_get(this, _provider).send('childstate_getStorageEntries', params, !!hash).then((values)=>_lodash.default.zip(keys, values));
+        } else {
+            // main storage key, use state_getStorageAt
+            const params = [
+                keys
+            ];
+            if (hash) params.push(hash);
+            return _class_private_field_get(this, _provider).send('state_queryStorageAt', params, !!hash).then((result)=>result[0]?.['changes'] || []);
+        }
+    }
     async subscribeRemoteNewHeads(cb) {
         if (!_class_private_field_get(this, _provider).hasSubscriptions) {
             throw new Error('subscribeRemoteNewHeads only works with subscriptions');

package/dist/cjs/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/cjs/blockchain/block-builder.js

@@ -27,7 +27,6 @@ const _storagelayer = require("./storage-layer.js");
 const _util = require("@polkadot/util");
 const _index = require("../utils/index.js");
 const _logger = require("../logger.js");
-const _timetravel = require("../utils/time-travel.js");
 const logger = _logger.defaultLogger.child({
     name: 'block-builder'
 });
@@ -74,7 +73,7 @@ const newHeader = async (head, unsafeBlockHeight)=>{
     let newLogs = parentHeader.digest.logs;
     const consensus = getConsensus(parentHeader);
     if (consensus?.consensusEngine.isAura) {
-        const slot = await (0, _timetravel.getCurrentSlot)(head.chain);
+        const slot = await (0, _index.getCurrentSlot)(head.chain);
         const newSlot = (0, _util.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
         newLogs = [
             {
@@ -86,7 +85,7 @@ const newHeader = async (head, unsafeBlockHeight)=>{
             ...consensus.rest
         ];
     } else if (consensus?.consensusEngine.isBabe) {
-        const slot = await (0, _timetravel.getCurrentSlot)(head.chain);
+        const slot = await (0, _index.getCurrentSlot)(head.chain);
         const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
         const newSlot = (0, _util.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
         newLogs = [
@@ -127,7 +126,7 @@ 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.Block(head.chain, blockNumber, hash, head, {
@@ -155,16 +154,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);
@@ -173,18 +176,20 @@ const initNewBlock = async (head, header, inherents, storageLayer, callback)=>{
     }
     return {
         block: newBlock,
-        layers: layers
+        layers,
+        inherents
     };
 };
-const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight)=>{
+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(_logger.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) {
@@ -273,7 +278,7 @@ const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlo
             layer.set((0, _index.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
@@ -322,21 +327,21 @@ const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlo
         storageDiff
     });
     logger.info({
-        number: newBlock.number,
+        number: finalBlock.number,
         hash: finalBlock.hash,
         extrinsics: (0, _logger.truncate)(includedExtrinsic),
-        pendingExtrinsicsCount: pendingExtrinsics.length,
+        pendingExtrinsics: pendingExtrinsics.map(_logger.truncate),
         ump: (0, _logger.truncate)(ump)
-    }, 'Block built');
+    }, `${await head.chain.api.getSystemChain()} new head #${finalBlock.number.toLocaleString()}`);
     return [
         finalBlock,
         pendingExtrinsics
     ];
 };
-const dryRunExtrinsic = async (head, inherents, extrinsic)=>{
+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`');
@@ -375,9 +380,9 @@ const dryRunExtrinsic = async (head, inherents, extrinsic)=>{
         extrinsic
     ]);
 };
-const dryRunInherents = async (head, inherents)=>{
+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/cjs/blockchain/block.js

@@ -139,12 +139,10 @@ class Block {
     /**
    * Get paged storage keys.
    */ async getKeysPaged(options) {
-        const layer = new _storagelayer.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/cjs/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/cjs/blockchain/index.js

@@ -91,7 +91,7 @@ function _interop_require_default(obj) {
 const logger = _logger.defaultLogger.child({
     name: 'blockchain'
 });
-var _runtimeLogLevel = /*#__PURE__*/ new WeakMap(), _txpool1 = /*#__PURE__*/ new WeakMap(), _inherentProvider = /*#__PURE__*/ new WeakMap(), _head = /*#__PURE__*/ new WeakMap(), _blocksByNumber = /*#__PURE__*/ new WeakMap(), _blocksByHash = /*#__PURE__*/ new WeakMap(), _loadingBlocks = /*#__PURE__*/ new WeakMap(), _maxMemoryBlockCount = /*#__PURE__*/ new WeakMap(), _registryBuilder = /*#__PURE__*/ new WeakMap(), _registerBlock = /*#__PURE__*/ new WeakSet();
+var _runtimeLogLevel = /*#__PURE__*/ new WeakMap(), _txpool1 = /*#__PURE__*/ new WeakMap(), _inherentProviders = /*#__PURE__*/ new WeakMap(), _head = /*#__PURE__*/ new WeakMap(), _blocksByNumber = /*#__PURE__*/ new WeakMap(), _blocksByHash = /*#__PURE__*/ new WeakMap(), _loadingBlocks = /*#__PURE__*/ new WeakMap(), _maxMemoryBlockCount = /*#__PURE__*/ new WeakMap(), _registryBuilder = /*#__PURE__*/ new WeakMap(), _registerBlock = /*#__PURE__*/ new WeakSet();
 class Blockchain {
     get head() {
         return _class_private_field_get(this, _head);
@@ -312,13 +312,13 @@ class Blockchain {
             throw new Error(`Cannot find block ${at}`);
         }
         const registry = await head.registry;
-        const inherents = await _class_private_field_get(this, _inherentProvider).createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        const { result, storageDiff } = await (0, _blockbuilder.dryRunExtrinsic)(head, inherents, extrinsic);
+        };
+        const { result, storageDiff } = await (0, _blockbuilder.dryRunExtrinsic)(head, _class_private_field_get(this, _inherentProviders), extrinsic, params);
         const outcome = registry.createType('ApplyExtrinsicResult', result);
         return {
             outcome,
@@ -334,13 +334,13 @@ class Blockchain {
         if (!head) {
             throw new Error(`Cannot find block ${at}`);
         }
-        const inherents = await _class_private_field_get(this, _inherentProvider).createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: hrmp
-        });
-        return (0, _blockbuilder.dryRunInherents)(head, inherents);
+        };
+        return (0, _blockbuilder.dryRunInherents)(head, _class_private_field_get(this, _inherentProviders), params);
     }
     /**
    * Dry run dmp messages in block `at`.
@@ -351,13 +351,13 @@ class Blockchain {
         if (!head) {
             throw new Error(`Cannot find block ${at}`);
         }
-        const inherents = await _class_private_field_get(this, _inherentProvider).createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: dmp,
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        return (0, _blockbuilder.dryRunInherents)(head, inherents);
+        };
+        return (0, _blockbuilder.dryRunInherents)(head, _class_private_field_get(this, _inherentProviders), params);
     }
     /**
    * Dry run ump messages in block `at`.
@@ -393,25 +393,18 @@ class Blockchain {
             ]);
         }
         head.pushStorageLayer().setAll(storageValues);
-        const inherents = await _class_private_field_get(this, _inherentProvider).createInherents(head, {
+        const params = {
             transactions: [],
             downwardMessages: [],
             upwardMessages: [],
             horizontalMessages: {}
-        });
-        return (0, _blockbuilder.dryRunInherents)(head, inherents);
+        };
+        return (0, _blockbuilder.dryRunInherents)(head, _class_private_field_get(this, _inherentProviders), params);
     }
     /**
    * Get inherents of head.
-   */ async getInherents() {
-        await this.api.isReady;
-        const inherents = await _class_private_field_get(this, _inherentProvider).createInherents(this.head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: {}
-        });
-        return inherents;
+   */ getInherents() {
+        return _class_private_field_get(this, _inherentProviders);
     }
     /**
    * Close the db and disconnect api.
@@ -421,7 +414,7 @@ class Blockchain {
     }
     /**
    * @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 }){
         _class_private_method_init(this, _registerBlock);
         /** API instance, for getting on-chain data. */ _define_property(this, "api", void 0);
         /** Datasource for caching storage and blocks data. */ _define_property(this, "db", void 0);
@@ -436,7 +429,7 @@ class Blockchain {
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _inherentProvider, {
+        _class_private_field_init(this, _inherentProviders, {
             writable: true,
             value: void 0
         });
@@ -485,8 +478,8 @@ class Blockchain {
         this.registeredTypes = registeredTypes;
         _class_private_field_set(this, _head, new _block.Block(this, header.number, header.hash));
         _class_private_method_get(this, _registerBlock, registerBlock).call(this, _class_private_field_get(this, _head));
-        _class_private_field_set(this, _txpool1, new _txpool.TxPool(this, inherentProvider, buildBlockMode));
-        _class_private_field_set(this, _inherentProvider, inherentProvider);
+        _class_private_field_set(this, _txpool1, new _txpool.TxPool(this, inherentProviders, buildBlockMode));
+        _class_private_field_set(this, _inherentProviders, inherentProviders);
         this.headState = new _headstate.HeadState(_class_private_field_get(this, _head));
         if (offchainWorker) {
             this.offchainWorker = new _offchain.OffchainWorker();

package/dist/cjs/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/cjs/blockchain/inherent/index.js

@@ -2,108 +2,21 @@
 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, {
-    InherentProviders: function() {
-        return InherentProviders;
-    },
-    ParaInherentEnter: function() {
-        return _paraenter.ParaInherentEnter;
-    },
-    SetBabeRandomness: function() {
-        return _baberandomness.SetBabeRandomness;
-    },
-    SetNimbusAuthorInherent: function() {
-        return _nimbusauthorinherent.SetNimbusAuthorInherent;
-    },
-    SetTimestamp: function() {
-        return SetTimestamp;
-    },
-    SetValidationData: function() {
-        return _validationdata.SetValidationData;
+Object.defineProperty(exports, "inherentProviders", {
+    enumerable: true,
+    get: function() {
+        return inherentProviders;
     }
 });
-const _types = require("@polkadot/types");
-const _timetravel = require("../../utils/time-travel.js");
-const _validationdata = require("./parachain/validation-data.js");
 const _paraenter = require("./para-enter.js");
 const _baberandomness = require("./parachain/babe-randomness.js");
 const _nimbusauthorinherent = require("./parachain/nimbus-author-inherent.js");
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) {
-        throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
-    return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
-}
-class SetTimestamp {
-    async createInherents(parent) {
-        const meta = await parent.meta;
-        const slotDuration = await (0, _timetravel.getSlotDuration)(parent.chain);
-        const currentTimestamp = await (0, _timetravel.getCurrentTimestamp)(parent.chain);
-        return [
-            new _types.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + BigInt(slotDuration))).toHex()
-        ];
-    }
-}
-var _base = /*#__PURE__*/ new WeakMap(), _providers = /*#__PURE__*/ new WeakMap();
-class InherentProviders {
-    async createInherents(parent, params) {
-        const base = await _class_private_field_get(this, _base).createInherents(parent, params);
-        const extra = await Promise.all(_class_private_field_get(this, _providers).map((provider)=>provider.createInherents(parent, params)));
-        return [
-            ...base,
-            ...extra.flat()
-        ];
-    }
-    constructor(base, providers){
-        _class_private_field_init(this, _base, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_init(this, _providers, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_set(this, _base, base);
-        _class_private_field_set(this, _providers, providers);
-    }
-}
+const _timestamp = require("./timestamp.js");
+const _validationdata = require("./parachain/validation-data.js");
+const inherentProviders = [
+    new _timestamp.SetTimestamp(),
+    new _validationdata.SetValidationData(),
+    new _paraenter.ParaInherentEnter(),
+    new _nimbusauthorinherent.SetNimbusAuthorInherent(),
+    new _baberandomness.SetBabeRandomness()
+];

package/dist/cjs/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/cjs/blockchain/inherent/para-enter.js

@@ -10,7 +10,9 @@ Object.defineProperty(exports, "ParaInherentEnter", {
 });
 const _types = require("@polkadot/types");
 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 [];

package/dist/cjs/blockchain/inherent/parachain/babe-randomness.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 SetBabeRandomness implements CreateInherents {
-    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+import { InherentProvider } from '../index.js';
+export declare class SetBabeRandomness implements InherentProvider {
+    createInherents(newBlock: Block, _params: BuildBlockParams): Promise<HexString[]>;
 }

package/dist/cjs/blockchain/inherent/parachain/babe-randomness.js

@@ -10,7 +10,9 @@ Object.defineProperty(exports, "SetBabeRandomness", {
 });
 const _types = require("@polkadot/types");
 class SetBabeRandomness {
-    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.randomness?.setBabeRandomnessResults) {
             return [];

package/dist/cjs/blockchain/inherent/parachain/nimbus-author-inherent.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 SetNimbusAuthorInherent implements CreateInherents {
-    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+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

@@ -9,12 +9,31 @@ Object.defineProperty(exports, "SetNimbusAuthorInherent", {
     }
 });
 const _types = require("@polkadot/types");
+const _index = require("../../../utils/index.js");
 class SetNimbusAuthorInherent {
-    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.authorInherent?.kickOffAuthorshipValidation) {
             return [];
         }
+        // mock author inherent data and authorities noting data
+        const layer = newBlock.pushStorageLayer();
+        const accountType = meta.registry.hasType('NimbusPrimitivesNimbusCryptoPublic') ? 'NimbusPrimitivesNimbusCryptoPublic' : 'AccountId';
+        const alice = meta.registry.hasType('NimbusPrimitivesNimbusCryptoPublic') ? '0x567b6ddb05396c0a83853b6f40d27450534c7963df8619b8c6064480c4db9703' : '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+        layer.set((0, _index.compactHex)(meta.query.authorInherent.author()), meta.registry.createType(accountType, alice).toHex());
+        if (meta.query.authoritiesNoting) {
+            layer.set((0, _index.compactHex)(meta.query.authoritiesNoting.authorities()), meta.registry.createType(`Vec<${accountType}>`, [
+                alice
+            ]).toHex());
+            layer.set((0, _index.compactHex)(meta.query.authoritiesNoting.didSetOrchestratorAuthorityData()), meta.registry.createType('bool', true).toHex());
+        }
+        if (meta.query.parachainStaking) {
+            layer.set((0, _index.compactHex)(meta.query.parachainStaking.selectedCandidates()), meta.registry.createType(`Vec<${accountType}>`, [
+                alice
+            ]).toHex());
+        }
         return [
             new _types.GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()
         ];

package/dist/cjs/blockchain/inherent/parachain/validation-data.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from '../../block.js';
 import { BuildBlockParams, DownwardMessage, HorizontalMessage } from '../../txpool.js';
-import { CreateInherents } from '../index.js';
+import { InherentProvider } from '../index.js';
 export type ValidationData = {
     downwardMessages: DownwardMessage[];
     horizontalMessages: Record<number, HorizontalMessage[]>;
@@ -14,6 +14,6 @@ export type ValidationData = {
         trieNodes: HexString[];
     };
 };
-export declare class SetValidationData implements CreateInherents {
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
+export declare class SetValidationData implements InherentProvider {
+    createInherents(newBlock: Block, params: BuildBlockParams): Promise<HexString[]>;
 }