@elsoul/erpc-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,785 @@
+type JsonPrimitive = boolean | null | number | string;
+type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+type JsonRpcId = number | string;
+type JsonRpcParams = object | readonly unknown[];
+type RpcMethodSpec<TParams extends JsonRpcParams | undefined, TResult> = {
+    readonly params: TParams;
+    readonly result: TResult;
+};
+type RpcParams<TSpec> = TSpec extends RpcMethodSpec<infer TParams, unknown> ? TParams : never;
+type RpcResult<TSpec> = TSpec extends RpcMethodSpec<JsonRpcParams | undefined, infer TResult> ? TResult : never;
+interface JsonRpcRequest<TParams extends JsonRpcParams | undefined> {
+    readonly jsonrpc: '2.0';
+    readonly id: JsonRpcId;
+    readonly method: string;
+    readonly params?: TParams;
+}
+interface JsonRpcSuccess<TResult> {
+    readonly jsonrpc: '2.0';
+    readonly id: JsonRpcId;
+    readonly result: TResult;
+}
+interface JsonRpcErrorObject {
+    readonly code: number;
+    readonly message: string;
+    readonly data?: unknown;
+}
+interface JsonRpcFailure {
+    readonly jsonrpc: '2.0';
+    readonly id: JsonRpcId | null;
+    readonly error: JsonRpcErrorObject;
+}
+type JsonRpcResponse<TResult> = JsonRpcFailure | JsonRpcSuccess<TResult>;
+interface RpcSendOptions {
+    readonly signal?: AbortSignal;
+}
+interface RpcBatchCall {
+    readonly method: string;
+    readonly params?: JsonRpcParams;
+}
+
+type QueryValue = boolean | number | readonly string[] | string | undefined;
+type Query = Readonly<Record<string, QueryValue>>;
+interface RestTransportConfig {
+    readonly apiKey: string;
+    readonly endpoint: URL;
+    readonly fetch: typeof globalThis.fetch;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly timeoutMs: number;
+}
+interface RestStreamResponse {
+    readonly response: Response;
+    close(): void;
+    normalizeError(error: unknown): Error;
+}
+declare class RestTransport {
+    #private;
+    readonly endpoint: string;
+    constructor(config: RestTransportConfig);
+    url(path: string, query?: Query): URL;
+    get<TResult>(path: string, query?: Query, options?: RpcSendOptions): Promise<TResult>;
+    stream(path: string, query?: Query, options?: RpcSendOptions): Promise<RestStreamResponse>;
+}
+
+type ErpcPlan = 'business' | 'developer' | 'free' | 'pro';
+interface TokenBalance {
+    readonly max_tokens: number;
+    readonly next_refill_at: string | null;
+    readonly plan: ErpcPlan;
+    readonly remaining_tokens: number;
+}
+declare class AccountClient {
+    #private;
+    constructor(transport: RestTransport);
+    getTokenBalance(options?: RpcSendOptions): Promise<TokenBalance>;
+}
+
+declare const DEFAULT_ENDPOINT = "https://edge.erpc.global";
+declare const DEFAULT_ACCOUNT_ENDPOINT = "https://solana-rpc.erpc.global";
+declare const DEFAULT_TIMEOUT_MS = 30000;
+interface ErpcClientConfig {
+    readonly accountEndpoint?: string;
+    readonly apiKey: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly timeoutMs?: number;
+    readonly webSocket?: typeof globalThis.WebSocket;
+}
+
+type PriceEncoding = 'base64' | 'hex';
+type PriceAssetType = 'crypto' | 'equity' | 'fx' | 'metal' | 'rates';
+interface PriceFeedMetadata {
+    readonly attributes?: Readonly<Record<string, string>>;
+    readonly id: string;
+}
+interface PricePoint {
+    readonly conf: string;
+    readonly expo: number;
+    readonly price: string;
+    readonly publish_time: number;
+}
+interface ParsedPriceUpdate {
+    readonly ema_price: PricePoint;
+    readonly id: string;
+    readonly metadata?: {
+        readonly prev_publish_time?: number;
+        readonly proof_available_time?: number;
+        readonly slot?: number;
+    };
+    readonly price: PricePoint;
+}
+interface BinaryUpdate {
+    readonly data: readonly string[];
+    readonly encoding: string;
+}
+interface PriceUpdateResponse {
+    readonly binary: BinaryUpdate;
+    readonly parsed?: readonly ParsedPriceUpdate[];
+}
+interface PriceUpdateOptions {
+    readonly encoding?: PriceEncoding;
+    readonly ids: readonly string[];
+    readonly ignoreInvalidPriceIds?: boolean;
+    readonly parsed?: boolean;
+}
+interface PriceStreamOptions extends PriceUpdateOptions {
+    readonly allowUnordered?: boolean;
+    readonly benchmarksOnly?: boolean;
+}
+interface PublisherStakeCap {
+    readonly cap: number;
+    readonly publisher: string;
+}
+interface PublisherStakeCapsResponse {
+    readonly binary: BinaryUpdate;
+    readonly parsed?: readonly {
+        readonly publisher_stake_caps: readonly PublisherStakeCap[];
+    }[];
+}
+interface PriceStreamEvent {
+    readonly data: PriceUpdateResponse;
+    readonly event?: string;
+    readonly id?: string;
+}
+declare class PriceClient {
+    #private;
+    constructor(transport: RestTransport);
+    getPriceFeeds(options?: {
+        readonly assetType?: PriceAssetType;
+        readonly query?: string;
+    }, sendOptions?: RpcSendOptions): Promise<readonly PriceFeedMetadata[]>;
+    getLatestPriceUpdates(options: PriceUpdateOptions, sendOptions?: RpcSendOptions): Promise<PriceUpdateResponse>;
+    getPriceUpdatesAtTimestamp(publishTime: number | string, options: PriceUpdateOptions, sendOptions?: RpcSendOptions): Promise<PriceUpdateResponse>;
+    getLatestPublisherStakeCaps(options?: {
+        readonly encoding?: PriceEncoding;
+        readonly parsed?: boolean;
+    }, sendOptions?: RpcSendOptions): Promise<PublisherStakeCapsResponse>;
+    streamPriceUpdates(options: PriceStreamOptions, sendOptions?: RpcSendOptions): AsyncGenerator<PriceStreamEvent, void, undefined>;
+}
+
+interface JsonRpcTransport {
+    readonly endpoint: string;
+    readonly maxBatchSize: number;
+    batch<TResult extends readonly unknown[]>(calls: readonly RpcBatchCall[], options?: RpcSendOptions): Promise<TResult>;
+    request<TResult>(method: string, params?: JsonRpcParams, options?: RpcSendOptions): Promise<TResult>;
+}
+declare class PendingRpcRequest<TResult> {
+    #private;
+    constructor(send: (options?: RpcSendOptions) => Promise<TResult>);
+    send(options?: RpcSendOptions): Promise<TResult>;
+}
+declare class PendingRpcBatchRequest<TResult extends readonly unknown[]> {
+    #private;
+    constructor(send: (options?: RpcSendOptions) => Promise<TResult>);
+    send(options?: RpcSendOptions): Promise<TResult>;
+}
+type SchemaConstraint<TSchema> = {
+    readonly [TMethod in keyof TSchema]: RpcMethodSpec<JsonRpcParams | undefined, unknown>;
+};
+type MethodName<TSchema> = Extract<keyof TSchema, string>;
+type MethodFunction<TSpec> = TSpec extends RpcMethodSpec<infer TParams, infer TResult> ? TParams extends readonly unknown[] ? (...params: TParams) => PendingRpcRequest<TResult> : TParams extends object ? (params: TParams) => PendingRpcRequest<TResult> : () => PendingRpcRequest<TResult> : never;
+type BatchCall<TSchema> = {
+    readonly [TMethod in MethodName<TSchema>]: RpcParams<TSchema[TMethod]> extends undefined ? {
+        readonly method: TMethod;
+        readonly params?: undefined;
+    } : {
+        readonly method: TMethod;
+        readonly params: RpcParams<TSchema[TMethod]>;
+    };
+}[MethodName<TSchema>];
+type BatchResults<TSchema, TCalls extends readonly BatchCall<TSchema>[]> = {
+    readonly [TIndex in keyof TCalls]: TCalls[TIndex] extends {
+        readonly method: infer TMethod;
+    } ? TMethod extends MethodName<TSchema> ? RpcResult<TSchema[TMethod]> : never : never;
+};
+interface RpcNamespaceBase<TSchema> {
+    readonly endpoint: string;
+    batch<const TCalls extends readonly BatchCall<TSchema>[]>(calls: TCalls): PendingRpcBatchRequest<BatchResults<TSchema, TCalls>>;
+    raw<TResult = unknown>(method: string, params?: JsonRpcParams): PendingRpcRequest<TResult>;
+    request<TMethod extends MethodName<TSchema>>(method: TMethod, ...params: RpcParams<TSchema[TMethod]> extends undefined ? [] : [params: RpcParams<TSchema[TMethod]>]): PendingRpcRequest<RpcResult<TSchema[TMethod]>>;
+}
+type RpcNamespace<TSchema extends SchemaConstraint<TSchema>> = RpcNamespaceBase<TSchema> & {
+    readonly [TMethod in MethodName<TSchema>]: MethodFunction<TSchema[TMethod]>;
+};
+
+type Hex = `0x${string}`;
+type EthereumAddress = Hex;
+type EthereumBlockTag = 'earliest' | 'finalized' | 'latest' | 'pending' | 'safe' | Hex;
+type EthereumObject = Readonly<Record<string, unknown>>;
+type EthereumTransactionRequest = EthereumObject;
+type EthereumFilter = EthereumObject;
+interface EthereumRpcSchema {
+    readonly eth_accounts: RpcMethodSpec<readonly [], readonly EthereumAddress[]>;
+    readonly eth_baseFee: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_blobBaseFee: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_blockNumber: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_call: RpcMethodSpec<readonly [
+        transaction: EthereumTransactionRequest,
+        block?: EthereumBlockTag,
+        stateOverride?: EthereumObject
+    ], Hex>;
+    readonly eth_callMany: RpcMethodSpec<readonly [
+        calls: readonly EthereumObject[],
+        simulationContext?: EthereumObject,
+        stateOverride?: EthereumObject,
+        timeout?: number
+    ], JsonValue>;
+    readonly eth_capabilities: RpcMethodSpec<readonly [], JsonValue>;
+    readonly eth_chainId: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_createAccessList: RpcMethodSpec<readonly [
+        transaction: EthereumTransactionRequest,
+        block?: EthereumBlockTag
+    ], JsonValue>;
+    readonly eth_estimateGas: RpcMethodSpec<readonly [
+        transaction: EthereumTransactionRequest,
+        block?: EthereumBlockTag,
+        stateOverride?: EthereumObject
+    ], Hex>;
+    readonly eth_feeHistory: RpcMethodSpec<readonly [
+        blockCount: Hex,
+        newestBlock: EthereumBlockTag,
+        rewardPercentiles: readonly number[]
+    ], JsonValue>;
+    readonly eth_gasPrice: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_getAccount: RpcMethodSpec<readonly [address: EthereumAddress, block: EthereumBlockTag], JsonValue>;
+    readonly eth_getBalance: RpcMethodSpec<readonly [address: EthereumAddress, block?: EthereumBlockTag], Hex>;
+    readonly eth_getBlockByHash: RpcMethodSpec<readonly [hash: Hex, includeTransactions: boolean], JsonValue | null>;
+    readonly eth_getBlockByNumber: RpcMethodSpec<readonly [block: EthereumBlockTag, includeTransactions: boolean], JsonValue | null>;
+    readonly eth_getBlockReceipts: RpcMethodSpec<readonly [block: EthereumBlockTag], JsonValue | null>;
+    readonly eth_getBlockTransactionCountByHash: RpcMethodSpec<readonly [hash: Hex], Hex | null>;
+    readonly eth_getBlockTransactionCountByNumber: RpcMethodSpec<readonly [block: EthereumBlockTag], Hex | null>;
+    readonly eth_getCode: RpcMethodSpec<readonly [address: EthereumAddress, block?: EthereumBlockTag], Hex>;
+    readonly eth_getFilterChanges: RpcMethodSpec<readonly [filterId: Hex], JsonValue>;
+    readonly eth_getFilterLogs: RpcMethodSpec<readonly [filterId: Hex], JsonValue>;
+    readonly eth_getLogs: RpcMethodSpec<readonly [filter?: EthereumFilter], JsonValue>;
+    readonly eth_getProof: RpcMethodSpec<readonly [
+        address: EthereumAddress,
+        storageKeys: readonly Hex[],
+        block: EthereumBlockTag
+    ], JsonValue>;
+    readonly eth_getRawTransactionByHash: RpcMethodSpec<readonly [hash: Hex], Hex | null>;
+    readonly eth_getStorageAt: RpcMethodSpec<readonly [
+        address: EthereumAddress,
+        position: Hex,
+        block?: EthereumBlockTag
+    ], Hex>;
+    readonly eth_getTransactionByBlockHashAndIndex: RpcMethodSpec<readonly [blockHash: Hex, index: Hex], JsonValue | null>;
+    readonly eth_getTransactionByBlockNumberAndIndex: RpcMethodSpec<readonly [block: EthereumBlockTag, index: Hex], JsonValue | null>;
+    readonly eth_getTransactionByHash: RpcMethodSpec<readonly [hash: Hex], JsonValue | null>;
+    readonly eth_getTransactionBySenderAndNonce: RpcMethodSpec<readonly [sender: EthereumAddress, nonce: Hex], JsonValue | null>;
+    readonly eth_getTransactionCount: RpcMethodSpec<readonly [address: EthereumAddress, block?: EthereumBlockTag], Hex>;
+    readonly eth_getTransactionReceipt: RpcMethodSpec<readonly [hash: Hex], JsonValue | null>;
+    readonly eth_getUncleCountByBlockHash: RpcMethodSpec<readonly [hash: Hex], Hex>;
+    readonly eth_getUncleCountByBlockNumber: RpcMethodSpec<readonly [block: EthereumBlockTag], Hex>;
+    readonly eth_maxPriorityFeePerGas: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_newBlockFilter: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_newFilter: RpcMethodSpec<readonly [filter?: EthereumFilter], Hex>;
+    readonly eth_newPendingTransactionFilter: RpcMethodSpec<readonly [], Hex>;
+    readonly eth_sendRawTransaction: RpcMethodSpec<readonly [transaction: Hex], Hex>;
+    readonly eth_signTransaction: RpcMethodSpec<readonly [transaction: EthereumTransactionRequest], Hex>;
+    readonly eth_simulateV1: RpcMethodSpec<readonly [simulation: EthereumObject, block?: EthereumBlockTag], JsonValue>;
+    readonly eth_submitWork: RpcMethodSpec<readonly [nonce: Hex, proofOfWorkHash: Hex, digest: Hex], boolean>;
+    readonly eth_syncing: RpcMethodSpec<readonly [], boolean | JsonValue>;
+    readonly eth_uninstallFilter: RpcMethodSpec<readonly [filterId: Hex], boolean>;
+    readonly net_listening: RpcMethodSpec<readonly [], boolean>;
+    readonly net_peerCount: RpcMethodSpec<readonly [], Hex>;
+    readonly net_version: RpcMethodSpec<readonly [], string>;
+    readonly txpool_content: RpcMethodSpec<readonly [], JsonValue>;
+    readonly txpool_contentFrom: RpcMethodSpec<readonly [address: EthereumAddress], JsonValue>;
+    readonly txpool_inspect: RpcMethodSpec<readonly [], JsonValue>;
+    readonly txpool_status: RpcMethodSpec<readonly [], JsonValue>;
+    readonly web3_clientVersion: RpcMethodSpec<readonly [], string>;
+    readonly web3_sha3: RpcMethodSpec<readonly [data: Hex], Hex>;
+}
+interface EthereumSubscriptionSchema {
+    readonly eth_subscribe: RpcMethodSpec<readonly [subscription: string, ...options: readonly unknown[]], string>;
+    readonly eth_unsubscribe: RpcMethodSpec<readonly [subscriptionId: string], boolean>;
+}
+declare const ETHEREUM_RPC_METHODS: readonly ["eth_accounts", "eth_baseFee", "eth_blobBaseFee", "eth_blockNumber", "eth_call", "eth_callMany", "eth_capabilities", "eth_chainId", "eth_createAccessList", "eth_estimateGas", "eth_feeHistory", "eth_gasPrice", "eth_getAccount", "eth_getBalance", "eth_getBlockByHash", "eth_getBlockByNumber", "eth_getBlockReceipts", "eth_getBlockTransactionCountByHash", "eth_getBlockTransactionCountByNumber", "eth_getCode", "eth_getFilterChanges", "eth_getFilterLogs", "eth_getLogs", "eth_getProof", "eth_getRawTransactionByHash", "eth_getStorageAt", "eth_getTransactionByBlockHashAndIndex", "eth_getTransactionByBlockNumberAndIndex", "eth_getTransactionByHash", "eth_getTransactionBySenderAndNonce", "eth_getTransactionCount", "eth_getTransactionReceipt", "eth_getUncleCountByBlockHash", "eth_getUncleCountByBlockNumber", "eth_maxPriorityFeePerGas", "eth_newBlockFilter", "eth_newFilter", "eth_newPendingTransactionFilter", "eth_sendRawTransaction", "eth_signTransaction", "eth_simulateV1", "eth_submitWork", "eth_syncing", "eth_uninstallFilter", "net_listening", "net_peerCount", "net_version", "txpool_content", "txpool_contentFrom", "txpool_inspect", "txpool_status", "web3_clientVersion", "web3_sha3"];
+declare const ETHEREUM_SUBSCRIPTION_METHODS: readonly ["eth_subscribe", "eth_unsubscribe"];
+interface EthereumClient {
+    readonly rpc: RpcNamespace<EthereumRpcSchema>;
+}
+
+type SolanaCommitment = 'confirmed' | 'finalized' | 'processed';
+type SolanaEncoding = 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
+type SolanaConfig = Readonly<Record<string, unknown>>;
+interface SolanaContext {
+    readonly apiVersion?: string;
+    readonly slot: number;
+}
+interface SolanaContextResult<TValue> {
+    readonly context: SolanaContext;
+    readonly value: TValue;
+}
+interface PriorityFeeEstimate {
+    readonly priorityFeeEstimate: number;
+    readonly [key: string]: unknown;
+}
+interface SolanaRpcSchema {
+    readonly getAccountInfo: RpcMethodSpec<readonly [address: string, config?: SolanaConfig], SolanaContextResult<JsonValue | null>>;
+    readonly getBalance: RpcMethodSpec<readonly [address: string, config?: SolanaConfig], SolanaContextResult<number>>;
+    readonly getBlock: RpcMethodSpec<readonly [slot: number, config?: SolanaConfig], JsonValue | null>;
+    readonly getBlockCommitment: RpcMethodSpec<readonly [slot: number], JsonValue>;
+    readonly getBlockHeight: RpcMethodSpec<readonly [config?: SolanaConfig], number>;
+    readonly getBlockProduction: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getBlockTime: RpcMethodSpec<readonly [slot: number], number | null>;
+    readonly getBlocks: RpcMethodSpec<readonly [startSlot: number, endSlot?: number, commitment?: SolanaCommitment], readonly number[]>;
+    readonly getBlocksWithLimit: RpcMethodSpec<readonly [startSlot: number, limit: number, commitment?: SolanaCommitment], readonly number[]>;
+    readonly getClusterNodes: RpcMethodSpec<readonly [], JsonValue>;
+    readonly getEpochInfo: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getEpochSchedule: RpcMethodSpec<readonly [], JsonValue>;
+    readonly getFeeForMessage: RpcMethodSpec<readonly [message: string, config?: SolanaConfig], SolanaContextResult<number | null>>;
+    readonly getFirstAvailableBlock: RpcMethodSpec<readonly [], number>;
+    readonly getGenesisHash: RpcMethodSpec<readonly [], string>;
+    readonly getHealth: RpcMethodSpec<readonly [], string>;
+    readonly getHighestSnapshotSlot: RpcMethodSpec<readonly [], JsonValue>;
+    readonly getIdentity: RpcMethodSpec<readonly [], JsonValue>;
+    readonly getInflationGovernor: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getInflationRate: RpcMethodSpec<readonly [], JsonValue>;
+    readonly getInflationReward: RpcMethodSpec<readonly [addresses: readonly string[], config?: SolanaConfig], JsonValue>;
+    readonly getLargestAccounts: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getLatestBlockhash: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getLeaderSchedule: RpcMethodSpec<readonly [slot?: number | null, config?: SolanaConfig], JsonValue | null>;
+    readonly getMaxRetransmitSlot: RpcMethodSpec<readonly [], number>;
+    readonly getMaxShredInsertSlot: RpcMethodSpec<readonly [], number>;
+    readonly getMinimumBalanceForRentExemption: RpcMethodSpec<readonly [dataLength: number, config?: SolanaConfig], number>;
+    readonly getMultipleAccounts: RpcMethodSpec<readonly [addresses: readonly string[], config?: SolanaConfig], SolanaContextResult<JsonValue>>;
+    readonly getParsedTransaction: RpcMethodSpec<readonly [signature: string, config?: SolanaConfig], JsonValue | null>;
+    readonly getPriorityFeeEstimate: RpcMethodSpec<readonly [request: SolanaConfig], PriorityFeeEstimate>;
+    readonly getProgramAccounts: RpcMethodSpec<readonly [programAddress: string, config?: SolanaConfig], JsonValue>;
+    readonly getProgramAccountsV2: RpcMethodSpec<readonly [programAddress: string, config: SolanaConfig], JsonValue>;
+    readonly getRecentPerformanceSamples: RpcMethodSpec<readonly [limit?: number], JsonValue>;
+    readonly getRecentPrioritizationFees: RpcMethodSpec<readonly [addresses?: readonly string[]], JsonValue>;
+    readonly getSignatureStatuses: RpcMethodSpec<readonly [signatures: readonly string[], config?: SolanaConfig], JsonValue>;
+    readonly getSignaturesForAddress: RpcMethodSpec<readonly [address: string, config?: SolanaConfig], JsonValue>;
+    readonly getSlot: RpcMethodSpec<readonly [config?: SolanaConfig], number>;
+    readonly getSlotLeader: RpcMethodSpec<readonly [config?: SolanaConfig], string>;
+    readonly getSlotLeaders: RpcMethodSpec<readonly [startSlot: number, limit: number], readonly string[]>;
+    readonly getStakeMinimumDelegation: RpcMethodSpec<readonly [config?: SolanaConfig], SolanaContextResult<number>>;
+    readonly getSupply: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly getTokenAccountBalance: RpcMethodSpec<readonly [address: string, config?: SolanaConfig], JsonValue>;
+    readonly getTokenAccountsByDelegate: RpcMethodSpec<readonly [delegate: string, filter: SolanaConfig, config?: SolanaConfig], JsonValue>;
+    readonly getTokenAccountsByOwner: RpcMethodSpec<readonly [owner: string, filter: SolanaConfig, config?: SolanaConfig], JsonValue>;
+    readonly getTokenLargestAccounts: RpcMethodSpec<readonly [mint: string, config?: SolanaConfig], JsonValue>;
+    readonly getTokenSupply: RpcMethodSpec<readonly [mint: string, config?: SolanaConfig], JsonValue>;
+    readonly getTransaction: RpcMethodSpec<readonly [signature: string, config?: SolanaConfig], JsonValue | null>;
+    readonly getTransactionCount: RpcMethodSpec<readonly [config?: SolanaConfig], number>;
+    readonly getVersion: RpcMethodSpec<readonly [], JsonObject>;
+    readonly getVoteAccounts: RpcMethodSpec<readonly [config?: SolanaConfig], JsonValue>;
+    readonly isBlockhashValid: RpcMethodSpec<readonly [blockhash: string, config?: SolanaConfig], SolanaContextResult<boolean>>;
+    readonly minimumLedgerSlot: RpcMethodSpec<readonly [], number>;
+    readonly requestAirdrop: RpcMethodSpec<readonly [address: string, lamports: number, config?: SolanaConfig], string>;
+    readonly sendTransaction: RpcMethodSpec<readonly [transaction: string, config?: SolanaConfig], string>;
+    readonly simulateTransaction: RpcMethodSpec<readonly [transaction: string, config?: SolanaConfig], JsonValue>;
+}
+interface AssetRequest {
+    readonly id: string;
+    readonly displayOptions?: Readonly<Record<string, boolean>>;
+}
+interface AssetBatchRequest {
+    readonly ids: readonly string[];
+    readonly displayOptions?: Readonly<Record<string, boolean>>;
+}
+interface AssetListRequest {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly page?: number;
+    readonly [key: string]: unknown;
+}
+type IndexedAsset = Readonly<Record<string, unknown>>;
+type IndexedAssetProof = Readonly<Record<string, unknown>>;
+interface IndexedAssetList<TItem = IndexedAsset> {
+    readonly cursor?: string;
+    readonly items: readonly TItem[];
+    readonly limit?: number;
+    readonly page?: number;
+    readonly total?: number;
+    readonly [key: string]: unknown;
+}
+interface SolanaDasSchema {
+    readonly getAsset: RpcMethodSpec<AssetRequest, IndexedAsset | null>;
+    readonly getAssetBatch: RpcMethodSpec<AssetBatchRequest, readonly (IndexedAsset | null)[]>;
+    readonly getAssetProof: RpcMethodSpec<AssetRequest, IndexedAssetProof | null>;
+    readonly getAssetProofBatch: RpcMethodSpec<AssetBatchRequest, readonly (IndexedAssetProof | null)[]>;
+    readonly getAssetsByAuthority: RpcMethodSpec<AssetListRequest & {
+        readonly authorityAddress: string;
+    }, IndexedAssetList>;
+    readonly getAssetsByCreator: RpcMethodSpec<AssetListRequest & {
+        readonly creatorAddress: string;
+        readonly onlyVerified?: boolean;
+    }, IndexedAssetList>;
+    readonly getAssetsByGroup: RpcMethodSpec<AssetListRequest & {
+        readonly groupKey: string;
+        readonly groupValue: string;
+    }, IndexedAssetList>;
+    readonly getAssetsByOwner: RpcMethodSpec<AssetListRequest & {
+        readonly ownerAddress: string;
+    }, IndexedAssetList>;
+    readonly getNftEditions: RpcMethodSpec<AssetListRequest & {
+        readonly mint: string;
+    }, Readonly<Record<string, unknown>>>;
+    readonly getSignaturesForAsset: RpcMethodSpec<AssetListRequest & {
+        readonly id: string;
+    }, Readonly<Record<string, unknown>>>;
+    readonly getTokenAccounts: RpcMethodSpec<AssetListRequest, Readonly<Record<string, unknown>>>;
+    readonly getTokensByDelegate: RpcMethodSpec<AssetListRequest & {
+        readonly delegate: string;
+    }, Readonly<Record<string, unknown>>>;
+    readonly getTokensByOwner: RpcMethodSpec<AssetListRequest & {
+        readonly owner: string;
+    }, Readonly<Record<string, unknown>>>;
+    readonly searchAssets: RpcMethodSpec<AssetListRequest, IndexedAssetList>;
+}
+interface NumericFilter {
+    readonly eq?: number;
+    readonly gt?: number;
+    readonly gte?: number;
+    readonly lt?: number;
+    readonly lte?: number;
+}
+interface AddressTransactionsOptions {
+    readonly before?: string;
+    readonly commitment?: SolanaCommitment;
+    readonly encoding?: 'base58' | 'base64' | 'json';
+    readonly filters?: Readonly<Record<string, unknown>>;
+    readonly limit?: number;
+    readonly maxSupportedTransactionVersion?: number;
+    readonly paginationToken?: string;
+    readonly sortOrder?: 'asc' | 'desc';
+    readonly transactionDetails?: 'full' | 'signatures';
+    readonly until?: string;
+}
+interface AddressTransaction {
+    readonly blockTime: number | null;
+    readonly confirmationStatus: SolanaCommitment;
+    readonly err: unknown;
+    readonly memo: string | null;
+    readonly meta?: unknown;
+    readonly signature: string;
+    readonly slot: number;
+    readonly transaction?: unknown;
+    readonly transactionIndex: number;
+    readonly version?: unknown;
+    readonly [key: string]: unknown;
+}
+interface AddressTransactionPage {
+    readonly data: readonly AddressTransaction[];
+    readonly paginationToken: string | null;
+    readonly windowStart: number | null;
+}
+interface AddressTransfersOptions {
+    readonly commitment?: SolanaCommitment;
+    readonly direction?: 'any' | 'in' | 'out';
+    readonly filters?: {
+        readonly amount?: NumericFilter;
+        readonly blockTime?: NumericFilter;
+        readonly slot?: NumericFilter;
+    };
+    readonly limit?: number;
+    readonly mint?: string;
+    readonly paginationToken?: string;
+    readonly solMode?: 'merged' | 'separate';
+    readonly sortOrder?: 'asc' | 'desc';
+    readonly with?: string;
+}
+interface AddressTransfer {
+    readonly amount: string;
+    readonly blockTime: number | null;
+    readonly confirmationStatus: 'finalized';
+    readonly decimals: number;
+    readonly feeAmount: string | null;
+    readonly feeUiAmount: string | null;
+    readonly fromTokenAccount: string | null;
+    readonly fromUserAccount: string | null;
+    readonly innerInstructionIdx: number;
+    readonly instructionIdx: number;
+    readonly mint: string | null;
+    readonly signature: string;
+    readonly slot: number;
+    readonly toTokenAccount: string | null;
+    readonly toUserAccount: string | null;
+    readonly transactionIdx: number;
+    readonly type: 'burn' | 'changeOwner' | 'mint' | 'transfer' | 'unwrap' | 'withdrawWithheldFee' | 'wrap';
+    readonly uiAmount: string;
+    readonly [key: string]: unknown;
+}
+interface AddressTransferPage {
+    readonly data: readonly AddressTransfer[];
+    readonly paginationToken: string | null;
+    readonly windowStart: number | null;
+}
+interface SolanaHistorySchema {
+    readonly getTransactionsForAddress: RpcMethodSpec<readonly [address: string, options?: AddressTransactionsOptions], AddressTransactionPage | null>;
+    readonly getTransfersByAddress: RpcMethodSpec<readonly [address: string, options?: AddressTransfersOptions], AddressTransferPage>;
+}
+interface PingMeasurement {
+    readonly city: string | null;
+    readonly country: string | null;
+    readonly fromIp: string | null;
+    readonly icmpReplied: boolean;
+    readonly lat: number | null;
+    readonly lon: number | null;
+    readonly measuredAt: string | null;
+    readonly ms: number | null;
+    readonly org: string | null;
+    readonly postal: string | null;
+    readonly region: string | null;
+    readonly timezone: string | null;
+    readonly [key: string]: unknown;
+}
+interface LeaderSlot {
+    readonly epoch: number;
+    readonly featureSet: string | null;
+    readonly gossipPort: number | null;
+    readonly gossipUpdatedAt: string | null;
+    readonly identity: string;
+    readonly ipAddress: string | null;
+    readonly leaderCity: string | null;
+    readonly leaderCountry: string | null;
+    readonly leaderLat: number | null;
+    readonly leaderLon: number | null;
+    readonly leaderOrg: string | null;
+    readonly leaderRegion: string | null;
+    readonly leaderTimezone: string | null;
+    readonly pingToLeaders: readonly PingMeasurement[];
+    readonly rpcAddress: string | null;
+    readonly slot: string;
+    readonly stakeWeight: number;
+    readonly tpuPort: number | null;
+    readonly tpuQuicPort: number | null;
+    readonly version: string | null;
+    readonly [key: string]: unknown;
+}
+interface LeaderSlotsResult {
+    readonly data: readonly LeaderSlot[];
+    readonly message: string;
+    readonly success: boolean;
+    readonly total: number;
+    readonly [key: string]: unknown;
+}
+interface ValidatorInformation extends Omit<LeaderSlot, 'epoch' | 'slot'> {
+    readonly gossipNodeId: number | null;
+    readonly slotCount: number;
+}
+interface ValidatorsInformationOptions {
+    readonly country?: string;
+    readonly limit?: number;
+    readonly region?: string;
+}
+interface ValidatorsInformationResult {
+    readonly data: readonly ValidatorInformation[];
+    readonly epoch: number;
+    readonly message: string;
+    readonly success: boolean;
+    readonly total: number;
+    readonly totalValidators: number;
+    readonly [key: string]: unknown;
+}
+interface SolanaLeaderSchema {
+    readonly getLeaderSlots: RpcMethodSpec<readonly [slot: number], LeaderSlotsResult>;
+    readonly getValidatorsInformation: RpcMethodSpec<readonly [options: ValidatorsInformationOptions], ValidatorsInformationResult>;
+}
+type AnalyticsTimeBound = number | string;
+interface TopProgramsOptions {
+    readonly includeVotes?: boolean;
+    readonly limit?: number;
+    readonly since?: AnalyticsTimeBound;
+    readonly until?: AnalyticsTimeBound;
+}
+interface TopProgramRow {
+    readonly errors: string;
+    readonly invocations: string;
+    readonly program: string;
+    readonly total_cus: string;
+    readonly [key: string]: unknown;
+}
+type SlotStatsOptions = {
+    readonly slot: number;
+} | {
+    readonly fromSlot: number;
+    readonly toSlot: number;
+};
+interface SlotStatsRow {
+    readonly block_time: number;
+    readonly non_vote_transaction_count: number;
+    readonly slot: number;
+    readonly transaction_count: number;
+    readonly vote_transaction_count: number;
+    readonly [key: string]: unknown;
+}
+interface TpsTimeseriesOptions {
+    readonly bucketSec?: number;
+    readonly from: AnalyticsTimeBound;
+    readonly to: AnalyticsTimeBound;
+}
+interface TpsBucket {
+    readonly bucket: number;
+    readonly non_vote_tps: number;
+    readonly total_tps: number;
+    readonly [key: string]: unknown;
+}
+interface EpochSummary {
+    readonly distinct_programs: string;
+    readonly epoch: number;
+    readonly first_block_time: number;
+    readonly last_block_time: number;
+    readonly non_vote_txs: string;
+    readonly program_invocations: string;
+    readonly slots: string;
+    readonly total_txs: string;
+    readonly vote_txs: string;
+    readonly [key: string]: unknown;
+}
+interface ProgramStatsOptions {
+    readonly bucketSec?: number;
+    readonly programIdBase58: string;
+    readonly since?: AnalyticsTimeBound;
+    readonly until?: AnalyticsTimeBound;
+}
+interface ProgramStatsBucket {
+    readonly bucket: number;
+    readonly errors: string;
+    readonly invocations: string;
+    readonly total_cus: string;
+    readonly [key: string]: unknown;
+}
+interface SolanaAnalyticsSchema {
+    readonly jetEpochSummary: RpcMethodSpec<readonly [options: {
+        readonly epoch: number;
+    }], EpochSummary | null>;
+    readonly jetProgramStats: RpcMethodSpec<readonly [options: ProgramStatsOptions], readonly ProgramStatsBucket[]>;
+    readonly jetSlotStats: RpcMethodSpec<readonly [options: SlotStatsOptions], readonly SlotStatsRow[]>;
+    readonly jetTopPrograms: RpcMethodSpec<readonly [options: TopProgramsOptions], readonly TopProgramRow[]>;
+    readonly jetTpsTimeseries: RpcMethodSpec<readonly [options: TpsTimeseriesOptions], readonly TpsBucket[]>;
+}
+declare const SOLANA_RPC_METHODS: readonly ["getAccountInfo", "getBalance", "getBlock", "getBlockCommitment", "getBlockHeight", "getBlockProduction", "getBlockTime", "getBlocks", "getBlocksWithLimit", "getClusterNodes", "getEpochInfo", "getEpochSchedule", "getFeeForMessage", "getFirstAvailableBlock", "getGenesisHash", "getHealth", "getHighestSnapshotSlot", "getIdentity", "getInflationGovernor", "getInflationRate", "getInflationReward", "getLargestAccounts", "getLatestBlockhash", "getLeaderSchedule", "getMaxRetransmitSlot", "getMaxShredInsertSlot", "getMinimumBalanceForRentExemption", "getMultipleAccounts", "getParsedTransaction", "getPriorityFeeEstimate", "getProgramAccounts", "getProgramAccountsV2", "getRecentPerformanceSamples", "getRecentPrioritizationFees", "getSignatureStatuses", "getSignaturesForAddress", "getSlot", "getSlotLeader", "getSlotLeaders", "getStakeMinimumDelegation", "getSupply", "getTokenAccountBalance", "getTokenAccountsByDelegate", "getTokenAccountsByOwner", "getTokenLargestAccounts", "getTokenSupply", "getTransaction", "getTransactionCount", "getVersion", "getVoteAccounts", "isBlockhashValid", "minimumLedgerSlot", "requestAirdrop", "sendTransaction", "simulateTransaction"];
+declare const SOLANA_DAS_METHODS: readonly ["getAsset", "getAssetBatch", "getAssetProof", "getAssetProofBatch", "getAssetsByAuthority", "getAssetsByCreator", "getAssetsByGroup", "getAssetsByOwner", "getNftEditions", "getSignaturesForAsset", "getTokenAccounts", "getTokensByDelegate", "getTokensByOwner", "searchAssets"];
+declare const SOLANA_HISTORY_METHODS: readonly ["getTransactionsForAddress", "getTransfersByAddress"];
+declare const SOLANA_LEADER_METHODS: readonly ["getLeaderSlots", "getValidatorsInformation"];
+declare const SOLANA_ANALYTICS_METHODS: readonly ["jetEpochSummary", "jetProgramStats", "jetSlotStats", "jetTopPrograms", "jetTpsTimeseries"];
+interface SolanaClient {
+    readonly analytics: RpcNamespace<SolanaAnalyticsSchema>;
+    readonly das: RpcNamespace<SolanaDasSchema>;
+    readonly history: RpcNamespace<SolanaHistorySchema>;
+    readonly leaders: RpcNamespace<SolanaLeaderSchema>;
+    readonly rpc: RpcNamespace<SolanaRpcSchema>;
+}
+
+interface RpcNotification {
+    readonly jsonrpc: '2.0';
+    readonly method: string;
+    readonly params: unknown;
+}
+type RpcNotificationListener = (notification: RpcNotification) => void;
+interface WebSocketTransportConfig {
+    readonly endpoint: URL;
+    readonly maxBatchSize?: number;
+    readonly timeoutMs: number;
+    readonly webSocket?: typeof globalThis.WebSocket;
+}
+declare class WebSocketJsonRpcTransport implements JsonRpcTransport {
+    #private;
+    readonly endpoint: string;
+    readonly maxBatchSize: number;
+    constructor(config: WebSocketTransportConfig);
+    connect(): Promise<void>;
+    close(code?: number, reason?: string): void;
+    onNotification(listener: RpcNotificationListener): () => void;
+    request<TResult>(method: string, params?: JsonRpcParams, options?: RpcSendOptions): Promise<TResult>;
+    batch<TResult extends readonly unknown[]>(calls: readonly RpcBatchCall[], options?: RpcSendOptions): Promise<TResult>;
+}
+
+type SubscriptionId = number | string;
+type SubscriptionListener<TResult> = (result: TResult) => void;
+declare class RpcSubscription<TId extends SubscriptionId = SubscriptionId> {
+    #private;
+    readonly id: TId;
+    constructor(id: TId, unsubscribe: () => Promise<boolean>);
+    unsubscribe(): Promise<boolean>;
+}
+declare class EthereumSubscriptions {
+    #private;
+    readonly rpc: RpcNamespace<EthereumSubscriptionSchema>;
+    constructor(transport: WebSocketJsonRpcTransport);
+    close(): void;
+    onNotification(listener: RpcNotificationListener): () => void;
+    subscribe<TResult = unknown>(subscription: string, listener: SubscriptionListener<TResult>, ...options: readonly unknown[]): Promise<RpcSubscription<string>>;
+}
+interface SolanaEnhancedSubscriptionSchema {
+    readonly accountSubscribe: RpcMethodSpec<readonly [address: string, options?: Readonly<Record<string, unknown>>], number>;
+    readonly accountUnsubscribe: RpcMethodSpec<readonly [subscriptionId: number], boolean>;
+    readonly transactionSubscribe: RpcMethodSpec<readonly [
+        filter: Readonly<Record<string, unknown>>,
+        options?: Readonly<Record<string, unknown>>
+    ], number>;
+    readonly transactionUnsubscribe: RpcMethodSpec<readonly [subscriptionId: number], boolean>;
+}
+declare const SOLANA_ENHANCED_SUBSCRIPTION_METHODS: readonly ["accountSubscribe", "accountUnsubscribe", "transactionSubscribe", "transactionUnsubscribe"];
+declare class SolanaSubscriptions {
+    #private;
+    readonly rpc: RpcNamespace<SolanaEnhancedSubscriptionSchema>;
+    constructor(transport: WebSocketJsonRpcTransport);
+    close(): void;
+    onNotification(listener: RpcNotificationListener): () => void;
+    accountSubscribe<TResult = unknown>(address: string, listener: SubscriptionListener<TResult>, options?: Readonly<Record<string, unknown>>): Promise<RpcSubscription<number>>;
+    transactionSubscribe<TResult = unknown>(filter: Readonly<Record<string, unknown>>, listener: SubscriptionListener<TResult>, options?: Readonly<Record<string, unknown>>): Promise<RpcSubscription<number>>;
+    rawSubscribe<TResult = unknown>(subscribeMethod: string, params: readonly unknown[], unsubscribeMethod: string, listener: SubscriptionListener<TResult>): Promise<RpcSubscription>;
+}
+
+interface ErpcSolanaClient extends SolanaClient {
+    readonly subscriptions: SolanaSubscriptions;
+}
+interface ErpcEthereumClient extends EthereumClient {
+    readonly subscriptions: EthereumSubscriptions;
+}
+interface ErpcClient {
+    readonly account: AccountClient;
+    readonly ethereum: ErpcEthereumClient;
+    readonly price: PriceClient;
+    readonly solana: ErpcSolanaClient;
+    close(): void;
+}
+declare const createErpcClient: (config: ErpcClientConfig) => ErpcClient;
+
+type ErpcErrorCode = 'ERPC_ABORTED' | 'ERPC_BATCH_POLICY' | 'ERPC_CONFIG' | 'ERPC_HTTP' | 'ERPC_INVALID_RESPONSE' | 'ERPC_RPC' | 'ERPC_TIMEOUT' | 'ERPC_TRANSPORT';
+declare class ErpcError extends Error {
+    readonly code: ErpcErrorCode;
+    constructor(code: ErpcErrorCode, message: string, options?: ErrorOptions);
+}
+declare class ErpcConfigError extends ErpcError {
+    constructor(message: string);
+}
+declare class ErpcTransportError extends ErpcError {
+    constructor(message: string, options?: ErrorOptions);
+}
+declare class ErpcHttpError extends ErpcError {
+    readonly status: number;
+    constructor(status: number, message?: string);
+}
+declare class ErpcTimeoutError extends ErpcError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+declare class ErpcAbortedError extends ErpcError {
+    constructor();
+}
+declare class ErpcInvalidResponseError extends ErpcError {
+    constructor(message?: string);
+}
+declare class ErpcJsonRpcError extends ErpcError {
+    readonly rpcCode: number;
+    readonly data?: unknown;
+    constructor(error: JsonRpcErrorObject);
+}
+declare class ErpcBatchPolicyError extends ErpcError {
+    constructor(message: string);
+}
+
+export { AccountClient, type AddressTransaction, type AddressTransactionPage, type AddressTransactionsOptions, type AddressTransfer, type AddressTransferPage, type AddressTransfersOptions, type AnalyticsTimeBound, type AssetBatchRequest, type AssetListRequest, type AssetRequest, type BinaryUpdate, DEFAULT_ACCOUNT_ENDPOINT, DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS, ETHEREUM_RPC_METHODS, ETHEREUM_SUBSCRIPTION_METHODS, type EpochSummary, ErpcAbortedError, ErpcBatchPolicyError, type ErpcClient, type ErpcClientConfig, ErpcConfigError, ErpcError, type ErpcErrorCode, type ErpcEthereumClient, ErpcHttpError, ErpcInvalidResponseError, ErpcJsonRpcError, type ErpcPlan, type ErpcSolanaClient, ErpcTimeoutError, ErpcTransportError, type EthereumAddress, type EthereumBlockTag, type EthereumClient, type EthereumFilter, type EthereumObject, type EthereumRpcSchema, type EthereumSubscriptionSchema, EthereumSubscriptions, type EthereumTransactionRequest, type Hex, type IndexedAsset, type IndexedAssetList, type IndexedAssetProof, type JsonObject, type JsonPrimitive, type JsonRpcErrorObject, type JsonRpcFailure, type JsonRpcId, type JsonRpcParams, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccess, type JsonRpcTransport, type JsonValue, type LeaderSlot, type LeaderSlotsResult, type NumericFilter, type ParsedPriceUpdate, PendingRpcBatchRequest, PendingRpcRequest, type PingMeasurement, type PriceAssetType, PriceClient, type PriceEncoding, type PriceFeedMetadata, type PricePoint, type PriceStreamEvent, type PriceStreamOptions, type PriceUpdateOptions, type PriceUpdateResponse, type PriorityFeeEstimate, type ProgramStatsBucket, type ProgramStatsOptions, type PublisherStakeCap, type PublisherStakeCapsResponse, type RpcBatchCall, type RpcMethodSpec, type RpcNamespace, type RpcNamespaceBase, type RpcNotification, type RpcNotificationListener, type RpcParams, type RpcResult, type RpcSendOptions, RpcSubscription, SOLANA_ANALYTICS_METHODS, SOLANA_DAS_METHODS, SOLANA_ENHANCED_SUBSCRIPTION_METHODS, SOLANA_HISTORY_METHODS, SOLANA_LEADER_METHODS, SOLANA_RPC_METHODS, type SlotStatsOptions, type SlotStatsRow, type SolanaAnalyticsSchema, type SolanaClient, type SolanaCommitment, type SolanaConfig, type SolanaContext, type SolanaContextResult, type SolanaDasSchema, type SolanaEncoding, type SolanaEnhancedSubscriptionSchema, type SolanaHistorySchema, type SolanaLeaderSchema, type SolanaRpcSchema, SolanaSubscriptions, type SubscriptionId, type SubscriptionListener, type TokenBalance, type TopProgramRow, type TopProgramsOptions, type TpsBucket, type TpsTimeseriesOptions, type ValidatorInformation, type ValidatorsInformationOptions, type ValidatorsInformationResult, createErpcClient };