@psalomo/jsonrpc-client 1.1.0 → 1.3.0

package/dist/chunk-GCIU6ZLN.mjs

@@ -0,0 +1,395 @@
+// src/client.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, originalError, responseBody) {
+    super(message);
+    this.originalError = originalError;
+    this.responseBody = responseBody;
+    this.name = "JsonRpcNetworkError";
+  }
+};
+var NearRpcClient = class _NearRpcClient {
+  endpoint;
+  headers;
+  timeout;
+  retries;
+  validation;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.endpoint = config;
+      this.headers = {};
+      this.timeout = 3e4;
+      this.retries = 3;
+    } else {
+      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 requestForValidation = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: params !== void 0 ? params : null
+    };
+    if (this.validation) {
+      if ("validateMethodRequest" in this.validation) {
+        this.validation.validateMethodRequest(method, requestForValidation);
+      } else {
+        this.validation.validateRequest(requestForValidation);
+      }
+    }
+    const snakeCaseParams = params !== void 0 ? convertKeysToSnakeCase(params) : null;
+    const request = {
+      jsonrpc: "2.0",
+      id: REQUEST_ID,
+      method,
+      params: snakeCaseParams
+    };
+    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);
+        let jsonResponse;
+        try {
+          jsonResponse = await response.json();
+        } catch (parseError) {
+          if (!response.ok) {
+            throw new JsonRpcNetworkError(
+              `HTTP error! status: ${response.status} - Failed to parse JSON response`,
+              parseError
+            );
+          }
+          throw new JsonRpcNetworkError(
+            "Failed to parse JSON response",
+            parseError
+          );
+        }
+        if (jsonResponse.error) {
+          throw new JsonRpcClientError(
+            jsonResponse.error.message,
+            jsonResponse.error.code,
+            jsonResponse.error.data
+          );
+        }
+        if (!response.ok) {
+          throw new JsonRpcNetworkError(
+            `HTTP error! status: ${response.status}`,
+            void 0,
+            jsonResponse
+          );
+        }
+        if (this.validation) {
+          this.validation.validateResponse(jsonResponse);
+        }
+        const camelCaseResult = jsonResponse.result ? convertKeysToCamelCase(jsonResponse.result) : jsonResponse.result;
+        if (camelCaseResult && typeof camelCaseResult === "object" && "error" in camelCaseResult) {
+          const errorMessage = camelCaseResult.error;
+          throw new JsonRpcClientError(
+            `RPC Error: ${errorMessage}`,
+            -32e3,
+            // Generic RPC error code
+            camelCaseResult
+          );
+        }
+        if (this.validation && "validateMethodResponse" in this.validation) {
+          const camelCaseResponse = {
+            ...jsonResponse,
+            result: camelCaseResult
+          };
+          this.validation.validateMethodResponse(method, camelCaseResponse);
+        }
+        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 new JsonRpcNetworkError(
+      lastError?.message || "Request failed after all retries",
+      lastError || void 0
+    );
+  }
+  /**
+   * 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/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 blockEffects(client, params) {
+  return client.makeRequest("block_effects", 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 genesisConfig(client, params) {
+  return client.makeRequest("genesis_config", 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 maintenanceWindows(client, params) {
+  return client.makeRequest("maintenance_windows", 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);
+}
+function parseCallResultToJson(callResult) {
+  const bytes = new Uint8Array(callResult.result);
+  const text = new TextDecoder().decode(bytes);
+  return JSON.parse(text);
+}
+async function viewFunctionAsJson(client, params) {
+  const result = await viewFunction(client, params);
+  return parseCallResultToJson(result);
+}
+
+export {
+  JsonRpcClientError,
+  JsonRpcNetworkError,
+  NearRpcClient,
+  defaultClient,
+  NearRpcError,
+  experimentalChanges,
+  experimentalChangesInBlock,
+  experimentalCongestionLevel,
+  experimentalGenesisConfig,
+  experimentalLightClientBlockProof,
+  experimentalLightClientProof,
+  experimentalMaintenanceWindows,
+  experimentalProtocolConfig,
+  experimentalReceipt,
+  experimentalSplitStorageInfo,
+  experimentalTxStatus,
+  experimentalValidatorsOrdered,
+  block,
+  blockEffects,
+  broadcastTxAsync,
+  broadcastTxCommit,
+  changes,
+  chunk,
+  clientConfig,
+  gasPrice,
+  genesisConfig,
+  health,
+  lightClientProof,
+  maintenanceWindows,
+  networkInfo,
+  nextLightClientBlock,
+  query,
+  sendTx,
+  status,
+  tx,
+  validators,
+  viewAccount,
+  viewFunction,
+  viewAccessKey,
+  parseCallResultToJson,
+  viewFunctionAsJson
+};