@sidhujag/sysweb3-keyring 2.1.13 → 2.1.15

package/types/providers.d.ts

@@ -1,23 +1,19 @@
 import { BigNumber, JsonRpcProvider, type Networkish } from './ethers-v6';
+import { type RpcReadOptions, type RpcReadRequest } from './rpc-read-client';
 import type { JsonRpcPayload } from 'ethers/providers';
-export declare class RpcResponseIntegrityError extends Error {
-    readonly retryable: boolean;
-    readonly code = "SYSWEB3_RPC_RESPONSE_INVALID";
-    constructor(message?: string, retryable?: boolean);
-}
+export { RpcResponseIntegrityError } from './rpc-transport';
 export declare const wrapTransactionReceipt: (receipt: any) => any;
 export declare const wrapTransactionResponse: (transaction: any) => any;
 declare class BaseProvider extends JsonRpcProvider {
-    private isPossibleGetChainId;
     private cooldownTime;
     private rateLimit;
     private requestCount;
     private lastRequestTime;
-    private currentChainId;
     private feeDataCache;
     private feeDataPromise;
     private readonly configuredChainId?;
     private chainIdVerificationPromise;
+    private readonly readClient;
     isInCooldown: boolean;
     errorMessage: any;
     serverHasAnError: boolean;
@@ -41,12 +37,14 @@ declare class BaseProvider extends JsonRpcProvider {
     private canMakeRequest;
     verifyConfiguredChainId(fresh?: boolean): Promise<void>;
     private fetchAndVerifyConfiguredChainId;
+    private readChainId;
     private cooldown;
-    private validateRpcResponses;
     private requestRpc;
+    readMany(inputs: readonly RpcReadRequest[], options?: RpcReadOptions): Promise<PromiseSettledResult<unknown>[]>;
     _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<any[]>;
     send: (method: string, params: any[]) => Promise<any>;
     sendBatch(method: string, params: Array<any[]>): Promise<any[]>;
+    destroy(): void;
     getGasPrice(): Promise<BigNumber>;
     getFeeData(): Promise<any>;
     private readFeeData;
@@ -64,4 +62,3 @@ export declare class CustomJsonRpcProvider extends BaseProvider {
         url: string;
     }, network?: Networkish);
 }
-export {};

package/types/rpc-read-client.d.ts

@@ -0,0 +1,45 @@
+import { type RpcReadRequest, type RpcResponse } from './rpc-transport';
+export type { RpcReadRequest } from './rpc-transport';
+export type RpcReadOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+};
+export type RpcReadClientOptions = {
+    fetch?: (url: string, init: RequestInit) => Promise<Response>;
+    requestInit?: Omit<RequestInit, 'method' | 'body' | 'signal'>;
+    recoverResponse?: boolean;
+    signal?: AbortSignal;
+    maxBatchItems?: number;
+    maxRequestBytes?: number;
+    maxResponseBytes?: number;
+    maxConcurrency?: number;
+    timeoutMs?: number;
+};
+export declare class RpcReadError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(value: NonNullable<RpcResponse['error']>);
+}
+/** Bounded, read-only JSON-RPC transport. Each instance belongs to one endpoint generation. */
+export declare class JsonRpcReadClient {
+    private readonly fetcher;
+    private readonly endpoint;
+    private readonly options;
+    private readonly lifetime;
+    private readonly queue;
+    private active;
+    private batchLimit;
+    private chainGeneration;
+    private chainCache?;
+    private chainRequest?;
+    constructor(url: string, options?: RpcReadClientOptions);
+    get url(): string;
+    destroy(): void;
+    private slot;
+    readMany(inputs: readonly RpcReadRequest[], options?: RpcReadOptions): Promise<PromiseSettledResult<unknown>[]>;
+    read(method: string, params: readonly unknown[], options?: RpcReadOptions): Promise<unknown>;
+    getChainId(options?: RpcReadOptions & {
+        fresh?: boolean;
+    }): Promise<string>;
+}

package/types/rpc-transport.d.ts

@@ -0,0 +1,27 @@
+export type RpcReadRequest = Readonly<{
+    method: string;
+    params: readonly unknown[];
+}>;
+export type RpcTransportRequest = Readonly<{
+    method: string;
+    params: readonly unknown[] | Record<string, unknown>;
+}>;
+export type RpcResponse = {
+    jsonrpc: '2.0';
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export type RpcJsonTransport = (url: string, body: string, signal: AbortSignal) => Promise<unknown>;
+export declare class RpcResponseIntegrityError extends Error {
+    readonly retryable: boolean;
+    readonly code = "SYSWEB3_RPC_RESPONSE_INVALID";
+    constructor(message?: string, retryable?: boolean);
+}
+export declare const isReadOnlyRpcMethod: (method: string) => boolean;
+/** Correlate exact wire responses and recover one stale read response. */
+export declare function requestJsonRpc(url: string, inputs: readonly RpcTransportRequest[], batch: boolean, signal: AbortSignal, transport: RpcJsonTransport, recoverResponse?: boolean): Promise<RpcResponse[]>;