@acala-network/chopsticks 0.2.3 → 0.3.1

package/README.md

@@ -26,7 +26,13 @@ Make sure you have setup Rust environment (>= 1.64).
 - Replay latest block
   - `yarn start run-block --endpoint=wss://acala-rpc-2.aca-api.network/ws`
   - This will replay the last block and print out the changed storages
+  - Use option `--block` to replay certain block hash
   - Use option `--output-path=<file_path>` to print out JSON file
+  - Use option `--html` to generate storage diff preview (add `--open` to automatically open file)
+
+- Dry run extrinsic, same as `run-block`, example:
+  - `yarn start dry-run --config=configs/mandala.yml --html --open --extrinsic 0x51028400d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01a4143d076116f80a4074ed7acc90f9e1f9e2db54603900be53145a6ef5faa333f2614e687a06a9c886a909d77f3115b1a9d989afdc9fd73e5dca941bc690ae8a0000000a00008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a481b000000a1edccce1bc2d3`
+
 - Run a test node
   - `yarn start dev --endpoint=wss://acala-rpc-2.aca-api.network/ws`
   - You have a test node running at `ws://localhost:8000`
@@ -34,7 +40,6 @@ Make sure you have setup Rust environment (>= 1.64).
   - Submit any transaction to produce a new block in the in parallel reality
   - (Optional) Pre-define/override storage using option `--import-storage=storage.[json/yaml]`. See example storage below.
   ```json5
-  // prettier-ignore
   {
     "Sudo": {
       "Key": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
@@ -57,3 +62,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,5 @@
+import { Block, TaskCallResponse } from './block';
+import { HexString } from '@polkadot/util/types';
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[]) => Promise<[Block, HexString[]]>;
+export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString) => Promise<TaskCallResponse>;
+export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/dist/blockchain/block-builder.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = void 0;
+const block_1 = require("./block");
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const time_travel_1 = require("../utils/time-travel");
+const logger = logger_1.defaultLogger.child({ name: 'block-builder' });
+const getConsensus = (header) => {
+    if (header.digest.logs.length === 0)
+        return;
+    const preRuntime = header.digest.logs[0].asPreRuntime;
+    const [consensusEngine, slot] = preRuntime;
+    return { consensusEngine, slot, rest: header.digest.logs.slice(1) };
+};
+const getNewSlot = (digest, slotNumber) => {
+    if (digest.isPrimary) {
+        return {
+            primary: {
+                ...digest.asPrimary.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryPlain) {
+        return {
+            secondaryPlain: {
+                ...digest.asSecondaryPlain.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryVRF) {
+        return {
+            secondaryVRF: {
+                ...digest.asSecondaryVRF.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    return digest.toJSON();
+};
+const newHeader = async (head) => {
+    const meta = await head.meta;
+    const parentHeader = await head.header;
+    let newLogs = parentHeader.digest.logs;
+    const consensus = getConsensus(parentHeader);
+    if (consensus?.consensusEngine.isAura) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
+        const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine.isBabe) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
+        const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
+        const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine?.toString() == 'nmbs') {
+        const nmbsKey = (0, util_1.stringToHex)('nmbs');
+        newLogs = [
+            {
+                // Using previous block author
+                PreRuntime: [
+                    consensus.consensusEngine,
+                    parentHeader.digest.logs
+                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)
+                        ?.asPreRuntime[1].toHex(),
+                ],
+            },
+            ...consensus.rest,
+            head.pushStorageLayer().set((0, utils_1.compactHex)(meta.query.randomness.notFirstBlock()), "Deleted" /* StorageValueKind.Deleted */),
+        ];
+    }
+    const header = meta.registry.createType('Header', {
+        parentHash: head.hash,
+        number: head.number + 1,
+        stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        digest: {
+            logs: newLogs,
+        },
+    });
+    return header;
+};
+const initNewBlock = async (head, header, inherents) => {
+    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 });
+    {
+        // initialize block
+        const { storageDiff } = await newBlock.call('Core_initialize_block', header.toHex());
+        newBlock.pushStorageLayer().setAll(storageDiff);
+        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Initialize block');
+    }
+    // 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');
+        }
+    }
+    return newBlock;
+};
+const buildBlock = async (head, inherents, extrinsics) => {
+    const registry = await head.registry;
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    logger.info({
+        number: newBlock.number,
+        extrinsicsCount: extrinsics.length,
+        tempHash: newBlock.hash,
+    }, `Building block #${newBlock.number.toLocaleString()}`);
+    const pendingExtrinsics = [];
+    // 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, newBlock.number, blockData.hash.toHex(), head, {
+        header,
+        extrinsics: [...inherents, ...extrinsics],
+        storage: head.storage,
+        storageDiff,
+    });
+    logger.info({ hash: finalBlock.hash, number: newBlock.number }, `Block built #${newBlock.number.toLocaleString()} hash ${finalBlock.hash}`);
+    return [finalBlock, pendingExtrinsics];
+};
+exports.buildBlock = buildBlock;
+const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    return newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
+};
+exports.dryRunExtrinsic = dryRunExtrinsic;
+const dryRunInherents = async (head, inherents) => {
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    return Object.entries(await newBlock.storageDiff());
+};
+exports.dryRunInherents = dryRunInherents;

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>;
@@ -30,7 +32,7 @@ export declare class Block {
     }): Promise<string[]>;
     pushStorageLayer(): StorageLayer;
     popStorageLayer(): void;
