@acala-network/chopsticks 0.7.2 → 0.8.0-0

package/lib/blockchain/txpool.js

@@ -1,184 +0,0 @@
-"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 = exports.APPLY_EXTRINSIC_ERROR = void 0;
-const node_stream_1 = require("node:stream");
-const lodash_1 = __importDefault(require("lodash"));
-const utils_1 = require("../utils");
-const block_builder_1 = require("./block-builder");
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'txpool' });
-exports.APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
-var BuildBlockMode;
-(function (BuildBlockMode) {
-    BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
-    BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
-    BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
-})(BuildBlockMode || (exports.BuildBlockMode = BuildBlockMode = {}));
-class TxPool {
-    #chain;
-    #pool = [];
-    #ump = {};
-    #dmp = [];
-    #hrmp = {};
-    #mode;
-    #inherentProvider;
-    #pendingBlocks = [];
-    event = new node_stream_1.EventEmitter();
-    #isBuilding = false;
-    constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
-        this.#chain = chain;
-        this.#mode = mode;
-        this.#inherentProvider = inherentProvider;
-    }
-    get pendingExtrinsics() {
-        return this.#pool.map(({ extrinsic }) => extrinsic);
-    }
-    get ump() {
-        return this.#ump;
-    }
-    get dmp() {
-        return this.#dmp;
-    }
-    get hrmp() {
-        return this.#hrmp;
-    }
-    get mode() {
-        return this.#mode;
-    }
-    set mode(mode) {
-        this.#mode = mode;
-    }
-    clear() {
-        this.#pool.length = 0;
-        for (const id of Object.keys(this.#ump)) {
-            delete this.#ump[id];
-        }
-        this.#dmp.length = 0;
-        for (const id of Object.keys(this.#hrmp)) {
-            delete this.#hrmp[id];
-        }
-    }
-    pendingExtrinsicsBy(address) {
-        return this.#pool.filter(({ signer }) => signer === address).map(({ extrinsic }) => extrinsic);
-    }
-    async submitExtrinsic(extrinsic) {
-        logger.debug({ extrinsic: (0, logger_1.truncate)(extrinsic) }, 'submit extrinsic');
-        this.#pool.push({ extrinsic, signer: await this.#getSigner(extrinsic) });
-        this.#maybeBuildBlock();
-    }
-    async #getSigner(extrinsic) {
-        const registry = await this.#chain.head.registry;
-        const tx = registry.createType('GenericExtrinsic', extrinsic);
-        return tx.signer.toString();
-    }
-    submitUpwardMessages(id, ump) {
-        logger.debug({ id, ump: (0, logger_1.truncate)(ump) }, 'submit upward messages');
-        if (!this.#ump[id]) {
-            this.#ump[id] = [];
-        }
-        this.#ump[id].push(...ump);
-        this.#maybeBuildBlock();
-    }
-    submitDownwardMessages(dmp) {
-        logger.debug({ dmp: (0, logger_1.truncate)(dmp) }, 'submit downward messages');
-        this.#dmp.push(...dmp);
-        this.#maybeBuildBlock();
-    }
-    submitHorizontalMessages(id, hrmp) {
-        logger.debug({ id, hrmp: (0, logger_1.truncate)(hrmp) }, 'submit horizontal messages');
-        if (!this.#hrmp[id]) {
-            this.#hrmp[id] = [];
-        }
-        this.#hrmp[id].push(...hrmp);
-        this.#maybeBuildBlock();
-    }
-    #maybeBuildBlock() {
-        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 buildBlockWithParams(params) {
-        this.#pendingBlocks.push({
-            params,
-            deferred: (0, utils_1.defer)(),
-        });
-        this.#buildBlockIfNeeded();
-        await this.upcomingBlocks();
-    }
-    async buildBlock(params) {
-        const transactions = params?.transactions || this.#pool.splice(0).map(({ extrinsic }) => extrinsic);
-        const upwardMessages = params?.upwardMessages || { ...this.#ump };
-        const downwardMessages = params?.downwardMessages || this.#dmp.splice(0);
-        const horizontalMessages = params?.horizontalMessages || { ...this.#hrmp };
-        if (!params?.upwardMessages) {
-            for (const id of Object.keys(this.#ump)) {
-                delete this.#ump[id];
-            }
-        }
-        if (!params?.horizontalMessages) {
-            for (const id of Object.keys(this.#hrmp)) {
-                delete this.#hrmp[id];
-            }
-        }
-        await this.buildBlockWithParams({
-            transactions,
-            upwardMessages,
-            downwardMessages,
-            horizontalMessages,
-        });
-    }
-    async upcomingBlocks() {
-        const count = this.#pendingBlocks.length;
-        if (count > 0) {
-            await this.#pendingBlocks[count - 1].deferred.promise;
-        }
-        return count;
-    }
-    async #buildBlockIfNeeded() {
-        if (this.#isBuilding)
-            return;
-        if (this.#pendingBlocks.length === 0)
-            return;
-        this.#isBuilding = true;
-        try {
-            await this.#buildBlock();
-        }
-        finally {
-            this.#isBuilding = false;
-        }
-        this.#buildBlockIfNeeded();
-    }
-    async #buildBlock() {
-        await this.#chain.api.isReady;
-        const pending = this.#pendingBlocks[0];
-        if (!pending) {
-            throw new Error('Unreachable');
-        }
-        const { params, deferred } = pending;
-        logger.trace({ params }, 'build block');
-        const head = this.#chain.head;
-        const inherents = await this.#inherentProvider.createInherents(head, params);
-        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
-            this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
-        });
-        for (const extrinsic of pendingExtrinsics) {
-            this.#pool.push({ extrinsic, signer: await this.#getSigner(extrinsic) });
-        }
-        await this.#chain.setHead(newBlock);
-        this.#pendingBlocks.shift();
-        deferred.resolve();
-    }
-}
-exports.TxPool = TxPool;

package/lib/db/entities.d.ts

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

package/lib/db/entities.js

@@ -1,33 +0,0 @@
-"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 = exports.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);
-exports.KeyValuePair = KeyValuePair = __decorate([
-    (0, typeorm_1.Entity)()
-], KeyValuePair);

package/lib/db/index.d.ts

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

package/lib/db/index.js

@@ -1,41 +0,0 @@
-"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/lib/dry-run.d.ts

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

package/lib/executor.d.ts

@@ -1,40 +0,0 @@
-import { HexString } from '@polkadot/util/types';
-import { Block } from './blockchain/block';
-import { JsCallback } from '@acala-network/chopsticks-executor';
-import { Registry } from '@polkadot/types-codec/types';
-import _ from 'lodash';
-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

@@ -1,131 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
-const util_1 = require("@polkadot/util");
-const util_crypto_1 = require("@polkadot/util-crypto");
-const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
-const key_cache_1 = require("./utils/key-cache");
-const logger_1 = require("./logger");
-const lodash_1 = __importDefault(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) => {
-        version.specName = (0, util_1.hexToString)(version.specName);
-        version.implName = (0, util_1.hexToString)(version.implName);
-        return version;
-    });
-};
-exports.getRuntimeVersion = getRuntimeVersion;
-// trie_version: 0 for old trie, 1 for new trie
-const calculateStateRoot = async (entries, trie_version) => {
-    return (0, chopsticks_executor_1.calculate_state_root)(entries, trie_version);
-};
-exports.calculateStateRoot = calculateStateRoot;
-const decodeProof = async (trieRootHash, keys, nodes) => {
-    const decoded = await (0, chopsticks_executor_1.decode_proof)(trieRootHash, keys, nodes);
-    return decoded.reduce((accum, [key, value]) => {
-        accum[key] = value;
-        return accum;
-    }, {});
-};
-exports.decodeProof = decodeProof;
-const createProof = async (nodes, entries) => {
-    const result = await (0, chopsticks_executor_1.create_proof)(nodes, entries);
-    return { trieRootHash: result[0], nodes: result[1] };
-};
-exports.createProof = createProof;
-const runTask = async (task, callback = exports.emptyTaskHandler) => {
-    logger.trace((0, logger_1.truncate)(task), 'taskRun');
-    const response = await (0, chopsticks_executor_1.run_task)(task, callback, process.env.RUST_LOG);
-    if (response.Call) {
-        logger.trace((0, logger_1.truncate)(response.Call), 'taskResponse');
-    }
-    else {
-        logger.trace({ response }, 'taskResponse');
-    }
-    return response;
-};
-exports.runTask = runTask;
-const taskHandler = (block) => {
-    return {
-        getStorage: async function (key) {
-            return block.get(key);
-        },
-        getStateRoot: async function () {
-            const header = await block.header;
-            return header.stateRoot.toHex();
-        },
-        getNextKey: async function (prefix, key) {
-            const [nextKey] = await block.getKeysPaged({
-                prefix: prefix.length === 2 /** 0x */ ? key.slice(0, key_cache_1.PREFIX_LENGTH) : prefix,
-                pageSize: 1,
-                startKey: key,
-            });
-            return nextKey;
-        },
-        offchainGetStorage: async function (key) {
-            if (!block.chain.offchainWorker)
-                throw new Error('offchain worker not found');
-            return block.chain.offchainWorker.get(key);
-        },
-        offchainTimestamp: async function () {
-            return Date.now();
-        },
-        offchainRandomSeed: async function () {
-            return (0, util_crypto_1.randomAsHex)(32);
-        },
-        offchainSubmitTransaction: async function (tx) {
-            if (!block.chain.offchainWorker)
-                throw new Error('offchain worker not found');
-            try {
-                const hash = await block.chain.offchainWorker.pushExtrinsic(block, tx);
-                logger.trace({ hash }, 'offchainSubmitTransaction');
-                return true;
-            }
-            catch (error) {
-                logger.trace({ error }, 'offchainSubmitTransaction');
-                return false;
-            }
-        },
-    };
-};
-exports.taskHandler = taskHandler;
-exports.emptyTaskHandler = {
-    getStorage: async function (_key) {
-        throw new Error('Method not implemented');
-    },
-    getStateRoot: async function () {
-        throw new Error('Method not implemented');
-    },
-    getNextKey: async function (_prefix, _key) {
-        throw new Error('Method not implemented');
-    },
-    offchainGetStorage: async function (_key) {
-        throw new Error('Method not implemented');
-    },
-    offchainTimestamp: async function () {
-        throw new Error('Method not implemented');
-    },
-    offchainRandomSeed: async function () {
-        throw new Error('Method not implemented');
-    },
-    offchainSubmitTransaction: async function (_tx) {
-        throw new Error('Method not implemented');
-    },
-};
-exports.getAuraSlotDuration = lodash_1.default.memoize(async (wasm, registry) => {
-    const result = await (0, exports.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', (0, util_1.hexToU8a)(result.Call.result)).toNumber();
-    return slotDuration;
-});

package/lib/genesis-provider.d.ts

@@ -1,44 +0,0 @@
-import { HexString } from '@polkadot/util/types';
-import { JsCallback } from '@acala-network/chopsticks-executor';
-import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
-import { Genesis } from './schema';
-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>;
-}

