@acala-network/chopsticks 0.2.3 → 0.3.0

package/README.md

@@ -57,3 +57,9 @@ Make sure you have setup Rust environment (>= 1.64).
 - Run Kusama fork
   - Edit configs/kusama.yml if needed. (e.g. update the block number)
   - `yarn start dev --config=configs/kusama.yml`
+
+- Setup XCM multichain (UpwardMessages not yet supported)
+**_NOTE:_** You can also connect multiple parachains without a relaychain
+```bash
+yarn start xcm --relaychain=configs/kusama.yml --parachain=configs/karura.yml --parachain=configs/statemine.yml
+```

package/dist/api.d.ts

@@ -1,6 +1,7 @@
 import { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
 import { HexString } from '@polkadot/util/types';
 import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { WsProvider } from '@polkadot/rpc-provider';
 type ChainProperties = {
     ss58Format?: number;
     tokenDecimals?: number[];
@@ -27,14 +28,14 @@ export declare class Api {
     readonly signedExtensions: ExtDef;
     constructor(provider: ProviderInterface, signedExtensions?: ExtDef);
     disconnect(): Promise<void>;
-    get isReady(): Promise<void>;
+    get isReady(): Promise<void> | Promise<WsProvider>;
     get chain(): Promise<string>;
     get chainProperties(): Promise<ChainProperties>;
     getSystemName(): Promise<string>;
     getSystemProperties(): Promise<ChainProperties>;
     getSystemChain(): Promise<string>;
     getMetadata(hash?: string): Promise<string>;
-    getBlockHash(blockNumber?: number): Promise<string>;
+    getBlockHash(blockNumber?: number): Promise<`0x${string}`>;
     getHeader(hash?: string): Promise<Header>;
     getBlock(hash?: string): Promise<SignedBlock>;
     getStorage(key: string, hash?: string): Promise<string>;

package/dist/api.js

@@ -1,44 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Api = void 0;
+const rpc_provider_1 = require("@polkadot/rpc-provider");
 class Api {
     #provider;
-    #isReady;
+    #ready;
     #chain;
     #chainProperties;
     signedExtensions;
     constructor(provider, signedExtensions) {
         this.#provider = provider;
         this.signedExtensions = signedExtensions || {};
-        this.#isReady = new Promise((resolve, reject) => {
-            if (this.#provider.isConnected) {
-                setTimeout(resolve, 500);
-            }
-            else {
-                this.#provider.on('connected', () => {
-                    setTimeout(resolve, 500);
-                });
-            }
-            this.#provider.on('error', reject);
-        });
-        this.#provider.on('disconnected', () => {
-            // TODO: reconnect
-            console.warn('Api disconnected');
-        });
-        this.#chain = this.#isReady.then(() => this.getSystemChain());
-        this.#chainProperties = this.#isReady.then(() => this.getSystemProperties());
-        this.#provider.connect();
     }
     async disconnect() {
         return this.#provider.disconnect();
     }
     get isReady() {
-        return this.#isReady;
+        if (this.#provider instanceof rpc_provider_1.WsProvider) {
+            return this.#provider.isReady;
+        }
+        if (!this.#ready) {
+            this.#ready = this.#provider.connect();
+        }
+        return this.#ready;
     }
     get chain() {
+        if (!this.#chain) {
+            this.#chain = this.getSystemChain();
+        }
         return this.#chain;
     }
     get chainProperties() {
+        if (!this.#chainProperties) {
+            this.#chainProperties = this.getSystemProperties();
+        }
         return this.#chainProperties;
     }
     async getSystemName() {

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

@@ -0,0 +1,4 @@
+import { Block } from './block';
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+export declare const buildBlock: (head: Block, header: Header, inherents: HexString[], extrinsics: HexString[]) => Promise<[Block, HexString[]]>;

package/dist/blockchain/block-builder.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBlock = void 0;
+const block_1 = require("./block");
+const logger_1 = require("../logger");
+const logger = logger_1.defaultLogger.child({ name: 'block-builder' });
+const buildBlock = async (head, header, inherents, extrinsics) => {
+    const registry = await head.registry;
+    const pendingExtrinsics = [];
+    const blockNumber = header.number.toNumber();
+    const hash = `0x${Math.round(Math.random() * 100000000)
+        .toString(16)
+        .padEnd(64, '0')}`;
+    const newBlock = new block_1.Block(head.chain, blockNumber, hash, head, { header, extrinsics: [], storage: head.storage });
+    logger.info({
+        number: blockNumber,
+        extrinsicsCount: extrinsics.length,
+        tempHash: newBlock.hash,
+    }, `Building block #${blockNumber.toLocaleString()}`);
+    {
+        // initialize block
+        const { storageDiff } = await newBlock.call('Core_initialize_block', header.toHex());
+        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Initialize block');
+        newBlock.pushStorageLayer().setAll(storageDiff);
+    }
+    // apply inherents
+    for (const extrinsic of inherents) {
+        try {
+            const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
+            newBlock.pushStorageLayer().setAll(storageDiff);
+            logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Applied inherent');
+        }
+        catch (e) {
+            logger.warn('Failed to apply inherents %o %s', e, e);
+            throw new Error('Failed to apply inherents');
+        }
+    }
+    // apply extrinsics
+    for (const extrinsic of extrinsics) {
+        try {
+            const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
+            newBlock.pushStorageLayer().setAll(storageDiff);
+            logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Applied extrinsic');
+        }
+        catch (e) {
+            logger.info('Failed to apply extrinsic %o %s', e, e);
+            pendingExtrinsics.push(extrinsic);
+        }
+    }
+    {
+        // finalize block
+        const { storageDiff } = await newBlock.call('BlockBuilder_finalize_block', '0x');
+        newBlock.pushStorageLayer().setAll(storageDiff);
+        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Finalize block');
+    }
+    const blockData = registry.createType('Block', {
+        header,
+        extrinsics,
+    });
+    const storageDiff = await newBlock.storageDiff();
+    logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
+    const finalBlock = new block_1.Block(head.chain, blockNumber, blockData.hash.toHex(), head, {
+        header,
+        extrinsics: [...inherents, ...extrinsics],
+        storage: head.storage,
+        storageDiff,
+    });
+    logger.info({ hash: finalBlock.hash, number: blockNumber }, `Block built #${blockNumber.toLocaleString()} hash ${finalBlock.hash}`);
+    return [finalBlock, pendingExtrinsics];
+};
+exports.buildBlock = buildBlock;

package/dist/blockchain/block.d.ts

@@ -3,7 +3,7 @@ import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
 import { TypeRegistry } from '@polkadot/types';
 import type { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
-import { StorageLayer, StorageLayerProvider } from './storage-layer';
+import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
 import type { RuntimeVersion } from '../executor';
 export type TaskCallResponse = {
     result: HexString;
@@ -12,12 +12,14 @@ export type TaskCallResponse = {
 export declare class Block {
     #private;
     readonly number: number;
-    readonly hash: string;
-    constructor(chain: Blockchain, number: number, hash: string, parentBlock?: Block, block?: {
+    readonly hash: HexString;
+    constructor(chain: Blockchain, number: number, hash: HexString, parentBlock?: Block, block?: {
         header: Header;
         extrinsics: HexString[];
         storage?: StorageLayerProvider;
+        storageDiff?: Record<string, StorageValue | null>;
     });
+    get chain(): Blockchain;
     get header(): Header | Promise<Header>;
     get extrinsics(): HexString[] | Promise<HexString[]>;
     get parentBlock(): undefined | Block | Promise<Block | undefined>;

package/dist/blockchain/block.js

@@ -31,7 +31,18 @@ class Block {
         this.#extrinsics = block?.extrinsics;
         this.#baseStorage = block?.storage ?? new storage_layer_1.RemoteStorageLayer(chain.api, hash, chain.db);
         this.#storages = [];
-        this.#registry = parentBlock?.registry;
+        const storageDiff = block?.storageDiff || {};
+        // if code doesn't change then reuse parent block's meta
+        if (!storageDiff[(0, util_2.stringToHex)(':code')]) {
+            this.#runtimeVersion = parentBlock?.runtimeVersion;
+            this.#metadata = parentBlock?.metadata;
+            this.#registry = parentBlock?.registry;
+            this.#meta = parentBlock?.meta;
+        }
+        this.pushStorageLayer().setAll(storageDiff);
+    }
+    get chain() {
+        return this.#chain;
     }
     get header() {
         if (!this.#header) {
@@ -90,16 +101,15 @@ class Block {
         return storage;
     }
     get wasm() {
-        const getWasm = async () => {
-            const wasmKey = (0, util_2.stringToHex)(':code');
-            const wasm = await this.get(wasmKey);
-            if (!wasm) {
-                throw new Error('No wasm found');
-            }
-            return wasm;
-        };
         if (!this.#wasm) {
-            this.#wasm = getWasm();
+            this.#wasm = (async () => {
+                const wasmKey = (0, util_2.stringToHex)(':code');
+                const wasm = await this.get(wasmKey);
+                if (!wasm) {
+                    throw new Error('No wasm found');
+                }
+                return wasm;
+            })();
         }
         return this.#wasm;
     }
@@ -138,17 +148,7 @@ class Block {
     }
     get metadata() {
         if (!this.#metadata) {
-            this.#metadata = this.wasm.then(async (wasm) => {
-                const response = await (0, executor_1.runTask)({
-                    blockHash: this.hash,
-                    wasm,
-                    calls: [['Metadata_metadata', '0x']],
-                    storage: [],
-                    mockSignatureHost: this.#chain.mockSignatureHost,
-                    allowUnresolvedImports: this.#chain.allowUnresolvedImports,
-                });
-                return (0, utils_1.compactHex)((0, util_2.hexToU8a)(response.Call.result));
-            });
+            this.#metadata = this.call('Metadata_metadata', '0x').then((resp) => (0, utils_1.compactHex)((0, util_2.hexToU8a)(resp.result)));
         }
         return this.#metadata;
     }
@@ -164,13 +164,12 @@ class Block {
     async call(method, args, storage = []) {
         const wasm = await this.wasm;
         const response = await (0, executor_1.runTask)({
-            blockHash: this.hash,
             wasm,
             calls: [[method, args]],
             storage,
             mockSignatureHost: this.#chain.mockSignatureHost,
             allowUnresolvedImports: this.#chain.allowUnresolvedImports,
-        });
+        }, (0, executor_1.taskHandler)(this));
         if (response.Call)
             return response.Call;
         if (response.Error)

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

@@ -1,13 +1,15 @@
 import { Block } from './block';
+type Callback = (block: Block, pairs: [string, string][]) => 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: (block: Block, pairs: [string, string][]) => void): Promise<string>;
+    subscribeStorage(keys: string[], cb: Callback): Promise<string>;
     unsubscribeStorage(id: string): void;
-    subscrubeRuntimeVersion(cb: (block: Block) => void): string;
+    subscrubeRuntimeVersion(cb: (block: Block) => void): Promise<string>;
     unsubscribeRuntimeVersion(id: string): void;
     setHead(head: Block): Promise<void>;
 }
+export {};

package/dist/blockchain/head-state.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HeadState = exports.randomId = void 0;
+const util_1 = require("@polkadot/util");
+const logger_1 = require("../logger");
 const randomId = () => Math.random().toString(36).substring(2);
 exports.randomId = randomId;
+const logger = logger_1.defaultLogger.child({ name: 'head-state' });
 class HeadState {
     #headListeners = {};
     #storageListeners = {};
@@ -30,14 +33,15 @@ class HeadState {
     unsubscribeStorage(id) {
         delete this.#storageListeners[id];
     }
-    subscrubeRuntimeVersion(cb) {
-        // TODO: actually subscribe
-        void cb;
-        return (0, exports.randomId)();
+    async subscrubeRuntimeVersion(cb) {
+        const id = (0, exports.randomId)();
+        const codeKey = (0, util_1.stringToHex)(':code');
+        this.#storageListeners[id] = [[codeKey], cb];
+        this.#oldValues[codeKey] = await this.#head.get(codeKey);
+        return id;
     }
     unsubscribeRuntimeVersion(id) {
-        // TODO: actually unsubscribe
-        void id;
+        delete this.#storageListeners[id];
     }
     async setHead(head) {
         this.#head = head;
@@ -48,7 +52,9 @@ class HeadState {
         for (const [keys, cb] of Object.values(this.#storageListeners)) {
             const changed = keys.filter((key) => diff[key]).map((key) => [key, diff[key]]);
             if (changed.length > 0) {
-                cb(head, changed);
+                await Promise.resolve(cb(head, changed)).catch((error) => {
+                    logger.error(error, 'callback');
+                });
             }
         }
         Object.assign(this.#oldValues, diff);

package/dist/blockchain/index.d.ts

@@ -1,11 +1,10 @@
 import { DataSource } from 'typeorm';
-import { Header } from '@polkadot/types/interfaces';
 import { HexString } from '@polkadot/util/types';
 import { Api } from '../api';
 import { Block } from './block';
-import { BuildBlockMode } from './txpool';
+import { BuildBlockMode, BuildBlockParams } from './txpool';
 import { HeadState } from './head-state';
-import { InherentProvider } from './inherents';
+import { InherentProvider } from './inherent';
 export interface Options {
     api: Api;
     buildBlockMode?: BuildBlockMode;
@@ -13,7 +12,7 @@ export interface Options {
     db?: DataSource;
     header: {
         number: number;
-        hash: string;
+        hash: HexString;
     };
     mockSignatureHost?: boolean;
     allowUnresolvedImports?: boolean;
@@ -27,11 +26,11 @@ export declare class Blockchain {
     readonly headState: HeadState;
     constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, }: Options);
     get head(): Block;
+    get pendingExtrinsics(): HexString[];
     getBlockAt(number?: number): Promise<Block | undefined>;
-    getBlock(hash?: string): Promise<Block | undefined>;
-    newTempBlock(parent: Block, header: Header): Block;
+    getBlock(hash?: HexString): Promise<Block | undefined>;
     unregisterBlock(block: Block): void;
-    setHead(block: Block): void;
+    setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
-    newBlock(): Promise<Block>;
+    newBlock(params?: BuildBlockParams): Promise<Block>;
 }

package/dist/blockchain/index.js

@@ -6,9 +6,7 @@ const util_1 = require("@polkadot/util");
 const block_1 = require("./block");
 const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
-const shared_1 = require("../rpc/shared");
 const logger_1 = require("../logger");
-const bindings_1 = require("../bindings");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
     api;
@@ -19,6 +17,7 @@ class Blockchain {
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
+    #loadingBlocks = {};
     headState;
     constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, }) {
         this.api = api;
@@ -27,7 +26,6 @@ class Blockchain {
         this.allowUnresolvedImports = allowUnresolvedImports;
         this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
-        (0, bindings_1.setupBindings)(this);
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
         this.headState = new head_state_1.HeadState(this.#head);
     }
@@ -38,6 +36,9 @@ class Blockchain {
     get head() {
         return this.#head;
     }
+    get pendingExtrinsics() {
+        return this.#txpool.pendingExtrinsics;
+    }
     async getBlockAt(number) {
         if (number === undefined) {
             return this.head;
@@ -58,29 +59,28 @@ class Blockchain {
             hash = this.head.hash;
         }
         if (!this.#blocksByHash[hash]) {
-            try {
-                const registry = await this.head.registry;
-                const header = registry.createType('Header', await this.api.getHeader(hash));
-                const block = new block_1.Block(this, header.number.toNumber(), hash);
-                this.#registerBlock(block);
+            const loadingBlock = this.#loadingBlocks[hash];
+            if (loadingBlock) {
+                await loadingBlock;
             }
-            catch (e) {
-                logger.debug(`getBlock(${hash}) failed: ${e}`);
-                return undefined;
+            else {
+                const loadingBlock = (async () => {
+                    try {
+                        const header = await this.api.getHeader(hash);
+                        const block = new block_1.Block(this, Number(header.number), hash);
+                        this.#registerBlock(block);
+                    }
+                    catch (e) {
+                        logger.debug(`getBlock(${hash}) failed: ${e}`);
+                    }
+                })();
+                this.#loadingBlocks[hash] = loadingBlock;
+                await loadingBlock;
+                delete this.#loadingBlocks[hash];
             }
         }
         return this.#blocksByHash[hash];
     }
-    newTempBlock(parent, header) {
-        const number = parent.number + 1;
-        const hash = '0x' +
-            Math.round(Math.random() * 100000000)
-                .toString(16)
-                .padEnd(64, '0');
-        const block = new block_1.Block(this, number, hash, parent, { header, extrinsics: [], storage: parent.storage });
-        this.#blocksByHash[hash] = block;
-        return block;
-    }
     unregisterBlock(block) {
         if (block.hash === this.head.hash) {
             throw new Error('Cannot unregister head block');
@@ -90,14 +90,14 @@ class Blockchain {
         }
         delete this.#blocksByHash[block.hash];
     }
-    setHead(block) {
+    async setHead(block) {
         logger.debug({
             number: block.number,
             hash: block.hash,
         }, 'setHead');
         this.#head = block;
         this.#registerBlock(block);
-        this.headState.setHead(block);
+        await this.headState.setHead(block);
     }
     async submitExtrinsic(extrinsic) {
         const source = '0x02'; // External
@@ -109,10 +109,10 @@ class Blockchain {
             this.#txpool.submitExtrinsic(extrinsic);
             return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
         }
-        throw new shared_1.ResponseError(1, `Extrinsic is invalid: ${validity.asErr.toString()}`);
+        throw new Error(`Extrinsic is invalid: ${validity.asErr.toString()}`);
     }
-    async newBlock() {
-        await this.#txpool.buildBlock();
+    async newBlock(params) {
+        await this.#txpool.buildBlock(params);
         return this.#head;
     }
 }

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

@@ -0,0 +1,17 @@
+import { Block } from '../block';
+import { BuildBlockParams } from '../txpool';
+import { HexString } from '@polkadot/util/types';
+export { SetValidationData } from './parachain/validation-data';
+export { ParaInherentEnter } from './para-enter';
+export interface CreateInherents {
+    createInherents(parent: Block, params?: BuildBlockParams['inherent']): 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['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/inherent/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InherentProviders = exports.SetTimestamp = exports.ParaInherentEnter = exports.SetValidationData = void 0;
+const types_1 = require("@polkadot/types");
+const time_travel_1 = require("../../utils/time-travel");
+var validation_data_1 = require("./parachain/validation-data");
+Object.defineProperty(exports, "SetValidationData", { enumerable: true, get: function () { return validation_data_1.SetValidationData; } });
+var para_enter_1 = require("./para-enter");
+Object.defineProperty(exports, "ParaInherentEnter", { enumerable: true, get: function () { return para_enter_1.ParaInherentEnter; } });
+class SetTimestamp {
+    async createInherents(parent) {
+        const meta = await parent.meta;
+        const slotDuration = await (0, time_travel_1.getSlotDuration)(parent.chain);
+        const currentTimestamp = await (0, time_travel_1.getCurrentTimestamp)(parent.chain);
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + slotDuration)).toHex()];
+    }
+}
+exports.SetTimestamp = SetTimestamp;
+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()];
+    }
+}
+exports.InherentProviders = InherentProviders;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaInherentEnter = void 0;
+const types_1 = require("@polkadot/types");
+class ParaInherentEnter {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.paraInherent?.enter) {
+            return [];
+        }
+        const extrinsics = await parent.extrinsics;
+        const paraEnterExtrinsic = extrinsics.find((extrinsic) => {
+            const firstArg = meta.registry.createType('GenericExtrinsic', extrinsic)?.args?.[0];
+            return firstArg && 'bitfields' in firstArg;
+        });
+        if (!paraEnterExtrinsic) {
+            throw new Error('Missing paraInherent data from block');
+        }
+        const extrinsic = meta.registry
+            .createType('GenericExtrinsic', paraEnterExtrinsic)
+            .args[0].toJSON();
+        const parentHeader = (await parent.header).toJSON();
+        const newData = {
+            ...extrinsic,
+            bitfields: [],
+            backedCandidates: [],
+            parentHeader,
+        };
+        // TODO: fill with data
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
+    }
+}
+exports.ParaInherentEnter = ParaInherentEnter;

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

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