@acala-network/chopsticks 0.2.3 → 0.3.1

package/dist/blockchain/inherent/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+        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/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/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[]>;
+}

package/dist/blockchain/{inherents.js → inherent/parachain/validation-data.js}

@@ -1,24 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetValidationData = exports.InherentProviders = exports.SetTimestamp = void 0;
+exports.SetValidationData = void 0;
 const types_1 = require("@polkadot/types");
-const utils_1 = require("../utils");
-const executor_1 = require("../executor");
 const util_1 = require("@polkadot/util");
-const proof_1 = require("../utils/proof");
-class SetTimestamp {
-    #getTimestamp;
-    constructor(getTimestamp = Date.now) {
-        this.#getTimestamp = getTimestamp;
-    }
-    async createInherents(meta, timestamp, _parent) {
-        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(timestamp)).toHex()];
-    }
-    getTimestamp(blockNumber) {
-        return this.#getTimestamp(blockNumber);
-    }
-}
-exports.SetTimestamp = SetTimestamp;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const utils_1 = require("../../../utils");
+const executor_1 = require("../../../executor");
+const proof_1 = require("../../../utils/proof");
 const MOCK_VALIDATION_DATA = {
     validationData: {
         relayParentNumber: 1000,
@@ -43,35 +31,15 @@ const MOCK_VALIDATION_DATA = {
         ],
     },
 };
