@elsoul/erpc-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1257 @@
+// src/errors.ts
+var REDACTED = "[REDACTED]";
+var credentialVariants = (credential) => {
+  const queryEncoded = new URLSearchParams({ value: credential }).toString().slice("value=".length);
+  let componentEncoded;
+  try {
+    componentEncoded = encodeURIComponent(credential);
+  } catch {
+  }
+  return [.../* @__PURE__ */ new Set([credential, componentEncoded, queryEncoded])].filter((value) => Boolean(value)).sort((left, right) => right.length - left.length);
+};
+var redactString = (value, variants) => {
+  let redacted = value;
+  for (const variant of variants) redacted = redacted.replaceAll(variant, REDACTED);
+  return redacted;
+};
+var redactValue = (value, variants, seen, depth) => {
+  if (typeof value === "string") return redactString(value, variants);
+  if (typeof value !== "object" || value === null) return value;
+  if (depth >= 32 || seen.has(value)) return REDACTED;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, variants, seen, depth + 1));
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      value: redactValue(item, variants, seen, depth + 1),
+      writable: true
+    });
+  }
+  return result;
+};
+var redactJsonRpcError = (error, credential) => {
+  if (!credential) return error;
+  const variants = credentialVariants(credential);
+  const result = {
+    code: error.code,
+    message: redactString(error.message, variants)
+  };
+  if (error.data !== void 0) {
+    result.data = redactValue(error.data, variants, /* @__PURE__ */ new WeakSet(), 0);
+  }
+  return result;
+};
+var ErpcError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ErpcError";
+    this.code = code;
+  }
+};
+var ErpcConfigError = class extends ErpcError {
+  constructor(message) {
+    super("ERPC_CONFIG", message);
+    this.name = "ErpcConfigError";
+  }
+};
+var ErpcTransportError = class extends ErpcError {
+  constructor(message, options) {
+    super("ERPC_TRANSPORT", message, options);
+    this.name = "ErpcTransportError";
+  }
+};
+var ErpcHttpError = class extends ErpcError {
+  status;
+  constructor(status, message = `ERPC request failed with HTTP ${status}`) {
+    super("ERPC_HTTP", message);
+    this.name = "ErpcHttpError";
+    this.status = status;
+  }
+};
+var ErpcTimeoutError = class extends ErpcError {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super("ERPC_TIMEOUT", `ERPC request timed out after ${timeoutMs}ms`);
+    this.name = "ErpcTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var ErpcAbortedError = class extends ErpcError {
+  constructor() {
+    super("ERPC_ABORTED", "ERPC request was aborted");
+    this.name = "ErpcAbortedError";
+  }
+};
+var ErpcInvalidResponseError = class extends ErpcError {
+  constructor(message = "ERPC returned an invalid response") {
+    super("ERPC_INVALID_RESPONSE", message);
+    this.name = "ErpcInvalidResponseError";
+  }
+};
+var ErpcJsonRpcError = class extends ErpcError {
+  rpcCode;
+  data;
+  constructor(error) {
+    super("ERPC_RPC", error.message);
+    this.name = "ErpcJsonRpcError";
+    this.rpcCode = error.code;
+    if (error.data !== void 0) this.data = error.data;
+  }
+};
+var ErpcBatchPolicyError = class extends ErpcError {
+  constructor(message) {
+    super("ERPC_BATCH_POLICY", message);
+    this.name = "ErpcBatchPolicyError";
+  }
+};
+
+// src/transport/rest.ts
+var controlledSignal = (timeoutMs, external) => {
+  const controller = new AbortController();
+  let didTimeOut = false;
+  let timeout = setTimeout(() => {
+    didTimeOut = true;
+    controller.abort();
+  }, timeoutMs);
+  const abort = () => controller.abort();
+  if (external?.aborted) controller.abort();
+  else external?.addEventListener("abort", abort, { once: true });
+  const stopTimeout = () => {
+    if (timeout === void 0) return;
+    clearTimeout(timeout);
+    timeout = void 0;
+  };
+  return {
+    signal: controller.signal,
+    stopTimeout,
+    timeoutMs,
+    timedOut: () => didTimeOut,
+    cleanup: () => {
+      stopTimeout();
+      external?.removeEventListener("abort", abort);
+    }
+  };
+};
+var normalizeError = (error, controlled, external) => {
+  if (error instanceof ErpcAbortedError || error instanceof ErpcHttpError || error instanceof ErpcInvalidResponseError || error instanceof ErpcTimeoutError || error instanceof ErpcTransportError) {
+    return error;
+  }
+  if (controlled.timedOut()) {
+    return new ErpcTimeoutError(controlled.timeoutMs);
+  }
+  if (external?.aborted) return new ErpcAbortedError();
+  return new ErpcTransportError("Unable to reach ERPC");
+};
+var applyQuery = (url, query) => {
+  if (!query) return;
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, item);
+    } else {
+      url.searchParams.set(key, String(value));
+    }
+  }
+};
+var RestTransport = class {
+  endpoint;
+  #apiKey;
+  #endpoint;
+  #fetch;
+  #headers;
+  #timeoutMs;
+  constructor(config) {
+    this.#apiKey = config.apiKey;
+    this.#endpoint = new URL(config.endpoint);
+    this.#fetch = config.fetch;
+    this.#headers = config.headers;
+    this.#timeoutMs = config.timeoutMs;
+    const endpoint = new URL(config.endpoint);
+    endpoint.search = "";
+    endpoint.hash = "";
+    this.endpoint = endpoint.toString();
+  }
+  url(path, query) {
+    const url = new URL(this.#endpoint);
+    const base = url.pathname === "/" ? "" : url.pathname.replace(/\/+$/, "");
+    url.pathname = `${base}/${path.replace(/^\/+/, "")}`.replace(/\/{2,}/g, "/");
+    applyQuery(url, query);
+    return url;
+  }
+  async get(path, query, options = {}) {
+    const controlled = controlledSignal(this.#timeoutMs, options.signal);
+    try {
+      const response = await this.#get(path, query, controlled.signal);
+      if (!response.ok) throw new ErpcHttpError(response.status);
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        throw new ErpcInvalidResponseError("ERPC returned malformed JSON");
+      }
+    } catch (error) {
+      throw normalizeError(error, controlled, options.signal);
+    } finally {
+      controlled.cleanup();
+    }
+  }
+  async stream(path, query, options = {}) {
+    const controlled = controlledSignal(this.#timeoutMs, options.signal);
+    try {
+      const response = await this.#get(path, query, controlled.signal);
+      if (!response.ok) throw new ErpcHttpError(response.status);
+      controlled.stopTimeout();
+      return {
+        response,
+        close: controlled.cleanup,
+        normalizeError: (error) => normalizeError(error, controlled, options.signal)
+      };
+    } catch (error) {
+      controlled.cleanup();
+      throw normalizeError(error, controlled, options.signal);
+    }
+  }
+  #get(path, query, signal) {
+    return this.#fetch(this.url(path, query), {
+      method: "GET",
+      headers: {
+        ...this.#headers,
+        authorization: `Bearer ${this.#apiKey}`,
+        accept: "application/json"
+      },
+      signal
+    });
+  }
+};
+
+// src/account.ts
+var AccountClient = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  getTokenBalance(options) {
+    return this.#transport.get("/v3/erpc/token-balance", void 0, options);
+  }
+};
+
+// src/config.ts
+var DEFAULT_ENDPOINT = "https://edge.erpc.global";
+var DEFAULT_ACCOUNT_ENDPOINT = "https://solana-rpc.erpc.global";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var requireFetch = (provided) => {
+  const implementation = provided ?? globalThis.fetch;
+  if (typeof implementation !== "function") {
+    throw new ErpcConfigError(
+      "A Fetch API implementation is required in this runtime"
+    );
+  }
+  return implementation;
+};
+var resolveConfig = (config) => {
+  const apiKey = config.apiKey.trim();
+  if (!apiKey) throw new ErpcConfigError("apiKey must not be empty");
+  let endpoint;
+  let accountEndpoint;
+  try {
+    endpoint = new URL(config.endpoint ?? DEFAULT_ENDPOINT);
+    accountEndpoint = new URL(
+      config.accountEndpoint ?? DEFAULT_ACCOUNT_ENDPOINT
+    );
+  } catch {
+    throw new ErpcConfigError("endpoint must be an absolute HTTP(S) URL");
+  }
+  if (endpoint.protocol !== "https:" && endpoint.protocol !== "http:") {
+    throw new ErpcConfigError("endpoint must use HTTP or HTTPS");
+  }
+  if (accountEndpoint.protocol !== "https:" && accountEndpoint.protocol !== "http:") {
+    throw new ErpcConfigError("accountEndpoint must use HTTP or HTTPS");
+  }
+  endpoint.search = "";
+  endpoint.hash = "";
+  endpoint.pathname = endpoint.pathname.replace(/\/+$/, "") || "/";
+  accountEndpoint.search = "";
+  accountEndpoint.hash = "";
+  accountEndpoint.pathname = accountEndpoint.pathname.replace(/\/+$/, "") || "/";
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ErpcConfigError("timeoutMs must be a positive finite number");
+  }
+  return {
+    accountEndpoint,
+    apiKey,
+    endpoint,
+    fetch: requireFetch(config.fetch),
+    headers: config.headers ?? {},
+    timeoutMs,
+    ...config.webSocket === void 0 ? {} : { webSocket: config.webSocket }
+  };
+};
+var endpointWithPath = (endpoint, path) => {
+  const url = new URL(endpoint);
+  const base = endpoint.pathname === "/" ? "" : endpoint.pathname;
+  url.pathname = `${base}/${path.replace(/^\/+/, "")}`.replace(/\/{2,}/g, "/");
+  return url;
+};
+var websocketUrl = (endpoint, apiKey, path = "") => {
+  const url = endpointWithPath(endpoint, path);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("api-key", apiKey);
+  return url;
+};
+
+// src/price.ts
+var updateQuery = (options) => ({
+  "ids[]": options.ids,
+  encoding: options.encoding,
+  parsed: options.parsed,
+  ignore_invalid_price_ids: options.ignoreInvalidPriceIds
+});
+var parseSseBlock = (block) => {
+  const data = [];
+  let event;
+  let id;
+  for (const line of block.split(/\r?\n/)) {
+    if (!line || line.startsWith(":")) continue;
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    const raw = separator === -1 ? "" : line.slice(separator + 1);
+    const value = raw.startsWith(" ") ? raw.slice(1) : raw;
+    if (field === "data") data.push(value);
+    else if (field === "event") event = value;
+    else if (field === "id") id = value;
+  }
+  if (data.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(data.join("\n"));
+  } catch {
+    throw new ErpcInvalidResponseError("ERPC returned malformed stream data");
+  }
+  const result = { data: parsed };
+  if (event !== void 0) result.event = event;
+  if (id !== void 0) result.id = id;
+  return result;
+};
+var PriceClient = class {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  getPriceFeeds(options = {}, sendOptions) {
+    return this.#transport.get(
+      "/v2/price_feeds",
+      { query: options.query, asset_type: options.assetType },
+      sendOptions
+    );
+  }
+  getLatestPriceUpdates(options, sendOptions) {
+    return this.#transport.get(
+      "/v2/updates/price/latest",
+      updateQuery(options),
+      sendOptions
+    );
+  }
+  getPriceUpdatesAtTimestamp(publishTime, options, sendOptions) {
+    return this.#transport.get(
+      `/v2/updates/price/${encodeURIComponent(String(publishTime))}`,
+      updateQuery(options),
+      sendOptions
+    );
+  }
+  getLatestPublisherStakeCaps(options = {}, sendOptions) {
+    return this.#transport.get(
+      "/v2/updates/publisher_stake_caps/latest",
+      options,
+      sendOptions
+    );
+  }
+  async *streamPriceUpdates(options, sendOptions) {
+    const stream = await this.#transport.stream(
+      "/v2/updates/price/stream",
+      {
+        ...updateQuery(options),
+        allow_unordered: options.allowUnordered,
+        benchmarks_only: options.benchmarksOnly
+      },
+      sendOptions
+    );
+    const response = stream.response;
+    if (!response.body) {
+      stream.close();
+      throw new ErpcInvalidResponseError("ERPC returned an empty stream");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value, { stream: !done });
+        let boundary = buffer.search(/\r?\n\r?\n/);
+        while (boundary !== -1) {
+          const separatorLength = buffer.slice(boundary).startsWith("\r\n") ? 4 : 2;
+          const block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + separatorLength);
+          const event = parseSseBlock(block);
+          if (event) yield event;
+          boundary = buffer.search(/\r?\n\r?\n/);
+        }
+        if (done) break;
+      }
+      const finalEvent = parseSseBlock(buffer);
+      if (finalEvent) yield finalEvent;
+    } catch (error) {
+      throw stream.normalizeError(error);
+    } finally {
+      try {
+        await reader.cancel();
+      } catch {
+      } finally {
+        reader.releaseLock();
+        stream.close();
+      }
+    }
+  }
+};
+
+// src/rpc/client.ts
+var PendingRpcRequest = class {
+  #send;
+  constructor(send) {
+    this.#send = send;
+  }
+  send(options) {
+    return this.#send(options);
+  }
+};
+var PendingRpcBatchRequest = class {
+  #send;
+  constructor(send) {
+    this.#send = send;
+  }
+  send(options) {
+    return this.#send(options);
+  }
+};
+var methodParams = (mode, args) => {
+  if (mode === "positional") return args;
+  if (args.length === 0) return void 0;
+  return args[0];
+};
+var createRpcNamespace = (config) => {
+  const base = {
+    endpoint: config.transport.endpoint,
+    batch: (calls) => {
+      const wireCalls = calls;
+      config.validateBatch?.(wireCalls);
+      return new PendingRpcBatchRequest(
+        (options) => config.transport.batch(
+          wireCalls,
+          options
+        )
+      );
+    },
+    raw: (method, params) => new PendingRpcRequest(
+      (options) => config.transport.request(method, params, options)
+    ),
+    request: (method, ...params) => new PendingRpcRequest(
+      (options) => config.transport.request(
+        method,
+        params[0],
+        options
+      )
+    )
+  };
+  return new Proxy(base, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property === "then") return void 0;
+      return (...args) => new PendingRpcRequest(
+        (options) => config.transport.request(
+          property,
+          methodParams(config.parameterMode, args),
+          options
+        )
+      );
+    }
+  });
+};
+
+// src/rpc/ethereum.ts
+var ETHEREUM_RPC_METHODS = [
+  "eth_accounts",
+  "eth_baseFee",
+  "eth_blobBaseFee",
+  "eth_blockNumber",
+  "eth_call",
+  "eth_callMany",
+  "eth_capabilities",
+  "eth_chainId",
+  "eth_createAccessList",
+  "eth_estimateGas",
+  "eth_feeHistory",
+  "eth_gasPrice",
+  "eth_getAccount",
+  "eth_getBalance",
+  "eth_getBlockByHash",
+  "eth_getBlockByNumber",
+  "eth_getBlockReceipts",
+  "eth_getBlockTransactionCountByHash",
+  "eth_getBlockTransactionCountByNumber",
+  "eth_getCode",
+  "eth_getFilterChanges",
+  "eth_getFilterLogs",
+  "eth_getLogs",
+  "eth_getProof",
+  "eth_getRawTransactionByHash",
+  "eth_getStorageAt",
+  "eth_getTransactionByBlockHashAndIndex",
+  "eth_getTransactionByBlockNumberAndIndex",
+  "eth_getTransactionByHash",
+  "eth_getTransactionBySenderAndNonce",
+  "eth_getTransactionCount",
+  "eth_getTransactionReceipt",
+  "eth_getUncleCountByBlockHash",
+  "eth_getUncleCountByBlockNumber",
+  "eth_maxPriorityFeePerGas",
+  "eth_newBlockFilter",
+  "eth_newFilter",
+  "eth_newPendingTransactionFilter",
+  "eth_sendRawTransaction",
+  "eth_signTransaction",
+  "eth_simulateV1",
+  "eth_submitWork",
+  "eth_syncing",
+  "eth_uninstallFilter",
+  "net_listening",
+  "net_peerCount",
+  "net_version",
+  "txpool_content",
+  "txpool_contentFrom",
+  "txpool_inspect",
+  "txpool_status",
+  "web3_clientVersion",
+  "web3_sha3"
+];
+var ETHEREUM_SUBSCRIPTION_METHODS = [
+  "eth_subscribe",
+  "eth_unsubscribe"
+];
+var createEthereumClient = (transport) => ({
+  rpc: createRpcNamespace({
+    transport,
+    parameterMode: "positional"
+  })
+});
+
+// src/rpc/solana.ts
+var SOLANA_RPC_METHODS = [
+  "getAccountInfo",
+  "getBalance",
+  "getBlock",
+  "getBlockCommitment",
+  "getBlockHeight",
+  "getBlockProduction",
+  "getBlockTime",
+  "getBlocks",
+  "getBlocksWithLimit",
+  "getClusterNodes",
+  "getEpochInfo",
+  "getEpochSchedule",
+  "getFeeForMessage",
+  "getFirstAvailableBlock",
+  "getGenesisHash",
+  "getHealth",
+  "getHighestSnapshotSlot",
+  "getIdentity",
+  "getInflationGovernor",
+  "getInflationRate",
+  "getInflationReward",
+  "getLargestAccounts",
+  "getLatestBlockhash",
+  "getLeaderSchedule",
+  "getMaxRetransmitSlot",
+  "getMaxShredInsertSlot",
+  "getMinimumBalanceForRentExemption",
+  "getMultipleAccounts",
+  "getParsedTransaction",
+  "getPriorityFeeEstimate",
+  "getProgramAccounts",
+  "getProgramAccountsV2",
+  "getRecentPerformanceSamples",
+  "getRecentPrioritizationFees",
+  "getSignatureStatuses",
+  "getSignaturesForAddress",
+  "getSlot",
+  "getSlotLeader",
+  "getSlotLeaders",
+  "getStakeMinimumDelegation",
+  "getSupply",
+  "getTokenAccountBalance",
+  "getTokenAccountsByDelegate",
+  "getTokenAccountsByOwner",
+  "getTokenLargestAccounts",
+  "getTokenSupply",
+  "getTransaction",
+  "getTransactionCount",
+  "getVersion",
+  "getVoteAccounts",
+  "isBlockhashValid",
+  "minimumLedgerSlot",
+  "requestAirdrop",
+  "sendTransaction",
+  "simulateTransaction"
+];
+var SOLANA_DAS_METHODS = [
+  "getAsset",
+  "getAssetBatch",
+  "getAssetProof",
+  "getAssetProofBatch",
+  "getAssetsByAuthority",
+  "getAssetsByCreator",
+  "getAssetsByGroup",
+  "getAssetsByOwner",
+  "getNftEditions",
+  "getSignaturesForAsset",
+  "getTokenAccounts",
+  "getTokensByDelegate",
+  "getTokensByOwner",
+  "searchAssets"
+];
+var SOLANA_HISTORY_METHODS = [
+  "getTransactionsForAddress",
+  "getTransfersByAddress"
+];
+var SOLANA_LEADER_METHODS = [
+  "getLeaderSlots",
+  "getValidatorsInformation"
+];
+var SOLANA_ANALYTICS_METHODS = [
+  "jetEpochSummary",
+  "jetProgramStats",
+  "jetSlotStats",
+  "jetTopPrograms",
+  "jetTpsTimeseries"
+];
+var heavyRpcMethods = /* @__PURE__ */ new Set([
+  "getPriorityFeeEstimate",
+  "getProgramAccounts",
+  "getProgramAccountsV2",
+  "getTokenLargestAccounts"
+]);
+var validateStandardBatch = (calls) => {
+  let containsHeavy = false;
+  let containsStandard = false;
+  for (const call of calls) {
+    if (heavyRpcMethods.has(call.method)) containsHeavy = true;
+    else containsStandard = true;
+  }
+  if (containsHeavy && containsStandard) {
+    throw new ErpcBatchPolicyError(
+      "Solana indexed and standard RPC methods cannot share a batch"
+    );
+  }
+};
+var rejectLeaderBatch = (calls) => {
+  if (calls.length > 0) {
+    throw new ErpcBatchPolicyError("Leader RPC methods do not support batching");
+  }
+};
+var createSolanaClient = (transport) => ({
+  rpc: createRpcNamespace({
+    transport,
+    parameterMode: "positional",
+    validateBatch: validateStandardBatch
+  }),
+  das: createRpcNamespace({
+    transport,
+    parameterMode: "named"
+  }),
+  history: createRpcNamespace({
+    transport,
+    parameterMode: "positional"
+  }),
+  leaders: createRpcNamespace({
+    transport,
+    parameterMode: "positional",
+    validateBatch: rejectLeaderBatch
+  }),
+  analytics: createRpcNamespace({
+    transport,
+    parameterMode: "positional"
+  })
+});
+
+// src/transport/websocket.ts
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRpcError = (value) => isObject(value) && typeof value.code === "number" && typeof value.message === "string";
+var publicEndpoint = (endpoint) => {
+  const url = new URL(endpoint);
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+};
+var WebSocketJsonRpcTransport = class {
+  endpoint;
+  maxBatchSize;
+  #connectionUrl;
+  #credential;
+  #listeners = /* @__PURE__ */ new Set();
+  #pending = /* @__PURE__ */ new Map();
+  #timeoutMs;
+  #webSocket;
+  #connectPromise;
+  #nextId = 1;
+  #socket;
+  constructor(config) {
+    const implementation = config.webSocket ?? globalThis.WebSocket;
+    if (typeof implementation === "function") this.#webSocket = implementation;
+    this.#credential = config.endpoint.searchParams.get("api-key") ?? void 0;
+    this.#connectionUrl = config.endpoint.toString();
+    this.endpoint = publicEndpoint(config.endpoint);
+    this.maxBatchSize = config.maxBatchSize ?? 256;
+    this.#timeoutMs = config.timeoutMs;
+  }
+  async connect() {
+    if (this.#socket?.readyState === 1) return;
+    if (this.#connectPromise) return this.#connectPromise;
+    if (!this.#webSocket) {
+      throw new ErpcConfigError(
+        "A WebSocket implementation is required for subscriptions"
+      );
+    }
+    this.#connectPromise = new Promise((resolve, reject) => {
+      const socket = new this.#webSocket(this.#connectionUrl);
+      this.#socket = socket;
+      const timeout = setTimeout(() => {
+        socket.close();
+        reject(new ErpcTimeoutError(this.#timeoutMs));
+      }, this.#timeoutMs);
+      socket.addEventListener(
+        "open",
+        () => {
+          clearTimeout(timeout);
+          resolve();
+        },
+        { once: true }
+      );
+      socket.addEventListener(
+        "error",
+        () => {
+          clearTimeout(timeout);
+          reject(new ErpcTransportError("Unable to connect to ERPC WebSocket"));
+        },
+        { once: true }
+      );
+      socket.addEventListener("message", (event) => {
+        void this.#onMessage(event.data);
+      });
+      socket.addEventListener("close", () => {
+        this.#socket = void 0;
+        this.#connectPromise = void 0;
+        const error = new ErpcTransportError("ERPC WebSocket connection closed");
+        for (const pending of this.#pending.values()) pending.reject(error);
+        this.#pending.clear();
+      });
+    }).catch((error) => {
+      this.#connectPromise = void 0;
+      throw error;
+    });
+    return this.#connectPromise;
+  }
+  close(code = 1e3, reason = "Client closed connection") {
+    this.#socket?.close(code, reason);
+    this.#socket = void 0;
+    this.#connectPromise = void 0;
+  }
+  onNotification(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  async request(method, params, options = {}) {
+    await this.connect();
+    const id = this.#id();
+    const promise = this.#waitFor(id, options);
+    const request = { jsonrpc: "2.0", id, method };
+    if (params !== void 0) request.params = params;
+    this.#send(request, id);
+    return promise;
+  }
+  async batch(calls, options = {}) {
+    if (calls.length === 0) return [];
+    if (calls.length > this.maxBatchSize) {
+      throw new ErpcInvalidResponseError(
+        `A batch may contain at most ${this.maxBatchSize} calls`
+      );
+    }
+    await this.connect();
+    const requests = calls.map((call) => {
+      const id = this.#id();
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method: call.method
+      };
+      if (call.params !== void 0) request.params = call.params;
+      return { id, request, response: this.#waitFor(id, options) };
+    });
+    try {
+      this.#socket?.send(JSON.stringify(requests.map(({ request }) => request)));
+    } catch (error) {
+      for (const { id } of requests) this.#reject(id, error);
+    }
+    return Promise.all(requests.map(({ response }) => response));
+  }
+  #id() {
+    const id = this.#nextId;
+    this.#nextId = id >= Number.MAX_SAFE_INTEGER ? 1 : id + 1;
+    return id;
+  }
+  #send(request, id) {
+    try {
+      this.#socket?.send(JSON.stringify(request));
+    } catch (error) {
+      this.#reject(id, error);
+    }
+  }
+  #waitFor(id, options) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new ErpcTimeoutError(this.#timeoutMs));
+      }, this.#timeoutMs);
+      const abort = () => {
+        clearTimeout(timeout);
+        this.#pending.delete(id);
+        reject(new ErpcAbortedError());
+      };
+      options.signal?.addEventListener("abort", abort, { once: true });
+      const cleanup = () => {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener("abort", abort);
+      };
+      this.#pending.set(id, {
+        resolve: (value) => resolve(value),
+        reject,
+        cleanup
+      });
+      if (options.signal?.aborted) abort();
+    });
+  }
+  #reject(id, _reason) {
+    const pending = this.#pending.get(id);
+    if (!pending) return;
+    pending.cleanup();
+    this.#pending.delete(id);
+    pending.reject(
+      new ErpcTransportError("Unable to send ERPC WebSocket request")
+    );
+  }
+  async #onMessage(data) {
+    const text = await this.#messageText(data);
+    if (text === null) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (Array.isArray(parsed)) {
+      for (const item of parsed) this.#dispatch(item);
+    } else {
+      this.#dispatch(parsed);
+    }
+  }
+  async #messageText(data) {
+    if (typeof data === "string") return data;
+    if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+    if (ArrayBuffer.isView(data)) {
+      return new TextDecoder().decode(
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      );
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) return data.text();
+    return null;
+  }
+  #dispatch(message) {
+    if (!isObject(message)) return;
+    const id = message.id;
+    if (typeof id === "number" || typeof id === "string") {
+      const pending = this.#pending.get(id);
+      if (!pending) return;
+      pending.cleanup();
+      this.#pending.delete(id);
+      if (isRpcError(message.error)) {
+        pending.reject(
+          new ErpcJsonRpcError(
+            redactJsonRpcError(message.error, this.#credential)
+          )
+        );
+      } else if ("result" in message) pending.resolve(message.result);
+      else pending.reject(new ErpcInvalidResponseError());
+      return;
+    }
+    if (message.jsonrpc === "2.0" && typeof message.method === "string" && "params" in message) {
+      const notification = {
+        jsonrpc: "2.0",
+        method: message.method,
+        params: message.params
+      };
+      for (const listener of this.#listeners) listener(notification);
+    }
+  }
+};
+
+// src/subscriptions.ts
+var notificationParams = (notification) => {
+  if (typeof notification.params !== "object" || notification.params === null) {
+    return null;
+  }
+  const params = notification.params;
+  if (typeof params.subscription !== "number" && typeof params.subscription !== "string" || !("result" in params)) {
+    return null;
+  }
+  return {
+    subscription: params.subscription,
+    result: params.result
+  };
+};
+var RpcSubscription = class {
+  id;
+  #unsubscribe;
+  #closed = false;
+  constructor(id, unsubscribe) {
+    this.id = id;
+    this.#unsubscribe = unsubscribe;
+  }
+  async unsubscribe() {
+    if (this.#closed) return true;
+    const result = await this.#unsubscribe();
+    if (result) this.#closed = true;
+    return result;
+  }
+};
+var EthereumSubscriptions = class {
+  rpc;
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+    this.rpc = createRpcNamespace({
+      transport,
+      parameterMode: "positional"
+    });
+  }
+  close() {
+    this.#transport.close();
+  }
+  onNotification(listener) {
+    return this.#transport.onNotification(listener);
+  }
+  async subscribe(subscription, listener, ...options) {
+    let id;
+    const removeListener = this.#transport.onNotification((notification) => {
+      const params = notificationParams(notification);
+      if (params && params.subscription === id) listener(params.result);
+    });
+    try {
+      id = await this.#transport.request("eth_subscribe", [
+        subscription,
+        ...options
+      ]);
+    } catch (error) {
+      removeListener();
+      throw error;
+    }
+    return new RpcSubscription(id, async () => {
+      const result = await this.#transport.request("eth_unsubscribe", [
+        id
+      ]);
+      if (result) removeListener();
+      return result;
+    });
+  }
+};
+var SOLANA_ENHANCED_SUBSCRIPTION_METHODS = [
+  "accountSubscribe",
+  "accountUnsubscribe",
+  "transactionSubscribe",
+  "transactionUnsubscribe"
+];
+var SolanaSubscriptions = class {
+  rpc;
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+    this.rpc = createRpcNamespace({
+      transport,
+      parameterMode: "positional"
+    });
+  }
+  close() {
+    this.#transport.close();
+  }
+  onNotification(listener) {
+    return this.#transport.onNotification(listener);
+  }
+  accountSubscribe(address, listener, options) {
+    const params = options === void 0 ? [address] : [address, options];
+    return this.#subscribe(
+      "accountSubscribe",
+      params,
+      "accountUnsubscribe",
+      listener
+    );
+  }
+  transactionSubscribe(filter, listener, options) {
+    const params = options === void 0 ? [filter] : [filter, options];
+    return this.#subscribe(
+      "transactionSubscribe",
+      params,
+      "transactionUnsubscribe",
+      listener
+    );
+  }
+  async rawSubscribe(subscribeMethod, params, unsubscribeMethod, listener) {
+    return this.#subscribe(
+      subscribeMethod,
+      params,
+      unsubscribeMethod,
+      listener
+    );
+  }
+  async #subscribe(subscribeMethod, params, unsubscribeMethod, listener) {
+    let id;
+    const removeListener = this.#transport.onNotification((notification) => {
+      const value = notificationParams(notification);
+      if (value && value.subscription === id) listener(value.result);
+    });
+    try {
+      id = await this.#transport.request(subscribeMethod, params);
+    } catch (error) {
+      removeListener();
+      throw error;
+    }
+    return new RpcSubscription(id, async () => {
+      const result = await this.#transport.request(unsubscribeMethod, [
+        id
+      ]);
+      if (result) removeListener();
+      return result;
+    });
+  }
+};
+
+// src/transport/http.ts
+var controlledSignal2 = (timeoutMs, external) => {
+  const controller = new AbortController();
+  let didTimeOut = false;
+  const timeout = setTimeout(() => {
+    didTimeOut = true;
+    controller.abort();
+  }, timeoutMs);
+  const abort = () => controller.abort();
+  if (external?.aborted) controller.abort();
+  else external?.addEventListener("abort", abort, { once: true });
+  return {
+    signal: controller.signal,
+    timedOut: () => didTimeOut,
+    cleanup: () => {
+      clearTimeout(timeout);
+      external?.removeEventListener("abort", abort);
+    }
+  };
+};
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFailure = (value) => isObject2(value) && isObject2(value.error) && typeof value.error.code === "number" && typeof value.error.message === "string";
+var parseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ErpcInvalidResponseError("ERPC returned malformed JSON");
+  }
+};
+var HttpJsonRpcTransport = class {
+  endpoint;
+  maxBatchSize;
+  #apiKey;
+  #fetch;
+  #headers;
+  #timeoutMs;
+  #nextId = 1;
+  constructor(config) {
+    this.#apiKey = config.apiKey;
+    this.#fetch = config.fetch;
+    this.#headers = config.headers;
+    this.#timeoutMs = config.timeoutMs;
+    this.maxBatchSize = config.maxBatchSize ?? 256;
+    const endpoint = new URL(config.endpoint);
+    endpoint.search = "";
+    endpoint.hash = "";
+    this.endpoint = endpoint.toString();
+  }
+  async request(method, params, options = {}) {
+    const id = this.#id();
+    const request = this.#request(id, method, params);
+    const response = await this.#post(request, options);
+    return this.#unwrap(response, id);
+  }
+  async batch(calls, options = {}) {
+    if (calls.length === 0) return [];
+    if (calls.length > this.maxBatchSize) {
+      throw new ErpcInvalidResponseError(
+        `A batch may contain at most ${this.maxBatchSize} calls`
+      );
+    }
+    const requests = calls.map((call) => {
+      const id = this.#id();
+      return this.#request(id, call.method, call.params);
+    });
+    const raw = await this.#post(requests, options);
+    if (!Array.isArray(raw)) {
+      if (isFailure(raw)) {
+        throw new ErpcJsonRpcError(redactJsonRpcError(raw.error, this.#apiKey));
+      }
+      throw new ErpcInvalidResponseError("ERPC returned a non-array batch response");
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const response of raw) {
+      if (!isObject2(response) || !("id" in response)) {
+        throw new ErpcInvalidResponseError("ERPC returned an invalid batch item");
+      }
+      const id = response.id;
+      if (typeof id !== "number" && typeof id !== "string") {
+        throw new ErpcInvalidResponseError("ERPC returned an invalid batch id");
+      }
+      byId.set(id, response);
+    }
+    const results = requests.map((request) => {
+      const response = byId.get(request.id);
+      if (response === void 0) {
+        throw new ErpcInvalidResponseError(
+          `ERPC omitted batch response id ${String(request.id)}`
+        );
+      }
+      return this.#unwrap(response, request.id);
+    });
+    return results;
+  }
+  #id() {
+    const id = this.#nextId;
+    this.#nextId = id >= Number.MAX_SAFE_INTEGER ? 1 : id + 1;
+    return id;
+  }
+  #request(id, method, params) {
+    const request = { jsonrpc: "2.0", id, method };
+    if (params !== void 0) request.params = params;
+    return request;
+  }
+  async #post(body, options) {
+    const url = new URL(this.endpoint);
+    url.searchParams.set("api-key", this.#apiKey);
+    const controlled = controlledSignal2(this.#timeoutMs, options.signal);
+    try {
+      const response = await this.#fetch(url, {
+        method: "POST",
+        headers: {
+          ...this.#headers,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: controlled.signal
+      });
+      const text = await response.text();
+      if (!response.ok) throw new ErpcHttpError(response.status);
+      return parseJson(text);
+    } catch (error) {
+      if (error instanceof ErpcHttpError || error instanceof ErpcInvalidResponseError) {
+        throw error;
+      }
+      if (controlled.timedOut()) throw new ErpcTimeoutError(this.#timeoutMs);
+      if (options.signal?.aborted) throw new ErpcAbortedError();
+      throw new ErpcTransportError("Unable to reach ERPC");
+    } finally {
+      controlled.cleanup();
+    }
+  }
+  #unwrap(response, expectedId) {
+    if (!isObject2(response)) throw new ErpcInvalidResponseError();
+    if (response.id !== expectedId) {
+      throw new ErpcInvalidResponseError("ERPC returned an unexpected response id");
+    }
+    if (isFailure(response)) {
+      throw new ErpcJsonRpcError(
+        redactJsonRpcError(response.error, this.#apiKey)
+      );
+    }
+    if (!("result" in response)) throw new ErpcInvalidResponseError();
+    return response.result;
+  }
+};
+
+// src/client.ts
+var createErpcClient = (config) => {
+  const resolved = resolveConfig(config);
+  const sharedTransport = {
+    apiKey: resolved.apiKey,
+    fetch: resolved.fetch,
+    headers: resolved.headers,
+    timeoutMs: resolved.timeoutMs
+  };
+  const solanaTransport = new HttpJsonRpcTransport({
+    ...sharedTransport,
+    endpoint: resolved.endpoint
+  });
+  const ethereumEndpoint = endpointWithPath(resolved.endpoint, "/eth");
+  const ethereumTransport = new HttpJsonRpcTransport({
+    ...sharedTransport,
+    endpoint: ethereumEndpoint
+  });
+  const solanaWebSocket = new WebSocketJsonRpcTransport({
+    endpoint: websocketUrl(resolved.endpoint, resolved.apiKey),
+    timeoutMs: resolved.timeoutMs,
+    ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
+  });
+  const ethereumWebSocket = new WebSocketJsonRpcTransport({
+    endpoint: websocketUrl(resolved.endpoint, resolved.apiKey, "/eth"),
+    timeoutMs: resolved.timeoutMs,
+    ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
+  });
+  const priceTransport = new RestTransport({
+    ...sharedTransport,
+    endpoint: resolved.endpoint
+  });
+  const accountTransport = new RestTransport({
+    ...sharedTransport,
+    endpoint: resolved.accountEndpoint
+  });
+  const solana = {
+    ...createSolanaClient(solanaTransport),
+    subscriptions: new SolanaSubscriptions(solanaWebSocket)
+  };
+  const ethereum = {
+    ...createEthereumClient(ethereumTransport),
+    subscriptions: new EthereumSubscriptions(ethereumWebSocket)
+  };
+  return {
+    solana,
+    ethereum,
+    price: new PriceClient(priceTransport),
+    account: new AccountClient(accountTransport),
+    close: () => {
+      solana.subscriptions.close();
+      ethereum.subscriptions.close();
+    }
+  };
+};
+
+export { AccountClient, DEFAULT_ACCOUNT_ENDPOINT, DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS, ETHEREUM_RPC_METHODS, ETHEREUM_SUBSCRIPTION_METHODS, ErpcAbortedError, ErpcBatchPolicyError, ErpcConfigError, ErpcError, ErpcHttpError, ErpcInvalidResponseError, ErpcJsonRpcError, ErpcTimeoutError, ErpcTransportError, EthereumSubscriptions, PendingRpcBatchRequest, PendingRpcRequest, PriceClient, RpcSubscription, SOLANA_ANALYTICS_METHODS, SOLANA_DAS_METHODS, SOLANA_ENHANCED_SUBSCRIPTION_METHODS, SOLANA_HISTORY_METHODS, SOLANA_LEADER_METHODS, SOLANA_RPC_METHODS, SolanaSubscriptions, createErpcClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map