@acala-network/chopsticks 0.1.0

package/dist/blockchain/inherents.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetValidationData = exports.InherentProviders = exports.SetTimestamp = void 0;
+const types_1 = require("@polkadot/types");
+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() {
+        return this.#getTimestamp();
+    }
+}
+exports.SetTimestamp = SetTimestamp;
+const MOCK_VALIDATION_DATA = {
+    validationData: {
+        relayParentNumber: 1000,
+        relayParentStorageRoot: '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1',
+        maxPovSize: 5242880,
+    },
+    relayChainState: {
+        trieNodes: [
+            '0x5f04b49d95320d9021994c850f25b8e385f902000030000080000008000000000010000000100005000000050000000a0000000a000000000050000000100000e8764817000000040000000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000400000000001000b0040000000000000000000014000000040000000400000000000000010100000000060000006400000002000000c8000000020000001900000000000000020000000200000000c817a804000000',
+            '0x80011080ace5323aee784b03389c0e2cc68d81973f8fa26d395f333ecad7399271c781e1808e5db75be813c05205986cbd6fdede707a4d26816063a41eb42ebc262c734fad',
+            '0x8004648086a9239b72237f5bf119e2a880c32f5866460632700509cb874c60f67fe815ea80f6f6801e4b41e2e6d8ec194dba122bfb9eb33feb2545ef5144cea79551f7cc5280c629a7e712d763fe83b35d2a082430af6737a89f23219c0eb3051c83bc5af5ad80fed5ecd6097308a6540f8cf31aeaad186e6898d2ecc0e623767c521c70e39953',
+            '0x800804809f3ada68c357b5e0a3ebb39ef181acfa9943af4725c244330a4b2c60837612e88082ad3fbdf392429afeacc70177704b760bb145547c1f152e1fcf651916b43820',
+            '0x8008208042793f557c1d003b647e2eda79c2b5088c7d8cab2e82c1dcc87f4343cca91ae4485ead6eef5c4b1c68eaa71ea17a02d9de0400',
+            '0x80210280de38445d825563f8e218255a417c16971afa85b4f2ef18fbe08fbc5b976dc0d6801a2ff24096295cfccf1adda80b8dfffe380b9f3b54d7a3cdb67864a4655e62968022a699b2cc90a6654c84163d2a498506b192afe7cd9777227e5288e8ff069c0f',
+            '0x80400180ebebd1a1cd0bbc6714b7fb0ac854cca5a4c4e34e69485da48be3c8087b56e09b80128645c79ca6581c248a412fd7b8bc532a187600e6e1cc20c915538ba4df6a79',
+            '0x80ffbe80d9302a505e2b1ac931f539aed33bf791d1982906ae64c7197324044f191e9bca80972cd2f703f9c94fd516e14b7013c6f1545095855b6c4b36f21d89dad30aa54d80b2495ce4d07001927bb0857611f8d3a1449e791d0b010e3861c32dec0c44179680f5929c8ef9b0ac6ec8a529c91348d8cd6c169920dd37d055544a6c31c53b11e380402a0bf7ff07cee790d9cc065fc138ff6afa7db016d898d65b2b716af354c6f68042aef1dafffd1d9debbb8e6c4eb48b5c141ddf0aad2b0f3f4ddf53e6b38e65c080b31fa0392c1abdce1aa29d1544c94634ecab87ecaba6409db33aaa7621992a8280b1f4de7c3ac5665016d561a60659cd2d8f2d3e0a97e2ea9749279bd8e35eb1f180816ac87a2893694016b21768137a76ea459190ea0fc3c645d85e1a3d4eb194fe802e563b43e7334454c841953424be8c2b7a1c3295dbc391045cb6b88388ad5e7080b1ed3b02e5989b7d134ca056c778f1f5b6ffd377b2d8064483da6e94b82b0e40800cb3299c44a5db8fdcb4932e1b6ab0385d6ef1c9f8d85e0a75b787b6f4fd6c3c805a44c30e2676dc2d4c17451f51d9502e85064387999f366e6f3d404509a7780f80d6788ca71c6aabe421c352027acdb9532563dc5f1b25e6154b721f431e9990ed',
+            '0x9d0da05ca59913bc38a8630590f2627c154080834dda0ba5adf00d798e981a28a13e728cf83e35aefc87318440a61869f724474c5f0a351b6a99a5b21324516e668bb86a570400505f0e7b9012096b41c4eb3aaf947f6ea4290800007c7700e67da63472835bb0b737093a19ad4c63f5a4efb16ffa83d00700000400',
+            '0x9e207f03cfdce586301014700e2c25931040505f0e7b9012096b41c4eb3aaf947f6ea4290800004c5f0ec2d17a76153ff51817f12d9cfc3c7f0400',
+            '0x9e710b30bd2eab0352ddcc26417aa1945fc180699a53b51a9709a3a86039c49b5ef278e9fc244dae27e1a0380c91bff5b0488580c0d4096d94e724b8e86f952e5456c7253776de04c405582d2c350ee172d3eaa77c77081e0bfde17b36573208a06cb5cfba6b63f5a4efb16ffa83d00700000402803d0ae0b8f6832e8fabf0ec62521c2487c58b69eb97060faa8059b00ff6b7262d505f0e7b9012096b41c4eb3aaf947f6ea4290800004c5f03c716fb8fff3de61a883bb76adb34a20400806c8122e0f7f786071d6a51b330d612eccdcbe8d8f79936accabd640506dffdf380a6abfb72ed49b586829cca4ce631c092d45a017ab0d68288d308873025cfe5d280521b868fc212b25f021984cf02ced547cd45952b88360766839dfde7d4683e61',
+            '0x9ede3d8a54d27e44a9d5ce189618f22d1008505f0e7b9012096b41c4eb3aaf947f6ea42908010080c74756edffa217dfb07ab596d82753deff985ac215e5cc2997d29afe1d397c16',
+            '0x9ef78c98723ddc9073523ef3beefda0c1004505f0e7b9012096b41c4eb3aaf947f6ea4290800007c77095dac46c07a40d91506e7637ec4ba5763f5a4efb16ffa83d00700000400',
+        ],
+    },
+};
+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() {
+        return this.#base.getTimestamp();
+    }
+}
+exports.InherentProviders = InherentProviders;
+class SetValidationData {
+    #tasks;
+    #expectedIndex;
+    constructor(tasks, expectedIndex) {
+        this.#tasks = tasks;
+        this.#expectedIndex = expectedIndex;
+    }
+    async createInherents(meta, _timestamp, parent) {
+        if (!meta.tx.parachainSystem?.setValidationData) {
+            return [];
+        }
+        void this.#tasks; // TODO
+        const parentBlock = await parent.parentBlock;
+        if (!parentBlock) {
+            throw new Error('Parent block not found');
+        }
+        const extrinsics = await parentBlock.extrinsics;
+        let newData;
+        if (parentBlock.number === 0) {
+            // chain started with genesis, mock 1st validationData
+            newData = MOCK_VALIDATION_DATA;
+        }
+        else {
+            const method = meta.registry.createType('GenericExtrinsic', extrinsics[this.#expectedIndex]);
+            const validationData = method.args[0].toJSON();
+            newData = {
+                ...validationData,
+                validationData: {
+                    ...validationData.validationData,
+                    relayParentNumber: validationData.validationData.relayParentNumber + 2,
+                },
+            };
+        }
+        const inherent = new types_1.GenericExtrinsic(meta.registry, meta.tx.parachainSystem.setValidationData(newData));
+        return [inherent.toHex()];
+    }
+}
+exports.SetValidationData = SetValidationData;

package/dist/blockchain/storage-layer.d.ts

@@ -0,0 +1,32 @@
+import { DataSource } from 'typeorm';
+import { Api } from '../api';
+export declare const enum StorageValueKind {
+    Deleted = "Deleted",
+    DeletedPrefix = "DeletedPrefix"
+}
+export type StorageValue = string | StorageValueKind | undefined;
+export interface StorageLayerProvider {
+    get(key: string, cache: boolean): Promise<StorageValue>;
+    foldInto(into: StorageLayer): Promise<StorageLayerProvider | undefined>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+}
+export declare class RemoteStorageLayer implements StorageLayerProvider {
+    #private;
+    constructor(api: Api, at: string, db: DataSource | undefined);
+    get(key: string): Promise<StorageValue>;
+    foldInto(_into: StorageLayer): Promise<StorageLayerProvider>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+}
+export declare class StorageLayer implements StorageLayerProvider {
+    #private;
+    constructor(parent?: StorageLayerProvider);
+    get(key: string, cache: boolean): Promise<StorageValue | undefined>;
+    set(key: string, value: StorageValue): void;
+    setAll(values: Record<string, StorageValue | null> | [string, StorageValue | null][]): void;
+    foldInto(into: StorageLayer): Promise<StorageLayerProvider | undefined>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+    mergeInto(into: Record<string, string | null>): Promise<void>;
+}

package/dist/blockchain/storage-layer.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageLayer = exports.RemoteStorageLayer = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = require("../logger");
+const logger = logger_1.defaultLogger.child({ name: 'layer' });
+class RemoteStorageLayer {
+    #api;
+    #at;
+    #db;
+    constructor(api, at, db) {
+        this.#api = api;
+        this.#at = at;
+        this.#db = db;
+    }
+    async get(key) {
+        if (this.#db) {
+            const res = await this.#db.getRepository('KeyValuePair').findOne({ where: { key, blockHash: this.#at } });
+            if (res) {
+                return res.value;
+            }
+        }
+        logger.trace({ at: this.#at, key }, 'RemoteStorageLayer get');
+        const data = await this.#api.getStorage(key, this.#at);
+        this.#db?.getRepository('KeyValuePair').upsert({ key, blockHash: this.#at, value: data }, ['key', 'blockHash']);
+        return data;
+    }
+    async foldInto(_into) {
+        return this;
+    }
+    async fold() { }
+    async getKeysPaged(prefix, pageSize, startKey) {
+        logger.trace({ at: this.#at, prefix, pageSize, startKey }, 'RemoteStorageLayer getKeysPaged');
+        return this.#api.getKeysPaged(prefix, pageSize, startKey, this.#at);
+    }
+}
+exports.RemoteStorageLayer = RemoteStorageLayer;
+class StorageLayer {
+    #store = {};
+    #keys = [];
+    #deletedPrefix = [];
+    #parent;
+    constructor(parent) {
+        this.#parent = parent;
+    }
+    #addKey(key) {
+        const idx = lodash_1.default.sortedIndex(this.#keys, key);
+        const key2 = this.#keys[idx];
+        if (key === key2) {
+            return;
+        }
+        this.#keys.splice(idx, 0, key);
+    }
+    #removeKey(key) {
+        const idx = lodash_1.default.sortedIndex(this.#keys, key);
+        const key2 = this.#keys[idx];
+        if (key === key2) {
+            this.#keys.splice(idx, 1);
+        }
+    }
+    async get(key, cache) {
+        if (key in this.#store) {
+            return this.#store[key];
+        }
+        if (this.#deletedPrefix.some((prefix) => key.startsWith(prefix))) {
+            return "Deleted" /* StorageValueKind.Deleted */;
+        }
+        if (this.#parent) {
+            const val = this.#parent.get(key, false);
+            if (cache) {
+                this.#store[key] = val;
+            }
+            return val;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        switch (value) {
+            case "Deleted" /* StorageValueKind.Deleted */:
+                this.#store[key] = value;
+                this.#removeKey(key);
+                break;
+            case "DeletedPrefix" /* StorageValueKind.DeletedPrefix */:
+                this.#deletedPrefix.push(key);
+                for (const k of this.#keys) {
+                    if (k.startsWith(key)) {
+                        this.#store[k] = "Deleted" /* StorageValueKind.Deleted */;
+                        this.#removeKey(k);
+                    }
+                }
+                break;
+            case undefined:
+                delete this.#store[key];
+                this.#removeKey(key);
+                break;
+            default:
+                this.#store[key] = value;
+                this.#addKey(key);
+                break;
+        }
+    }
+    setAll(values) {
+        if (!Array.isArray(values)) {
+            values = Object.entries(values);
+        }
+        for (const [key, value] of values) {
+            this.set(key, value || "Deleted" /* StorageValueKind.Deleted */);
+        }
+    }
+    async foldInto(into) {
+        const newParent = await this.#parent?.foldInto(into);
+        for (const deletedPrefix of this.#deletedPrefix) {
+            into.set(deletedPrefix, "DeletedPrefix" /* StorageValueKind.DeletedPrefix */);
+        }
+        for (const key of this.#keys) {
+            const value = await this.#store[key];
+            into.set(key, value);
+        }
+        return newParent;
+    }
+    async fold() {
+        if (this.#parent) {
+            this.#parent = await this.#parent.foldInto(this);
+        }
+    }
+    async getKeysPaged(prefix, pageSize, startKey) {
+        if (!this.#deletedPrefix.some((prefix) => startKey.startsWith(prefix))) {
+            await this.fold();
+            // TODO: maintain a list of fetched ranges to avoid fetching the same range multiple times
+            const remote = (await this.#parent?.getKeysPaged(prefix, pageSize, startKey)) ?? [];
+            for (const key of remote) {
+                if (this.#deletedPrefix.some((prefix) => key.startsWith(prefix))) {
+                    continue;
+                }
+                this.#addKey(key);
+            }
+        }
+        let idx = lodash_1.default.sortedIndex(this.#keys, startKey);
+        if (this.#keys[idx] === startKey) {
+            ++idx;
+        }
+        const res = [];
+        while (res.length < pageSize) {
+            const key = this.#keys[idx];
+            if (!key || !key.startsWith(prefix)) {
+                break;
+            }
+            res.push(key);
+            ++idx;
+        }
+        return res;
+    }
+    async mergeInto(into) {
+        for (const [key, maybeValue] of Object.entries(this.#store)) {
+            const value = await maybeValue;
+            if (value === "Deleted" /* StorageValueKind.Deleted */) {
+                into[key] = null;
+            }
+            else {
+                into[key] = value;
+            }
+        }
+    }
+}
+exports.StorageLayer = StorageLayer;

package/dist/blockchain/txpool.d.ts

@@ -0,0 +1,13 @@
+import { Blockchain } from '.';
+import { InherentProvider } from './inherents';
+export declare enum BuildBlockMode {
+    Batch = 0,
+    Instant = 1,
+    Manual = 2
+}
+export declare class TxPool {
+    #private;
+    constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
+    submitExtrinsic(extrinsic: string): void;
+    buildBlock(): Promise<void>;
+}

package/dist/blockchain/txpool.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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' });
+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 = [];
+    #mode;
+    #inherentProvider;
+    #lastBuildBlockPromise = Promise.resolve();
+    constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
+        this.#chain = chain;
+        this.#mode = mode;
+        this.#inherentProvider = inherentProvider;
+    }
+    submitExtrinsic(extrinsic) {
+        this.#pool.push(extrinsic);
+        switch (this.#mode) {
+            case BuildBlockMode.Batch:
+                this.#batchBuildBlock();
+                break;
+            case BuildBlockMode.Instant:
+                this.buildBlock();
+                break;
+            case BuildBlockMode.Manual:
+                // does nothing
+                break;
+        }
+    }
+    #batchBuildBlock = lodash_1.default.debounce(this.buildBlock, 100, { maxWait: 1000 });
+    async buildBlock() {
+        const last = this.#lastBuildBlockPromise;
+        this.#lastBuildBlockPromise = this.#buildBlock(last);
+        await this.#lastBuildBlockPromise;
+    }
+    async #buildBlock(wait) {
+        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();
+        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)('0x02000000', (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,
+        }, 'Building block');
+        const resp = await newBlock.call('Core_initialize_block', header.toHex());
+        logger.trace(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(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');
+            }
+        }
+        if (meta.query.parachainSystem?.validationData) {
+            // this is a parachain
+            const validationDataKey = (0, utils_1.compactHex)(meta.query.parachainSystem.validationData());
+            const validationData = await newBlock.get(validationDataKey);
+            if (!validationData) {
+                // there is no set validation data inherent
+                // so we need to restore the old validation data to make the on_finalize check happy
+                const oldValidationData = await head.get(validationDataKey);
+                newBlock.pushStorageLayer().set(validationDataKey, oldValidationData);
+            }
+        }
+        for (const extrinsic of extrinsics) {
+            try {
+                const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
+                newBlock.pushStorageLayer().setAll(resp.storageDiff);
+                logger.trace(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(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(diff, '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');
+    }
+}
+exports.TxPool = TxPool;

package/dist/db/entities.d.ts

@@ -0,0 +1,5 @@
+export declare class KeyValuePair {
+    blockHash: string;
+    key: string;
+    value: string;
+}

package/dist/db/entities.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyValuePair = void 0;
+const typeorm_1 = require("typeorm");
+let KeyValuePair = class KeyValuePair {
+    blockHash;
+    key;
+    value;
+};
+__decorate([
+    (0, typeorm_1.PrimaryColumn)(),
+    __metadata("design:type", String)
+], KeyValuePair.prototype, "blockHash", void 0);
+__decorate([
+    (0, typeorm_1.PrimaryColumn)(),
+    __metadata("design:type", String)
+], KeyValuePair.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], KeyValuePair.prototype, "value", void 0);
+KeyValuePair = __decorate([
+    (0, typeorm_1.Entity)()
+], KeyValuePair);
+exports.KeyValuePair = KeyValuePair;

package/dist/db/index.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { DataSource } from 'typeorm';
+export declare const openDb: (dbPath: string) => Promise<DataSource>;

package/dist/db/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDb = void 0;
+require("reflect-metadata");
+const typeorm_1 = require("typeorm");
+const entities = __importStar(require("./entities"));
+const openDb = async (dbPath) => {
+    const source = new typeorm_1.DataSource({
+        type: 'sqlite',
+        database: dbPath,
+        entities: Object.values(entities),
+        synchronize: true,
+        logging: false,
+    });
+    await source.initialize();
+    return source;
+};
+exports.openDb = openDb;

package/dist/executor.d.ts

@@ -0,0 +1,16 @@
+import { HexString } from '@polkadot/util/types';
+import { run_task } from '@acala-network/chopsticks-executor';
+export type RuntimeVersion = {
+    specName: string;
+    implName: string;
+    authoringVersion: number;
+    specVersion: number;
+    implVersion: number;
+    apis: [HexString, number][];
+    transactionVersion: number;
+    stateVersion: number;
+};
+export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
+export declare const getMetadata: (code: HexString) => Promise<HexString>;
+export declare const calculateStateRoot: (entries: [HexString, HexString][]) => Promise<HexString>;
+export { run_task as runTask };

package/dist/executor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTask = exports.calculateStateRoot = exports.getMetadata = 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");
+Object.defineProperty(exports, "runTask", { enumerable: true, get: function () { return chopsticks_executor_1.run_task; } });
+const utils_1 = require("./utils");
+const getRuntimeVersion = async (code) => {
+    return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
+        version.specName = (0, util_1.hexToString)(version.specName);
+        version.implName = (0, util_1.hexToString)(version.implName);
+        return version;
+    });
+};
+exports.getRuntimeVersion = getRuntimeVersion;
+const getMetadata = async (code) => {
+    return (0, utils_1.compactHex)((0, util_1.hexToU8a)(await (0, chopsticks_executor_1.get_metadata)(code)));
+};
+exports.getMetadata = getMetadata;
+const calculateStateRoot = async (entries) => {
+    return (0, chopsticks_executor_1.calculate_state_root)(entries);
+};
+exports.calculateStateRoot = calculateStateRoot;

package/dist/executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/executor.test.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("@polkadot/types/metadata");
+const types_1 = require("@polkadot/types");
+const executor_1 = require("./executor");
+const decorate_1 = require("@polkadot/types/metadata/decorate");
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+(0, vitest_1.describe)('wasm', () => {
+    (0, vitest_1.it)('get metadata 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 registry = new types_1.TypeRegistry();
+        const metadata = new metadata_1.Metadata(registry, await (0, executor_1.getMetadata)(code));
+        registry.setMetadata(metadata);
+        (0, vitest_1.expect)(registry.metadata.pallets.length).toBeGreaterThan(0);
+        const storage = (0, decorate_1.decorateStorage)(registry, metadata.asLatest, metadata.version);
+        (0, vitest_1.expect)(storage.system).toBeTruthy;
+    });
+    (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,
+            implVersion: 0,
+            apis: [
+                ['0xdf6acb689907609b', 3],
+                ['0x37e397fc7c91f5e4', 1],
+                ['0x40fe3ad401f8959a', 5],
+                ['0xd2bc9897eed08f15', 3],
+                ['0xf78b278be53f454c', 2],
+                ['0xdd718d5cc53262d4', 1],
+                ['0xab3c0572291feb8b', 1],
+                ['0xbc9d89904f5b923f', 1],
+                ['0x37c8bb1350a9a2a8', 1],
+                ['0x6ef953004ba30e59', 1],
+                ['0xf485c9145d3f0aad', 1],
+                ['0xe3df3f2aa8a5cc57', 1],
+                ['0xea93e3f16f3d6962', 1],
+            ],
+            transactionVersion: 1,
+            stateVersion: 0,
+        };
+        (0, vitest_1.expect)(await (0, executor_1.getRuntimeVersion)(code)).toMatchObject(expectedRuntimeVersion);
+    });
+    (0, vitest_1.it)('calculate state root', async () => {
+        const a = await (0, executor_1.calculateStateRoot)([['0x5301bf5ff0298f5c7b93a446709f8e885f772afdd0d8ba3d4d559a06f0742f12', '0x01']]);
+        const b = await (0, executor_1.calculateStateRoot)([['0x5301bf5ff0298f5c7b93a446709f8e885f772afdd0d8ba3d4d559a06f0742f12', '0x02']]);
+        (0, vitest_1.expect)(a).to.not.eq(b);
+    });
+});