@acala-network/chopsticks-core 0.8.0-0

package/lib/blockchain/txpool.js

@@ -0,0 +1,210 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TxPool_instances, _TxPool_chain, _TxPool_pool, _TxPool_ump, _TxPool_dmp, _TxPool_hrmp, _TxPool_mode, _TxPool_inherentProvider, _TxPool_pendingBlocks, _TxPool_isBuilding, _TxPool_getSigner, _TxPool_maybeBuildBlock, _TxPool_batchBuildBlock, _TxPool_buildBlockIfNeeded, _TxPool_buildBlock;
+import { EventEmitter } from 'eventemitter3';
+import _ from 'lodash';
+import { defer } from '../utils';
+import { buildBlock } from './block-builder';
+import { defaultLogger, truncate } from '../logger';
+const logger = defaultLogger.child({ name: 'txpool' });
+export const APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
+export var BuildBlockMode;
+(function (BuildBlockMode) {
+    BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
+    BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
+    BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
+})(BuildBlockMode || (BuildBlockMode = {}));
+export class TxPool {
+    constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
+        _TxPool_instances.add(this);
+        _TxPool_chain.set(this, void 0);
+        _TxPool_pool.set(this, []);
+        _TxPool_ump.set(this, {});
+        _TxPool_dmp.set(this, []);
+        _TxPool_hrmp.set(this, {});
+        _TxPool_mode.set(this, void 0);
+        _TxPool_inherentProvider.set(this, void 0);
+        _TxPool_pendingBlocks.set(this, []);
+        this.event = new EventEmitter();
+        _TxPool_isBuilding.set(this, false);
+        _TxPool_batchBuildBlock.set(this, _.debounce(this.buildBlock, 100, { maxWait: 1000 }));
+        __classPrivateFieldSet(this, _TxPool_chain, chain, "f");
+        __classPrivateFieldSet(this, _TxPool_mode, mode, "f");
+        __classPrivateFieldSet(this, _TxPool_inherentProvider, inherentProvider, "f");
+    }
+    get pendingExtrinsics() {
+        return __classPrivateFieldGet(this, _TxPool_pool, "f").map(({ extrinsic }) => extrinsic);
+    }
+    get ump() {
+        return __classPrivateFieldGet(this, _TxPool_ump, "f");
+    }
+    get dmp() {
+        return __classPrivateFieldGet(this, _TxPool_dmp, "f");
+    }
+    get hrmp() {
+        return __classPrivateFieldGet(this, _TxPool_hrmp, "f");
+    }
+    get mode() {
+        return __classPrivateFieldGet(this, _TxPool_mode, "f");
+    }
+    set mode(mode) {
+        __classPrivateFieldSet(this, _TxPool_mode, mode, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _TxPool_pool, "f").length = 0;
+        for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_ump, "f"))) {
+            delete __classPrivateFieldGet(this, _TxPool_ump, "f")[id];
+        }
+        __classPrivateFieldGet(this, _TxPool_dmp, "f").length = 0;
+        for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_hrmp, "f"))) {
+            delete __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id];
+        }
+    }
+    pendingExtrinsicsBy(address) {
+        return __classPrivateFieldGet(this, _TxPool_pool, "f").filter(({ signer }) => signer === address).map(({ extrinsic }) => extrinsic);
+    }
+    submitExtrinsic(extrinsic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug({ extrinsic: truncate(extrinsic) }, 'submit extrinsic');
+            __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: yield __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });
+            __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+        });
+    }
+    submitUpwardMessages(id, ump) {
+        logger.debug({ id, ump: truncate(ump) }, 'submit upward messages');
+        if (!__classPrivateFieldGet(this, _TxPool_ump, "f")[id]) {
+            __classPrivateFieldGet(this, _TxPool_ump, "f")[id] = [];
+        }
+        __classPrivateFieldGet(this, _TxPool_ump, "f")[id].push(...ump);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    submitDownwardMessages(dmp) {
+        logger.debug({ dmp: truncate(dmp) }, 'submit downward messages');
+        __classPrivateFieldGet(this, _TxPool_dmp, "f").push(...dmp);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    submitHorizontalMessages(id, hrmp) {
+        logger.debug({ id, hrmp: truncate(hrmp) }, 'submit horizontal messages');
+        if (!__classPrivateFieldGet(this, _TxPool_hrmp, "f")[id]) {
+            __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id] = [];
+        }
+        __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id].push(...hrmp);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    buildBlockWithParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").push({
+                params,
+                deferred: defer(),
+            });
+            __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlockIfNeeded).call(this);
+            yield this.upcomingBlocks();
+        });
+    }
+    buildBlock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transactions = (params === null || params === void 0 ? void 0 : params.transactions) || __classPrivateFieldGet(this, _TxPool_pool, "f").splice(0).map(({ extrinsic }) => extrinsic);
+            const upwardMessages = (params === null || params === void 0 ? void 0 : params.upwardMessages) || Object.assign({}, __classPrivateFieldGet(this, _TxPool_ump, "f"));
+            const downwardMessages = (params === null || params === void 0 ? void 0 : params.downwardMessages) || __classPrivateFieldGet(this, _TxPool_dmp, "f").splice(0);
+            const horizontalMessages = (params === null || params === void 0 ? void 0 : params.horizontalMessages) || Object.assign({}, __classPrivateFieldGet(this, _TxPool_hrmp, "f"));
+            if (!(params === null || params === void 0 ? void 0 : params.upwardMessages)) {
+                for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_ump, "f"))) {
+                    delete __classPrivateFieldGet(this, _TxPool_ump, "f")[id];
+                }
+            }
+            if (!(params === null || params === void 0 ? void 0 : params.horizontalMessages)) {
+                for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_hrmp, "f"))) {
+                    delete __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id];
+                }
+            }
+            yield this.buildBlockWithParams({
+                transactions,
+                upwardMessages,
+                downwardMessages,
+                horizontalMessages,
+            });
+        });
+    }
+    upcomingBlocks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const count = __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").length;
+            if (count > 0) {
+                yield __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f")[count - 1].deferred.promise;
+            }
+            return count;
+        });
+    }
+}
+_TxPool_chain = new WeakMap(), _TxPool_pool = new WeakMap(), _TxPool_ump = new WeakMap(), _TxPool_dmp = new WeakMap(), _TxPool_hrmp = new WeakMap(), _TxPool_mode = new WeakMap(), _TxPool_inherentProvider = new WeakMap(), _TxPool_pendingBlocks = new WeakMap(), _TxPool_isBuilding = new WeakMap(), _TxPool_batchBuildBlock = new WeakMap(), _TxPool_instances = new WeakSet(), _TxPool_getSigner = function _TxPool_getSigner(extrinsic) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const registry = yield __classPrivateFieldGet(this, _TxPool_chain, "f").head.registry;
+        const tx = registry.createType('GenericExtrinsic', extrinsic);
+        return tx.signer.toString();
+    });
+}, _TxPool_maybeBuildBlock = function _TxPool_maybeBuildBlock() {
+    switch (__classPrivateFieldGet(this, _TxPool_mode, "f")) {
+        case BuildBlockMode.Batch:
+            __classPrivateFieldGet(this, _TxPool_batchBuildBlock, "f").call(this);
+            break;
+        case BuildBlockMode.Instant:
+            this.buildBlock();
+            break;
+        case BuildBlockMode.Manual:
+            // does nothing
+            break;
+    }
+}, _TxPool_buildBlockIfNeeded = function _TxPool_buildBlockIfNeeded() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (__classPrivateFieldGet(this, _TxPool_isBuilding, "f"))
+            return;
+        if (__classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").length === 0)
+            return;
+        __classPrivateFieldSet(this, _TxPool_isBuilding, true, "f");
+        try {
+            yield __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlock).call(this);
+        }
+        finally {
+            __classPrivateFieldSet(this, _TxPool_isBuilding, false, "f");
+        }
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlockIfNeeded).call(this);
+    });
+}, _TxPool_buildBlock = function _TxPool_buildBlock() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield __classPrivateFieldGet(this, _TxPool_chain, "f").api.isReady;
+        const pending = __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f")[0];
+        if (!pending) {
+            throw new Error('Unreachable');
+        }
+        const { params, deferred } = pending;
+        logger.trace({ params }, 'build block');
+        const head = __classPrivateFieldGet(this, _TxPool_chain, "f").head;
+        const inherents = yield __classPrivateFieldGet(this, _TxPool_inherentProvider, "f").createInherents(head, params);
+        const [newBlock, pendingExtrinsics] = yield buildBlock(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
+            this.event.emit(APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+        });
+        for (const extrinsic of pendingExtrinsics) {
+            __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: yield __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });
+        }
+        yield __classPrivateFieldGet(this, _TxPool_chain, "f").onNewBlock(newBlock);
+        __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").shift();
+        deferred.resolve();
+    });
+};

