@psalomo/jsonrpc-client 0.3.0 → 0.5.0

package/dist/index.js

@@ -22,9 +22,11 @@ var index_exports = {};
 __export(index_exports, {
   JsonRpcClientError: () => JsonRpcClientError,
   JsonRpcNetworkError: () => JsonRpcNetworkError,
+  JsonRpcRequestSchema: () => import_jsonrpc_types2.JsonRpcRequestSchema,
+  JsonRpcResponseSchema: () => import_jsonrpc_types2.JsonRpcResponseSchema,
   NearRpcClient: () => NearRpcClient,
   NearRpcError: () => NearRpcError,
-  RPC_METHODS: () => import_jsonrpc_types2.RPC_METHODS,
+  RPC_METHODS: () => import_jsonrpc_types3.RPC_METHODS,
   default: () => NearRpcClient
 });
 module.exports = __toCommonJS(index_exports);
@@ -86,7 +88,6 @@ var NearRpcClient = class {
   timeout;
   retries;
   validateResponses;
-  requestIdCounter = 0;
   constructor(config) {
     if (typeof config === "string") {
       this.endpoint = config;
@@ -108,16 +109,17 @@ var NearRpcClient = class {
     }
   }
   /**
-   * Generate a unique request ID
+   * Get request ID matching NEAR RPC documentation examples
    */
-  generateRequestId() {
-    return `near-rpc-${Date.now()}-${++this.requestIdCounter}`;
+  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.generateRequestId();
+    const requestId = this.getRequestId();
     const snakeCaseParams = params ? convertKeysToSnakeCase(params) : void 0;
     const request = {
       jsonrpc: "2.0",
@@ -187,162 +189,38 @@ var NearRpcClient = class {
       lastError
     );
   }
-  // Generated RPC methods will be added here
-  // This section will be auto-generated based on the OpenAPI spec
-  /**
-   * Get node status
-   */
-  async status() {
-    return this.call("status");
-  }
-  /**
-   * Get block information
-   */
-  async block(params) {
-    return this.call("block", params);
-  }
-  /**
-   * Get current gas price
-   */
-  async gasPrice(params) {
-    return this.call("gas_price", params);
-  }
-  /**
-   * Get chunk information
-   */
-  async chunk(params) {
-    return this.call("chunk", params);
-  }
-  /**
-   * Health check
-   */
-  async health() {
-    return this.call("health");
-  }
-  /**
-   * Get network information
-   */
-  async networkInfo() {
-    return this.call("network_info");
-  }
-  /**
-   * Get current validators
-   */
-  async validators(params) {
-    return this.call("validators", params);
-  }
-  /**
-   * Get client configuration
-   */
-  async clientConfig() {
-    return this.call("client_config");
-  }
-  /**
-   * Broadcast transaction asynchronously
-   */
-  async broadcastTxAsync(params) {
-    return this.call("broadcast_tx_async", params);
-  }
-  /**
-   * Broadcast transaction and wait for commit
-   */
-  async broadcastTxCommit(params) {
-    return this.call("broadcast_tx_commit", params);
-  }
-  /**
-   * Send transaction
-   */
-  async sendTx(params) {
-    return await this.call("send_tx", params);
-  }
-  /**
-   * Get transaction status
-   */
-  async tx(params) {
-    return this.call("tx", params);
-  }
-  /**
-   * Query account/contract state
-   */
-  async query(params) {
-    return this.call("query", params);
-  }
-  /**
-   * View account information (convenience method)
-   */
-  async viewAccount(params) {
-    return this.query({
-      requestType: "view_account",
-      ...params
-    });
-  }
-  /**
-   * View function call (convenience method)
-   */
-  async viewFunction(params) {
-    return this.query({
-      requestType: "call_function",
-      ...params
-    });
-  }
-  /**
-   * View access key (convenience method)
-   */
-  async viewAccessKey(params) {
-    return this.query({
-      requestType: "view_access_key",
-      ...params
-    });
-  }
-  /**
-   * Get light client proof
-   */
-  async lightClientProof(params) {
-    return this.call("light_client_proof", params);
-  }
-  // Experimental methods
-  /**
-   * Get state changes (experimental)
-   */
-  async experimentalChanges(params) {
-    return this.call("EXPERIMENTAL_changes", params);
-  }
-  /**
-   * Get state changes in block (experimental)
-   */
-  async experimentalChangesInBlock(params) {
-    return this.call("EXPERIMENTAL_changes_in_block", params);
-  }
-  /**
-   * Get ordered validators (experimental)
-   */
-  async experimentalValidatorsOrdered(params) {
-    return this.call("EXPERIMENTAL_validators_ordered", params);
-  }
-  /**
-   * Get protocol configuration (experimental)
-   */
-  async experimentalProtocolConfig(params) {
-    return this.call("EXPERIMENTAL_protocol_config", params);
-  }
-  /**
-   * Get genesis configuration (experimental)
-   */
-  async experimentalGenesisConfig() {
-    return this.call("EXPERIMENTAL_genesis_config");
-  }
-  /**
-   * Get receipt information (experimental)
-   */
-  async experimentalReceipt(params) {
-    return this.call("EXPERIMENTAL_receipt", params);
-  }
-  /**
-   * Get transaction status (experimental)
-   */
-  async experimentalTxStatus(params) {
-    return this.call("EXPERIMENTAL_tx_status", params);
+};
+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()
+    );
   }
+  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
+  });
 };
 
 // src/types.ts
