@acala-network/chopsticks 0.3.0 → 0.3.2

package/README.md

@@ -26,7 +26,14 @@ 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=0x39028400d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01183abac17ff331f8b65dbeddd27f014dedd892020cfdc6c40b574f6930f8cf391bde95997ae2edc5b1192a4036ea97804956c4b5497175c8d68b630301685889450200000a00008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480284d717`
+  - Dry run call `yarn start dry-run --config=configs/mandala.yml --html --open --extrinsic=0xff00000080969800 --address=5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY --at=0x5f660b32489966cc707ecde831864aeecf9092c4983e75f9880313e9158d62b9`
+
 - 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 +41,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"
@@ -58,7 +64,7 @@ Make sure you have setup Rust environment (>= 1.64).
   - 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)
+- Setup XCM multichain
 **_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/blockchain/block-builder.d.ts

@@ -1,4 +1,8 @@
-import { Block } from './block';
-import { Header } from '@polkadot/types/interfaces';
+import { Block, TaskCallResponse } from './block';
 import { HexString } from '@polkadot/util/types';
-export declare const buildBlock: (head: Block, header: Header, inherents: HexString[], extrinsics: HexString[]) => Promise<[Block, HexString[]]>;
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[]) => 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/blockchain/block-builder.js

@@ -1,46 +1,131 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBlock = void 0;
+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 buildBlock = async (head, header, inherents, extrinsics) => {
-    const registry = await head.registry;
-    const pendingExtrinsics = [];
+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 });
-    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);
+        logger.trace((0, logger_1.truncate)(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');
+            logger.trace((0, logger_1.truncate)(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');
+            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
         }
         catch (e) {
             logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -51,7 +136,7 @@ const buildBlock = async (head, header, inherents, extrinsics) => {
         // finalize block
         const { storageDiff } = await newBlock.call('BlockBuilder_finalize_block', '0x');
         newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncateStorageDiff)(storageDiff), 'Finalize block');
+        logger.trace((0, logger_1.truncate)(storageDiff), 'Finalize block');
     }
     const blockData = registry.createType('Block', {
         header,
@@ -59,13 +144,49 @@ const buildBlock = async (head, header, inherents, 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, {
+    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: blockNumber }, `Block built #${blockNumber.toLocaleString()} hash ${finalBlock.hash}`);
+    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 registry = await head.registry;
+    const header = await newHeader(head);
+    const newBlock = await initNewBlock(head, header, inherents);
+    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`');
+        }
+        const meta = await head.meta;
+        const call = registry.createType('Call', (0, util_1.hexToU8a)(extrinsic.call));
+        const generic = registry.createType('GenericExtrinsic', call);
+        const accountRaw = await head.get((0, utils_1.compactHex)(meta.query.system.account(extrinsic.address)));
+        const account = registry.createType('AccountInfo', (0, util_1.hexToU8a)(accountRaw));
+        generic.signFake(extrinsic.address, {
+            blockHash: head.hash,
+            genesisHash: head.hash,
+            runtimeVersion: await head.runtimeVersion,
+            nonce: account.nonce,
+        });
+        const mockSignature = new Uint8Array(64);
+        mockSignature.fill(0xcd);
+        mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
+        generic.signature.set(mockSignature);
+        logger_1.defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
+        return newBlock.call('BlockBuilder_apply_extrinsic', generic.toHex());
+    }
+    logger_1.defaultLogger.info({ call: registry.createType('GenericExtrinsic', (0, util_1.hexToU8a)(extrinsic)).toHuman() }, 'dry_run_extrinsic');
+    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

@@ -32,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/index.d.ts

@@ -1,8 +1,9 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
 import { DataSource } from 'typeorm';
 import { HexString } from '@polkadot/util/types';
 import { Api } from '../api';
 import { Block } from './block';
-import { BuildBlockMode, BuildBlockParams } from './txpool';
+import { BuildBlockMode, BuildBlockParams, HorizontalMessage } from './txpool';
 import { HeadState } from './head-state';
 import { InherentProvider } from './inherent';
 export interface Options {
@@ -19,6 +20,7 @@ export interface Options {
 }
 export declare class Blockchain {
     #private;
+    readonly uid: string;
     readonly api: Api;
     readonly db: DataSource | undefined;
     readonly mockSignatureHost: boolean;
@@ -33,4 +35,12 @@ export declare class Blockchain {
     setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
     newBlock(params?: BuildBlockParams): Promise<Block>;
+    dryRunExtrinsic(extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>): Promise<[HexString, HexString | null][]>;
 }

package/dist/blockchain/index.js

@@ -7,13 +7,16 @@ const block_1 = require("./block");
 const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
 const logger_1 = require("../logger");
+const block_builder_1 = require("./block-builder");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
+    uid = Math.random().toString(36).substring(2);
     api;
     db;
     mockSignatureHost;
     allowUnresolvedImports;
     #txpool;
+    #inherentProvider;
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
@@ -27,6 +30,7 @@ class Blockchain {
         this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
+        this.#inherentProvider = inherentProvider;
         this.headState = new head_state_1.HeadState(this.#head);
     }
     #registerBlock(block) {
@@ -115,5 +119,23 @@ class Blockchain {
         await this.#txpool.buildBlock(params);
         return this.#head;
     }
+    async dryRunExtrinsic(extrinsic, at) {
+        await this.api.isReady;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
+        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

@@ -3,6 +3,8 @@ 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[]>;
 }

package/dist/blockchain/inherent/index.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InherentProviders = exports.SetTimestamp = exports.ParaInherentEnter = exports.SetValidationData = void 0;
+exports.InherentProviders = exports.SetTimestamp = exports.SetNimbusAuthorInherent = exports.SetBabeRandomness = 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; } });
+var babe_randomness_1 = require("./parachain/babe-randomness");
+Object.defineProperty(exports, "SetBabeRandomness", { enumerable: true, get: function () { return babe_randomness_1.SetBabeRandomness; } });
+var nimbus_author_inherent_1 = require("./parachain/nimbus-author-inherent");
+Object.defineProperty(exports, "SetNimbusAuthorInherent", { enumerable: true, get: function () { return nimbus_author_inherent_1.SetNimbusAuthorInherent; } });
 class SetTimestamp {
     async createInherents(parent) {
         const meta = await parent.meta;

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetBabeRandomness = void 0;
+const types_1 = require("@polkadot/types");
+// Support for Moonbeam pallet-randomness mandatory inherent
+class SetBabeRandomness {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.randomness?.setBabeRandomnessResults) {
+            return [];
+        }
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
+    }
+}
+exports.SetBabeRandomness = SetBabeRandomness;

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

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

package/dist/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetNimbusAuthorInherent = void 0;
+const types_1 = require("@polkadot/types");
+// Support for Nimbus Author Inherent
+class SetNimbusAuthorInherent {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.authorInherent?.kickOffAuthorshipValidation) {
+            return [];
+        }
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
+    }
+}
+exports.SetNimbusAuthorInherent = SetNimbusAuthorInherent;

package/dist/blockchain/txpool.js

@@ -4,50 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxPool = exports.BuildBlockMode = void 0;
-const util_1 = require("@polkadot/util");
 const lodash_1 = __importDefault(require("lodash"));
 const block_builder_1 = require("./block-builder");
-const time_travel_1 = require("../utils/time-travel");
 var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
     BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
     BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
 })(BuildBlockMode = exports.BuildBlockMode || (exports.BuildBlockMode = {}));
-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();
-};
 class TxPool {
     #chain;
     #pool = [];
@@ -87,33 +51,8 @@ class TxPool {
         await wait.catch(() => { }); // ignore error
         const head = this.#chain.head;
         const extrinsics = this.#pool.splice(0);
-        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)(this.#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)(this.#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];
-        }
-        const registry = await head.registry;
-        const header = registry.createType('Header', {
-            parentHash: head.hash,
-            number: head.number + 1,
-            stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-            extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-            digest: {
-                logs: newLogs,
-            },
-        });
         const inherents = await this.#inherentProvider.createInherents(head, params?.inherent);
-        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, header, inherents, extrinsics);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, extrinsics);
         this.#pool.push(...pendingExtrinsics);
         await this.#chain.setHead(newBlock);
     }

package/dist/dry-run.d.ts

@@ -0,0 +1,2 @@
+import { Config } from './schema';
+export declare const dryRun: (argv: Config) => Promise<never>;

package/dist/dry-run.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRun = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const node_fs_1 = require("node:fs");
+const logger_1 = require("./logger");
+const generate_html_diff_1 = require("./utils/generate-html-diff");
+const open_html_1 = require("./utils/open-html");
+const setup_1 = require("./setup");
+const dryRun = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
+    const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+    const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input, argv['at']);
+    if (outcome.isErr) {
+        throw new Error(outcome.asErr.toString());
+    }
+    else {
+        logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+    }
+    if (argv['html']) {
+        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
+        console.log(`Generated preview ${filePath}`);
+        if (argv['open']) {
+            (0, open_html_1.openHtml)(filePath);
+        }
+    }
+    else if (argv['output-path']) {
+        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
+    }
+    else {
+        console.dir({ outcome: outcome.toHuman(), storageDiff }, { depth: null, colors: false });
+    }
+    process.exit(0);
+};
+exports.dryRun = dryRun;

package/dist/executor.js

@@ -38,10 +38,10 @@ const createProof = async (trieRootHash, nodes, entries) => {
 };
 exports.createProof = createProof;
 const runTask = async (task, callback = exports.emptyTaskHandler) => {
-    logger.trace({ task: { ...task, wasm: (0, logger_1.truncate)(task.wasm) } }, 'taskRun');
+    logger.trace((0, logger_1.truncate)(task), 'taskRun');
     const response = await (0, chopsticks_executor_1.run_task)(task, callback);
     if (response.Call) {
-        logger.trace({ result: (0, logger_1.truncate)(response.Call.result), storageDiff: (0, logger_1.truncateStorageDiff)(response.Call.storageDiff) }, 'taskResponse');
+        logger.trace((0, logger_1.truncate)(response.Call), 'taskResponse');
     }
     else {
         logger.trace({ response }, 'taskResponse');
@@ -58,7 +58,7 @@ const taskHandler = (block) => {
             return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
         },
         getNextKey: async function (key) {
-            const keys = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+            const keys = await block.getKeysPaged({ prefix: '0x', pageSize: 1, startKey: key });
             return keys[0];
         },
     };