@psalomo/jsonrpc-client 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -1,211 +1,43 @@
-// 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";
-  }
-};
+import {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  NearRpcClient,
+  NearRpcError,
+  block,
+  blockEffects,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  defaultClient,
+  experimentalChanges,
+  experimentalChangesInBlock,
+  experimentalCongestionLevel,
+  experimentalGenesisConfig,
+  experimentalLightClientBlockProof,
+  experimentalLightClientProof,
+  experimentalMaintenanceWindows,
+  experimentalProtocolConfig,
+  experimentalReceipt,
+  experimentalSplitStorageInfo,
+  experimentalTxStatus,
+  experimentalValidatorsOrdered,
+  gasPrice,
+  genesisConfig,
+  health,
+  lightClientProof,
+  maintenanceWindows,
+  networkInfo,
+  nextLightClientBlock,
+  parseCallResultToJson,
+  query,
+  sendTx,
+  status,
+  tx,
+  validators,
+  viewFunctionAsJson
+} from "./chunk-GCIU6ZLN.mjs";
 
 // src/index.ts
 import {
@@ -214,102 +46,53 @@ import {
 } from "@psalomo/jsonrpc-types";
 import { RPC_METHODS } from "@psalomo/jsonrpc-types";
 
-// 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
+// src/validated/index.ts
+import {
+  CryptoHashSchema,
+  GenesisConfigRequestSchema,
+  GenesisConfigSchema,
+  RpcBlockRequestSchema,
+  RpcBlockResponseSchema,
+  RpcChunkRequestSchema,
+  RpcChunkResponseSchema,
+  RpcClientConfigRequestSchema,
+  RpcClientConfigResponseSchema,
+  RpcCongestionLevelRequestSchema,
+  RpcCongestionLevelResponseSchema,
+  RpcGasPriceRequestSchema,
+  RpcGasPriceResponseSchema,
+  RpcHealthRequestSchema,
+  RpcHealthResponseSchema,
+  RpcLightClientBlockProofRequestSchema,
+  RpcLightClientBlockProofResponseSchema,
+  RpcLightClientExecutionProofRequestSchema,
+  RpcLightClientExecutionProofResponseSchema,
+  RpcLightClientNextBlockRequestSchema,
+  RpcLightClientNextBlockResponseSchema,
+  RpcMaintenanceWindowsRequestSchema,
+  RpcNetworkInfoRequestSchema,
+  RpcNetworkInfoResponseSchema,
+  RpcProtocolConfigRequestSchema,
+  RpcProtocolConfigResponseSchema,
+  RpcQueryRequestSchema,
+  RpcQueryResponseSchema,
+  RpcReceiptRequestSchema,
+  RpcReceiptResponseSchema,
+  RpcSendTransactionRequestSchema,
+  RpcSplitStorageInfoRequestSchema,
+  RpcSplitStorageInfoResponseSchema,
+  RpcStateChangesInBlockByTypeRequestSchema,
+  RpcStateChangesInBlockByTypeResponseSchema,
+  RpcStateChangesInBlockRequestSchema,
+  RpcStateChangesInBlockResponseSchema,
+  RpcStatusRequestSchema,
+  RpcStatusResponseSchema,
+  RpcTransactionResponseSchema,
+  RpcTransactionStatusRequestSchema,
+  RpcValidatorRequestSchema,
+  RpcValidatorResponseSchema,
+  RpcValidatorsOrderedRequestSchema
+} from "@psalomo/jsonrpc-types";
 async function viewAccount(client, params) {
   const queryParams = params.blockId ? {
     requestType: "view_account",
@@ -320,7 +103,7 @@ async function viewAccount(client, params) {
     accountId: params.accountId,
     finality: params.finality || "final"
   };
-  return query(client, queryParams);
+  return query2(client, queryParams);
 }
 async function viewFunction(client, params) {
   const baseParams = {
@@ -328,10 +111,9 @@ async function viewFunction(client, params) {
     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);
+  return query2(client, queryParams);
 }
 async function viewAccessKey(client, params) {
   const queryParams = params.blockId ? {
@@ -345,7 +127,556 @@ async function viewAccessKey(client, params) {
     publicKey: params.publicKey,
     finality: params.finality || "final"
   };
-  return query(client, queryParams);
+  return query2(client, queryParams);
+}
+async function experimentalChanges2(client, params) {
+  const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalChanges(client, params);
+  const responseSchema = RpcStateChangesInBlockResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalChangesInBlock2(client, params) {
+  const requestSchema = RpcStateChangesInBlockRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalChangesInBlock(client, params);
+  const responseSchema = RpcStateChangesInBlockByTypeResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalCongestionLevel2(client, params) {
+  const requestSchema = RpcCongestionLevelRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalCongestionLevel(
+    client,
+    params
+  );
+  const responseSchema = RpcCongestionLevelResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalGenesisConfig2(client, params) {
+  const requestSchema = GenesisConfigRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalGenesisConfig(client, params);
+  const responseSchema = GenesisConfigSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalLightClientBlockProof2(client, params) {
+  const requestSchema = RpcLightClientBlockProofRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalLightClientBlockProof(
+    client,
+    params
+  );
+  const responseSchema = RpcLightClientBlockProofResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalLightClientProof2(client, params) {
+  const requestSchema = RpcLightClientExecutionProofRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalLightClientProof(
+    client,
+    params
+  );
+  const responseSchema = RpcLightClientExecutionProofResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalMaintenanceWindows2(client, params) {
+  const requestSchema = RpcMaintenanceWindowsRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  return experimentalMaintenanceWindows(client, params);
+}
+async function experimentalProtocolConfig2(client, params) {
+  const requestSchema = RpcProtocolConfigRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalProtocolConfig(client, params);
+  const responseSchema = RpcProtocolConfigResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalReceipt2(client, params) {
+  const requestSchema = RpcReceiptRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalReceipt(client, params);
+  const responseSchema = RpcReceiptResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalSplitStorageInfo2(client, params) {
+  const requestSchema = RpcSplitStorageInfoRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalSplitStorageInfo(
+    client,
+    params
+  );
+  const responseSchema = RpcSplitStorageInfoResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalTxStatus2(client, params) {
+  const requestSchema = RpcTransactionStatusRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await experimentalTxStatus(client, params);
+  const responseSchema = RpcTransactionResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalValidatorsOrdered2(client, params) {
+  const requestSchema = RpcValidatorsOrderedRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  return experimentalValidatorsOrdered(client, params);
+}
+async function block2(client, params) {
+  const requestSchema = RpcBlockRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await block(client, params);
+  const responseSchema = RpcBlockResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function blockEffects2(client, params) {
+  const requestSchema = RpcStateChangesInBlockRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await blockEffects(client, params);
+  const responseSchema = RpcStateChangesInBlockByTypeResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function broadcastTxAsync2(client, params) {
+  const requestSchema = RpcSendTransactionRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await broadcastTxAsync(client, params);
+  const responseSchema = CryptoHashSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function broadcastTxCommit2(client, params) {
+  const requestSchema = RpcSendTransactionRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await broadcastTxCommit(client, params);
+  const responseSchema = RpcTransactionResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function changes2(client, params) {
+  const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await changes(client, params);
+  const responseSchema = RpcStateChangesInBlockResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function chunk2(client, params) {
+  const requestSchema = RpcChunkRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await chunk(client, params);
+  const responseSchema = RpcChunkResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function clientConfig2(client, params) {
+  const requestSchema = RpcClientConfigRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await clientConfig(client, params);
+  const responseSchema = RpcClientConfigResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function gasPrice2(client, params) {
+  const requestSchema = RpcGasPriceRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await gasPrice(client, params);
+  const responseSchema = RpcGasPriceResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function genesisConfig2(client, params) {
+  const requestSchema = GenesisConfigRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await genesisConfig(client, params);
+  const responseSchema = GenesisConfigSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function health2(client, params) {
+  const requestSchema = RpcHealthRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await health(client, params);
+  const responseSchema = RpcHealthResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function lightClientProof2(client, params) {
+  const requestSchema = RpcLightClientExecutionProofRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await lightClientProof(client, params);
+  const responseSchema = RpcLightClientExecutionProofResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function maintenanceWindows2(client, params) {
+  const requestSchema = RpcMaintenanceWindowsRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  return maintenanceWindows(client, params);
+}
+async function networkInfo2(client, params) {
+  const requestSchema = RpcNetworkInfoRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await networkInfo(client, params);
+  const responseSchema = RpcNetworkInfoResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function nextLightClientBlock2(client, params) {
+  const requestSchema = RpcLightClientNextBlockRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await nextLightClientBlock(client, params);
+  const responseSchema = RpcLightClientNextBlockResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function query2(client, params) {
+  const requestSchema = RpcQueryRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await query(client, params);
+  const responseSchema = RpcQueryResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function sendTx2(client, params) {
+  const requestSchema = RpcSendTransactionRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await sendTx(client, params);
+  const responseSchema = RpcTransactionResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function status2(client, params) {
+  const requestSchema = RpcStatusRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await status(client, params);
+  const responseSchema = RpcStatusResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function tx2(client, params) {
+  const requestSchema = RpcTransactionStatusRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await tx(client, params);
+  const responseSchema = RpcTransactionResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function validators2(client, params) {
+  const requestSchema = RpcValidatorRequestSchema();
+  if (params !== void 0) {
+    try {
+      requestSchema.parse(params);
+    } catch (error) {
+      throw new Error(`Request validation failed: ${error}`);
+    }
+  }
+  const result = await validators(client, params);
+  const responseSchema = RpcValidatorResponseSchema();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
 }
 
 // src/validation.ts
@@ -427,41 +758,43 @@ export {
   NearRpcClient,
   NearRpcError,
   RPC_METHODS,
-  block,
-  blockEffects,
-  broadcastTxAsync,
-  broadcastTxCommit,
-  changes,
-  chunk,
-  clientConfig,
+  block2 as block,
+  blockEffects2 as blockEffects,
+  broadcastTxAsync2 as broadcastTxAsync,
+  broadcastTxCommit2 as broadcastTxCommit,
+  changes2 as changes,
+  chunk2 as chunk,
+  clientConfig2 as clientConfig,
   NearRpcClient as default,
   defaultClient,
   enableValidation,
-  experimentalChanges,
-  experimentalChangesInBlock,
-  experimentalCongestionLevel,
-  experimentalGenesisConfig,
-  experimentalLightClientBlockProof,
-  experimentalLightClientProof,
-  experimentalMaintenanceWindows,
-  experimentalProtocolConfig,
-  experimentalReceipt,
-  experimentalSplitStorageInfo,
-  experimentalTxStatus,
-  experimentalValidatorsOrdered,
-  gasPrice,
-  genesisConfig,
-  health,
-  lightClientProof,
-  maintenanceWindows,
-  networkInfo,
-  nextLightClientBlock,
-  query,
-  sendTx,
-  status,
-  tx,
-  validators,
+  experimentalChanges2 as experimentalChanges,
+  experimentalChangesInBlock2 as experimentalChangesInBlock,
+  experimentalCongestionLevel2 as experimentalCongestionLevel,
+  experimentalGenesisConfig2 as experimentalGenesisConfig,
+  experimentalLightClientBlockProof2 as experimentalLightClientBlockProof,
+  experimentalLightClientProof2 as experimentalLightClientProof,
+  experimentalMaintenanceWindows2 as experimentalMaintenanceWindows,
+  experimentalProtocolConfig2 as experimentalProtocolConfig,
+  experimentalReceipt2 as experimentalReceipt,
+  experimentalSplitStorageInfo2 as experimentalSplitStorageInfo,
+  experimentalTxStatus2 as experimentalTxStatus,
+  experimentalValidatorsOrdered2 as experimentalValidatorsOrdered,
+  gasPrice2 as gasPrice,
+  genesisConfig2 as genesisConfig,
+  health2 as health,
+  lightClientProof2 as lightClientProof,
+  maintenanceWindows2 as maintenanceWindows,
+  networkInfo2 as networkInfo,
+  nextLightClientBlock2 as nextLightClientBlock,
+  parseCallResultToJson,
+  query2 as query,
+  sendTx2 as sendTx,
+  status2 as status,
+  tx2 as tx,
+  validators2 as validators,
   viewAccessKey,
   viewAccount,
-  viewFunction
+  viewFunction,
+  viewFunctionAsJson
 };