@@ -357,10 +235,13 @@ var NearRpcError = class extends Error {
 
 // src/index.ts
 var import_jsonrpc_types2 = require("@psalomo/jsonrpc-types");
+var import_jsonrpc_types3 = require("@psalomo/jsonrpc-types");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   JsonRpcClientError,
   JsonRpcNetworkError,
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema,
   NearRpcClient,
   NearRpcError,
   RPC_METHODS

package/dist/index.mini.cjs

@@ -0,0 +1,421 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.mini.ts
+var index_mini_exports = {};
+__export(index_mini_exports, {
+  JsonRpcClientError: () => JsonRpcClientError,
+  JsonRpcNetworkError: () => JsonRpcNetworkError,
+  JsonRpcRequestSchema: () => import_mini2.JsonRpcRequestSchema,
+  JsonRpcResponseSchema: () => import_mini2.JsonRpcResponseSchema,
+  NearRpcClient: () => NearRpcClient,
+  NearRpcError: () => NearRpcError,
+  RPC_METHODS: () => import_mini3.RPC_METHODS,
+  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_mini_exports);
+
+// src/client.mini.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToSnakeCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnake(key);
+    converted[snakeKey] = convertKeysToSnakeCase(value);
+  }
+  return converted;
+}
+function convertKeysToCamelCase(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertKeysToCamelCase);
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel(key);
+    converted[camelKey] = convertKeysToCamelCase(value);
+  }
+  return converted;
+}
+var REQUEST_ID = "dontcare";
+var JsonRpcClientError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "JsonRpcClientError";
+  }
+};
+var JsonRpcNetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "JsonRpcNetworkError";
+  }
+};
+var NearRpcClient = class _NearRpcClient {
+  endpoint;
+  headers;
+  timeout;
+  retries;
+  validation;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.headers = config.headers || {};
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries || 3;
+    if (config.validation) {
+      this.validation = config.validation;
+    }
+  }
+  /**
+   * Make a raw JSON-RPC request
+   * This is used internally by the standalone RPC functions
+   */
+  async makeRequest(method, params) {
+    const snakeCaseParams = params ? convertKeysToSnakeCase(params) : params;
+    const request = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: snakeCaseParams
+    };
+    if (this.validation) {
+      this.validation.validateRequest(request);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
+          body: JSON.stringify(request),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          throw new JsonRpcNetworkError(
+            `HTTP error! status: ${response.status}`
+          );
+        }
+        const jsonResponse = await response.json();
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
+        }
+        if (jsonResponse.error) {
+          throw new JsonRpcClientError(
+            jsonResponse.error.message,
+            jsonResponse.error.code,
+            jsonResponse.error.data
+          );
+        }
+        const camelCaseResult = jsonResponse.result ? convertKeysToCamelCase(jsonResponse.result) : jsonResponse.result;
+        return camelCaseResult;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof JsonRpcClientError) {
+          throw error;
+        }
+        if (attempt === this.retries) {
+          break;
+        }
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+        );
+      }
+    }
+    throw lastError || new JsonRpcNetworkError("Request failed after all retries");
+  }
+  /**
+   * Create a new client with modified configuration
+   */
+  withConfig(config) {
+    return new _NearRpcClient({
+      endpoint: config.endpoint ?? this.endpoint,
+      headers: config.headers ?? this.headers,
+      timeout: config.timeout ?? this.timeout,
+      retries: config.retries ?? this.retries,
+      ...config.validation !== void 0 ? { validation: config.validation } : this.validation !== void 0 ? { validation: this.validation } : {}
+    });
+  }
+};
+var defaultClient = new NearRpcClient({
+  endpoint: "https://rpc.mainnet.near.org"
+});
+
+// src/types.ts
+var NearRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "NearRpcError";
+  }
+};
+
+// src/index.mini.ts
+var import_mini2 = require("@near-js/jsonrpc-types/mini");
+var import_mini3 = require("@near-js/jsonrpc-types/mini");
+
+// src/generated-types.mini.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.mini.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.mini.ts
+var import_mini = require("@near-js/jsonrpc-types/mini");
+function enableValidation() {
+  const requestSchema = (0, import_mini.JsonRpcRequestSchema)();
+  const responseSchema = (0, import_mini.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"}`
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  JsonRpcRequestSchema,
+  JsonRpcResponseSchema,
+  NearRpcClient,
+  NearRpcError,
+  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
+});