package/lib/db/browser.d.ts

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

package/lib/db/browser.js

@@ -0,0 +1,33 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DataSource } from 'typeorm';
+import { createInstance } from 'localforage';
+import initSqlJs from 'sql.js';
+globalThis.localforage = createInstance({ name: 'chopsticks' });
+import * as entities from './entities';
+export const openDb = (dbPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const wasmUrl = new URL('../../../../node_modules/sql.js/dist/sql-wasm.wasm', import.meta.url);
+    const wasmBinary = yield fetch(wasmUrl).then((response) => response.arrayBuffer());
+    const source = new DataSource({
+        type: 'sqljs',
+        location: dbPath,
+        entities: Object.values(entities),
+        synchronize: true,
+        autoSave: true,
+        logging: false,
+        useLocalForage: true,
+        driver: initSqlJs,
+        sqlJsConfig: {
+            wasmBinary,
+        },
+    });
+    yield source.initialize();
+    return source;
+});

package/lib/db/entities.d.ts

@@ -0,0 +1,16 @@
+import { EntitySchema } from 'typeorm';
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+export declare const KeyValuePair: EntitySchema<{
+    blockHash: string;
+    key: string;
+    value?: string | undefined;
+}>;
+export declare const BlockEntity: EntitySchema<{
+    hash: HexString;
+    number: number;
+    header: Header;
+    parentHash?: `0x${string}` | undefined;
+    extrinsics: HexString[];
+    storageDiff?: Record<`0x${string}`, `0x${string}` | null> | undefined;
+}>;