package/lib/genesis-provider.js

@@ -1,155 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenesisProvider = void 0;
-const node_events_1 = require("node:events");
-const node_fs_1 = require("node:fs");
-const util_1 = require("@polkadot/util");
-const axios_1 = __importDefault(require("axios"));
-const schema_1 = require("./schema");
-const executor_1 = require("./executor");
-const utils_1 = require("./utils");
-class GenesisProvider {
-    #isConnected = false;
-    stats;
-    #eventemitter;
-    #isReadyPromise;
-    #genesis;
-    #stateRoot;
-    constructor(genesis) {
-        this.#genesis = genesis;
-        this.#stateRoot = (0, executor_1.calculateStateRoot)(Object.entries(this.#genesis.genesis.raw.top).reduce((accu, item) => {
-            accu.push(item);
-            return accu;
-        }, []), 1);
-        this.#eventemitter = new node_events_1.EventEmitter();
-        this.#isReadyPromise = new Promise((resolve, reject) => {
-            this.#eventemitter.once('connected', () => {
-                resolve();
-            });
-            this.#eventemitter.once('error', reject);
-        });
-    }
-    static fromUrl = async (url) => {
-        let file;
-        if ((0, utils_1.isUrl)(url)) {
-            file = await axios_1.default.get(url).then((x) => x.data);
-        }
-        else if ((0, node_fs_1.lstatSync)(url).isFile()) {
-            file = JSON.parse(String((0, node_fs_1.readFileSync)(url)));
-        }
-        else {
-            throw Error(`invalid genesis path or url ${url}`);
-        }
-        return new GenesisProvider(schema_1.genesisSchema.parse(file));
-    };
-    get isClonable() {
-        return true;
-    }
-    clone = () => {
-        return new GenesisProvider(this.#genesis);
-    };
-    get hasSubscriptions() {
-        return false;
-    }
-    get isConnected() {
-        return this.#isConnected;
-    }
-    get isReady() {
-        this.connect();
-        return this.#isReadyPromise;
-    }
-    connect = async () => {
-        this.#isConnected = true;
-        this.#eventemitter.emit('connected');
-    };
-    disconnect = async () => {
-        this.#isConnected = false;
-        this.#eventemitter.emit('disconnected');
-    };
-    on = (type, sub) => {
-        this.#eventemitter.on(type, sub);
-        return () => {
-            this.#eventemitter.removeListener(type, sub);
-        };
-    };
-    get blockHash() {
-        return '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3';
-    }
-    getHeader = async () => {
-        return {
-            blockHash: this.blockHash,
-            number: 0,
-            stateRoot: await this.#stateRoot,
-            digest: {
-                logs: [],
-            },
-        };
-    };
-    getBlock = async () => {
-        return {
-            block: {
-                header: await this.getHeader(),
-                extrinsics: [],
-            },
-        };
-    };
-    get _jsCallback() {
-        const storage = this.#genesis.genesis.raw.top;
-        return {
-            ...executor_1.emptyTaskHandler,
-            getStorage: async function (key) {
-                return storage[key];
-            },
-            getStateRoot: async function () {
-                return '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1';
-            },
-            getNextKey: async function (_prefix, _key) {
-                return undefined;
-            },
-        };
-    }
-    send = async (method, params, _isCacheable) => {
-        await this.isReady;
-        switch (method) {
-            case 'system_properties':
-                return this.#genesis.properties;
-            case 'system_chain':
-                return this.#genesis.id;
-            case 'system_name':
-                return this.#genesis.name;
-            case 'state_getMetadata': {
-                const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
-                return (0, executor_1.runTask)({
-                    wasm: code,
-                    calls: [['Metadata_metadata', []]],
-                    mockSignatureHost: false,
-                    allowUnresolvedImports: true,
-                    runtimeLogLevel: 0,
-                }, this._jsCallback);
-            }
-            case 'chain_getHeader':
-                return this.getHeader();
-            case 'chain_getBlock':
-                return this.getBlock();
-            case 'chain_getBlockHash':
-                return this.blockHash;
-            case 'state_getKeysPagedAt':
-                return [];
-            case 'state_getStorage':
-            case 'state_getStorageAt':
-                return this.#genesis.genesis.raw.top[params[0]];
-            default:
-                throw Error(`${method} not implemented`);
-        }
-    };
-    subscribe = async (_type, _method, _params, _cb) => {
-        throw Error('unimplemented');
-    };
-    unsubscribe = async (_type, _method, _id) => {
-        throw Error('unimplemented');
-    };
-}
-exports.GenesisProvider = GenesisProvider;

package/lib/offchain.d.ts

@@ -1,10 +0,0 @@
-import { Block } from './blockchain/block';
-import { HexString } from '@polkadot/util/types';
-export declare class OffchainWorker {
-    readonly pendingExtrinsics: HexString[];
-    readonly offchainStorage: Map<string, string | null | undefined>;
-    get(key: string): string | null | undefined;
-    set(key: string, value: string | null | undefined): void;
-    run(block: Block): Promise<void>;
-    pushExtrinsic(block: Block, extrinsic: HexString): Promise<`0x${string}`>;
-}