@acala-network/chopsticks 0.7.2 → 0.8.0-0

package/lib/blockchain/block.d.ts

@@ -1,45 +0,0 @@
-import { Header } from '@polkadot/types/interfaces';
-import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
-import { TypeRegistry } from '@polkadot/types';
-import type { HexString } from '@polkadot/util/types';
-import { Blockchain } from '.';
-import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
-import type { RuntimeVersion } from '../executor';
-export type TaskCallResponse = {
-    result: HexString;
-    storageDiff: [HexString, HexString | null][];
-    offchainStorageDiff: [HexString, HexString | null][];
-    runtimeLogs: string[];
-};
-export declare class Block {
-    #private;
-    readonly number: number;
-    readonly hash: HexString;
-    constructor(chain: Blockchain, number: number, hash: HexString, parentBlock?: Block, block?: {
-        header: Header;
-        extrinsics: HexString[];
-        storage?: StorageLayerProvider;
-        storageDiff?: Record<string, StorageValue | null>;
-    });
-    get chain(): Blockchain;
-    get header(): Header | Promise<Header>;
-    get extrinsics(): HexString[] | Promise<HexString[]>;
-    get parentBlock(): undefined | Block | Promise<Block | undefined>;
-    get storage(): StorageLayerProvider;
-    get(key: string): Promise<string | undefined>;
-    getKeysPaged(options: {
-        prefix?: string;
-        startKey?: string;
-        pageSize: number;
-    }): Promise<string[]>;
-    pushStorageLayer(): StorageLayer;
-    popStorageLayer(): void;
-    storageDiff(): Promise<Record<HexString, HexString | null>>;
-    get wasm(): Promise<`0x${string}`>;
-    setWasm(wasm: HexString): void;
-    get registry(): Promise<TypeRegistry>;
-    get runtimeVersion(): Promise<RuntimeVersion>;
-    get metadata(): Promise<HexString>;
-    get meta(): Promise<DecoratedMeta>;
-    call(method: string, args: HexString[]): Promise<TaskCallResponse>;
-}

