@psalomo/jsonrpc-client 1.0.3 → 1.2.0

package/dist/index.js

@@ -22,48 +22,50 @@ var index_exports = {};
 __export(index_exports, {
   JsonRpcClientError: () => JsonRpcClientError,
   JsonRpcNetworkError: () => JsonRpcNetworkError,
-  JsonRpcRequestSchema: () => import_jsonrpc_types2.JsonRpcRequestSchema,
-  JsonRpcResponseSchema: () => import_jsonrpc_types2.JsonRpcResponseSchema,
+  JsonRpcRequestSchema: () => import_jsonrpc_types3.JsonRpcRequestSchema,
+  JsonRpcResponseSchema: () => import_jsonrpc_types3.JsonRpcResponseSchema,
   NearRpcClient: () => NearRpcClient,
   NearRpcError: () => NearRpcError,
-  RPC_METHODS: () => import_jsonrpc_types3.RPC_METHODS,
-  block: () => block,
-  blockEffects: () => blockEffects,
-  broadcastTxAsync: () => broadcastTxAsync,
-  broadcastTxCommit: () => broadcastTxCommit,
-  changes: () => changes,
-  chunk: () => chunk,
-  clientConfig: () => clientConfig,
+  RPC_METHODS: () => import_jsonrpc_types4.RPC_METHODS,
+  block: () => block2,
+  blockEffects: () => blockEffects2,
+  broadcastTxAsync: () => broadcastTxAsync2,
+  broadcastTxCommit: () => broadcastTxCommit2,
+  changes: () => changes2,
+  chunk: () => chunk2,
+  clientConfig: () => clientConfig2,
   default: () => NearRpcClient,
   defaultClient: () => defaultClient,
   enableValidation: () => enableValidation,
-  experimentalChanges: () => experimentalChanges,
-  experimentalChangesInBlock: () => experimentalChangesInBlock,
-  experimentalCongestionLevel: () => experimentalCongestionLevel,
-  experimentalGenesisConfig: () => experimentalGenesisConfig,
-  experimentalLightClientBlockProof: () => experimentalLightClientBlockProof,
-  experimentalLightClientProof: () => experimentalLightClientProof,
-  experimentalMaintenanceWindows: () => experimentalMaintenanceWindows,
-  experimentalProtocolConfig: () => experimentalProtocolConfig,
-  experimentalReceipt: () => experimentalReceipt,
-  experimentalSplitStorageInfo: () => experimentalSplitStorageInfo,
-  experimentalTxStatus: () => experimentalTxStatus,
-  experimentalValidatorsOrdered: () => experimentalValidatorsOrdered,
-  gasPrice: () => gasPrice,
-  genesisConfig: () => genesisConfig,
-  health: () => health,
-  lightClientProof: () => lightClientProof,
-  maintenanceWindows: () => maintenanceWindows,
-  networkInfo: () => networkInfo,
-  nextLightClientBlock: () => nextLightClientBlock,
-  query: () => query,
-  sendTx: () => sendTx,
-  status: () => status,
-  tx: () => tx,
-  validators: () => validators,
-  viewAccessKey: () => viewAccessKey,
-  viewAccount: () => viewAccount,
-  viewFunction: () => viewFunction
+  experimentalChanges: () => experimentalChanges2,
+  experimentalChangesInBlock: () => experimentalChangesInBlock2,
+  experimentalCongestionLevel: () => experimentalCongestionLevel2,
+  experimentalGenesisConfig: () => experimentalGenesisConfig2,
+  experimentalLightClientBlockProof: () => experimentalLightClientBlockProof2,
+  experimentalLightClientProof: () => experimentalLightClientProof2,
+  experimentalMaintenanceWindows: () => experimentalMaintenanceWindows2,
+  experimentalProtocolConfig: () => experimentalProtocolConfig2,
+  experimentalReceipt: () => experimentalReceipt2,
+  experimentalSplitStorageInfo: () => experimentalSplitStorageInfo2,
+  experimentalTxStatus: () => experimentalTxStatus2,
+  experimentalValidatorsOrdered: () => experimentalValidatorsOrdered2,
+  gasPrice: () => gasPrice2,
+  genesisConfig: () => genesisConfig2,
+  health: () => health2,
+  lightClientProof: () => lightClientProof2,
+  maintenanceWindows: () => maintenanceWindows2,
+  networkInfo: () => networkInfo2,
+  nextLightClientBlock: () => nextLightClientBlock2,
+  parseCallResultToJson: () => parseCallResultToJson,
+  query: () => query2,
+  sendTx: () => sendTx2,
+  status: () => status2,
+  tx: () => tx2,
+  validators: () => validators2,
+  viewAccessKey: () => viewAccessKey2,
+  viewAccount: () => viewAccount2,
+  viewFunction: () => viewFunction2,
+  viewFunctionAsJson: () => viewFunctionAsJson
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -214,6 +216,15 @@ var NearRpcClient = class _NearRpcClient {
           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,
@@ -268,8 +279,8 @@ var NearRpcError = class extends Error {
 };
 
 // src/index.ts
-var import_jsonrpc_types2 = require("@psalomo/jsonrpc-types");
 var import_jsonrpc_types3 = require("@psalomo/jsonrpc-types");
+var import_jsonrpc_types4 = require("@psalomo/jsonrpc-types");
 
 // src/generated-types.ts
 async function experimentalChanges(client, params) {
@@ -367,7 +378,30 @@ async function validators(client, params) {
 }
 
 // src/convenience.ts
-async function viewAccount(client, params) {
+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);
+}
+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);
+}
+
+// src/validated/index.ts
+var import_jsonrpc_types = require("@psalomo/jsonrpc-types");
+async function viewAccount2(client, params) {
   const queryParams = params.blockId ? {
     requestType: "view_account",
     accountId: params.accountId,
@@ -377,20 +411,19 @@ 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) {
+async function viewFunction2(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);
+  return query2(client, queryParams);
 }
-async function viewAccessKey(client, params) {
+async function viewAccessKey2(client, params) {
   const queryParams = params.blockId ? {
     requestType: "view_access_key",
     accountId: params.accountId,
@@ -402,14 +435,563 @@ 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 = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcStateChangesInBlockResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalChangesInBlock2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcStateChangesInBlockByTypeResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalCongestionLevel2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcCongestionLevelResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalGenesisConfig2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.GenesisConfigSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalLightClientBlockProof2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcLightClientBlockProofResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalLightClientProof2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcLightClientExecutionProofResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalMaintenanceWindows2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcProtocolConfigResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalReceipt2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcReceiptResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalSplitStorageInfo2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcSplitStorageInfoResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalTxStatus2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcTransactionResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function experimentalValidatorsOrdered2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcBlockResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function blockEffects2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcStateChangesInBlockByTypeResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function broadcastTxAsync2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.CryptoHashSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function broadcastTxCommit2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcTransactionResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function changes2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcStateChangesInBlockResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function chunk2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcChunkResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function clientConfig2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcClientConfigResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function gasPrice2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcGasPriceResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function genesisConfig2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.GenesisConfigSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function health2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcHealthResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function lightClientProof2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcLightClientExecutionProofResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function maintenanceWindows2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcNetworkInfoResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function nextLightClientBlock2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcLightClientNextBlockResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function query2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcQueryResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function sendTx2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcTransactionResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function status2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcStatusResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function tx2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcTransactionResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
+}
+async function validators2(client, params) {
+  const requestSchema = (0, import_jsonrpc_types.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 = (0, import_jsonrpc_types.RpcValidatorResponseSchema)();
+  try {
+    responseSchema.parse(result);
+  } catch (error) {
+    throw new Error(`Response validation failed: ${error}`);
+  }
+  return result;
 }
 
 // src/validation.ts
-var import_jsonrpc_types = require("@psalomo/jsonrpc-types");
+var import_jsonrpc_types2 = require("@psalomo/jsonrpc-types");
 function enableValidation() {
-  const requestSchema = (0, import_jsonrpc_types.JsonRpcRequestSchema)();
-  const responseSchema = (0, import_jsonrpc_types.JsonRpcResponseSchema)();
+  const requestSchema = (0, import_jsonrpc_types2.JsonRpcRequestSchema)();
+  const responseSchema = (0, import_jsonrpc_types2.JsonRpcResponseSchema)();
   return {
     validateRequest: (request) => {
       try {
@@ -433,7 +1015,7 @@ function enableValidation() {
     validateMethodRequest: (method, request) => {
       try {
         requestSchema.parse(request);
-        const methodSchemas = import_jsonrpc_types.VALIDATION_SCHEMA_MAP[method];
+        const methodSchemas = import_jsonrpc_types2.VALIDATION_SCHEMA_MAP[method];
         if (methodSchemas?.requestSchema) {
           const methodRequestSchema = methodSchemas.requestSchema();
           methodRequestSchema.parse(request);
@@ -448,12 +1030,23 @@ function enableValidation() {
     validateMethodResponse: (method, response) => {
       try {
         responseSchema.parse(response);
-        const methodSchemas = import_jsonrpc_types.VALIDATION_SCHEMA_MAP[method];
+        if (response.result && typeof response.result === "object" && "error" in response.result) {
+          const serverError = response.result.error;
+          throw new JsonRpcClientError(
+            `Server error: ${serverError}`,
+            -32e3,
+            response.result
+          );
+        }
+        const methodSchemas = import_jsonrpc_types2.VALIDATION_SCHEMA_MAP[method];
         if (methodSchemas?.responseSchema) {
           const methodResponseSchema = methodSchemas.responseSchema();
           methodResponseSchema.parse(response);
         }
       } catch (error) {
+        if (error instanceof JsonRpcClientError) {
+          throw error;
+        }
         throw new JsonRpcClientError(
           `Invalid ${method} response: ${error instanceof Error ? error.message : "Unknown error"}`
         );
@@ -498,6 +1091,7 @@ function enableValidation() {
   maintenanceWindows,
   networkInfo,
   nextLightClientBlock,
+  parseCallResultToJson,
   query,
   sendTx,
   status,
@@ -505,5 +1099,6 @@ function enableValidation() {
   validators,
   viewAccessKey,
   viewAccount,
-  viewFunction
+  viewFunction,
+  viewFunctionAsJson
 });