@acala-network/chopsticks-core 0.9.4-1 → 0.9.4-3

package/dist/esm/api.d.ts

@@ -0,0 +1,56 @@
+import { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
+export type ChainProperties = {
+    ss58Format?: number;
+    tokenDecimals?: number[];
+    tokenSymbol?: string[];
+};
+type Header = {
+    parentHash: HexString;
+    number: HexString;
+    stateRoot: HexString;
+    extrinsicsRoot: HexString;
+    digest: {
+        logs: HexString[];
+    };
+};
+type SignedBlock = {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications?: HexString[];
+};
+/**
+ * API class. Calls provider to get on-chain data.
+ * Either `endpoint` or `genesis` porvider must be provided.
+ *
+ * @example Instantiate an API
+ *
+ * ```ts
+ * const provider = new WsProvider(options.endpoint)
+ * const api = new Api(provider)
+ * await api.isReady
+ * ```
+ */
+export declare class Api {
+    #private;
+    readonly signedExtensions: ExtDef;
+    constructor(provider: ProviderInterface, signedExtensions?: ExtDef);
+    disconnect(): Promise<void>;
+    get isReady(): Promise<void> | undefined;
+    get chain(): Promise<string>;
+    get chainProperties(): Promise<ChainProperties>;
+    getSystemName(): Promise<string>;
+    getSystemProperties(): Promise<ChainProperties>;
+    getSystemChain(): Promise<string>;
+    getBlockHash(blockNumber?: number): Promise<`0x${string}` | null>;
+    getHeader(hash?: string): Promise<Header | null>;
+    getBlock(hash?: string): Promise<SignedBlock | null>;
+    getStorage(key: string, hash?: string): Promise<`0x${string}` | null>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string, hash?: string): Promise<string[]>;
+    subscribeRemoteNewHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
+    subscribeRemoteFinalizedHeads(cb: ProviderInterfaceCallback): Promise<string | number>;
+}
+export {};

package/dist/esm/blockchain/block-builder.d.ts

@@ -0,0 +1,15 @@
+import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
+import { Block } from './block.js';
+import { HexString } from '@polkadot/util/types';
+import { TaskCallResponse } from '../wasm-executor/index.js';
+export declare const newHeader: (head: Block, unsafeBlockHeight?: number) => Promise<Header>;
+export type BuildBlockCallbacks = {
+    onApplyExtrinsicError?: (extrinsic: HexString, error: TransactionValidityError) => void;
+    onPhaseApplied?: (phase: 'initialize' | 'finalize' | number, resp: TaskCallResponse) => void;
+};
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, callbacks?: BuildBlockCallbacks, unsafeBlockHeight?: number) => Promise<[Block, HexString[]]>;
+export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
+    call: HexString;
+    address: string;
+}) => Promise<TaskCallResponse>;
+export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/dist/esm/blockchain/block.d.ts

