@acala-network/chopsticks 0.2.3 → 0.3.0

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

@@ -6,11 +6,8 @@ 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");
+const time_travel_1 = require("../utils/time-travel");
 var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
@@ -21,8 +18,35 @@ 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) };
+    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;
@@ -35,6 +59,9 @@ class TxPool {
         this.#mode = mode;
         this.#inherentProvider = inherentProvider;
     }
+    get pendingExtrinsics() {
+        return this.#pool;
+    }
     submitExtrinsic(extrinsic) {
         this.#pool.push(extrinsic);
         switch (this.#mode) {
@@ -50,29 +77,29 @@ 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 }));
+            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) {
-            // 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 })));
+            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;
@@ -85,72 +112,10 @@ class TxPool {
                 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, header, inherents, extrinsics);
+        this.#pool.push(...pendingExtrinsics);
+        await this.#chain.setHead(newBlock);
     }
 }
 exports.TxPool = TxPool;

package/dist/decode-key.d.ts

@@ -0,0 +1,2 @@
+import '@polkadot/types-codec';
+export declare const decodeKey: (argv: any) => Promise<void>;

package/dist/decode-key.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeKey = void 0;
+require("@polkadot/types-codec");
+const util_1 = require("@polkadot/util");
+const setup_1 = require("./setup");
+const decodeKey = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
+    const key = argv.key;
+    const meta = await context.chain.head.meta;
+    outer: for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                const decodedKey = meta.registry.createType('StorageKey', key);
+                decodedKey.setMeta(storage.meta);
+                console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
+                break outer;
+            }
+        }
+    }
+    setTimeout(() => process.exit(0), 50);
+};
+exports.decodeKey = decodeKey;

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;
+});

package/dist/executor.test.js

@@ -9,20 +9,23 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const proof_1 = require("./utils/proof");
 const executor_1 = require("./executor");
+const getCode = () => {
+    const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../e2e/blobs/acala-runtime-2101.txt'))).trim();
+    (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
+    return code;
+};
 (0, vitest_1.describe)('wasm', () => {
     (0, vitest_1.it)('get runtime version from wasm runtime', async () => {
-        const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, 'runtime.example'))).trim();
-        (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
         const expectedRuntimeVersion = {
             specName: 'acala',
             implName: 'acala',
             authoringVersion: 1,
-            specVersion: 2000,
+            specVersion: 2101,
             implVersion: 0,
             apis: [
-                ['0xdf6acb689907609b', 3],
+                ['0xdf6acb689907609b', 4],
                 ['0x37e397fc7c91f5e4', 1],
-                ['0x40fe3ad401f8959a', 5],
+                ['0x40fe3ad401f8959a', 6],
                 ['0xd2bc9897eed08f15', 3],
                 ['0xf78b278be53f454c', 2],
                 ['0xdd718d5cc53262d4', 1],
@@ -30,14 +33,14 @@ const executor_1 = require("./executor");
                 ['0xbc9d89904f5b923f', 1],
                 ['0x37c8bb1350a9a2a8', 1],
                 ['0x6ef953004ba30e59', 1],
-                ['0xf485c9145d3f0aad', 1],
-                ['0xe3df3f2aa8a5cc57', 1],
-                ['0xea93e3f16f3d6962', 1],
+                ['0x955e168e0cfb3409', 1],
+                ['0xe3df3f2aa8a5cc57', 2],
+                ['0xea93e3f16f3d6962', 2],
             ],
             transactionVersion: 1,
             stateVersion: 0,
         };
-        (0, vitest_1.expect)(await (0, executor_1.getRuntimeVersion)(code)).toMatchObject(expectedRuntimeVersion);
+        (0, vitest_1.expect)(await (0, executor_1.getRuntimeVersion)(getCode())).toMatchObject(expectedRuntimeVersion);
     });
     (0, vitest_1.it)('calculate state root', async () => {
         const a = await (0, executor_1.calculateStateRoot)([['0x5301bf5ff0298f5c7b93a446709f8e885f772afdd0d8ba3d4d559a06f0742f12', '0x01']]);
@@ -128,4 +131,8 @@ const executor_1 = require("./executor");
         (0, vitest_1.expect)(decoded).toMatchSnapshot();
         (0, vitest_1.expect)(decoded[upgradeKey]).toBe('0x01');
     });
+    (0, vitest_1.it)('get aura slot duration', async () => {
+        const slotDuration = await (0, executor_1.getAuraSlotDuration)(getCode(), new types_1.TypeRegistry());
+        (0, vitest_1.expect)(slotDuration).eq(12000);
+    });
 });

package/dist/genesis-provider.d.ts

@@ -36,6 +36,11 @@ export declare class GenesisProvider implements ProviderInterface {
             extrinsics: never[];
         };
     }>;
+    get _jsCallback(): {
+        getStorage: (key: HexString) => Promise<string>;
+        getNextKey: (_key: HexString) => Promise<string>;
+        getPrefixKeys: (_key: HexString) => Promise<never[]>;
+    };
     send: (method: string, params: unknown[], _isCacheable?: boolean) => Promise<any>;
     subscribe: (_type: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback) => Promise<number | string>;
     unsubscribe: (_type: string, _method: string, _id: number | string) => Promise<boolean>;

package/dist/genesis-provider.js

@@ -30,7 +30,6 @@ class GenesisProvider {
             });
             this.#eventemitter.once('error', reject);
         });
-        this.connect();
     }
     static fromUrl = async (url) => {
         let isUrl = false;
@@ -103,6 +102,20 @@ class GenesisProvider {
             },
         };
     };
+    get _jsCallback() {
+        const storage = this.#genesis.genesis.raw.top;
+        return {
+            getStorage: async function (key) {
+                return storage[key];
+            },
+            getNextKey: async function (_key) {
+                return '0x';
+            },
+            getPrefixKeys: async function (_key) {
+                return [];
+            },
+        };
+    }
     send = async (method, params, _isCacheable) => {
         await this.isReady;
         switch (method) {
@@ -115,13 +128,12 @@ class GenesisProvider {
             case 'state_getMetadata': {
                 const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
                 return (0, executor_1.runTask)({
-                    blockHash: this.blockHash,
                     wasm: code,
                     calls: [['Metadata_metadata', '0x']],
                     storage: [],
                     mockSignatureHost: false,
                     allowUnresolvedImports: true,
-                });
+                }, this._jsCallback);
             }
             case 'chain_getHeader':
                 return this.getHeader();

package/dist/index.d.ts

@@ -1,18 +1 @@
-import '@polkadot/types-codec';
-import { ProviderInterface } from '@polkadot/rpc-provider/types';
-import { Api } from './api';
-import { Blockchain } from './blockchain';
-import { Config } from './schema';
-export declare const setup: (argv: Config) => Promise<{
-    chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
-}>;
-export declare const setupWithServer: (argv: Config) => Promise<{
-    close: () => Promise<void>;
-    chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
-}>;
-export declare const runBlock: (argv: Config) => Promise<void>;
-export declare const decodeKey: (argv: any) => Promise<void>;
+export {};