-class InherentProviders {
-    #base;
-    #providers;
-    constructor(base, providers) {
-        this.#base = base;
-        this.#providers = providers;
-    }
-    async createInherents(meta, timestamp, parent) {
-        const base = await this.#base.createInherents(meta, timestamp, parent);
-        const extra = await Promise.all(this.#providers.map((provider) => provider.createInherents(meta, timestamp, parent)));
-        return [...base, ...extra.flat()];
-    }
-    getTimestamp(blockNumber) {
-        return this.#base.getTimestamp(blockNumber);
-    }
-}
-exports.InherentProviders = InherentProviders;
 class SetValidationData {
-    async createInherents(meta, _timestamp, parent) {
+    async createInherents(parent, params) {
+        const meta = await parent.meta;
         if (!meta.tx.parachainSystem?.setValidationData) {
             return [];
         }
-        const parentBlock = await parent.parentBlock;
-        if (!parentBlock) {
-            throw new Error('Parent block not found');
-        }
-        const extrinsics = await parentBlock.extrinsics;
+        const extrinsics = await parent.extrinsics;
         let newData;
-        if (parentBlock.number === 0) {
+        if (parent.number === 0) {
             // chain started with genesis, mock 1st validationData
             newData = MOCK_VALIDATION_DATA;
         }
@@ -87,17 +55,80 @@ class SetValidationData {
                 .createType('GenericExtrinsic', validationDataExtrinsic)
                 .args[0].toJSON();
             const newEntries = [];
-            const upgrade = await parentBlock.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
-            if (upgrade) {
-                const paraIdStorage = await parentBlock.get((0, utils_1.compactHex)(meta.query.parachainInfo.parachainId()));
-                const paraId = meta.registry.createType('u32', (0, util_1.hexToU8a)(paraIdStorage));
-                const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
+            const downwardMessages = [];
+            const horizontalMessages = {};
+            const paraId = await (0, utils_1.getParaId)(parent.chain);
+            const dmqMqcHeadKey = (0, proof_1.dmqMqcHead)(paraId);
+            const hrmpIngressChannelIndexKey = (0, proof_1.hrmpIngressChannelIndex)(paraId);
+            const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [dmqMqcHeadKey, hrmpIngressChannelIndexKey], extrinsic.relayChainState.trieNodes);
+            // inject downward messages
+            if (params?.downwardMessages) {
+                let dmqMqcHeadHash = decoded[dmqMqcHeadKey];
+                if (!dmqMqcHeadHash)
+                    throw new Error('Canoot find dmqMqcHead from validation data');
+                for (const { msg, sentAt } of params.downwardMessages) {
+                    // calculate new hash
+                    dmqMqcHeadHash = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', dmqMqcHeadHash).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(meta.registry.createType('Bytes', msg).toU8a(), 256)), 256);
+                    downwardMessages.push({
+                        msg,
+                        sent_at: sentAt,
+                    });
+                }
+                newEntries.push([dmqMqcHeadKey, dmqMqcHeadHash]);
+            }
+            const hrmpIngressChannels = meta.registry
+                .createType('Vec<ParaId>', decoded[hrmpIngressChannelIndexKey])
+                .toJSON();
+            // inject horizontal messages
+            if (params?.horizontalMessages) {
+                for (const [id, messages] of Object.entries(params.horizontalMessages)) {
+                    const sender = Number(id);
+                    if (hrmpIngressChannels.includes(sender)) {
+                        const channelId = meta.registry.createType('HrmpChannelId', {
+                            sender,
+                            receiver: paraId.toNumber(),
+                        });
+                        const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
+                        const decoded = await (0, executor_1.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_1.hexToU8a)(abridgedHrmpRaw))
+                            .toJSON();
+                        const paraMessages = [];
+                        for (const { data, sentAt } of messages) {
+                            // calculate new hash
+                            const bytes = meta.registry.createType('Bytes', data);
+                            abridgedHrmp.mqcHead = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', abridgedHrmp.mqcHead).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(bytes.toU8a(), 256)), 256);
+                            abridgedHrmp.msgCount = abridgedHrmp.msgCount + 1;
+                            abridgedHrmp.totalSize = abridgedHrmp.totalSize + bytes.length;
+                            paraMessages.push({
+                                data,
+                                sent_at: sentAt,
+                            });
+                        }
+                        horizontalMessages[sender] = paraMessages;
+                        newEntries.push([hrmpChannelKey, meta.registry.createType('AbridgedHrmpChannel', abridgedHrmp).toHex()]);
+                    }
+                }
+            }
+            const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
+            const pendingUpgrade = await parent.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
+            if (pendingUpgrade) {
+                // send goAhead signal
                 const goAhead = meta.registry.createType('UpgradeGoAhead', 'GoAhead');
                 newEntries.push([upgradeKey, goAhead.toHex()]);
             }
+            else {
+                // make sure previous goAhead is removed
+                newEntries.push([upgradeKey, null]);
+            }
             const { trieRootHash, nodes } = await (0, executor_1.createProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes, newEntries);
             newData = {
                 ...extrinsic,
+                downwardMessages,
+                horizontalMessages,
                 validationData: {
                     ...extrinsic.validationData,
                     relayParentStorageRoot: trieRootHash,

package/dist/blockchain/txpool.d.ts

@@ -1,14 +1,29 @@
 import { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
-import { InherentProvider } from './inherents';
+import { InherentProvider } from './inherent';
 export declare enum BuildBlockMode {
     Batch = 0,
     Instant = 1,
     Manual = 2
 }
+export interface DownwardMessage {
+    sentAt: number;
+    msg: HexString;
+}
+export interface HorizontalMessage {
+    sentAt: number;
+    data: HexString;
+}
+export interface BuildBlockParams {
+    inherent?: {
+        downwardMessages?: DownwardMessage[];
+        horizontalMessages?: Record<number, HorizontalMessage[]>;
+    };
+}
 export declare class TxPool {
     #private;
     constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
+    get pendingExtrinsics(): HexString[];
     submitExtrinsic(extrinsic: HexString): void;
-    buildBlock(): Promise<void>;
+    buildBlock(params?: BuildBlockParams): Promise<void>;
 }

package/dist/blockchain/txpool.js

@@ -4,26 +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_1 = require("./block");
-const shared_1 = require("../rpc/shared");
-const utils_1 = require("../utils");
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'txpool' });
+const block_builder_1 = require("./block-builder");
 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] = preRuntime;
-    return { consensusEngine, rest: header.digest.logs.slice(1) };
-};
 class TxPool {
     #chain;
     #pool = [];
@@ -35,6 +23,9 @@ class TxPool {
         this.#mode = mode;
         this.#inherentProvider = inherentProvider;
     }
+    get pendingExtrinsics() {
+        return this.#pool;
+    }
     submitExtrinsic(extrinsic) {
         this.#pool.push(extrinsic);
         switch (this.#mode) {
@@ -50,107 +41,20 @@ class TxPool {
         }
     }
     #batchBuildBlock = lodash_1.default.debounce(this.buildBlock, 100, { maxWait: 1000 });
-    async buildBlock() {
+    async buildBlock(params) {
         const last = this.#lastBuildBlockPromise;
-        this.#lastBuildBlockPromise = this.#buildBlock(last);
+        this.#lastBuildBlockPromise = this.#buildBlock(last, params);
         await this.#lastBuildBlockPromise;
     }
-    async #buildBlock(wait) {
+    async #buildBlock(wait, params) {
         await this.#chain.api.isReady;
         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;
-        const time = this.#inherentProvider.getTimestamp(head.number + 1);
-        let newLogs = parentHeader.digest.logs;
-        const expectedSlot = Math.floor(time / (meta.consts.timestamp.minimumPeriod.toNumber() * 2));
-        const consensus = getConsensus(parentHeader);
-        if (consensus?.consensusEngine.isAura) {
-            const newSlot = (0, util_1.compactAddLength)((0, util_1.bnToU8a)(expectedSlot, { isLe: true, bitLength: 64 }));
-            newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
-        }
-        else if (consensus?.consensusEngine.isBabe) {
-            // trying to make a SecondaryPlainPreDigest
-            const newSlot = (0, util_1.compactAddLength)((0, util_1.u8aConcat)('0x0200000000', (0, util_1.bnToU8a)(expectedSlot, { isLe: true, bitLength: 64 })));
-            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 newBlock = this.#chain.newTempBlock(head, header);
-        logger.info({
-            hash: head.hash,
-            number: head.number,
-            extrinsicsCount: extrinsics.length,
-            tempHash: newBlock.hash,
-            timeValue: time,
-            expectedSlot,
-        }, 'Building block');
-        const resp = await newBlock.call('Core_initialize_block', header.toHex());
-        logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Initialize block');
-        newBlock.pushStorageLayer().setAll(resp.storageDiff);
-        if (meta.query.babe?.currentSlot) {
-            // TODO: figure out how to generate a valid babe slot digest instead of just modify the data
-            // but hey, we can get it working without a valid digest
-            const key = (0, utils_1.compactHex)(meta.query.babe.currentSlot());
-            newBlock.pushStorageLayer().set(key, (0, util_1.bnToHex)(expectedSlot, { isLe: true, bitLength: 64 }));
-        }
-        const inherents = await this.#inherentProvider.createInherents(meta, time, newBlock);
-        for (const extrinsic of inherents) {
-            try {
-                const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
-                newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Applied inherent');
-            }
-            catch (e) {
-                logger.warn('Failed to apply inherents %o %s', e, e);
-                throw new shared_1.ResponseError(1, 'Failed to apply inherents');
-            }
-        }
-        for (const extrinsic of extrinsics) {
-            try {
-                const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
-                newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Applied extrinsic');
-            }
-            catch (e) {
-                logger.info('Failed to apply extrinsic %o %s', e, e);
-                this.#pool.push(extrinsic);
-            }
-        }
-        if (meta.query.paraInherent?.included) {
-            // TODO: remvoe this once paraInherent.enter is implemented
-            // we are relaychain, however as we have not yet implemented the paraInherent.enter
-            // so need to do some trick to make the on_finalize check happy
-            const paraInherentIncludedKey = (0, utils_1.compactHex)(meta.query.paraInherent.included());
-            newBlock.pushStorageLayer().set(paraInherentIncludedKey, '0x01');
-        }
-        const resp2 = await newBlock.call('BlockBuilder_finalize_block', '0x');
-        newBlock.pushStorageLayer().setAll(resp2.storageDiff);
-        logger.trace((0, logger_1.truncateStorageDiff)(resp2.storageDiff), 'Finalize block');
-        const blockData = registry.createType('Block', {
-            header,
-            extrinsics,
-        });
-        const finalBlock = new block_1.Block(this.#chain, newBlock.number, blockData.hash.toHex(), head, {
-            header,
-            extrinsics: [...inherents, ...extrinsics],
-            storage: head.storage,
-        });
-        const diff = await newBlock.storageDiff();
-        logger.trace(Object.entries(diff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
-        finalBlock.pushStorageLayer().setAll(diff);
-        this.#chain.unregisterBlock(newBlock);
-        this.#chain.setHead(finalBlock);
-        logger.info({ hash: finalBlock.hash, number: finalBlock.number, prevHash: newBlock.hash }, 'Block built');
+        const inherents = await this.#inherentProvider.createInherents(head, params?.inherent);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, extrinsics);
+        this.#pool.push(...pendingExtrinsics);
+        await this.#chain.setHead(newBlock);
     }
 }
 exports.TxPool = TxPool;

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,30 @@
+"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 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 { outcome, storageDiff } = await context.chain.dryRunExtrinsic(argv['extrinsic']);
+    if (outcome.isErr) {
+        throw new Error(outcome.asErr.toString());
+    }
+    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.d.ts

@@ -1,4 +1,11 @@
 import { HexString } from '@polkadot/util/types';
+import { Block } from './blockchain/block';
+import { Registry } from '@polkadot/types-codec/types';
+interface JsCallback {
+    getStorage: (key: HexString) => Promise<string | undefined>;
+    getPrefixKeys: (key: HexString) => Promise<string[]>;
+    getNextKey: (key: HexString) => Promise<string | undefined>;
+}
 export type RuntimeVersion = {
     specName: string;
     implName: string;
@@ -12,15 +19,22 @@ export type RuntimeVersion = {
 export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
 export declare const calculateStateRoot: (entries: [HexString, HexString][]) => Promise<HexString>;
 export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
-export declare const createProof: (trieRootHash: HexString, nodes: HexString[], entries: [HexString, HexString][]) => Promise<{
+export declare const createProof: (trieRootHash: HexString, nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
     trieRootHash: `0x${string}`;
     nodes: `0x${string}`[];
 }>;
 export declare const runTask: (task: {
-    blockHash: HexString;
     wasm: HexString;
     calls: [string, HexString][];
     storage: [HexString, HexString | null][];
     mockSignatureHost: boolean;
     allowUnresolvedImports: boolean;
-}) => Promise<any>;
+}, callback?: JsCallback) => Promise<any>;
+export declare const taskHandler: (block: Block) => JsCallback;
+export declare const emptyTaskHandler: {
+    getStorage: (_key: HexString) => Promise<never>;
+    getPrefixKeys: (_key: HexString) => Promise<never>;
+    getNextKey: (_key: HexString) => Promise<never>;
+};
+export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & import("lodash").MemoizedFunction;
+export {};

package/dist/executor.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
+exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
 const ws_1 = require("ws");
 const util_1 = require("@polkadot/util");
 global.WebSocket = ws_1.WebSocket;
 const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
 const logger_1 = require("./logger");
+const lodash_1 = require("lodash");
 const logger = logger_1.defaultLogger.child({ name: 'executor' });
 const getRuntimeVersion = async (code) => {
     return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
@@ -36,9 +37,9 @@ const createProof = async (trieRootHash, nodes, entries) => {
     return { trieRootHash: result[0], nodes: result[1] };
 };
 exports.createProof = createProof;
-const runTask = async (task) => {
+const runTask = async (task, callback = exports.emptyTaskHandler) => {
     logger.trace({ task: { ...task, wasm: (0, logger_1.truncate)(task.wasm) } }, 'taskRun');
-    const response = await (0, chopsticks_executor_1.run_task)(task);
+    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');
     }
@@ -48,3 +49,42 @@ const runTask = async (task) => {
     return response;
 };
 exports.runTask = runTask;
+const taskHandler = (block) => {
+    return {
+        getStorage: async function (key) {
+            return block.get(key);
+        },
+        getPrefixKeys: async function (key) {
+            return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
+        },
+        getNextKey: async function (key) {
+            const keys = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+            return keys[0];
+        },
+    };
+};
+exports.taskHandler = taskHandler;
+exports.emptyTaskHandler = {
+    getStorage: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    getPrefixKeys: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    getNextKey: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+};
+exports.getAuraSlotDuration = (0, lodash_1.memoize)(async (wasm, registry) => {
+    const result = await (0, exports.runTask)({
+        wasm,
+        calls: [['AuraApi_slot_duration', '0x']],
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+    });
+    if (!result.Call)
+        throw new Error(result.Error);
+    const slotDuration = registry.createType('u64', (0, util_1.hexToU8a)(result.Call.result)).toNumber();
+    return slotDuration;
+});