@acala-network/chopsticks-core 0.9.4-2 → 0.9.4-4

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

@@ -71,13 +71,7 @@ class SetValidationData {
             const dmqMqcHeadKey = (0, _proof.dmqMqcHead)(paraId);
             const hrmpIngressChannelIndexKey = (0, _proof.hrmpIngressChannelIndex)(paraId);
             const hrmpEgressChannelIndexKey = (0, _proof.hrmpEgressChannelIndex)(paraId);
-            // TODO: refactor this to have a single decodeProof
-            const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                ...Object.values(_proof.WELL_KNOWN_KEYS),
-                dmqMqcHeadKey,
-                hrmpIngressChannelIndexKey,
-                hrmpEgressChannelIndexKey
-            ], extrinsic.relayChainState.trieNodes);
+            const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes);
             for (const key of Object.values(_proof.WELL_KNOWN_KEYS)){
                 if (key === _proof.WELL_KNOWN_KEYS.CURRENT_SLOT) {
                     // increment current slot
@@ -140,9 +134,6 @@ class SetValidationData {
                     receiver: paraId.toNumber()
                 });
                 const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
-                const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 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();
@@ -175,9 +166,6 @@ class SetValidationData {
                     receiver
                 });
                 const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
-                const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 newEntries.push([
                     hrmpChannelKey,
                     decoded[hrmpChannelKey]

package/dist/cjs/rpc/substrate/author.js

@@ -72,6 +72,12 @@ const author_submitAndWatchExtrinsic = async (context, [extrinsic], { subscribe,
             callback({
                 ready: null
             });
+            // fake broadcast to alice peer
+            callback({
+                broadcast: [
+                    '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+                ]
+            });
         }, 50);
     } catch (error) {
         logger.error({

package/dist/cjs/utils/decoder.js

@@ -27,11 +27,15 @@ const _lrucache = require("lru-cache");
 const _util = require("@polkadot/util");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 const _wellknownkeys = require("./well-known-keys.js");
+const _logger = require("../logger.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+const logger = _logger.defaultLogger.child({
+    module: 'decoder'
+});
 const _CACHE = {};
 function createCache() {
     return new _lrucache.LRUCache({
@@ -85,11 +89,27 @@ const decodeKeyValue = (meta, block, key, value, toHuman = true)=>{
     }
     const { storage, decodedKey } = decodeKey(meta, block, key);
     if (!storage || !decodedKey) {
+        logger.warn({
+            key,
+            value
+        }, 'Failed to decode storage key');
         return undefined;
     }
     const decodeValue = ()=>{
         if (!value) return null;
-        return meta.registry.createType(decodedKey.outputType, (0, _util.hexToU8a)(value))[toHuman ? 'toHuman' : 'toJSON']();
+        try {
+            return meta.registry.createType(decodedKey.outputType, (0, _util.hexToU8a)(value))[toHuman ? 'toHuman' : 'toJSON']();
+        } catch (error) {
+            logger.warn(error, 'Failed to decode storage value');
+            logger.warn({
+                key,
+                value,
+                section: storage.section,
+                method: storage.method,
+                args: decodedKey.args
+            }, 'Failed to decode storage value');
+            return undefined;
+        }
     };
     return {
         section: storage.section,

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

@@ -52,11 +52,11 @@ const getRuntimeVersion = async (code)=>{
 const calculateStateRoot = async (entries, trie_version)=>{
     return _chopsticksexecutor.calculate_state_root(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
-    return _chopsticksexecutor.decode_proof(trieRootHash, keys, nodes);
+const decodeProof = async (trieRootHash, nodes)=>{
+    return _chopsticksexecutor.decode_proof(trieRootHash, nodes);
 };
-const createProof = async (nodes, entries)=>{
-    return _chopsticksexecutor.create_proof(nodes, entries);
+const createProof = async (nodes, updates)=>{
+    return _chopsticksexecutor.create_proof(nodes, updates);
 };
 const runTask = async (task, callback)=>{
     return _chopsticksexecutor.run_task(task, callback, 'info');

package/dist/{types → cjs}/wasm-executor/index.d.ts

@@ -33,8 +33,8 @@ export type TaskResponse = {
 export interface WasmExecutor {
     getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
     calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
-    createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<[HexString, HexString[]]>;
-    decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<[[HexString, HexString | null]]>;
+    createProof: (nodes: HexString[], updates: [HexString, HexString | null][]) => Promise<[HexString, HexString[]]>;
+    decodeProof: (trieRootHash: HexString, nodes: HexString[]) => Promise<[[HexString, HexString]]>;
     runTask: (task: {
         wasm: HexString;
         calls: [string, HexString[]][];
@@ -50,8 +50,10 @@ export declare const getWorker: () => Promise<{
 }>;
 export declare const getRuntimeVersion: ((code: HexString) => Promise<RuntimeVersion>) & _.MemoizedFunction;
 export declare const calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
-export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<{}>;
-export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
+export declare const decodeProof: (trieRootHash: HexString, nodes: HexString[]) => Promise<{
+    [key: `0x${string}`]: `0x${string}`;
+}>;
+export declare const createProof: (nodes: HexString[], updates: [HexString, HexString | null][]) => Promise<{
     trieRootHash: `0x${string}`;
     nodes: `0x${string}`[];
 }>;

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

@@ -120,17 +120,17 @@ const calculateStateRoot = async (entries, trie_version)=>{
     const worker = await getWorker();
     return worker.remote.calculateStateRoot(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
+const decodeProof = async (trieRootHash, nodes)=>{
     const worker = await getWorker();
-    const result = await worker.remote.decodeProof(trieRootHash, keys, nodes);
+    const result = await worker.remote.decodeProof(trieRootHash, nodes);
     return result.reduce((accum, [key, value])=>{
         accum[key] = value;
         return accum;
     }, {});
 };
-const createProof = async (nodes, entries)=>{
+const createProof = async (nodes, updates)=>{
     const worker = await getWorker();
-    const [trieRootHash, newNodes] = await worker.remote.createProof(nodes, entries);
+    const [trieRootHash, newNodes] = await worker.remote.createProof(nodes, updates);
     return {
         trieRootHash,
         nodes: newNodes

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

@@ -59,11 +59,11 @@ const getRuntimeVersion = async (code)=>{
 const calculateStateRoot = async (entries, trie_version)=>{
     return _chopsticksexecutor.calculate_state_root(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
-    return _chopsticksexecutor.decode_proof(trieRootHash, keys, nodes);
+const decodeProof = async (trieRootHash, nodes)=>{
+    return _chopsticksexecutor.decode_proof(trieRootHash, nodes);
 };
-const createProof = async (nodes, entries)=>{
-    return _chopsticksexecutor.create_proof(nodes, entries);
+const createProof = async (nodes, updates)=>{
+    return _chopsticksexecutor.create_proof(nodes, updates);
 };
 const runTask = async (task, callback)=>{
     return _chopsticksexecutor.run_task(task, callback, process.env.RUST_LOG);

package/dist/esm/api.d.ts

@@ -0,0 +1,56 @@
+import { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
+export type ChainProperties = {
+    ss58Format?: number;
+    tokenDecimals?: number[];
+    tokenSymbol?: string[];
+};
+type Header = {
+    parentHash: HexString;
+    number: HexString;
+    stateRoot: HexString;
+    extrinsicsRoot: HexString;
+    digest: {
+        logs: HexString[];
+    };
+};
+type SignedBlock = {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications?: HexString[];
+};
+/**
+ * API class. Calls provider to get on-chain data.
+ * Either `endpoint` or `genesis` porvider must be provided.
+ *
+ * @example Instantiate an API
+ *
+ * ```ts
+ * const provider = new WsProvider(options.endpoint)
+ * const api = new Api(provider)
+ * await api.isReady
+ * ```
+ */
+export declare class Api {
+    #private;
+    readonly signedExtensions: ExtDef;
+    constructor(provider: ProviderInterface, signedExtensions?: ExtDef);
+    disconnect(): Promise<void>;
+    get isReady(): Promise<void> | undefined;
+    get chain(): Promise<string>;
+    get chainProperties(): Promise<ChainProperties>;
+    getSystemName(): Promise<string>;
+    getSystemProperties(): Promise<ChainProperties>;
+    getSystemChain(): Promise<string>;
+    getBlockHash(blockNumber?: number): Promise<`0x${string}` | null>;
+    getHeader(hash?: string): Promise<Header | null>;
+    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[]>;
+    subscribeRemoteNewHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
+    subscribeRemoteFinalizedHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
+import { Block } from './block.js';
+import { HexString } from '@polkadot/util/types';
+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 | {
+    call: HexString;
+    address: string;
+}) => Promise<TaskCallResponse>;
+export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

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

@@ -0,0 +1,92 @@
+import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
+import { Header } from '@polkadot/types/interfaces';
+import { TypeRegistry } from '@polkadot/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
+import type { HexString } from '@polkadot/util/types';
+import { Blockchain } from './index.js';
+import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer.js';
+import type { RuntimeVersion, TaskCallResponse } from '../wasm-executor/index.js';
+/**
+ * Block class.
+ *
+ * @example Instantiate a block
+ *
+ * ```ts
+ * const block = new Block(chain, number, hash)
+ * ```
+ *
+ * @example Get storage
+ *
+ * ```ts
+ * const block = await chain.getBlock('0x...')
+ * block.storage()
+ * ```
+ */
+export declare class Block {
+    #private;
+    readonly number: number;
+    readonly hash: HexString;
+    constructor(chain: Blockchain, number: number, hash: HexString, parentBlock?: Block, block?: {
+        /** See `@polkadot/types/interfaces` Header */
+        header: Header;
+        /** Extrinsics */
+        extrinsics: HexString[];
+        /** Storage provider. Default to {@link RemoteStorageLayer} with {@link Blockchain.api chain.api} as remote. */
+        storage?: StorageLayerProvider;
+        /** Storage diff to apply. */
+        storageDiff?: Record<string, StorageValue | null>;
+    });
+    get chain(): Blockchain;
+    get header(): Header | Promise<Header>;
+    get extrinsics(): HexString[] | Promise<HexString[]>;
+    get parentBlock(): Promise<Block | undefined>;
+    /**
+     * Get the block storage.
+     */
+    get storage(): StorageLayerProvider;
+    /**
+     * Get the block storage by key.
+     */
+    get(key: string): Promise<HexString | undefined>;
+    read<T extends string>(type: T, query: StorageEntry, ...args: any[]): Promise<import("@polkadot/types/types").DetectCodec<import("@polkadot/types-codec/types").Codec, T> | undefined>;
+    /**
+     * Get paged storage keys.
+     */
+    getKeysPaged(options: {
+        prefix?: string;
+        startKey?: string;
+        pageSize: number;
+    }): Promise<string[]>;
+    /**
+     * Push a layer to the storage stack.
+     */
+    pushStorageLayer(): StorageLayer;
+    /**
+     * Pop a layer from the storage stack.
+     */
+    popStorageLayer(): void;
+    /**
+     * Get storage diff.
+     */
+    storageDiff(): Promise<Record<HexString, HexString | null>>;
+    /**
+     * Get the wasm string.
+     */
+    get wasm(): Promise<`0x${string}`>;
+    /**
+     * Set the runtime wasm.
+     */
+    setWasm(wasm: HexString): void;
+    /**
+     * Get the type registry.
+     * @see https://polkadot.js.org/docs/api/start/types.create#why-create-types
+     */
+    get registry(): Promise<TypeRegistry>;
+    get runtimeVersion(): Promise<RuntimeVersion>;
+    get metadata(): Promise<HexString>;
+    get meta(): Promise<DecoratedMeta>;
+    /**
+     * Call a runtime method.
+     */
+    call(method: string, args: HexString[]): Promise<TaskCallResponse>;
+}

package/dist/esm/blockchain/head-state.d.ts

@@ -0,0 +1,15 @@
+import { Block } from './block.js';
+type Callback = (block: Block, pairs: [string, string | null][]) => void | Promise<void>;
+export declare const randomId: () => string;
+export declare class HeadState {
+    #private;
+    constructor(head: Block);
+    subscribeHead(cb: (block: Block) => void): string;
+    unsubscribeHead(id: string): void;
+    subscribeStorage(keys: string[], cb: Callback): Promise<string>;
+    unsubscribeStorage(id: string): void;
+    subscrubeRuntimeVersion(cb: (block: Block) => void): Promise<string>;
+    unsubscribeRuntimeVersion(id: string): void;
+    setHead(head: Block): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,172 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { TypeRegistry } from '@polkadot/types';
+import { RegisteredTypes } from '@polkadot/types/types';
+import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue';
+import { Api } from '../api.js';
+import { Block } from './block.js';
+import { BuildBlockMode, BuildBlockParams, DownwardMessage, HorizontalMessage, TxPool } from './txpool.js';
+import { Database } from '../database.js';
+import { HeadState } from './head-state.js';
+import { InherentProvider } from './inherent/index.js';
+import { OffchainWorker } from '../offchain.js';
+import { RuntimeVersion } from '../wasm-executor/index.js';
+export interface Options {
+    /** API instance, for getting on-chain data. */
+    api: Api;
+    /** Build block mode. Default to Batch. */
+    buildBlockMode?: BuildBlockMode;
+    /** Inherent provider, for creating inherents. */
+    inherentProvider: InherentProvider;
+    /** Datasource for caching storage and blocks data. */
+    db?: Database;
+    /** Used to create the initial head. */
+    header: {
+        number: number;
+        hash: HexString;
+    };
+    /** Whether to enable mock signature. Any signature starts with 0xdeadbeef and filled by 0xcd is considered valid */
+    mockSignatureHost?: boolean;
+    /** Whether to allow wasm unresolved imports. */
+    allowUnresolvedImports?: boolean;
+    /** Wasm runtime log level. */
+    runtimeLogLevel?: number;
+    /** Polkadot.js custom types registration. */
+    registeredTypes: RegisteredTypes;
+    /** Whether to enable offchain Worker. */
+    offchainWorker?: boolean;
+    /** Max memory block count */
+    maxMemoryBlockCount?: number;
+}
+/**
+ * Local blockchain which provides access to blocks, txpool and methods
+ * to manipulate the chain such as build blocks, submit extrinsics, xcm and more!
+ *
+ * @example
+ *
+ * ```ts
+ * const chain = new Blockchain({
+ *  api,
+ *  buildBlockMode: BuildBlockMode.Manual,
+ *  inherentProvider: inherents,
+ *  header: {
+ *    hash: blockHash,
+ *    number: Number(header.number),
+ *  },
+ *  mockSignatureHost: true,
+ *  allowUnresolvedImports: true,
+ *  registeredTypes: {},
+ * })
+ * // build a block
+ * chain.newBlock()
+ * ```
+ */
+export declare class Blockchain {
+    #private;
+    readonly uid: string;
+    /** API instance, for getting on-chain data. */
+    readonly api: Api;
+    /** Datasource for caching storage and blocks data. */
+    readonly db: Database | undefined;
+    /** Enable mock signature. Any signature starts with 0xdeadbeef and filled by 0xcd is considered valid */
+    readonly mockSignatureHost: boolean;
+    /** Allow wasm unresolved imports. */
+    readonly allowUnresolvedImports: boolean;
+    /** Polkadot.js custom types registration. */
+    readonly registeredTypes: RegisteredTypes;
+    /** For subscribing and managing the head state. */
+    readonly headState: HeadState;
+    readonly offchainWorker: OffchainWorker | undefined;
+    /**
+     * @param options - Options for instantiating the blockchain
+     */
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, maxMemoryBlockCount, }: Options);
+    get head(): Block;
+    get txPool(): TxPool;
+    get runtimeLogLevel(): number;
+    set runtimeLogLevel(level: number);
+    buildRegistry(metadata: HexString, version: RuntimeVersion): Promise<TypeRegistry>;
+    saveBlockToDB(block: Block): Promise<void>;
+    /**
+     * Try to load block from db and register it.
+     * If pass in number, get block by number, else get block by hash.
+     */
+    loadBlockFromDB(hashOrNumber: number | HexString): Promise<Block | undefined>;
+    /**
+     * Get block by number.
+     */
+    getBlockAt(number?: number | null): Promise<Block | undefined>;
+    /**
+     * Get block by hash.
+     */
+    getBlock(hash?: HexString): Promise<Block | undefined>;
+    /**
+     * Get all blocks in memory.
+     */
+    blocksInMemory(): Block[];
+    /**
+     * Remove block from memory and db.
+     */
+    unregisterBlock(block: Block): Promise<void>;
+    onNewBlock(block: Block): Promise<void>;
+    /**
+     * Set block as head.
+     */
+    setHead(block: Block): Promise<void>;
+    /**
+     * Submit extrinsic to txpool.
+     */
+    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
+    /**
+     * Validate extrinsic by calling `TaggedTransactionQueue_validate_transaction`.
+     */
+    validateExtrinsic(extrinsic: HexString, source?: '0x00' | '0x01' | '0x02' /** External */): Promise<TransactionValidity>;
+    submitUpwardMessages(id: number, ump: HexString[]): void;
+    submitDownwardMessages(dmp: DownwardMessage[]): void;
+    submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;
+    /**
+     * Build a new block with optional params. Use this when you don't have all the {@link BuildBlockParams}
+     */
+    newBlock(params?: Partial<BuildBlockParams>): Promise<Block>;
+    /**
+     * Build a new block with {@link BuildBlockParams}.
+     */
+    newBlockWithParams(params: BuildBlockParams): Promise<Block>;
+    /**
+     * Get the upcoming blocks.
+     */
+    upcomingBlocks(): Promise<number>;
+    /**
+     * Dry run extrinsic in block `at`.
+     */
+    dryRunExtrinsic(extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    /**
+     * Dry run hrmp messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Dry run dmp messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunDmp(dmp: DownwardMessage[], at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Dry run ump messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunUmp(ump: Record<number, HexString[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Get inherents of head.
+     */
+    getInherents(): Promise<HexString[]>;
+    /**
+     * Close the db and disconnect api.
+     */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,19 @@
+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[]>;
+}

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

@@ -0,0 +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[]>;
+}

package/dist/esm/blockchain/inherent/parachain/babe-randomness.d.ts

@@ -0,0 +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[]>;
+}

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

@@ -0,0 +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[]>;
+}

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

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

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

@@ -56,13 +56,7 @@ export class SetValidationData {
             const dmqMqcHeadKey = dmqMqcHead(paraId);
             const hrmpIngressChannelIndexKey = hrmpIngressChannelIndex(paraId);
             const hrmpEgressChannelIndexKey = hrmpEgressChannelIndex(paraId);
-            // TODO: refactor this to have a single decodeProof
-            const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                ...Object.values(WELL_KNOWN_KEYS),
-                dmqMqcHeadKey,
-                hrmpIngressChannelIndexKey,
-                hrmpEgressChannelIndexKey
-            ], extrinsic.relayChainState.trieNodes);
+            const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes);
             for (const key of Object.values(WELL_KNOWN_KEYS)){
                 if (key === WELL_KNOWN_KEYS.CURRENT_SLOT) {
                     // increment current slot
@@ -125,9 +119,6 @@ export class SetValidationData {
                     receiver: paraId.toNumber()
                 });
                 const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 const abridgedHrmpRaw = decoded[hrmpChannelKey];
                 if (!abridgedHrmpRaw) throw new Error('Canoot find hrmp channels from validation data');
                 const abridgedHrmp = meta.registry.createType('AbridgedHrmpChannel', hexToU8a(abridgedHrmpRaw)).toJSON();
@@ -160,9 +151,6 @@ export class SetValidationData {
                     receiver
                 });
                 const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 newEntries.push([
                     hrmpChannelKey,
                     decoded[hrmpChannelKey]