package/lib/blockchain/block.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Block = void 0;
-const types_1 = require("@polkadot/types");
-const metadata_1 = require("@polkadot/types/metadata");
-const util_1 = require("@polkadot/types-known/util");
-const util_2 = require("@polkadot/util");
-const storage_layer_1 = require("./storage-layer");
-const utils_1 = require("../utils");
-const logger_1 = require("../logger");
-const executor_1 = require("../executor");
-class Block {
-    number;
-    hash;
-    #chain;
-    #header;
-    #parentBlock;
-    #extrinsics;
-    #wasm;
-    #runtimeVersion;
-    #metadata;
-    #registry;
-    #meta;
-    #baseStorage;
-    #storages;
-    constructor(chain, number, hash, parentBlock, block) {
-        this.number = number;
-        this.hash = hash;
-        this.#chain = chain;
-        this.#parentBlock = parentBlock;
-        this.#header = block?.header;
-        this.#extrinsics = block?.extrinsics;
-        this.#baseStorage = block?.storage ?? new storage_layer_1.RemoteStorageLayer(chain.api, hash, chain.db);
-        this.#storages = [];
-        const storageDiff = block?.storageDiff;
-        if (storageDiff) {
-            // if code doesn't change then reuse parent block's meta
-            if (!storageDiff?.[(0, util_2.stringToHex)(':code')]) {
-                this.#runtimeVersion = parentBlock?.runtimeVersion;
-                this.#metadata = parentBlock?.metadata;
-                this.#registry = parentBlock?.registry;
-                this.#meta = parentBlock?.meta;
-            }
-            this.pushStorageLayer().setAll(storageDiff);
-        }
-    }
-    get chain() {
-        return this.#chain;
-    }
-    get header() {
-        if (!this.#header) {
-            this.#header = Promise.all([this.registry, this.#chain.api.getHeader(this.hash)]).then(([registry, header]) => registry.createType('Header', header));
-        }
-        return this.#header;
-    }
-    get extrinsics() {
-        if (!this.#extrinsics) {
-            this.#extrinsics = this.#chain.api.getBlock(this.hash).then((b) => b.block.extrinsics);
-        }
-        return this.#extrinsics;
-    }
-    get parentBlock() {
-        if (this.number === 0) {
-            return undefined;
-        }
-        if (!this.#parentBlock) {
-            this.#parentBlock = Promise.resolve(this.header).then((h) => this.#chain.getBlock(h.parentHash.toHex()));
-        }
-        return this.#parentBlock;
-    }
-    get storage() {
-        return this.#storages[this.#storages.length - 1] ?? this.#baseStorage;
-    }
-    async get(key) {
-        const val = await this.storage.get(key, true);
-        switch (val) {
-            case "Deleted" /* StorageValueKind.Deleted */:
-                return undefined;
-            default:
-                return val;
-        }
-    }
-    async getKeysPaged(options) {
-        const layer = new storage_layer_1.StorageLayer(this.storage);
-        await layer.fold();
-        const prefix = options.prefix ?? '0x';
-        const startKey = options.startKey ?? prefix;
-        const pageSize = options.pageSize;
-        return layer.getKeysPaged(prefix, pageSize, startKey);
-    }
-    pushStorageLayer() {
-        const layer = new storage_layer_1.StorageLayer(this.storage);
-        this.#storages.push(layer);
-        return layer;
-    }
-    popStorageLayer() {
-        this.#storages.pop();
-    }
-    async storageDiff() {
-        const storage = {};
-        for (const layer of this.#storages) {
-            await layer.mergeInto(storage);
-        }
-        return storage;
-    }
-    get wasm() {
-        if (!this.#wasm) {
-            this.#wasm = (async () => {
-                const wasmKey = (0, util_2.stringToHex)(':code');
-                const wasm = await this.get(wasmKey);
-                if (!wasm) {
-                    throw new Error('No wasm found');
-                }
-                return wasm;
-            })();
-        }
-        return this.#wasm;
-    }
-    setWasm(wasm) {
-        const wasmKey = (0, util_2.stringToHex)(':code');
-        this.pushStorageLayer().set(wasmKey, wasm);
-        this.#wasm = Promise.resolve(wasm);
-        this.#runtimeVersion = undefined;
-        this.#registry = undefined;
-        this.#meta = undefined;
-        this.#metadata = undefined;
-    }
-    get registry() {
-        if (!this.#registry) {
-            this.#registry = Promise.all([
-                this.metadata,
-                this.#chain.api.chainProperties,
-                this.#chain.api.chain,
-                this.runtimeVersion,
-            ]).then(([data, properties, chain, version]) => {
-                const registry = new types_1.TypeRegistry(this.hash);
-                registry.setKnownTypes(this.chain.registeredTypes);
-                registry.setChainProperties(registry.createType('ChainProperties', properties));
-                registry.register((0, util_1.getSpecTypes)(registry, chain, version.specName, version.specVersion));
-                registry.setHasher((0, util_1.getSpecHasher)(registry, chain, version.specName));
-                registry.setMetadata(new types_1.Metadata(registry, data), undefined, (0, util_2.objectSpread)({}, (0, util_1.getSpecExtensions)(registry, chain, version.specName), this.#chain.api.signedExtensions));
-                return registry;
-            });
-        }
-        return this.#registry;
-    }
-    get runtimeVersion() {
-        if (!this.#runtimeVersion) {
-            this.#runtimeVersion = this.wasm.then(executor_1.getRuntimeVersion);
-        }
-        return this.#runtimeVersion;
-    }
-    get metadata() {
-        if (!this.#metadata) {
-            this.#metadata = this.call('Metadata_metadata', []).then((resp) => (0, utils_1.compactHex)((0, util_2.hexToU8a)(resp.result)));
-        }
-        return this.#metadata;
-    }
-    get meta() {
-        if (!this.#meta) {
-            this.#meta = Promise.all([this.registry, this.metadata]).then(([registry, metadataStr]) => {
-                const metadata = new types_1.Metadata(registry, metadataStr);
-                return (0, metadata_1.expandMetadata)(registry, metadata);
-            });
-        }
-        return this.#meta;
-    }
-    async call(method, args) {
-        const wasm = await this.wasm;
-        const response = await (0, executor_1.runTask)({
-            wasm,
-            calls: [[method, args]],
-            mockSignatureHost: this.#chain.mockSignatureHost,
-            allowUnresolvedImports: this.#chain.allowUnresolvedImports,
-            runtimeLogLevel: this.#chain.runtimeLogLevel,
-        }, (0, executor_1.taskHandler)(this));
-        if (response.Call) {
-            for (const log of response.Call.runtimeLogs) {
-                logger_1.defaultLogger.info(`RuntimeLogs:\n${log}`);
-            }
-            if (this.chain.offchainWorker) {
-                // apply offchain storage
-                for (const [key, value] of response.Call.offchainStorageDiff) {
-                    this.chain.offchainWorker.set(key, value);
-                }
-            }
-            return response.Call;
-        }
-        if (response.Error)
-            throw Error(response.Error);
-        throw Error('Unexpected response');
-    }
-}
-exports.Block = Block;