@@ -0,0 +1,92 @@
+import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
+import { Header } from '@polkadot/types/interfaces';
+import { TypeRegistry } from '@polkadot/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
+import type { HexString } from '@polkadot/util/types';
+import { Blockchain } from './index.js';
+import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer.js';
+import type { RuntimeVersion, TaskCallResponse } from '../wasm-executor/index.js';
+/**
+ * Block class.
+ *
+ * @example Instantiate a block
+ *
+ * ```ts
+ * const block = new Block(chain, number, hash)
+ * ```
+ *
+ * @example Get storage
+ *
+ * ```ts
+ * const block = await chain.getBlock('0x...')
+ * block.storage()
+ * ```
+ */
+export declare class Block {
+    #private;
+    readonly number: number;
+    readonly hash: HexString;
+    constructor(chain: Blockchain, number: number, hash: HexString, parentBlock?: Block, block?: {
+        /** See `@polkadot/types/interfaces` Header */
+        header: Header;
+        /** Extrinsics */
+        extrinsics: HexString[];
+        /** Storage provider. Default to {@link RemoteStorageLayer} with {@link Blockchain.api chain.api} as remote. */
+        storage?: StorageLayerProvider;
+        /** Storage diff to apply. */
+        storageDiff?: Record<string, StorageValue | null>;
+    });
+    get chain(): Blockchain;
+    get header(): Header | Promise<Header>;
+    get extrinsics(): HexString[] | Promise<HexString[]>;
+    get parentBlock(): Promise<Block | undefined>;
+    /**
+     * Get the block storage.
+     */
+    get storage(): StorageLayerProvider;
+    /**
+     * Get the block storage by key.
+     */
+    get(key: string): Promise<HexString | undefined>;
+    read<T extends string>(type: T, query: StorageEntry, ...args: any[]): Promise<import("@polkadot/types/types").DetectCodec<import("@polkadot/types-codec/types").Codec, T> | undefined>;
+    /**
+     * Get paged storage keys.
+     */
+    getKeysPaged(options: {
+        prefix?: string;
+        startKey?: string;
+        pageSize: number;
+    }): Promise<string[]>;
+    /**
+     * Push a layer to the storage stack.
+     */
+    pushStorageLayer(): StorageLayer;
+    /**
+     * Pop a layer from the storage stack.
+     */
+    popStorageLayer(): void;
+    /**
+     * Get storage diff.
+     */
+    storageDiff(): Promise<Record<HexString, HexString | null>>;
+    /**
+     * Get the wasm string.
+     */
+    get wasm(): Promise<`0x${string}`>;
+    /**
+     * Set the runtime wasm.
+     */
+    setWasm(wasm: HexString): void;
+    /**
+     * Get the type registry.
+     * @see https://polkadot.js.org/docs/api/start/types.create#why-create-types
+     */
+    get registry(): Promise<TypeRegistry>;
+    get runtimeVersion(): Promise<RuntimeVersion>;
+    get metadata(): Promise<HexString>;
+    get meta(): Promise<DecoratedMeta>;
+    /**
+     * Call a runtime method.
+     */
+    call(method: string, args: HexString[]): Promise<TaskCallResponse>;
+}

package/dist/esm/blockchain/head-state.d.ts

@@ -0,0 +1,15 @@
+import { Block } from './block.js';
+type Callback = (block: Block, pairs: [string, string | null][]) => 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/dist/esm/blockchain/index.d.ts

