@psalomo/jsonrpc-client 1.0.3 → 1.2.0

package/dist/chunk-GCIU6ZLN.mjs

@@ -0,0 +1,395 @@
+// src/client.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToSnakeCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake(key);
+    converted[snakeKey] = convertKeysToSnakeCase(value);
+  }
+  return converted;
+}
+function convertKeysToCamelCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToCamelCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel(key);
+    converted[camelKey] = convertKeysToCamelCase(value);
+  }
+  return converted;
+}
+var REQUEST_ID = "dontcare";
+var JsonRpcClientError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "JsonRpcClientError";
+  }
+};
+var JsonRpcNetworkError = class extends Error {
+  constructor(message, originalError, responseBody) {
+    super(message);
+    this.originalError = originalError;
+    this.responseBody = responseBody;
+    this.name = "JsonRpcNetworkError";
+  }
+};
+var NearRpcClient = class _NearRpcClient {
+  endpoint;
+  headers;
+  timeout;
+  retries;
+  validation;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.endpoint = config;
+      this.headers = {};
+      this.timeout = 3e4;
+      this.retries = 3;
+    } else {
+      this.endpoint = config.endpoint;
+      this.headers = config.headers || {};
+      this.timeout = config.timeout || 3e4;
+      this.retries = config.retries || 3;
+      if (config.validation) {
+        this.validation = config.validation;
+      }
+    }
+  }
+  /**
+   * Make a raw JSON-RPC request
+   * This is used internally by the standalone RPC functions
+   */
+  async makeRequest(method, params) {
+    const requestForValidation = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: params !== void 0 ? params : null
+    };
+    if (this.validation) {
+      if ("validateMethodRequest" in this.validation) {
+        this.validation.validateMethodRequest(method, requestForValidation);
+      } else {
+        this.validation.validateRequest(requestForValidation);
+      }
+    }
+    const snakeCaseParams = params !== void 0 ? convertKeysToSnakeCase(params) : null;
+    const request = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: snakeCaseParams
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
+          body: JSON.stringify(request),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        let jsonResponse;
+        try {
+          jsonResponse = await response.json();
+        } catch (parseError) {
+          if (!response.ok) {
+            throw new JsonRpcNetworkError(
+              `HTTP error! status: ${response.status} - Failed to parse JSON response`,
+              parseError
+            );
+          }
+          throw new JsonRpcNetworkError(
+            "Failed to parse JSON response",
+            parseError
+          );
+        }
+        if (jsonResponse.error) {
+          throw new JsonRpcClientError(
+            jsonResponse.error.message,
+            jsonResponse.error.code,
+            jsonResponse.error.data
+          );
+        }
+        if (!response.ok) {
+          throw new JsonRpcNetworkError(
+            `HTTP error! status: ${response.status}`,
+            void 0,
+            jsonResponse
+          );
+        }
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
+        }
+        const camelCaseResult = jsonResponse.result ? convertKeysToCamelCase(jsonResponse.result) : jsonResponse.result;
+        if (camelCaseResult && typeof camelCaseResult === "object" && "error" in camelCaseResult) {
+          const errorMessage = camelCaseResult.error;
+          throw new JsonRpcClientError(
+            `RPC Error: ${errorMessage}`,
+            -32e3,
+            // Generic RPC error code
+            camelCaseResult
+          );
+        }
+        if (this.validation && "validateMethodResponse" in this.validation) {
+          const camelCaseResponse = {
+            ...jsonResponse,
+            result: camelCaseResult
+          };
+          this.validation.validateMethodResponse(method, camelCaseResponse);
+        }
+        return camelCaseResult;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof JsonRpcClientError) {
+          throw error;
+        }
+        if (attempt === this.retries) {
+          break;
+        }
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+        );
+      }
+    }
+    throw new JsonRpcNetworkError(
+      lastError?.message || "Request failed after all retries",
+      lastError || void 0
+    );
+  }
+  /**
+   * Create a new client with modified configuration
+   */
+  withConfig(config) {
+    return new _NearRpcClient({
+      endpoint: config.endpoint ?? this.endpoint,
+      headers: config.headers ?? this.headers,
+      timeout: config.timeout ?? this.timeout,
+      retries: config.retries ?? this.retries,
+      ...config.validation !== void 0 ? { validation: config.validation } : this.validation !== void 0 ? { validation: this.validation } : {}
+    });
+  }
+};
+var defaultClient = new NearRpcClient({
+  endpoint: "https://rpc.mainnet.near.org"
+});
+
+// src/types.ts
+var NearRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "NearRpcError";
+  }
+};
+
+// src/generated-types.ts
+async function experimentalChanges(client, params) {
+  return client.makeRequest("EXPERIMENTAL_changes", params);
+}
+async function experimentalChangesInBlock(client, params) {
+  return client.makeRequest("EXPERIMENTAL_changes_in_block", params);
+}
+async function experimentalCongestionLevel(client, params) {
+  return client.makeRequest("EXPERIMENTAL_congestion_level", params);
+}
+async function experimentalGenesisConfig(client, params) {
+  return client.makeRequest("EXPERIMENTAL_genesis_config", params);
+}
+async function experimentalLightClientBlockProof(client, params) {
+  return client.makeRequest("EXPERIMENTAL_light_client_block_proof", params);
+}
+async function experimentalLightClientProof(client, params) {
+  return client.makeRequest("EXPERIMENTAL_light_client_proof", params);
+}
+async function experimentalMaintenanceWindows(client, params) {
+  return client.makeRequest("EXPERIMENTAL_maintenance_windows", params);
+}
+async function experimentalProtocolConfig(client, params) {
+  return client.makeRequest("EXPERIMENTAL_protocol_config", params);
+}
+async function experimentalReceipt(client, params) {
+  return client.makeRequest("EXPERIMENTAL_receipt", params);
+}
+async function experimentalSplitStorageInfo(client, params) {
+  return client.makeRequest("EXPERIMENTAL_split_storage_info", params);
+}
+async function experimentalTxStatus(client, params) {
+  return client.makeRequest("EXPERIMENTAL_tx_status", params);
+}
+async function experimentalValidatorsOrdered(client, params) {
+  return client.makeRequest("EXPERIMENTAL_validators_ordered", params);
+}
+async function block(client, params) {
+  return client.makeRequest("block", params);
+}
+async function blockEffects(client, params) {
+  return client.makeRequest("block_effects", params);
+}
+async function broadcastTxAsync(client, params) {
+  return client.makeRequest("broadcast_tx_async", params);
+}
+async function broadcastTxCommit(client, params) {
+  return client.makeRequest("broadcast_tx_commit", params);
+}
+async function changes(client, params) {
+  return client.makeRequest("changes", params);
+}
+async function chunk(client, params) {
+  return client.makeRequest("chunk", params);
+}
+async function clientConfig(client, params) {
+  return client.makeRequest("client_config", params);
+}
+async function gasPrice(client, params) {
+  return client.makeRequest("gas_price", params);
+}
+async function genesisConfig(client, params) {
+  return client.makeRequest("genesis_config", params);
+}
+async function health(client, params) {
+  return client.makeRequest("health", params);
+}
+async function lightClientProof(client, params) {
+  return client.makeRequest("light_client_proof", params);
+}
+async function maintenanceWindows(client, params) {
+  return client.makeRequest("maintenance_windows", params);
+}
+async function networkInfo(client, params) {
+  return client.makeRequest("network_info", params);
+}
+async function nextLightClientBlock(client, params) {
+  return client.makeRequest("next_light_client_block", params);
+}
+async function query(client, params) {
+  return client.makeRequest("query", params);
+}
+async function sendTx(client, params) {
+  return client.makeRequest("send_tx", params);
+}
+async function status(client, params) {
+  return client.makeRequest("status", params);
+}
+async function tx(client, params) {
+  return client.makeRequest("tx", params);
+}
+async function validators(client, params) {
+  return client.makeRequest("validators", params);
+}
+
+// src/convenience.ts
+async function viewAccount(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_account",
+    accountId: params.accountId,
+    blockId: params.blockId
+  } : {
+    requestType: "view_account",
+    accountId: params.accountId,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+async function viewFunction(client, params) {
+  const baseParams = {
+    requestType: "call_function",
+    accountId: params.accountId,
+    methodName: params.methodName,
+    argsBase64: params.argsBase64 ?? ""
+    // Default to empty string if no arguments
+  };
+  const queryParams = params.blockId ? { ...baseParams, blockId: params.blockId } : { ...baseParams, finality: params.finality || "final" };
+  return query(client, queryParams);
+}
+async function viewAccessKey(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    blockId: params.blockId
+  } : {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+function parseCallResultToJson(callResult) {
+  const bytes = new Uint8Array(callResult.result);
+  const text = new TextDecoder().decode(bytes);
+  return JSON.parse(text);
+}
+async function viewFunctionAsJson(client, params) {
+  const result = await viewFunction(client, params);
+  return parseCallResultToJson(result);
+}
+
+export {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  NearRpcClient,
+  defaultClient,
+  NearRpcError,
+  experimentalChanges,
+  experimentalChangesInBlock,
+  experimentalCongestionLevel,
+  experimentalGenesisConfig,
+  experimentalLightClientBlockProof,
+  experimentalLightClientProof,
+  experimentalMaintenanceWindows,
+  experimentalProtocolConfig,
+  experimentalReceipt,
+  experimentalSplitStorageInfo,
+  experimentalTxStatus,
+  experimentalValidatorsOrdered,
+  block,
+  blockEffects,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  gasPrice,
+  genesisConfig,
+  health,
+  lightClientProof,
+  maintenanceWindows,
+  networkInfo,
+  nextLightClientBlock,
+  query,
+  sendTx,
+  status,
+  tx,
+  validators,
+  viewAccount,
+  viewFunction,
+  viewAccessKey,
+  parseCallResultToJson,
+  viewFunctionAsJson
+};

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAiDxD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAGD,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,CAAC,CAAC;CACZ;AAGD,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAGD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAGD,qBAAa,kBAAmB,SAAQ,KAAK;IAGlC,IAAI,CAAC,EAAE,MAAM;IACb,IAAI,CAAC,EAAE,OAAO;gBAFrB,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,IAAI,CAAC,EAAE,OAAO,YAAA;CAKxB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAGnC,aAAa,CAAC,EAAE,KAAK;IACrB,YAAY,CAAC,EAAE,OAAO;gBAF7B,OAAO,EAAE,MAAM,EACR,aAAa,CAAC,EAAE,KAAK,YAAA,EACrB,YAAY,CAAC,EAAE,OAAO,YAAA;CAKhC;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;gBAE9C,MAAM,EAAE,MAAM,GAAG,YAAY;IAiBzC;;;OAGG;IACG,WAAW,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACpD,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC;IAmInB;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,aAAa;CAazD;AAGD,eAAO,MAAM,aAAa,eAExB,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAiDxD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAGD,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,CAAC,CAAC;CACZ;AAGD,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAGD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAGD,qBAAa,kBAAmB,SAAQ,KAAK;IAGlC,IAAI,CAAC,EAAE,MAAM;IACb,IAAI,CAAC,EAAE,OAAO;gBAFrB,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,IAAI,CAAC,EAAE,OAAO,YAAA;CAKxB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAGnC,aAAa,CAAC,EAAE,KAAK;IACrB,YAAY,CAAC,EAAE,OAAO;gBAF7B,OAAO,EAAE,MAAM,EACR,aAAa,CAAC,EAAE,KAAK,YAAA,EACrB,YAAY,CAAC,EAAE,OAAO,YAAA;CAKhC;AAED;;;;GAIG;AACH,qBAAa,aAAa;IACxB,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;gBAE9C,MAAM,EAAE,MAAM,GAAG,YAAY;IAiBzC;;;OAGG;IACG,WAAW,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACpD,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC;IAkJnB;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,aAAa;CAazD;AAGD,eAAO,MAAM,aAAa,eAExB,CAAC"}

package/dist/convenience-DFvZCHOk.d.mts

@@ -0,0 +1,212 @@
+import { RpcStateChangesInBlockByTypeRequest, RpcStateChangesInBlockResponse, RpcStateChangesInBlockRequest, RpcStateChangesInBlockByTypeResponse, RpcCongestionLevelRequest, RpcCongestionLevelResponse, GenesisConfigRequest, GenesisConfig, RpcLightClientBlockProofRequest, RpcLightClientBlockProofResponse, RpcLightClientExecutionProofRequest, RpcLightClientExecutionProofResponse, RpcMaintenanceWindowsRequest, EXPERIMENTALMaintenanceWindowsResponse, RpcProtocolConfigRequest, RpcProtocolConfigResponse, RpcReceiptRequest, RpcReceiptResponse, RpcSplitStorageInfoRequest, RpcSplitStorageInfoResponse, RpcTransactionStatusRequest, RpcTransactionResponse, RpcValidatorsOrderedRequest, EXPERIMENTALValidatorsOrderedResponse, RpcBlockRequest, RpcBlockResponse, RpcSendTransactionRequest, CryptoHash, RpcChunkRequest, RpcChunkResponse, RpcClientConfigRequest, RpcClientConfigResponse, RpcGasPriceRequest, RpcGasPriceResponse, RpcHealthRequest, RpcHealthResponse, MaintenanceWindowsResponse, RpcNetworkInfoRequest, RpcNetworkInfoResponse, RpcLightClientNextBlockRequest, RpcLightClientNextBlockResponse, RpcQueryRequest, RpcQueryResponse, RpcStatusRequest, RpcStatusResponse, RpcValidatorRequest, RpcValidatorResponse, AccountView, CallResult, AccessKeyView } from '@psalomo/jsonrpc-types';
+
+interface ValidationResult {
+    validateRequest: (request: JsonRpcRequest) => void;
+    validateResponse: (response: JsonRpcResponse) => void;
+    validateMethodRequest?: (method: string, request: JsonRpcRequest) => void;
+    validateMethodResponse?: (method: string, response: JsonRpcResponse) => void;
+}
+/**
+ * Enable validation for the client
+ * This function should only be called if you want to include schema validation
+ * Calling this function will include Zod schemas in your bundle
+ */
+declare function enableValidation(): ValidationResult;
+
+interface ClientConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retries?: number;
+    validation?: ValidationResult;
+}
+interface JsonRpcRequest<T = unknown> {
+    jsonrpc: '2.0';
+    id: string;
+    method: string;
+    params?: T;
+}
+interface JsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string;
+    result?: T;
+    error?: JsonRpcError;
+}
+interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+declare class JsonRpcClientError extends Error {
+    code?: number | undefined;
+    data?: unknown | undefined;
+    constructor(message: string, code?: number | undefined, data?: unknown | undefined);
+}
+declare class JsonRpcNetworkError extends Error {
+    originalError?: Error | undefined;
+    responseBody?: unknown | undefined;
+    constructor(message: string, originalError?: Error | undefined, responseBody?: unknown | undefined);
+}
+/**
+ * NEAR RPC Client with static function architecture
+ * This client only holds configuration and provides a makeRequest method
+ * Individual RPC methods are provided as standalone functions that take this client as a parameter
+ */
+declare class NearRpcClient {
+    readonly endpoint: string;
+    readonly headers: Record<string, string>;
+    readonly timeout: number;
+    readonly retries: number;
+    private readonly validation;
+    constructor(config: string | ClientConfig);
+    /**
+     * Make a raw JSON-RPC request
+     * This is used internally by the standalone RPC functions
+     */
+    makeRequest<TParams = unknown, TResult = unknown>(method: string, params?: TParams): Promise<TResult>;
+    /**
+     * Create a new client with modified configuration
+     */
+    withConfig(config: Partial<ClientConfig>): NearRpcClient;
+}
+declare const defaultClient: NearRpcClient;
+
+interface RpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params: unknown;
+}
+interface RpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: T;
+    error?: RpcError;
+}
+interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+declare class NearRpcError extends Error {
+    code: number;
+    data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+
+interface DynamicRpcMethods {
+    experimentalChanges(params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+    experimentalChangesInBlock(params?: RpcStateChangesInBlockRequest): Promise<RpcStateChangesInBlockByTypeResponse>;
+    experimentalCongestionLevel(params?: RpcCongestionLevelRequest): Promise<RpcCongestionLevelResponse>;
+    experimentalGenesisConfig(params?: GenesisConfigRequest): Promise<GenesisConfig>;
+    experimentalLightClientBlockProof(params?: RpcLightClientBlockProofRequest): Promise<RpcLightClientBlockProofResponse>;
+    experimentalLightClientProof(params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+    experimentalMaintenanceWindows(params?: RpcMaintenanceWindowsRequest): Promise<EXPERIMENTALMaintenanceWindowsResponse>;
+    experimentalProtocolConfig(params?: RpcProtocolConfigRequest): Promise<RpcProtocolConfigResponse>;
+    experimentalReceipt(params?: RpcReceiptRequest): Promise<RpcReceiptResponse>;
+    experimentalSplitStorageInfo(params?: RpcSplitStorageInfoRequest): Promise<RpcSplitStorageInfoResponse>;
+    experimentalTxStatus(params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+    experimentalValidatorsOrdered(params?: RpcValidatorsOrderedRequest): Promise<EXPERIMENTALValidatorsOrderedResponse>;
+    block(params?: RpcBlockRequest): Promise<RpcBlockResponse>;
+    blockEffects(params?: RpcStateChangesInBlockRequest): Promise<RpcStateChangesInBlockByTypeResponse>;
+    broadcastTxAsync(params?: RpcSendTransactionRequest): Promise<CryptoHash>;
+    broadcastTxCommit(params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+    changes(params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+    chunk(params?: RpcChunkRequest): Promise<RpcChunkResponse>;
+    clientConfig(params?: RpcClientConfigRequest): Promise<RpcClientConfigResponse>;
+    gasPrice(params?: RpcGasPriceRequest): Promise<RpcGasPriceResponse>;
+    genesisConfig(params?: GenesisConfigRequest): Promise<GenesisConfig>;
+    health(params?: RpcHealthRequest): Promise<RpcHealthResponse>;
+    lightClientProof(params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+    maintenanceWindows(params?: RpcMaintenanceWindowsRequest): Promise<MaintenanceWindowsResponse>;
+    networkInfo(params?: RpcNetworkInfoRequest): Promise<RpcNetworkInfoResponse>;
+    nextLightClientBlock(params?: RpcLightClientNextBlockRequest): Promise<RpcLightClientNextBlockResponse>;
+    query(params?: RpcQueryRequest): Promise<RpcQueryResponse>;
+    sendTx(params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+    status(params?: RpcStatusRequest): Promise<RpcStatusResponse>;
+    tx(params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+    validators(params?: RpcValidatorRequest): Promise<RpcValidatorResponse>;
+}
+interface ConvenienceMethods {
+    viewAccount(params: {
+        accountId: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<AccountView>;
+    viewFunction(params: {
+        accountId: string;
+        methodName: string;
+        argsBase64?: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<CallResult>;
+    viewAccessKey(params: {
+        accountId: string;
+        publicKey: string;
+        finality?: 'final' | 'near-final' | 'optimistic';
+        blockId?: string | number;
+    }): Promise<AccessKeyView>;
+}
+interface CompleteClientInterface extends DynamicRpcMethods, ConvenienceMethods {
+    call<TParams = unknown, TResult = unknown>(method: string, params?: TParams): Promise<TResult>;
+}
+declare function experimentalChanges(client: NearRpcClient, params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+declare function experimentalChangesInBlock(client: NearRpcClient, params?: RpcStateChangesInBlockRequest): Promise<RpcStateChangesInBlockByTypeResponse>;
+declare function experimentalCongestionLevel(client: NearRpcClient, params?: RpcCongestionLevelRequest): Promise<RpcCongestionLevelResponse>;
+declare function experimentalGenesisConfig(client: NearRpcClient, params?: GenesisConfigRequest): Promise<GenesisConfig>;
+declare function experimentalLightClientBlockProof(client: NearRpcClient, params?: RpcLightClientBlockProofRequest): Promise<RpcLightClientBlockProofResponse>;
+declare function experimentalLightClientProof(client: NearRpcClient, params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+declare function experimentalMaintenanceWindows(client: NearRpcClient, params?: RpcMaintenanceWindowsRequest): Promise<EXPERIMENTALMaintenanceWindowsResponse>;
+declare function experimentalProtocolConfig(client: NearRpcClient, params?: RpcProtocolConfigRequest): Promise<RpcProtocolConfigResponse>;
+declare function experimentalReceipt(client: NearRpcClient, params?: RpcReceiptRequest): Promise<RpcReceiptResponse>;
+declare function experimentalSplitStorageInfo(client: NearRpcClient, params?: RpcSplitStorageInfoRequest): Promise<RpcSplitStorageInfoResponse>;
+declare function experimentalTxStatus(client: NearRpcClient, params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+declare function experimentalValidatorsOrdered(client: NearRpcClient, params?: RpcValidatorsOrderedRequest): Promise<EXPERIMENTALValidatorsOrderedResponse>;
+declare function block(client: NearRpcClient, params?: RpcBlockRequest): Promise<RpcBlockResponse>;
+declare function blockEffects(client: NearRpcClient, params?: RpcStateChangesInBlockRequest): Promise<RpcStateChangesInBlockByTypeResponse>;
+declare function broadcastTxAsync(client: NearRpcClient, params?: RpcSendTransactionRequest): Promise<CryptoHash>;
+declare function broadcastTxCommit(client: NearRpcClient, params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+declare function changes(client: NearRpcClient, params?: RpcStateChangesInBlockByTypeRequest): Promise<RpcStateChangesInBlockResponse>;
+declare function chunk(client: NearRpcClient, params?: RpcChunkRequest): Promise<RpcChunkResponse>;
+declare function clientConfig(client: NearRpcClient, params?: RpcClientConfigRequest): Promise<RpcClientConfigResponse>;
+declare function gasPrice(client: NearRpcClient, params?: RpcGasPriceRequest): Promise<RpcGasPriceResponse>;
+declare function genesisConfig(client: NearRpcClient, params?: GenesisConfigRequest): Promise<GenesisConfig>;
+declare function health(client: NearRpcClient, params?: RpcHealthRequest): Promise<RpcHealthResponse>;
+declare function lightClientProof(client: NearRpcClient, params?: RpcLightClientExecutionProofRequest): Promise<RpcLightClientExecutionProofResponse>;
+declare function maintenanceWindows(client: NearRpcClient, params?: RpcMaintenanceWindowsRequest): Promise<MaintenanceWindowsResponse>;
+declare function networkInfo(client: NearRpcClient, params?: RpcNetworkInfoRequest): Promise<RpcNetworkInfoResponse>;
+declare function nextLightClientBlock(client: NearRpcClient, params?: RpcLightClientNextBlockRequest): Promise<RpcLightClientNextBlockResponse>;
+declare function query(client: NearRpcClient, params?: RpcQueryRequest): Promise<RpcQueryResponse>;
+declare function sendTx(client: NearRpcClient, params?: RpcSendTransactionRequest): Promise<RpcTransactionResponse>;
+declare function status(client: NearRpcClient, params?: RpcStatusRequest): Promise<RpcStatusResponse>;
+declare function tx(client: NearRpcClient, params?: RpcTransactionStatusRequest): Promise<RpcTransactionResponse>;
+declare function validators(client: NearRpcClient, params?: RpcValidatorRequest): Promise<RpcValidatorResponse>;
+
+declare function viewAccount(client: NearRpcClient, params: {
+    accountId: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<AccountView>;
+declare function viewFunction(client: NearRpcClient, params: {
+    accountId: string;
+    methodName: string;
+    argsBase64?: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<CallResult>;
+declare function viewAccessKey(client: NearRpcClient, params: {
+    accountId: string;
+    publicKey: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<AccessKeyView>;
+declare function parseCallResultToJson<T = unknown>(callResult: CallResult): T;
+declare function viewFunctionAsJson<T = unknown>(client: NearRpcClient, params: {
+    accountId: string;
+    methodName: string;
+    argsBase64?: string;
+    finality?: 'final' | 'near-final' | 'optimistic';
+    blockId?: string | number;
+}): Promise<T>;
+
+export { blockEffects as A, broadcastTxAsync as B, type ConvenienceMethods as C, type DynamicRpcMethods as D, broadcastTxCommit as E, changes as F, chunk as G, clientConfig as H, gasPrice as I, type JsonRpcRequest as J, genesisConfig as K, health as L, lightClientProof as M, NearRpcClient as N, maintenanceWindows as O, networkInfo as P, nextLightClientBlock as Q, type RpcRequest as R, query as S, sendTx as T, status as U, tx as V, validators as W, viewAccount as X, viewFunction as Y, viewAccessKey as Z, type CompleteClientInterface as a, type ClientConfig as b, type JsonRpcResponse as c, defaultClient as d, enableValidation as e, type JsonRpcError as f, JsonRpcClientError as g, JsonRpcNetworkError as h, type RpcResponse as i, type RpcError as j, NearRpcError as k, experimentalChanges as l, experimentalChangesInBlock as m, experimentalCongestionLevel as n, experimentalGenesisConfig as o, parseCallResultToJson as p, experimentalLightClientBlockProof as q, experimentalLightClientProof as r, experimentalMaintenanceWindows as s, experimentalProtocolConfig as t, experimentalReceipt as u, viewFunctionAsJson as v, experimentalSplitStorageInfo as w, experimentalTxStatus as x, experimentalValidatorsOrdered as y, block as z };