@acala-network/chopsticks-core 0.9.4-2 → 0.9.4-4

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;

package/dist/esm/offchain.d.ts

@@ -0,0 +1,10 @@
+import { Block } from './blockchain/block.js';
+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}`>;
+}

package/dist/esm/rpc/index.d.ts

@@ -0,0 +1,5 @@
+import { Handlers } from './shared.js';
+export declare const allHandlers: Handlers;
+export { default as substrate } from './substrate/index.js';
+export { ResponseError } from './shared.js';
+export type { Context, SubscriptionManager, Handler, Handlers } from './shared.js';

package/dist/esm/rpc/shared.d.ts

@@ -0,0 +1,27 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare class ResponseError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+    toJSON(): {
+        code: number;
+        message: string;
+    };
+}
+export interface Context {
+    /**
+     * The blockchain instance
+     */
+    chain: Blockchain;
+}
+export interface SubscriptionManager {
+    subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+    unsubscribe: (subid: string) => void;
+}
+export type Handler<TParams = any, TReturn = any> = (context: Context, params: TParams, subscriptionManager: SubscriptionManager) => Promise<TReturn>;
+export type Handlers = Record<string, Handler>;

package/dist/esm/rpc/substrate/author.d.ts

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared.js';
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+export declare const author_submitExtrinsic: Handler<[HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const author_submitAndWatchExtrinsic: Handler<[HexString], string>;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+export declare const author_unwatchExtrinsic: Handler<[string], void>;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+export declare const author_pendingExtrinsics: Handler<void, HexString[]>;

package/dist/esm/rpc/substrate/author.js

@@ -59,6 +59,12 @@ const logger = defaultLogger.child({
             callback({
                 ready: null
             });
+            // fake broadcast to alice peer
+            callback({
+                broadcast: [
+                    '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+                ]
+            });
         }, 50);
     } catch (error) {
         logger.error({

package/dist/esm/rpc/substrate/chain.d.ts

@@ -0,0 +1,45 @@
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared.js';
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+export declare const chain_getBlockHash: Handler<[number | number[] | null], HexString | (HexString | null)[] | null>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+export declare const chain_getHeader: Handler<[HexString], Header>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+export declare const chain_getBlock: Handler<[
+    HexString
+], {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications: null;
+}>;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+export declare const chain_getFinalizedHead: Handler<void, HexString>;
+export declare const chain_subscribeNewHead: Handler<void, string>;
+export declare const chain_subscribeFinalizedHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHead: Handler<[string], void>;
+export declare const chain_getHead: Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+export declare const chain_subscribeNewHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHeads: Handler<[string], void>;
+export declare const chain_unsubscribeFinalizedHeads: Handler<[string], void>;

package/dist/esm/rpc/substrate/index.d.ts

@@ -0,0 +1,66 @@
+import * as AuthorRPC from './author.js';
+import * as ChainRPC from './chain.js';
+import * as PaymentRPC from './payment.js';
+import * as StateRPC from './state.js';
+import * as SystemRPC from './system.js';
+export { AuthorRPC };
+export { ChainRPC };
+export { PaymentRPC };
+export { StateRPC };
+export { SystemRPC };
+declare const handlers: {
+    system_localPeerId: () => Promise<string>;
+    system_nodeRoles: () => Promise<string[]>;
+    system_localListenAddresses: () => Promise<never[]>;
+    system_chain: import("../shared.js").Handler<void, string>;
+    system_properties: import("../shared.js").Handler<void, import("../../api.js").ChainProperties>;
+    system_name: import("../shared.js").Handler<void, string>;
+    system_version: import("../shared.js").Handler<void, string>;
+    system_chainType: import("../shared.js").Handler<void, string>;
+    system_health: () => Promise<{
+        peers: number;
+        isSyncing: boolean;
+        shouldHavePeers: boolean;
+    }>;
+    system_dryRun: import("../shared.js").Handler<[`0x${string}`, `0x${string}`], string>;
+    system_accountNextIndex: import("../shared.js").Handler<[`0x${string}`], number>;
+    state_getRuntimeVersion: import("../shared.js").Handler<[`0x${string}`], import("../../index.js").RuntimeVersion | null>;
+    state_getMetadata: import("../shared.js").Handler<[`0x${string}`], `0x${string}` | null>;
+    state_getStorage: import("../shared.js").Handler<[`0x${string}`, `0x${string}`], string | null>;
+    state_getKeysPaged: import("../shared.js").Handler<[string, number, string, `0x${string}`], string[] | undefined>;
+    state_queryStorageAt: import("../shared.js").Handler<[string[], `0x${string}`], [] | [{
+        block: `0x${string}`;
+        changes: [string, string | null][];
+    }]>;
+    state_call: import("../shared.js").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
+    state_subscribeRuntimeVersion: import("../shared.js").Handler<[], string>;
+    state_unsubscribeRuntimeVersion: import("../shared.js").Handler<[`0x${string}`], void>;
+    state_subscribeStorage: import("../shared.js").Handler<[string[]], string>;
+    state_unsubscribeStorage: import("../shared.js").Handler<[string], void>;
+    childstate_getStorage: import("../shared.js").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | null>;
+    childstate_getKeysPaged: import("../shared.js").Handler<[`0x${string}`, `0x${string}`, number, `0x${string}`, `0x${string}`], `0x${string}`[] | undefined>;
+    payment_queryFeeDetails: import("../shared.js").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    payment_queryInfo: import("../shared.js").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    chain_getBlockHash: import("../shared.js").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_getHeader: import("../shared.js").Handler<[`0x${string}`], import("@polkadot/types/interfaces").Header>;
+    chain_getBlock: import("../shared.js").Handler<[`0x${string}`], {
+        block: {
+            header: import("@polkadot/types/interfaces").Header;
+            extrinsics: `0x${string}`[];
+        };
+        justifications: null;
+    }>;
+    chain_getFinalizedHead: import("../shared.js").Handler<void, `0x${string}`>;
+    chain_subscribeNewHead: import("../shared.js").Handler<void, string>;
+    chain_subscribeFinalizedHeads: import("../shared.js").Handler<void, string>;
+    chain_unsubscribeNewHead: import("../shared.js").Handler<[string], void>;
+    chain_getHead: import("../shared.js").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_subscribeNewHeads: import("../shared.js").Handler<void, string>;
+    chain_unsubscribeNewHeads: import("../shared.js").Handler<[string], void>;
+    chain_unsubscribeFinalizedHeads: import("../shared.js").Handler<[string], void>;
+    author_submitExtrinsic: import("../shared.js").Handler<[`0x${string}`], `0x${string}`>;
+    author_submitAndWatchExtrinsic: import("../shared.js").Handler<[`0x${string}`], string>;
+    author_unwatchExtrinsic: import("../shared.js").Handler<[string], void>;
+    author_pendingExtrinsics: import("../shared.js").Handler<void, `0x${string}`[]>;
+};
+export default handlers;

package/dist/esm/rpc/substrate/payment.d.ts

@@ -0,0 +1,16 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared.js';
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryFeeDetails: Handler<[HexString, HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryInfo: Handler<[HexString, HexString], HexString>;

package/dist/esm/rpc/substrate/state.d.ts

@@ -0,0 +1,97 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared.js';
+import { RuntimeVersion } from '../../wasm-executor/index.js';
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return runtime version
+ */
+export declare const state_getRuntimeVersion: Handler<[HexString], RuntimeVersion | null>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return metadata
+ */
+export declare const state_getMetadata: Handler<[HexString], HexString | null>;
+/**
+ * @param context
+ * @param params - [`key`, `blockhash`]
+ *
+ * @return storage value
+ */
+export declare const state_getStorage: Handler<[HexString, HexString], string | null>;
+/**
+ * @param context
+ * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const state_getKeysPaged: Handler<[string, number, string, HexString], string[] | undefined>;
+/**
+ * @param context
+ * @param params - [`keys`, `blockhash`]
+ *
+ * @return storage values
+ */
+export declare const state_queryStorageAt: Handler<[
+    string[],
+    HexString
+], [] | [
+    {
+        block: HexString;
+        changes: [string, string | null][];
+    }
+]>;
+/**
+ * @param context
+ * @param params - [`method`, `data`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const state_call: Handler<[HexString, HexString, HexString], HexString>;
+/**
+ * @return subscription id
+ */
+export declare const state_subscribeRuntimeVersion: Handler<[], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeRuntimeVersion: Handler<[HexString], void>;
+/**
+ * @param context
+ * @param params - [`keys`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const state_subscribeStorage: Handler<[string[]], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeStorage: Handler<[string], void>;
+/**
+ * @param context
+ * @param params - [`child`, `key`, `blockhash`]
+ *
+ * @return storage valuse
+ */
+export declare const childstate_getStorage: Handler<[HexString, HexString, HexString], string | null>;
+/**
+ * @param context
+ * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const childstate_getKeysPaged: Handler<[
+    HexString,
+    HexString,
+    number,
+    HexString,
+    HexString
+], HexString[] | undefined>;

package/dist/esm/rpc/substrate/system.d.ts

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { ChainProperties } from '../../api.js';
+import { Handler } from '../shared.js';
+export declare const system_localPeerId: () => Promise<string>;
+export declare const system_nodeRoles: () => Promise<string[]>;
+export declare const system_localListenAddresses: () => Promise<never[]>;
+export declare const system_chain: Handler<void, string>;
+export declare const system_properties: Handler<void, ChainProperties>;
+export declare const system_name: Handler<void, string>;
+export declare const system_version: Handler<void, string>;
+export declare const system_chainType: Handler<void, string>;
+export declare const system_health: () => Promise<{
+    peers: number;
+    isSyncing: boolean;
+    shouldHavePeers: boolean;
+}>;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `at`]
+ *
+ * @return ApplyExtrinsicResult (see `@polkadot/types/interfaces`) in hash
+ */
+export declare const system_dryRun: Handler<[HexString, HexString], string>;
+/**
+ * @param context
+ * @param params - [`address`]
+ */
+export declare const system_accountNextIndex: Handler<[HexString], number>;

package/dist/esm/schema/index.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const genesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    properties: z.ZodObject<{
+        ss58Format: z.ZodOptional<z.ZodNumber>;
+        tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+        tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }>;
+    genesis: z.ZodObject<{
+        raw: z.ZodObject<{
+            top: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            top: Record<string, string>;
+        }, {
+            top: Record<string, string>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}, {
+    name: string;
+    id: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}>;
+export type Genesis = z.infer<typeof genesisSchema>;