-    storageDiff(): Promise<Record<string, string>>;
+    storageDiff(): Promise<Record<HexString, HexString | null>>;
     get wasm(): Promise<`0x${string}`>;
     setWasm(wasm: HexString): void;
     get registry(): Promise<TypeRegistry>;

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,11 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
 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, HorizontalMessage } from './txpool';
 import { HeadState } from './head-state';
-import { InherentProvider } from './inherents';
+import { InherentProvider } from './inherent';
 export interface Options {
     api: Api;
     buildBlockMode?: BuildBlockMode;
@@ -13,7 +13,7 @@ export interface Options {
     db?: DataSource;
     header: {
         number: number;
-        hash: string;
+        hash: HexString;
     };
     mockSignatureHost?: boolean;
     allowUnresolvedImports?: boolean;
@@ -27,11 +27,16 @@ 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>;
+    dryRunExtrinsic(extrinsic: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>): Promise<[HexString, HexString | null][]>;
 }

package/dist/blockchain/index.js

@@ -6,9 +6,8 @@ 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 block_builder_1 = require("./block-builder");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
     api;
@@ -16,9 +15,11 @@ class Blockchain {
     mockSignatureHost;
     allowUnresolvedImports;
     #txpool;
+    #inherentProvider;
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
+    #loadingBlocks = {};
     headState;
     constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, }) {
         this.api = api;
@@ -27,8 +28,8 @@ 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.#inherentProvider = inherentProvider;
         this.headState = new head_state_1.HeadState(this.#head);
     }
     #registerBlock(block) {
@@ -38,6 +39,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 +62,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 +93,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,11 +112,26 @@ 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;
     }
+    async dryRunExtrinsic(extrinsic) {
+        await this.api.isReady;
+        const head = this.head;
+        const registry = await head.registry;
+        const inherents = await this.#inherentProvider.createInherents(head);
+        const { result, storageDiff } = await (0, block_builder_1.dryRunExtrinsic)(head, inherents, extrinsic);
+        const outcome = registry.createType('ApplyExtrinsicResult', result);
+        return { outcome, storageDiff };
+    }
+    async dryRunHrmp(hrmp) {
+        await this.api.isReady;
+        const head = this.head;
+        const inherents = await this.#inherentProvider.createInherents(head, { horizontalMessages: hrmp });
+        return (0, block_builder_1.dryRunInherents)(head, inherents);
+    }
 }
 exports.Blockchain = Blockchain;

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

@@ -0,0 +1,19 @@
+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 { SetBabeRandomness } from './parachain/babe-randomness';
+export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
+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[]>;
+}