@psalomo/jsonrpc-client 0.4.0 → 1.0.0

package/dist/index.js

@@ -27,27 +27,44 @@ __export(index_exports, {
   NearRpcClient: () => NearRpcClient,
   NearRpcError: () => NearRpcError,
   RPC_METHODS: () => import_jsonrpc_types3.RPC_METHODS,
-  default: () => NearRpcClient
+  block: () => block,
+  broadcastTxAsync: () => broadcastTxAsync,
+  broadcastTxCommit: () => broadcastTxCommit,
+  changes: () => changes,
+  chunk: () => chunk,
+  clientConfig: () => clientConfig,
+  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,
+  health: () => health,
+  lightClientProof: () => lightClientProof,
+  networkInfo: () => networkInfo,
+  nextLightClientBlock: () => nextLightClientBlock,
+  query: () => query,
+  sendTx: () => sendTx,
+  status: () => status,
+  tx: () => tx,
+  validators: () => validators,
+  viewAccessKey: () => viewAccessKey,
+  viewAccount: () => viewAccount,
+  viewFunction: () => viewFunction
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_jsonrpc_types = require("@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()}`);
 }
@@ -82,60 +99,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;
-  requestIdCounter = 0;
+  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;
+      }
     }
   }
   /**
-   * Generate a unique request ID
+   * Make a raw JSON-RPC request
+   * This is used internally by the standalone RPC functions
    */
-  generateRequestId() {
-    return `near-rpc-${Date.now()}-${++this.requestIdCounter}`;
-  }
-  /**
-   * 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.generateRequestId();
-    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 {
-        import_jsonrpc_types.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;
@@ -145,84 +163,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 {
-            import_jsonrpc_types.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
+          );
         }
-        const rpcResponse = jsonResponse;
-        if (rpcResponse.error) {
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
+        }
+        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
     );
   }
-};
-import_jsonrpc_types.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 {
@@ -237,6 +252,188 @@ var NearRpcError = class extends Error {
 // src/index.ts
 var import_jsonrpc_types2 = require("@psalomo/jsonrpc-types");
 var import_jsonrpc_types3 = require("@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
+var import_jsonrpc_types = require("@psalomo/jsonrpc-types");
+function enableValidation() {
+  const requestSchema = (0, import_jsonrpc_types.JsonRpcRequestSchema)();
+  const responseSchema = (0, import_jsonrpc_types.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 = import_jsonrpc_types.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 = import_jsonrpc_types.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"}`
+        );
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   JsonRpcClientError,
@@ -245,5 +442,38 @@ var import_jsonrpc_types3 = require("@psalomo/jsonrpc-types");
   JsonRpcResponseSchema,
   NearRpcClient,
   NearRpcError,
-  RPC_METHODS
+  RPC_METHODS,
+  block,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  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
 });