@psalomo/jsonrpc-client 1.0.3 → 1.2.0

package/dist/browser-standalone.js

@@ -156,6 +156,15 @@ class NearRpcClient {
                 const camelCaseResult = jsonResponse.result
                     ? convertKeysToCamelCase(jsonResponse.result)
                     : jsonResponse.result;
+                // Check if the result contains an error field (non-standard NEAR RPC error response)
+                // This happens when validation is disabled and certain RPC errors occur
+                if (camelCaseResult &&
+                    typeof camelCaseResult === 'object' &&
+                    'error' in camelCaseResult) {
+                    const errorMessage = camelCaseResult.error;
+                    throw new JsonRpcClientError(`RPC Error: ${errorMessage}`, -32000, // Generic RPC error code
+                    camelCaseResult);
+                }
                 // Validate method-specific response structure after camelCase conversion
                 if (this.validation && 'validateMethodResponse' in this.validation) {
                     // Create a camelCase version of the response for validation
@@ -4881,138 +4890,168 @@ Object.entries(PATH_TO_METHOD_MAP).forEach(([path, method]) => {
 var RPC_METHODS = Object.values(PATH_TO_METHOD_MAP);
 
 // Auto-generated static RPC functions for tree-shaking
-// Generated at: 2025-07-29T20:18:38.221Z
+// Generated at: 2025-07-31T19:21:47.589Z
 // Total functions: 31
 //
 // This file is automatically generated by tools/codegen/generate-client-interface.ts
 // Do not edit manually - changes will be overwritten
 // EXPERIMENTAL_changes static function
-async function experimentalChanges(client, params) {
+async function experimentalChanges$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_changes', params);
 }
 // EXPERIMENTAL_changes_in_block static function
-async function experimentalChangesInBlock(client, params) {
+async function experimentalChangesInBlock$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_changes_in_block', params);
 }
 // EXPERIMENTAL_congestion_level static function
-async function experimentalCongestionLevel(client, params) {
+async function experimentalCongestionLevel$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_congestion_level', params);
 }
 // EXPERIMENTAL_genesis_config static function
-async function experimentalGenesisConfig(client, params) {
+async function experimentalGenesisConfig$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_genesis_config', params);
 }
 // EXPERIMENTAL_light_client_block_proof static function
-async function experimentalLightClientBlockProof(client, params) {
+async function experimentalLightClientBlockProof$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_light_client_block_proof', params);
 }
 // EXPERIMENTAL_light_client_proof static function
-async function experimentalLightClientProof(client, params) {
+async function experimentalLightClientProof$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_light_client_proof', params);
 }
 // EXPERIMENTAL_maintenance_windows static function
-async function experimentalMaintenanceWindows(client, params) {
+async function experimentalMaintenanceWindows$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_maintenance_windows', params);
 }
 // EXPERIMENTAL_protocol_config static function
-async function experimentalProtocolConfig(client, params) {
+async function experimentalProtocolConfig$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_protocol_config', params);
 }
 // EXPERIMENTAL_receipt static function
-async function experimentalReceipt(client, params) {
+async function experimentalReceipt$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_receipt', params);
 }
 // EXPERIMENTAL_split_storage_info static function
-async function experimentalSplitStorageInfo(client, params) {
+async function experimentalSplitStorageInfo$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_split_storage_info', params);
 }
 // EXPERIMENTAL_tx_status static function
-async function experimentalTxStatus(client, params) {
+async function experimentalTxStatus$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_tx_status', params);
 }
 // EXPERIMENTAL_validators_ordered static function
-async function experimentalValidatorsOrdered(client, params) {
+async function experimentalValidatorsOrdered$1(client, params) {
     return client.makeRequest('EXPERIMENTAL_validators_ordered', params);
 }
 // block static function
-async function block(client, params) {
+async function block$1(client, params) {
     return client.makeRequest('block', params);
 }
 // block_effects static function
-async function blockEffects(client, params) {
+async function blockEffects$1(client, params) {
     return client.makeRequest('block_effects', params);
 }
 // broadcast_tx_async static function
-async function broadcastTxAsync(client, params) {
+async function broadcastTxAsync$1(client, params) {
     return client.makeRequest('broadcast_tx_async', params);
 }
 // broadcast_tx_commit static function
-async function broadcastTxCommit(client, params) {
+async function broadcastTxCommit$1(client, params) {
     return client.makeRequest('broadcast_tx_commit', params);
 }
 // changes static function
-async function changes(client, params) {
+async function changes$1(client, params) {
     return client.makeRequest('changes', params);
 }
 // chunk static function
-async function chunk(client, params) {
+async function chunk$1(client, params) {
     return client.makeRequest('chunk', params);
 }
 // client_config static function
-async function clientConfig(client, params) {
+async function clientConfig$1(client, params) {
     return client.makeRequest('client_config', params);
 }
 // gas_price static function
-async function gasPrice(client, params) {
+async function gasPrice$1(client, params) {
     return client.makeRequest('gas_price', params);
 }
 // genesis_config static function
-async function genesisConfig(client, params) {
+async function genesisConfig$1(client, params) {
     return client.makeRequest('genesis_config', params);
 }
 // health static function
-async function health(client, params) {
+async function health$1(client, params) {
     return client.makeRequest('health', params);
 }
 // light_client_proof static function
-async function lightClientProof(client, params) {
+async function lightClientProof$1(client, params) {
     return client.makeRequest('light_client_proof', params);
 }
 // maintenance_windows static function
-async function maintenanceWindows(client, params) {
+async function maintenanceWindows$1(client, params) {
     return client.makeRequest('maintenance_windows', params);
 }
 // network_info static function
-async function networkInfo(client, params) {
+async function networkInfo$1(client, params) {
     return client.makeRequest('network_info', params);
 }
 // next_light_client_block static function
-async function nextLightClientBlock(client, params) {
+async function nextLightClientBlock$1(client, params) {
     return client.makeRequest('next_light_client_block', params);
 }
 // query static function
-async function query(client, params) {
+async function query$1(client, params) {
     return client.makeRequest('query', params);
 }
 // send_tx static function
-async function sendTx(client, params) {
+async function sendTx$1(client, params) {
     return client.makeRequest('send_tx', params);
 }
 // status static function
-async function status(client, params) {
+async function status$1(client, params) {
     return client.makeRequest('status', params);
 }
 // tx static function
-async function tx(client, params) {
+async function tx$1(client, params) {
     return client.makeRequest('tx', params);
 }
 // validators static function
-async function validators(client, params) {
+async function validators$1(client, params) {
     return client.makeRequest('validators', params);
 }
 
-async function viewAccount(client, params) {
+async function viewFunction$1(client, params) {
     // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    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$1(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$1(client, params);
+    return parseCallResultToJson(result);
+}
+
+// Auto-generated validation wrapper functions
+// Generated at: 2025-07-31T19:21:47.592Z
+// Total functions: 31
+//
+// This file is automatically generated by tools/codegen/generate-validation-wrappers.ts
+// Do not edit manually - changes will be overwritten
+// Convenience function wrappers with validation
+async function viewAccount(client, params) {
+    // Use the validated query function
     const queryParams = params.blockId
         ? {
             requestType: 'view_account',
@@ -5027,12 +5066,12 @@ async function viewAccount(client, params) {
     return query(client, queryParams);
 }
 async function viewFunction(client, params) {
-    // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    // Use the validated query function
     const baseParams = {
         requestType: 'call_function',
         accountId: params.accountId,
         methodName: params.methodName,
-        argsBase64: params.argsBase64 ?? '', // Default to empty string if no arguments
+        argsBase64: params.argsBase64 ?? '',
     };
     const queryParams = params.blockId
         ? { ...baseParams, blockId: params.blockId }
@@ -5040,7 +5079,7 @@ async function viewFunction(client, params) {
     return query(client, queryParams);
 }
 async function viewAccessKey(client, params) {
-    // Construct query parameters: use blockId if provided, otherwise use finality (default 'final')
+    // Use the validated query function
     const queryParams = params.blockId
         ? {
             requestType: 'view_access_key',
@@ -5056,6 +5095,721 @@ async function viewAccessKey(client, params) {
         };
     return query(client, queryParams);
 }
+// Validation wrapper functions
+async function experimentalChanges(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalChanges$1(client, params);
+    // Validate response
+    const responseSchema = RpcStateChangesInBlockResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalChangesInBlock(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcStateChangesInBlockRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalChangesInBlock$1(client, params);
+    // Validate response
+    const responseSchema = RpcStateChangesInBlockByTypeResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalCongestionLevel(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcCongestionLevelRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalCongestionLevel$1(client, params);
+    // Validate response
+    const responseSchema = RpcCongestionLevelResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalGenesisConfig(client, params) {
+    // Validate request parameters
+    const requestSchema = GenesisConfigRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalGenesisConfig$1(client, params);
+    // Validate response
+    const responseSchema = GenesisConfigSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalLightClientBlockProof(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcLightClientBlockProofRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalLightClientBlockProof$1(client, params);
+    // Validate response
+    const responseSchema = RpcLightClientBlockProofResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalLightClientProof(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcLightClientExecutionProofRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalLightClientProof$1(client, params);
+    // Validate response
+    const responseSchema = RpcLightClientExecutionProofResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalMaintenanceWindows(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcMaintenanceWindowsRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function (no response validation needed)
+    return experimentalMaintenanceWindows$1(client, params);
+}
+async function experimentalProtocolConfig(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcProtocolConfigRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalProtocolConfig$1(client, params);
+    // Validate response
+    const responseSchema = RpcProtocolConfigResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalReceipt(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcReceiptRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalReceipt$1(client, params);
+    // Validate response
+    const responseSchema = RpcReceiptResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalSplitStorageInfo(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcSplitStorageInfoRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalSplitStorageInfo$1(client, params);
+    // Validate response
+    const responseSchema = RpcSplitStorageInfoResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalTxStatus(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcTransactionStatusRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await experimentalTxStatus$1(client, params);
+    // Validate response
+    const responseSchema = RpcTransactionResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function experimentalValidatorsOrdered(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcValidatorsOrderedRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function (no response validation needed)
+    return experimentalValidatorsOrdered$1(client, params);
+}
+async function block(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcBlockRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await block$1(client, params);
+    // Validate response
+    const responseSchema = RpcBlockResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function blockEffects(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcStateChangesInBlockRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await blockEffects$1(client, params);
+    // Validate response
+    const responseSchema = RpcStateChangesInBlockByTypeResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function broadcastTxAsync(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcSendTransactionRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await broadcastTxAsync$1(client, params);
+    // Validate response
+    const responseSchema = CryptoHashSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function broadcastTxCommit(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcSendTransactionRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await broadcastTxCommit$1(client, params);
+    // Validate response
+    const responseSchema = RpcTransactionResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function changes(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcStateChangesInBlockByTypeRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await changes$1(client, params);
+    // Validate response
+    const responseSchema = RpcStateChangesInBlockResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function chunk(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcChunkRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await chunk$1(client, params);
+    // Validate response
+    const responseSchema = RpcChunkResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function clientConfig(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcClientConfigRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await clientConfig$1(client, params);
+    // Validate response
+    const responseSchema = RpcClientConfigResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function gasPrice(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcGasPriceRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await gasPrice$1(client, params);
+    // Validate response
+    const responseSchema = RpcGasPriceResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function genesisConfig(client, params) {
+    // Validate request parameters
+    const requestSchema = GenesisConfigRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await genesisConfig$1(client, params);
+    // Validate response
+    const responseSchema = GenesisConfigSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function health(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcHealthRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await health$1(client, params);
+    // Validate response
+    const responseSchema = RpcHealthResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function lightClientProof(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcLightClientExecutionProofRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await lightClientProof$1(client, params);
+    // Validate response
+    const responseSchema = RpcLightClientExecutionProofResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function maintenanceWindows(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcMaintenanceWindowsRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function (no response validation needed)
+    return maintenanceWindows$1(client, params);
+}
+async function networkInfo(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcNetworkInfoRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await networkInfo$1(client, params);
+    // Validate response
+    const responseSchema = RpcNetworkInfoResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function nextLightClientBlock(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcLightClientNextBlockRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await nextLightClientBlock$1(client, params);
+    // Validate response
+    const responseSchema = RpcLightClientNextBlockResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function query(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcQueryRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await query$1(client, params);
+    // Validate response
+    const responseSchema = RpcQueryResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function sendTx(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcSendTransactionRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await sendTx$1(client, params);
+    // Validate response
+    const responseSchema = RpcTransactionResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function status(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcStatusRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await status$1(client, params);
+    // Validate response
+    const responseSchema = RpcStatusResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function tx(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcTransactionStatusRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await tx$1(client, params);
+    // Validate response
+    const responseSchema = RpcTransactionResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
+async function validators(client, params) {
+    // Validate request parameters
+    const requestSchema = RpcValidatorRequestSchema();
+    if (params !== undefined) {
+        try {
+            requestSchema.parse(params);
+        }
+        catch (error) {
+            throw new Error(`Request validation failed: ${error}`);
+        }
+    }
+    // Call the base function
+    const result = await validators$1(client, params);
+    // Validate response
+    const responseSchema = RpcValidatorResponseSchema();
+    try {
+        // Wrap in JSON-RPC response format for validation
+        responseSchema.parse(result);
+    }
+    catch (error) {
+        throw new Error(`Response validation failed: ${error}`);
+    }
+    return result;
+}
 
 // Optional validation for client - only imported when explicitly enabled
 /**
@@ -5102,6 +5856,14 @@ function enableValidation() {
             try {
                 // First validate basic JSON-RPC structure
                 responseSchema.parse(response);
+                // Check if the result contains an error field before validating the schema
+                // This provides a better error message when NEAR RPC returns non-standard errors
+                if (response.result &&
+                    typeof response.result === 'object' &&
+                    'error' in response.result) {
+                    const serverError = response.result.error;
+                    throw new JsonRpcClientError(`Server error: ${serverError}`, -32000, response.result);
+                }
                 // Then validate method-specific response structure if schema exists
                 const methodSchemas = VALIDATION_SCHEMA_MAP[method];
                 if (methodSchemas?.responseSchema) {
@@ -5110,10 +5872,15 @@ function enableValidation() {
                 }
             }
             catch (error) {
+                // If it's already a JsonRpcClientError (from server error check), re-throw it
+                if (error instanceof JsonRpcClientError) {
+                    throw error;
+                }
+                // Otherwise, it's a validation error
                 throw new JsonRpcClientError(`Invalid ${method} response: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         },
     };
 }
 
-export { JsonRpcClientError, JsonRpcNetworkError, JsonRpcRequestSchema, JsonRpcResponseSchema, NearRpcClient, NearRpcError, RPC_METHODS, block, blockEffects, broadcastTxAsync, broadcastTxCommit, changes, chunk, 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, viewAccessKey, viewAccount, viewFunction };
+export { JsonRpcClientError, JsonRpcNetworkError, JsonRpcRequestSchema, JsonRpcResponseSchema, NearRpcClient, NearRpcError, RPC_METHODS, block, blockEffects, broadcastTxAsync, broadcastTxCommit, changes, chunk, 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, parseCallResultToJson, query, sendTx, status, tx, validators, viewAccessKey, viewAccount, viewFunction, viewFunctionAsJson };