package/lib/blockchain/head-state.d.ts

@@ -1,15 +0,0 @@
-import { Block } from './block';
-type Callback = (block: Block, pairs: [string, string][]) => void | Promise<void>;
-export declare const randomId: () => string;
-export declare class HeadState {
-    #private;
-    constructor(head: Block);
-    subscribeHead(cb: (block: Block) => void): string;
-    unsubscribeHead(id: string): void;
-    subscribeStorage(keys: string[], cb: Callback): Promise<string>;
-    unsubscribeStorage(id: string): void;
-    subscrubeRuntimeVersion(cb: (block: Block) => void): Promise<string>;
-    unsubscribeRuntimeVersion(id: string): void;
-    setHead(head: Block): Promise<void>;
-}
-export {};

package/lib/blockchain/head-state.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeadState = exports.randomId = void 0;
-const util_1 = require("@polkadot/util");
-const logger_1 = require("../logger");
-const randomId = () => Math.random().toString(36).substring(2);
-exports.randomId = randomId;
-const logger = logger_1.defaultLogger.child({ name: 'head-state' });
-class HeadState {
-    #headListeners = {};
-    #storageListeners = {};
-    #oldValues = {};
-    #head;
-    constructor(head) {
-        this.#head = head;
-    }
-    subscribeHead(cb) {
-        const id = (0, exports.randomId)();
-        this.#headListeners[id] = cb;
-        return id;
-    }
-    unsubscribeHead(id) {
-        delete this.#headListeners[id];
-    }
-    async subscribeStorage(keys, cb) {
-        const id = (0, exports.randomId)();
-        this.#storageListeners[id] = [keys, cb];
-        for (const key of keys) {
-            this.#oldValues[key] = await this.#head.get(key);
-        }
-        return id;
-    }
-    unsubscribeStorage(id) {
-        delete this.#storageListeners[id];
-    }
-    async subscrubeRuntimeVersion(cb) {
-        const id = (0, exports.randomId)();
-        const codeKey = (0, util_1.stringToHex)(':code');
-        this.#storageListeners[id] = [[codeKey], cb];
-        this.#oldValues[codeKey] = await this.#head.get(codeKey);
-        return id;
-    }
-    unsubscribeRuntimeVersion(id) {
-        delete this.#storageListeners[id];
-    }
-    async setHead(head) {
-        this.#head = head;
-        for (const cb of Object.values(this.#headListeners)) {
-            try {
-                await cb(head);
-            }
-            catch (error) {
-                logger.error(error, 'setHead head callback error');
-            }
-        }
-        const diff = await this.#head.storageDiff();
-        for (const [keys, cb] of Object.values(this.#storageListeners)) {
-            const changed = keys.filter((key) => diff[key]).map((key) => [key, diff[key]]);
-            if (changed.length > 0) {
-                try {
-                    await cb(head, changed);
-                }
-                catch (error) {
-                    logger.error(error, 'setHead storaeg diff callback error');
-                }
-            }
-        }
-        Object.assign(this.#oldValues, diff);
-    }
-}
-exports.HeadState = HeadState;

package/lib/blockchain/index.d.ts

@@ -1,64 +0,0 @@
-import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
-import { DataSource } from 'typeorm';
-import { HexString } from '@polkadot/util/types';
-import { RegisteredTypes } from '@polkadot/types/types';
-import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue';
-import { Api } from '../api';
-import { Block } from './block';
-import { BuildBlockMode, BuildBlockParams, DownwardMessage, HorizontalMessage, TxPool } from './txpool';
-import { HeadState } from './head-state';
-import { InherentProvider } from './inherent';
-import { OffchainWorker } from '../offchain';
-export interface Options {
-    api: Api;
-    buildBlockMode?: BuildBlockMode;
-    inherentProvider: InherentProvider;
-    db?: DataSource;
-    header: {
-        number: number;
-        hash: HexString;
-    };
-    mockSignatureHost?: boolean;
-    allowUnresolvedImports?: boolean;
-    runtimeLogLevel?: number;
-    registeredTypes: RegisteredTypes;
-    offchainWorker?: boolean;
-}
-export declare class Blockchain {
-    #private;
-    readonly uid: string;
-    readonly api: Api;
-    readonly db: DataSource | undefined;
-    readonly mockSignatureHost: boolean;
-    readonly allowUnresolvedImports: boolean;
-    readonly runtimeLogLevel: number;
-    readonly registeredTypes: RegisteredTypes;
-    readonly headState: HeadState;
-    readonly offchainWorker: OffchainWorker | undefined;
-    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, }: Options);
-    get head(): Block;
-    get txPool(): TxPool;
-    getBlockAt(number?: number): Promise<Block | undefined>;
-    getBlock(hash?: HexString): Promise<Block | undefined>;
-    unregisterBlock(block: Block): void;
-    setHead(block: Block): Promise<void>;
-    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
-    validateExtrinsic(extrinsic: HexString, source?: '0x00' | '0x01' | '0x02' /** External */): Promise<TransactionValidity>;
-    submitUpwardMessages(id: number, ump: HexString[]): void;
-    submitDownwardMessages(dmp: DownwardMessage[]): void;
-    submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;
-    newBlock(params?: Partial<BuildBlockParams>): Promise<Block>;
-    newBlockWithParams(params: BuildBlockParams): Promise<Block>;
-    upcomingBlocks(): Promise<number>;
-    dryRunExtrinsic(extrinsic: HexString | {
-        call: HexString;
-        address: string;
-    }, at?: HexString): Promise<{
-        outcome: ApplyExtrinsicResult;
-        storageDiff: [HexString, HexString | null][];
-    }>;
-    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
-    dryRunDmp(dmp: DownwardMessage[], at?: HexString): Promise<[HexString, HexString | null][]>;
-    dryRunUmp(ump: Record<number, HexString[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
-    getInherents(): Promise<HexString[]>;
-}

package/lib/blockchain/index.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Blockchain = void 0;
-const util_crypto_1 = require("@polkadot/util-crypto");
-const util_1 = require("@polkadot/util");
-const block_1 = require("./block");
-const txpool_1 = require("./txpool");
-const head_state_1 = require("./head-state");
-const offchain_1 = require("../offchain");
-const utils_1 = require("../utils");
-const logger_1 = require("../logger");
-const block_builder_1 = require("./block-builder");
-const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
-class Blockchain {
-    uid = Math.random().toString(36).substring(2);
-    api;
-    db;
-    mockSignatureHost;
-    allowUnresolvedImports;
-    runtimeLogLevel;
-    registeredTypes;
-    #txpool;
-    #inherentProvider;
-    #head;
-    #blocksByNumber = [];
-    #blocksByHash = {};
-    #loadingBlocks = {};
-    headState;
-    offchainWorker;
-    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, }) {
-        this.api = api;
-        this.db = db;
-        this.mockSignatureHost = mockSignatureHost;
-        this.allowUnresolvedImports = allowUnresolvedImports;
-        this.runtimeLogLevel = runtimeLogLevel;
-        this.registeredTypes = registeredTypes;
-        this.#head = new block_1.Block(this, header.number, header.hash);
-        this.#registerBlock(this.#head);
-        this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
-        this.#inherentProvider = inherentProvider;
-        this.headState = new head_state_1.HeadState(this.#head);
-        if (offchainWorker) {
-            this.offchainWorker = new offchain_1.OffchainWorker();
-        }
-    }
-    #registerBlock(block) {
-        this.#blocksByNumber[block.number] = block;
-        this.#blocksByHash[block.hash] = block;
-    }
-    get head() {
-        return this.#head;
-    }
-    get txPool() {
-        return this.#txpool;
-    }
-    async getBlockAt(number) {
-        if (number === undefined) {
-            return this.head;
-        }
-        if (number > this.#head.number) {
-            return undefined;
-        }
-        if (!this.#blocksByNumber[number]) {
-            const hash = await this.api.getBlockHash(number);
-            const block = new block_1.Block(this, number, hash);
-            this.#registerBlock(block);
-        }
-        return this.#blocksByNumber[number];
-    }
-    async getBlock(hash) {
-        await this.api.isReady;
-        if (hash == null) {
-            hash = this.head.hash;
-        }
-        if (!this.#blocksByHash[hash]) {
-            const loadingBlock = this.#loadingBlocks[hash];
-            if (loadingBlock) {
-                await loadingBlock;
-            }
-            else {
-                const loadingBlock = (async () => {
-                    try {
-                        const header = await this.api.getHeader(hash);
-                        const block = new block_1.Block(this, Number(header.number), hash);
-                        this.#registerBlock(block);
-                    }
-                    catch (e) {
-                        logger.debug(`getBlock(${hash}) failed: ${e}`);
-                    }
-                })();
-                this.#loadingBlocks[hash] = loadingBlock;
-                await loadingBlock;
-                delete this.#loadingBlocks[hash];
-            }
-        }
-        return this.#blocksByHash[hash];
-    }
-    unregisterBlock(block) {
-        if (block.hash === this.head.hash) {
-            throw new Error('Cannot unregister head block');
-        }
-        if (this.#blocksByNumber[block.number]?.hash === block.hash) {
-            delete this.#blocksByNumber[block.number];
-        }
-        delete this.#blocksByHash[block.hash];
-    }
-    async setHead(block) {
-        logger.debug({
-            number: block.number,
-            hash: block.hash,
-        }, 'setHead');
-        this.#head = block;
-        this.#registerBlock(block);
-        await this.headState.setHead(block);
-        if (this.offchainWorker) {
-            await this.offchainWorker.run(block);
-        }
-    }
-    async submitExtrinsic(extrinsic) {
-        const validity = await this.validateExtrinsic(extrinsic);
-        if (validity.isOk) {
-            await this.#txpool.submitExtrinsic(extrinsic);
-            return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
-        }
-        throw validity.asErr;
-    }
-    async validateExtrinsic(extrinsic, source = '0x02' /** External */) {
-        const args = (0, util_1.u8aToHex)((0, util_1.u8aConcat)(source, extrinsic, this.head.hash));
-        const res = await this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
-        const registry = await this.head.registry;
-        return registry.createType('TransactionValidity', res.result);
-    }
-    submitUpwardMessages(id, ump) {
-        this.#txpool.submitUpwardMessages(id, ump);
-        logger.debug({ id, ump }, 'submitUpwardMessages');
-    }
-    submitDownwardMessages(dmp) {
-        this.#txpool.submitDownwardMessages(dmp);
-        logger.debug({ dmp }, 'submitDownwardMessages');
-    }
-    submitHorizontalMessages(id, hrmp) {
-        this.#txpool.submitHorizontalMessages(id, hrmp);
-        logger.debug({ id, hrmp }, 'submitHorizontalMessages');
-    }
-    async newBlock(params) {
-        await this.#txpool.buildBlock(params);
-        return this.#head;
-    }
-    async newBlockWithParams(params) {
-        await this.#txpool.buildBlockWithParams(params);
-        return this.#head;
-    }
-    async upcomingBlocks() {
-        return this.#txpool.upcomingBlocks();
-    }
-    async dryRunExtrinsic(extrinsic, at) {
-        await this.api.isReady;
-        const head = at ? await this.getBlock(at) : this.head;
-        if (!head) {
-            throw new Error(`Cannot find block ${at}`);
-        }
-        const registry = await head.registry;
-        const inherents = await this.#inherentProvider.createInherents(head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: {},
-        });
-        const { result, storageDiff } = await (0, block_builder_1.dryRunExtrinsic)(head, inherents, extrinsic);
-        const outcome = registry.createType('ApplyExtrinsicResult', result);
-        return { outcome, storageDiff };
-    }
-    async dryRunHrmp(hrmp, at) {
-        await this.api.isReady;
-        const head = at ? await this.getBlock(at) : this.head;
-        if (!head) {
-            throw new Error(`Cannot find block ${at}`);
-        }
-        const inherents = await this.#inherentProvider.createInherents(head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: hrmp,
-        });
-        return (0, block_builder_1.dryRunInherents)(head, inherents);
-    }
-    async dryRunDmp(dmp, at) {
-        await this.api.isReady;
-        const head = at ? await this.getBlock(at) : this.head;
-        if (!head) {
-            throw new Error(`Cannot find block ${at}`);
-        }
-        const inherents = await this.#inherentProvider.createInherents(head, {
-            transactions: [],
-            downwardMessages: dmp,
-            upwardMessages: [],
-            horizontalMessages: {},
-        });
-        return (0, block_builder_1.dryRunInherents)(head, inherents);
-    }
-    async dryRunUmp(ump, at) {
-        await this.api.isReady;
-        const head = at ? await this.getBlock(at) : this.head;
-        if (!head) {
-            throw new Error(`Cannot find block ${at}`);
-        }
-        const meta = await head.meta;
-        const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
-        const stroageValues = [
-            [(0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex()],
-        ];
-        for (const [paraId, messages] of Object.entries(ump)) {
-            const upwardMessages = meta.registry.createType('Vec<Bytes>', messages);
-            if (upwardMessages.length === 0)
-                throw new Error('No upward meesage');
-            const queueSize = meta.registry.createType('(u32, u32)', [
-                upwardMessages.length,
-                upwardMessages.map((x) => x.byteLength).reduce((s, i) => s + i, 0),
-            ]);
-            stroageValues.push([(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex()]);
-            stroageValues.push([(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()]);
-        }
-        head.pushStorageLayer().setAll(stroageValues);
-        const inherents = await this.#inherentProvider.createInherents(head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: {},
-        });
-        return (0, block_builder_1.dryRunInherents)(head, inherents);
-    }
-    async getInherents() {
-        await this.api.isReady;
-        const inherents = await this.#inherentProvider.createInherents(this.head, {
-            transactions: [],
-            downwardMessages: [],
-            upwardMessages: [],
-            horizontalMessages: {},
-        });
-        return inherents;
-    }
-}
-exports.Blockchain = Blockchain;

package/lib/blockchain/inherent/index.d.ts

@@ -1,19 +0,0 @@
-import { Block } from '../block';
-import { BuildBlockParams } from '../txpool';
-import { HexString } from '@polkadot/util/types';
-export { SetValidationData } from './parachain/validation-data';
-export { ParaInherentEnter } from './para-enter';
-export { SetBabeRandomness } from './parachain/babe-randomness';
-export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
-export interface CreateInherents {
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
-}
-export type InherentProvider = CreateInherents;
-export declare class SetTimestamp implements InherentProvider {
-    createInherents(parent: Block): Promise<HexString[]>;
-}
-export declare class InherentProviders implements InherentProvider {
-    #private;
-    constructor(base: InherentProvider, providers: CreateInherents[]);
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
-}