@@ -0,0 +1,172 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { TypeRegistry } from '@polkadot/types';
+import { RegisteredTypes } from '@polkadot/types/types';
+import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue';
+import { Api } from '../api.js';
+import { Block } from './block.js';
+import { BuildBlockMode, BuildBlockParams, DownwardMessage, HorizontalMessage, TxPool } from './txpool.js';
+import { Database } from '../database.js';
+import { HeadState } from './head-state.js';
+import { InherentProvider } from './inherent/index.js';
+import { OffchainWorker } from '../offchain.js';
+import { RuntimeVersion } from '../wasm-executor/index.js';
+export interface Options {
+    /** API instance, for getting on-chain data. */
+    api: Api;
+    /** Build block mode. Default to Batch. */
+    buildBlockMode?: BuildBlockMode;
+    /** Inherent provider, for creating inherents. */
+    inherentProvider: InherentProvider;
+    /** Datasource for caching storage and blocks data. */
+    db?: Database;
+    /** Used to create the initial head. */
+    header: {
+        number: number;
+        hash: HexString;
+    };
+    /** Whether to enable mock signature. Any signature starts with 0xdeadbeef and filled by 0xcd is considered valid */
+    mockSignatureHost?: boolean;
+    /** Whether to allow wasm unresolved imports. */
+    allowUnresolvedImports?: boolean;
+    /** Wasm runtime log level. */
+    runtimeLogLevel?: number;
+    /** Polkadot.js custom types registration. */
+    registeredTypes: RegisteredTypes;
+    /** Whether to enable offchain Worker. */
+    offchainWorker?: boolean;
+    /** Max memory block count */
+    maxMemoryBlockCount?: number;
+}
+/**
+ * Local blockchain which provides access to blocks, txpool and methods
+ * to manipulate the chain such as build blocks, submit extrinsics, xcm and more!
+ *
+ * @example
+ *
+ * ```ts
+ * const chain = new Blockchain({
+ *  api,
+ *  buildBlockMode: BuildBlockMode.Manual,
+ *  inherentProvider: inherents,
+ *  header: {
+ *    hash: blockHash,
+ *    number: Number(header.number),
+ *  },
+ *  mockSignatureHost: true,
+ *  allowUnresolvedImports: true,
+ *  registeredTypes: {},
+ * })
+ * // build a block
+ * chain.newBlock()
+ * ```
+ */
+export declare class Blockchain {
+    #private;
+    readonly uid: string;
+    /** API instance, for getting on-chain data. */
+    readonly api: Api;
+    /** Datasource for caching storage and blocks data. */
+    readonly db: Database | undefined;
+    /** Enable mock signature. Any signature starts with 0xdeadbeef and filled by 0xcd is considered valid */
+    readonly mockSignatureHost: boolean;
+    /** Allow wasm unresolved imports. */
+    readonly allowUnresolvedImports: boolean;
+    /** Polkadot.js custom types registration. */
+    readonly registeredTypes: RegisteredTypes;
+    /** For subscribing and managing the head state. */
+    readonly headState: HeadState;
+    readonly offchainWorker: OffchainWorker | undefined;
+    /**
+     * @param options - Options for instantiating the blockchain
+     */
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, maxMemoryBlockCount, }: Options);
+    get head(): Block;
+    get txPool(): TxPool;
+    get runtimeLogLevel(): number;
+    set runtimeLogLevel(level: number);
+    buildRegistry(metadata: HexString, version: RuntimeVersion): Promise<TypeRegistry>;
+    saveBlockToDB(block: Block): Promise<void>;
+    /**
+     * Try to load block from db and register it.
+     * If pass in number, get block by number, else get block by hash.
+     */
+    loadBlockFromDB(hashOrNumber: number | HexString): Promise<Block | undefined>;
+    /**
+     * Get block by number.
+     */
+    getBlockAt(number?: number | null): Promise<Block | undefined>;
+    /**
+     * Get block by hash.
+     */
+    getBlock(hash?: HexString): Promise<Block | undefined>;
+    /**
+     * Get all blocks in memory.
+     */
+    blocksInMemory(): Block[];
+    /**
+     * Remove block from memory and db.
+     */
+    unregisterBlock(block: Block): Promise<void>;
+    onNewBlock(block: Block): Promise<void>;
+    /**
+     * Set block as head.
+     */
+    setHead(block: Block): Promise<void>;
+    /**
+     * Submit extrinsic to txpool.
+     */
+    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
+    /**
+     * Validate extrinsic by calling `TaggedTransactionQueue_validate_transaction`.
+     */
+    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;
+    /**
+     * Build a new block with optional params. Use this when you don't have all the {@link BuildBlockParams}
+     */
+    newBlock(params?: Partial<BuildBlockParams>): Promise<Block>;
+    /**
+     * Build a new block with {@link BuildBlockParams}.
+     */
+    newBlockWithParams(params: BuildBlockParams): Promise<Block>;
+    /**
+     * Get the upcoming blocks.
+     */
+    upcomingBlocks(): Promise<number>;
+    /**
+     * Dry run extrinsic in block `at`.
+     */
+    dryRunExtrinsic(extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    /**
+     * Dry run hrmp messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Dry run dmp messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunDmp(dmp: DownwardMessage[], at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Dry run ump messages in block `at`.
+     * Return the storage diff.
+     */
+    dryRunUmp(ump: Record<number, HexString[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    /**
+     * Get inherents of head.
+     */
+    getInherents(): Promise<HexString[]>;
+    /**
+     * Close the db and disconnect api.
+     */
+    close(): Promise<void>;
+}

package/dist/esm/blockchain/inherent/index.d.ts

@@ -0,0 +1,19 @@
+import { Block } from '../block.js';
+import { BuildBlockParams } from '../txpool.js';
+import { HexString } from '@polkadot/util/types';
+export { SetValidationData } from './parachain/validation-data.js';
+export { ParaInherentEnter } from './para-enter.js';
+export { SetBabeRandomness } from './parachain/babe-randomness.js';
+export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent.js';
+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[]>;
+}

package/dist/esm/blockchain/inherent/para-enter.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../block.js';
+import { BuildBlockParams } from '../txpool.js';
+import { CreateInherents } from './index.js';
+export declare class ParaInherentEnter implements CreateInherents {
+    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+}

package/dist/esm/blockchain/inherent/parachain/babe-randomness.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../block.js';
+import { BuildBlockParams } from '../../txpool.js';
+import { CreateInherents } from '../index.js';
+export declare class SetBabeRandomness implements CreateInherents {
+    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+}

package/dist/esm/blockchain/inherent/parachain/nimbus-author-inherent.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../block.js';
+import { BuildBlockParams } from '../../txpool.js';
+import { CreateInherents } from '../index.js';
+export declare class SetNimbusAuthorInherent implements CreateInherents {
+    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+}

package/dist/esm/blockchain/inherent/parachain/validation-data.d.ts

@@ -0,0 +1,19 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../block.js';
+import { BuildBlockParams, DownwardMessage, HorizontalMessage } from '../../txpool.js';
+import { CreateInherents } from '../index.js';
+export type ValidationData = {
+    downwardMessages: DownwardMessage[];
+    horizontalMessages: Record<number, HorizontalMessage[]>;
+    validationData: {
+        relayParentNumber: number;
+        relayParentStorageRoot: HexString;
+        maxPovSize: number;
+    };
+    relayChainState: {
+        trieNodes: HexString[];
+    };
+};
+export declare class SetValidationData implements CreateInherents {
+    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
+}

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

@@ -0,0 +1,47 @@
+import { Api } from '../api.js';
+import { Database } from '../database.js';
+export declare const enum StorageValueKind {
+    Deleted = "Deleted",
+    DeletedPrefix = "DeletedPrefix"
+}
+export type StorageValue = string | StorageValueKind | undefined;
+export interface StorageLayerProvider {
+    /**
+     * Get the value of a storage key.
+     */
+    get(key: string, cache: boolean): Promise<StorageValue>;
+    /**
+     * Fold the storage layer into another layer.
+     */
+    foldInto(into: StorageLayer): Promise<StorageLayerProvider | undefined>;
+    /**
+     * Fold the storage layer into the parent if it exists.
+     */
+    fold(): Promise<void>;
+    /**
+     * Get paged storage keys.
+     */
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+}
+export declare class RemoteStorageLayer implements StorageLayerProvider {
+    #private;
+    constructor(api: Api, at: string, db: Database | undefined);
+    get(key: string, _cache: boolean): 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[]>;
+    /**
+     * Merge the storage layer into the given object, can be used to get sotrage diff.
+     */
+    mergeInto(into: Record<string, string | null>): Promise<void>;
+}

package/dist/esm/blockchain/txpool.d.ts

@@ -0,0 +1,48 @@
+import { EventEmitter } from 'eventemitter3';
+import { HexString } from '@polkadot/util/types';
+import { Blockchain } from './index.js';
+import { InherentProvider } from './inherent/index.js';
+export declare const APPLY_EXTRINSIC_ERROR = "TxPool::ApplyExtrinsicError";
+export declare enum BuildBlockMode {
+    /** One block per batch (default) */
+    Batch = 0,
+    /** One block per tx */
+    Instant = 1,
+    /** Only build when triggered */
+    Manual = 2
+}
+export interface DownwardMessage {
+    sentAt: number;
+    msg: HexString;
+}
+export interface HorizontalMessage {
+    sentAt: number;
+    data: HexString;
+}
+export interface BuildBlockParams {
+    downwardMessages: DownwardMessage[];
+    upwardMessages: Record<number, HexString[]>;
+    horizontalMessages: Record<number, HorizontalMessage[]>;
+    transactions: HexString[];
+    unsafeBlockHeight?: number;
+}
+export declare class TxPool {
+    #private;
+    readonly event: EventEmitter<string | symbol, any>;
+    constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
+    get pendingExtrinsics(): HexString[];
+    get ump(): Record<number, HexString[]>;
+    get dmp(): DownwardMessage[];
+    get hrmp(): Record<number, HorizontalMessage[]>;
+    get mode(): BuildBlockMode;
+    set mode(mode: BuildBlockMode);
+    clear(): void;
+    pendingExtrinsicsBy(address: string): HexString[];
+    submitExtrinsic(extrinsic: HexString): Promise<void>;
+    submitUpwardMessages(id: number, ump: HexString[]): void;
+    submitDownwardMessages(dmp: DownwardMessage[]): void;
+    submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;
+    buildBlockWithParams(params: BuildBlockParams): Promise<void>;
+    buildBlock(params?: Partial<BuildBlockParams>): Promise<void>;
+    upcomingBlocks(): Promise<number>;
+}

package/dist/esm/chopsticks-provider.d.ts

@@ -0,0 +1,32 @@
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import { Blockchain } from './blockchain/index.js';
+import { Database } from './database.js';
+interface SubscriptionHandler {
+    callback: ProviderInterfaceCallback;
+    type: string;
+}
+/**
+ * Provider for local chopsticks chain
+ */
+export declare class ChopsticksProvider implements ProviderInterface {
+    #private;
+    readonly chain: Blockchain;
+    constructor(chain: Blockchain);
+    static fromEndpoint: (endpoint: string, block?: number | string | null, db?: Database) => Promise<ChopsticksProvider>;
+    get hasSubscriptions(): boolean;
+    get isClonable(): boolean;
+    get isConnected(): boolean;
+    get isReady(): Promise<void>;
+    clone: () => ChopsticksProvider;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    on: (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb) => (() => void);
+    subscriptionManager: {
+        subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+        unsubscribe: (subid: string) => void;
+    };
+    send: <T>(method: string, params: unknown[], _isCacheable?: boolean, subscription?: SubscriptionHandler) => Promise<T>;
+    subscribe(type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    unsubscribe(_type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};

package/dist/esm/database.d.ts

@@ -0,0 +1,26 @@
+import { HexString } from '@polkadot/util/types';
+export interface BlockEntry {
+    hash: HexString;
+    number: number;
+    header: HexString;
+    parentHash: HexString | null;
+    extrinsics: HexString[];
+    storageDiff: Record<HexString, HexString | null> | null;
+}
+export interface KeyValueEntry {
+    blockHash: string;
+    key: string;
+    value: string | null;
+}
+export declare class Database {
+    constructor(location: string);
+    close: () => Promise<void>;
+    saveBlock: (block: BlockEntry) => Promise<void>;
+    queryBlock: (hash: HexString) => Promise<BlockEntry | null>;
+    queryBlockByNumber: (number: number) => Promise<BlockEntry | null>;
+    queryHighestBlock: () => Promise<BlockEntry | null>;
+    deleteBlock: (hash: HexString) => Promise<void>;
+    blocksCount: () => Promise<number>;
+    saveStorage: (blockHash: HexString, key: HexString, value: HexString | null) => Promise<void>;
+    queryStorage: (blockHash: HexString, key: HexString) => Promise<KeyValueEntry | null>;
+}

package/dist/esm/genesis-provider.d.ts

@@ -0,0 +1,52 @@
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import { Genesis } from './schema/index.js';
+import { JsCallback } from './wasm-executor/index.js';
+/**
+ * Provider to start a chain from genesis
+ */
+export declare class GenesisProvider implements ProviderInterface {
+    #private;
+    /**
+     * @ignore
+     * Create a genesis provider
+     *
+     * @param genesis - genesis file
+     * @requires genesis provider
+     */
+    constructor(genesis: Genesis);
+    get isClonable(): boolean;
+    clone: () => GenesisProvider;
+    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: `0x${string}`;
+        stateRoot: `0x${string}`;
+        digest: {
+            logs: never[];
+        };
+    }>;
+    getBlock: () => Promise<{
+        block: {
+            header: {
+                blockHash: `0x${string}`;
+                number: `0x${string}`;
+                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/dist/esm/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Chopsticks core package. A common package for usage in both server and browser.
+ * It contains a local blockchain implementation, a transaction pool, a runtime executor and more!
+ *
+ * @privateRemarks
+ * Above is the package description for `chopsticks-core` package.
+ *
+ * @packageDocumentation
+ */
+export * from './api.js';
+export * from './blockchain/index.js';
+export * from './blockchain/block.js';
+export * from './blockchain/block-builder.js';
+export * from './blockchain/txpool.js';
+export * from './blockchain/storage-layer.js';
+export * from './blockchain/head-state.js';
+export * from './utils/index.js';
+export * from './wasm-executor/index.js';
+export * from './schema/index.js';
+export * from './xcm/index.js';
+export * from './setup.js';
+export * from './database.js';
+export * from './blockchain/inherent/index.js';
+export * from './logger.js';
+export * from './offchain.js';
+export * from './chopsticks-provider.js';
+export * from './genesis-provider.js';
+export * from './rpc/index.js';

package/dist/esm/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultLogger: import("pino").Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare const truncate: (val: any) => any;