package/lib/db/entities.js

@@ -0,0 +1,50 @@
+import { EntitySchema } from 'typeorm';
+export const KeyValuePair = new EntitySchema({
+    name: 'KeyValuePair',
+    columns: {
+        blockHash: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        key: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        value: {
+            type: 'text',
+            nullable: true,
+        },
+    },
+});
+export const BlockEntity = new EntitySchema({
+    name: 'Block',
+    columns: {
+        hash: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        number: {
+            type: 'int',
+            nullable: false,
+        },
+        header: {
+            type: 'simple-json',
+            nullable: false,
+        },
+        parentHash: {
+            type: 'varchar',
+            nullable: true,
+        },
+        extrinsics: {
+            type: 'simple-array',
+            nullable: false,
+        },
+        storageDiff: {
+            type: 'simple-json',
+            nullable: true,
+        },
+    },
+});

package/lib/db/index.d.ts

@@ -0,0 +1 @@
+export declare const openDb: (dbPath: string) => Promise<import("typeorm").DataSource>;

package/lib/db/index.js

@@ -0,0 +1,17 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const openDb = (dbPath) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof window === 'undefined') {
+        return (yield import('./node')).openDb(dbPath);
+    }
+    else {
+        return (yield import('./browser')).openDb(dbPath);
+    }
+});

package/lib/db/node.d.ts

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

package/lib/db/node.js

@@ -0,0 +1,22 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DataSource } from 'typeorm';
+import * as entities from './entities';
+export const openDb = (dbPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const source = new DataSource({
+        type: 'sqlite',
+        database: dbPath,
+        entities: Object.values(entities),
+        synchronize: true,
+        logging: false,
+    });
+    yield source.initialize();
+    return source;
+});

package/lib/executor.d.ts

@@ -0,0 +1,41 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from './blockchain/block';
+import { Registry } from '@polkadot/types-codec/types';
+import _ from 'lodash';
+import type { JsCallback } from '@acala-network/chopsticks-executor';
+export { JsCallback };
+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 calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
+export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
+export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
+    trieRootHash: `0x${string}`;
+    nodes: `0x${string}`[];
+}>;
+export declare const runTask: (task: {
+    wasm: HexString;
+    calls: [string, HexString[]][];
+    mockSignatureHost: boolean;
+    allowUnresolvedImports: boolean;
+    runtimeLogLevel: number;
+}, callback?: JsCallback) => Promise<any>;
+export declare const taskHandler: (block: Block) => JsCallback;
+export declare const emptyTaskHandler: {
+    getStorage: (_key: HexString) => Promise<never>;
+    getStateRoot: () => Promise<never>;
+    getNextKey: (_prefix: HexString, _key: HexString) => Promise<never>;
+    offchainGetStorage: (_key: HexString) => Promise<never>;
+    offchainTimestamp: () => Promise<never>;
+    offchainRandomSeed: () => Promise<never>;
+    offchainSubmitTransaction: (_tx: HexString) => Promise<never>;
+};
+export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & _.MemoizedFunction;

package/lib/executor.js

