@psalomo/jsonrpc-client 0.5.0 → 1.0.1

package/dist/index.mjs

@@ -1,24 +1,4 @@
 // src/client.ts
-import {
-  JsonRpcRequestSchema,
-  JsonRpcResponseSchema,
-  RPC_METHODS
-} from "@psalomo/jsonrpc-types";
-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) {
-    super(message);
-    this.originalError = originalError;
-    this.name = "JsonRpcNetworkError";
-  }
-};
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -53,59 +33,61 @@ function convertKeysToCamelCase(obj) {
   }
   return converted;
 }
-var NearRpcClient = class {
+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) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "JsonRpcNetworkError";
+  }
+};
+var NearRpcClient = class _NearRpcClient {
   endpoint;
   headers;
   timeout;
   retries;
-  validateResponses;
+  validation;
   constructor(config) {
     if (typeof config === "string") {
       this.endpoint = config;
-      this.headers = {
-        "Content-Type": "application/json"
-      };
+      this.headers = {};
       this.timeout = 3e4;
       this.retries = 3;
-      this.validateResponses = true;
     } else {
       this.endpoint = config.endpoint;
-      this.headers = {
-        "Content-Type": "application/json",
-        ...config.headers
-      };
+      this.headers = config.headers || {};
       this.timeout = config.timeout || 3e4;
       this.retries = config.retries || 3;
-      this.validateResponses = config.validateResponses ?? true;
+      if (config.validation) {
+        this.validation = config.validation;
+      }
     }
   }
   /**
-   * Get request ID matching NEAR RPC documentation examples
+   * Make a raw JSON-RPC request
+   * This is used internally by the standalone RPC functions
    */
-  getRequestId() {
-    return "dontcare";
-  }
-  /**
-   * Make a raw JSON-RPC call
-   * This method is public to allow dynamic calls to any RPC method
-   */
-  async call(method, params) {
-    const requestId = this.getRequestId();
-    const snakeCaseParams = params ? convertKeysToSnakeCase(params) : void 0;
+  async makeRequest(method, params) {
+    const snakeCaseParams = params ? convertKeysToSnakeCase(params) : params;
     const request = {
       jsonrpc: "2.0",
-      id: requestId,
+      id: REQUEST_ID,
       method,
       params: snakeCaseParams
     };
-    if (this.validateResponses) {
-      try {
-        JsonRpcRequestSchema.parse(request);
-      } catch (error) {
-        throw new JsonRpcNetworkError(
-          `Invalid request format: ${error instanceof Error ? error.message : "Unknown error"}`,
-          error
-        );
+    if (this.validation) {
+      if ("validateMethodRequest" in this.validation) {
+        this.validation.validateMethodRequest(method, request);
+      } else {
+        this.validation.validateRequest(request);
       }
     }
     let lastError = null;
@@ -115,84 +97,81 @@ var NearRpcClient = class {
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         const response = await fetch(this.endpoint, {
           method: "POST",
-          headers: this.headers,
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
           body: JSON.stringify(request),
           signal: controller.signal
         });
         clearTimeout(timeoutId);
-        const jsonResponse = await response.json();
-        if (this.validateResponses) {
-          try {
-            JsonRpcResponseSchema.parse(jsonResponse);
-          } catch (error) {
-            throw new JsonRpcClientError(
-              `Invalid response format: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-          }
+        if (!response.ok) {
+          throw new JsonRpcNetworkError(
+            `HTTP error! status: ${response.status}`
+          );
+        }
+        let jsonResponse;
+        try {
+          jsonResponse = await response.json();
+        } catch (parseError) {
+          throw new JsonRpcNetworkError(
+            "Failed to parse JSON response",
+            parseError
+          );
+        }
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
         }
-        const rpcResponse = jsonResponse;
-        if (rpcResponse.error) {
+        if (jsonResponse.error) {
           throw new JsonRpcClientError(
-            rpcResponse.error.message,
-            rpcResponse.error.code,
-            rpcResponse.error.data
+            jsonResponse.error.message,
+            jsonResponse.error.code,
+            jsonResponse.error.data
           );
         }
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const camelCaseResult = jsonResponse.result ? convertKeysToCamelCase(jsonResponse.result) : jsonResponse.result;
+        if (this.validation && "validateMethodResponse" in this.validation) {
+          const camelCaseResponse = {
+            ...jsonResponse,
+            result: camelCaseResult
+          };
+          this.validation.validateMethodResponse(method, camelCaseResponse);
         }
-        const camelCaseResult = rpcResponse.result ? convertKeysToCamelCase(rpcResponse.result) : rpcResponse.result;
         return camelCaseResult;
       } catch (error) {
         lastError = error;
         if (error instanceof JsonRpcClientError) {
           throw error;
         }
-        if (attempt < this.retries) {
-          const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          continue;
+        if (attempt === this.retries) {
+          break;
         }
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+        );
       }
     }
     throw new JsonRpcNetworkError(
-      `Failed to make RPC call after ${this.retries + 1} attempts: ${lastError?.message}`,
-      lastError
+      lastError?.message || "Request failed after all retries",
+      lastError || void 0
     );
   }
-};
-RPC_METHODS.forEach((method) => {
-  let methodName = method;
-  if (methodName.startsWith("EXPERIMENTAL_")) {
-    methodName = "experimental" + methodName.substring(13).replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/^([a-z])/, (_, letter) => letter.toUpperCase());
-  } else {
-    methodName = methodName.replace(
-      /_([a-z])/g,
-      (_, letter) => letter.toUpperCase()
-    );
+  /**
+   * 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 } : {}
+    });
   }
-  NearRpcClient.prototype[methodName] = function(params) {
-    return this.call(method, params);
-  };
-});
-NearRpcClient.prototype.viewAccount = function(params) {
-  return this.query({
-    requestType: "view_account",
-    ...params
-  });
-};
-NearRpcClient.prototype.viewFunction = function(params) {
-  return this.query({
-    requestType: "call_function",
-    ...params
-  });
-};
-NearRpcClient.prototype.viewAccessKey = function(params) {
-  return this.query({
-    requestType: "view_access_key",
-    ...params
-  });
 };
+var defaultClient = new NearRpcClient({
+  endpoint: "https://rpc.mainnet.near.org"
+});
 
 // src/types.ts
 var NearRpcError = class extends Error {
@@ -209,7 +188,193 @@ import {
   JsonRpcRequestSchema as JsonRpcRequestSchema2,
   JsonRpcResponseSchema as JsonRpcResponseSchema2
 } from "@psalomo/jsonrpc-types";
-import { RPC_METHODS as RPC_METHODS2 } 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 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 health(client, params) {
+  return client.makeRequest("health", params);
+}
+async function lightClientProof(client, params) {
+  return client.makeRequest("light_client_proof", params);
+}
+async function networkInfo(client, params) {
+  return client.makeRequest("network_info", params);
+}
+async function nextLightClientBlock(client, params) {
+  return client.makeRequest("next_light_client_block", params);
+}
+async function query(client, params) {
+  return client.makeRequest("query", params);
+}
+async function sendTx(client, params) {
+  return client.makeRequest("send_tx", params);
+}
+async function status(client, params) {
+  return client.makeRequest("status", params);
+}
+async function tx(client, params) {
+  return client.makeRequest("tx", params);
+}
+async function validators(client, params) {
+  return client.makeRequest("validators", params);
+}
+
+// src/convenience.ts
+async function viewAccount(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_account",
+    accountId: params.accountId,
+    blockId: params.blockId
+  } : {
+    requestType: "view_account",
+    accountId: params.accountId,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+async function viewFunction(client, params) {
+  const baseParams = {
+    requestType: "call_function",
+    accountId: params.accountId,
+    methodName: params.methodName,
+    argsBase64: params.argsBase64 ?? ""
+    // Default to empty string if no arguments
+  };
+  const queryParams = params.blockId ? { ...baseParams, blockId: params.blockId } : { ...baseParams, finality: params.finality || "final" };
+  return query(client, queryParams);
+}
+async function viewAccessKey(client, params) {
+  const queryParams = params.blockId ? {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    blockId: params.blockId
+  } : {
+    requestType: "view_access_key",
+    accountId: params.accountId,
+    publicKey: params.publicKey,
+    finality: params.finality || "final"
+  };
+  return query(client, queryParams);
+}
+
+// src/validation.ts
+import {
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema,
+  VALIDATION_SCHEMA_MAP
+} from "@psalomo/jsonrpc-types";
+function enableValidation() {
+  const requestSchema = JsonRpcRequestSchema();
+  const responseSchema = JsonRpcResponseSchema();
+  return {
+    validateRequest: (request) => {
+      try {
+        requestSchema.parse(request);
+      } catch (error) {
+        throw new JsonRpcNetworkError(
+          `Invalid request format: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    },
+    validateResponse: (response) => {
+      try {
+        responseSchema.parse(response);
+      } catch (error) {
+        throw new JsonRpcClientError(
+          `Invalid response format: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    validateMethodRequest: (method, request) => {
+      try {
+        requestSchema.parse(request);
+        const methodSchemas = VALIDATION_SCHEMA_MAP[method];
+        if (methodSchemas?.requestSchema) {
+          const methodRequestSchema = methodSchemas.requestSchema();
+          methodRequestSchema.parse(request);
+        }
+      } catch (error) {
+        throw new JsonRpcNetworkError(
+          `Invalid ${method} request: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    },
+    validateMethodResponse: (method, response) => {
+      try {
+        responseSchema.parse(response);
+        const methodSchemas = VALIDATION_SCHEMA_MAP[method];
+        if (methodSchemas?.responseSchema) {
+          const methodResponseSchema = methodSchemas.responseSchema();
+          methodResponseSchema.parse(response);
+        }
+      } catch (error) {
+        throw new JsonRpcClientError(
+          `Invalid ${method} response: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  };
+}
 export {
   JsonRpcClientError,
   JsonRpcNetworkError,
@@ -217,6 +382,39 @@ export {
   JsonRpcResponseSchema2 as JsonRpcResponseSchema,
   NearRpcClient,
   NearRpcError,
-  RPC_METHODS2 as RPC_METHODS,
-  NearRpcClient as default
+  RPC_METHODS,
+  block,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  NearRpcClient as default,
+  defaultClient,
+  enableValidation,
+  experimentalChanges,
+  experimentalChangesInBlock,
+  experimentalCongestionLevel,
+  experimentalGenesisConfig,
+  experimentalLightClientBlockProof,
+  experimentalLightClientProof,
+  experimentalMaintenanceWindows,
+  experimentalProtocolConfig,
+  experimentalReceipt,
+  experimentalSplitStorageInfo,
+  experimentalTxStatus,
+  experimentalValidatorsOrdered,
+  gasPrice,
+  health,
+  lightClientProof,
+  networkInfo,
+  nextLightClientBlock,
+  query,
+  sendTx,
+  status,
+  tx,
+  validators,
+  viewAccessKey,
+  viewAccount,
+  viewFunction
 };

package/dist/{validation.mini.d.ts → validation.d.ts}

@@ -1,12 +1,14 @@
-import { JsonRpcRequest, JsonRpcResponse } from './client.mini.js';
+import { JsonRpcRequest, JsonRpcResponse } from './client.js';
 export interface ValidationResult {
     validateRequest: (request: JsonRpcRequest) => void;
     validateResponse: (response: JsonRpcResponse) => void;
+    validateMethodRequest?: (method: string, request: JsonRpcRequest) => void;
+    validateMethodResponse?: (method: string, response: JsonRpcResponse) => void;
 }
 /**
- * Enable validation for the mini client
+ * Enable validation for the client
  * This function should only be called if you want to include schema validation
  * Calling this function will include Zod schemas in your bundle
  */
 export declare function enableValidation(): ValidationResult;
-//# sourceMappingURL=validation.mini.d.ts.map
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,cAAc,EACd,eAAe,EAGhB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IACnD,gBAAgB,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;IACtD,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1E,sBAAsB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;CAC9E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CA+DnD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psalomo/jsonrpc-client",
-  "version": "0.5.0",
+  "version": "1.0.1",
   "description": "TypeScript client for NEAR Protocol JSON-RPC API",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -10,11 +10,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
-    },
-    "./mini": {
-      "types": "./dist/index.mini.d.ts",
-      "import": "./dist/index.mini.mjs",
-      "require": "./dist/index.mini.cjs"
     }
   },
   "files": [
@@ -35,7 +30,7 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@psalomo/jsonrpc-types": "^0.1.0"
+    "@psalomo/jsonrpc-types": "^1.0.1"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",