@@ -0,0 +1,160 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { hexToString, hexToU8a } from '@polkadot/util';
+import { randomAsHex } from '@polkadot/util-crypto';
+import { PREFIX_LENGTH } from './utils/key-cache';
+import { defaultLogger, truncate } from './logger';
+import _ from 'lodash';
+import wasmSetup, { calculate_state_root, create_proof, decode_proof, get_runtime_version, run_task, } from '@acala-network/chopsticks-executor';
+const logger = defaultLogger.child({ name: 'executor' });
+// init wasm on browser
+if (typeof wasmSetup === 'function') {
+    wasmSetup();
+}
+export const getRuntimeVersion = (code) => __awaiter(void 0, void 0, void 0, function* () {
+    return get_runtime_version(code).then((version) => {
+        version.specName = hexToString(version.specName);
+        version.implName = hexToString(version.implName);
+        return version;
+    });
+});
+// trie_version: 0 for old trie, 1 for new trie
+export const calculateStateRoot = (entries, trie_version) => __awaiter(void 0, void 0, void 0, function* () {
+    return calculate_state_root(entries, trie_version);
+});
+export const decodeProof = (trieRootHash, keys, nodes) => __awaiter(void 0, void 0, void 0, function* () {
+    const decoded = yield decode_proof(trieRootHash, keys, nodes);
+    return decoded.reduce((accum, [key, value]) => {
+        accum[key] = value;
+        return accum;
+    }, {});
+});
+export const createProof = (nodes, entries) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield create_proof(nodes, entries);
+    return { trieRootHash: result[0], nodes: result[1] };
+});
+export const runTask = (task, callback = emptyTaskHandler) => __awaiter(void 0, void 0, void 0, function* () {
+    logger.trace(truncate(task), 'taskRun');
+    const response = yield run_task(task, callback, typeof process === 'object' ? process.env.RUST_LOG : 'info');
+    if (response.Call) {
+        logger.trace(truncate(response.Call), 'taskResponse');
+    }
+    else {
+        logger.trace({ response }, 'taskResponse');
+    }
+    return response;
+});
+export const taskHandler = (block) => {
+    return {
+        getStorage: function (key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return block.get(key);
+            });
+        },
+        getStateRoot: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                const header = yield block.header;
+                return header.stateRoot.toHex();
+            });
+        },
+        getNextKey: function (prefix, key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const [nextKey] = yield block.getKeysPaged({
+                    prefix: prefix.length === 2 /** 0x */ ? key.slice(0, PREFIX_LENGTH) : prefix,
+                    pageSize: 1,
+                    startKey: key,
+                });
+                return nextKey;
+            });
+        },
+        offchainGetStorage: function (key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!block.chain.offchainWorker)
+                    throw new Error('offchain worker not found');
+                return block.chain.offchainWorker.get(key);
+            });
+        },
+        offchainTimestamp: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                return Date.now();
+            });
+        },
+        offchainRandomSeed: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                return randomAsHex(32);
+            });
+        },
+        offchainSubmitTransaction: function (tx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!block.chain.offchainWorker)
+                    throw new Error('offchain worker not found');
+                try {
+                    const hash = yield block.chain.offchainWorker.pushExtrinsic(block, tx);
+                    logger.trace({ hash }, 'offchainSubmitTransaction');
+                    return true;
+                }
+                catch (error) {
+                    logger.trace({ error }, 'offchainSubmitTransaction');
+                    return false;
+                }
+            });
+        },
+    };
+};
+export const emptyTaskHandler = {
+    getStorage: function (_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    getStateRoot: function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    getNextKey: function (_prefix, _key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    offchainGetStorage: function (_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    offchainTimestamp: function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    offchainRandomSeed: function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+    offchainSubmitTransaction: function (_tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented');
+        });
+    },
+};
+export const getAuraSlotDuration = _.memoize((wasm, registry) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield runTask({
+        wasm,
+        calls: [['AuraApi_slot_duration', []]],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+        runtimeLogLevel: 0,
+    });
+    if (!result.Call)
+        throw new Error(result.Error);
+    const slotDuration = registry.createType('u64', hexToU8a(result.Call.result)).toNumber();
+    return slotDuration;
+}));

package/lib/genesis-provider.d.ts

@@ -0,0 +1,44 @@
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
+import { Genesis } from './schema';
+import { JsCallback } from './executor';
+export declare class GenesisProvider implements ProviderInterface {
+    #private;
+    readonly stats?: ProviderStats;
+    constructor(genesis: Genesis);
+    static fromUrl: (url: string) => Promise<GenesisProvider>;
+    get isClonable(): boolean;
+    clone: () => ProviderInterface;
+    get hasSubscriptions(): boolean;
+    get isConnected(): boolean;
+    get isReady(): Promise<void>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    on: (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb) => (() => void);
+    get blockHash(): HexString;
+    getHeader: () => Promise<{
+        blockHash: `0x${string}`;
+        number: number;
+        stateRoot: `0x${string}`;
+        digest: {
+            logs: never[];
+        };
+    }>;
+    getBlock: () => Promise<{
+        block: {
+            header: {
+                blockHash: `0x${string}`;
+                number: number;
+                stateRoot: `0x${string}`;
+                digest: {
+                    logs: never[];
+                };
+            };
+            extrinsics: never[];
+        };
+    }>;
+    get _jsCallback(): JsCallback;
+    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>;
+}