@inodra/sui 0.1.0

package/dist/chunk-U6D5LGNF.js

@@ -0,0 +1,111 @@
+// src/core/auth.ts
+function resolveAuth(auth) {
+  if (typeof auth === "string") {
+    return staticAuth(apiKeyCredentials(auth));
+  }
+  if ("apiKey" in auth) {
+    return staticAuth(apiKeyCredentials(auth.apiKey));
+  }
+  if ("sessionToken" in auth) {
+    return staticAuth({
+      headers: { authorization: `Bearer ${auth.sessionToken}` }
+    });
+  }
+  return {
+    credentials: async () => auth.getCredentials(),
+    staticCredentials: () => void 0
+  };
+}
+function authFromOptions(options, context) {
+  if (options.auth !== void 0) {
+    return resolveAuth(options.auth);
+  }
+  if (options.apiKey) {
+    return resolveAuth(options.apiKey);
+  }
+  throw new Error(`${context} requires auth (or the apiKey shorthand)`);
+}
+function staticAuthHeaders(options, context) {
+  const credentials = authFromOptions(options, context).staticCredentials();
+  if (!credentials) {
+    throw new Error(
+      `${context} does not support dynamic credential providers \u2014 pass an apiKey or sessionToken`
+    );
+  }
+  return credentials.headers;
+}
+function apiKeyCredentials(apiKey) {
+  if (!apiKey) {
+    throw new Error("Inodra auth: apiKey must be a non-empty string");
+  }
+  return {
+    headers: { "x-api-key": apiKey },
+    queryParams: { api_key: apiKey }
+  };
+}
+function staticAuth(credentials) {
+  return {
+    credentials: async () => credentials,
+    staticCredentials: () => credentials
+  };
+}
+
+// src/core/network.ts
+var INODRA_ENDPOINTS = {
+  mainnet: {
+    rest: "https://mainnet-api.inodra.com/v1",
+    graphql: "https://mainnet-api.inodra.com/v1/graphql",
+    /** host:port for native gRPC transports */
+    grpc: "mainnet-grpc.inodra.com:443",
+    /** base URL for gRPC-Web transports */
+    grpcWeb: "https://mainnet-grpc.inodra.com",
+    warpWs: "wss://mainnet-api.inodra.com/v1"
+  },
+  testnet: {
+    rest: "https://testnet-api.inodra.com/v1",
+    graphql: "https://testnet-api.inodra.com/v1/graphql",
+    grpc: "testnet-grpc.inodra.com:443",
+    grpcWeb: "https://testnet-grpc.inodra.com",
+    warpWs: "wss://testnet-api.inodra.com/v1"
+  }
+};
+function restBaseUrl(network) {
+  return INODRA_ENDPOINTS[network].rest;
+}
+function graphqlUrl(network) {
+  return INODRA_ENDPOINTS[network].graphql;
+}
+function grpcBaseUrl(network) {
+  return INODRA_ENDPOINTS[network].grpcWeb;
+}
+function grpcHost(network) {
+  return INODRA_ENDPOINTS[network].grpc;
+}
+function warpStreamUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].rest}/warp/${subscriptionId}/stream`;
+}
+function warpWebSocketUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].warpWs}/warp/${subscriptionId}/ws`;
+}
+
+// src/core/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_HEADER_NAME = "x-inodra-sdk";
+var SDK_HEADER_VALUE = `inodra-sdk-ts/${SDK_VERSION}`;
+
+export {
+  resolveAuth,
+  authFromOptions,
+  staticAuthHeaders,
+  INODRA_ENDPOINTS,
+  restBaseUrl,
+  graphqlUrl,
+  grpcBaseUrl,
+  grpcHost,
+  warpStreamUrl,
+  warpWebSocketUrl,
+  SDK_VERSION,
+  SDK_HEADER_NAME,
+  SDK_HEADER_VALUE
+};
+//# sourceMappingURL=chunk-U6D5LGNF.js.map

package/dist/chunk-U6D5LGNF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/auth.ts","../src/core/network.ts","../src/core/version.ts"],"sourcesContent":["/**\n * Pluggable authentication for every Inodra transport.\n *\n * Most users pass an API key. The provider shape exists so future credential\n * types (x402 wallet session tokens, refreshing vault-issued keys) slot in\n * without changing any client constructor.\n */\n\nexport interface AuthCredentials {\n\t/** Sent as HTTP headers (REST, SSE, GraphQL) and gRPC metadata. */\n\theaders: Record<string, string>;\n\t/**\n\t * Sent as URL query parameters on transports that cannot carry headers\n\t * (WebSocket upgrades in browsers). Omit to disallow such transports.\n\t */\n\tqueryParams?: Record<string, string>;\n}\n\nexport type InodraAuth =\n\t| string\n\t| { apiKey: string }\n\t| { sessionToken: string }\n\t| {\n\t\t\tgetCredentials: () => AuthCredentials | Promise<AuthCredentials>;\n\t  };\n\n/** Normalized auth handle used internally by every transport. */\nexport interface ResolvedAuth {\n\t/** Resolve credentials. Called per request on REST/SSE, per connect on WS. */\n\tcredentials(): Promise<AuthCredentials>;\n\t/**\n\t * Resolve credentials synchronously, or undefined for dynamic providers.\n\t * Used by clients whose underlying transport takes static headers\n\t * (gRPC, GraphQL).\n\t */\n\tstaticCredentials(): AuthCredentials | undefined;\n}\n\nexport function resolveAuth(auth: InodraAuth): ResolvedAuth {\n\tif (typeof auth === \"string\") {\n\t\treturn staticAuth(apiKeyCredentials(auth));\n\t}\n\tif (\"apiKey\" in auth) {\n\t\treturn staticAuth(apiKeyCredentials(auth.apiKey));\n\t}\n\tif (\"sessionToken\" in auth) {\n\t\treturn staticAuth({\n\t\t\theaders: { authorization: `Bearer ${auth.sessionToken}` },\n\t\t});\n\t}\n\treturn {\n\t\tcredentials: async () => auth.getCredentials(),\n\t\tstaticCredentials: () => undefined,\n\t};\n}\n\n/**\n * Resolve auth from an options bag that accepts both the modern `auth` field\n * and the original `apiKey` shorthand.\n */\nexport function authFromOptions(\n\toptions: { auth?: InodraAuth; apiKey?: string },\n\tcontext: string,\n): ResolvedAuth {\n\tif (options.auth !== undefined) {\n\t\treturn resolveAuth(options.auth);\n\t}\n\tif (options.apiKey) {\n\t\treturn resolveAuth(options.apiKey);\n\t}\n\tthrow new Error(`${context} requires auth (or the apiKey shorthand)`);\n}\n\n/**\n * Headers for clients whose transports take static headers (gRPC, GraphQL).\n * Dynamic providers are rejected: the underlying Mysten clients cannot\n * re-resolve credentials per call, so a snapshot would silently go stale.\n */\nexport function staticAuthHeaders(\n\toptions: { auth?: InodraAuth; apiKey?: string },\n\tcontext: string,\n): Record<string, string> {\n\tconst credentials = authFromOptions(options, context).staticCredentials();\n\tif (!credentials) {\n\t\tthrow new Error(\n\t\t\t`${context} does not support dynamic credential providers — pass an apiKey or sessionToken`,\n\t\t);\n\t}\n\treturn credentials.headers;\n}\n\nfunction apiKeyCredentials(apiKey: string): AuthCredentials {\n\tif (!apiKey) {\n\t\tthrow new Error(\"Inodra auth: apiKey must be a non-empty string\");\n\t}\n\treturn {\n\t\theaders: { \"x-api-key\": apiKey },\n\t\tqueryParams: { api_key: apiKey },\n\t};\n}\n\nfunction staticAuth(credentials: AuthCredentials): ResolvedAuth {\n\treturn {\n\t\tcredentials: async () => credentials,\n\t\tstaticCredentials: () => credentials,\n\t};\n}\n","export type InodraNetwork = \"mainnet\" | \"testnet\";\n\n/**\n * Canonical Inodra endpoints per network and protocol.\n */\nexport const INODRA_ENDPOINTS = {\n\tmainnet: {\n\t\trest: \"https://mainnet-api.inodra.com/v1\",\n\t\tgraphql: \"https://mainnet-api.inodra.com/v1/graphql\",\n\t\t/** host:port for native gRPC transports */\n\t\tgrpc: \"mainnet-grpc.inodra.com:443\",\n\t\t/** base URL for gRPC-Web transports */\n\t\tgrpcWeb: \"https://mainnet-grpc.inodra.com\",\n\t\twarpWs: \"wss://mainnet-api.inodra.com/v1\",\n\t},\n\ttestnet: {\n\t\trest: \"https://testnet-api.inodra.com/v1\",\n\t\tgraphql: \"https://testnet-api.inodra.com/v1/graphql\",\n\t\tgrpc: \"testnet-grpc.inodra.com:443\",\n\t\tgrpcWeb: \"https://testnet-grpc.inodra.com\",\n\t\twarpWs: \"wss://testnet-api.inodra.com/v1\",\n\t},\n} as const satisfies Record<\n\tInodraNetwork,\n\t{ rest: string; graphql: string; grpc: string; grpcWeb: string; warpWs: string }\n>;\n\nexport function restBaseUrl(network: InodraNetwork): string {\n\treturn INODRA_ENDPOINTS[network].rest;\n}\n\nexport function graphqlUrl(network: InodraNetwork): string {\n\treturn INODRA_ENDPOINTS[network].graphql;\n}\n\n/** Base URL for gRPC-Web / Connect transports. */\nexport function grpcBaseUrl(network: InodraNetwork): string {\n\treturn INODRA_ENDPOINTS[network].grpcWeb;\n}\n\n/** host:port for native gRPC transports. */\nexport function grpcHost(network: InodraNetwork): string {\n\treturn INODRA_ENDPOINTS[network].grpc;\n}\n\nexport function warpStreamUrl(\n\tnetwork: InodraNetwork,\n\tsubscriptionId: string,\n): string {\n\treturn `${INODRA_ENDPOINTS[network].rest}/warp/${subscriptionId}/stream`;\n}\n\nexport function warpWebSocketUrl(\n\tnetwork: InodraNetwork,\n\tsubscriptionId: string,\n): string {\n\treturn `${INODRA_ENDPOINTS[network].warpWs}/warp/${subscriptionId}/ws`;\n}\n","export const SDK_VERSION = \"0.1.0\";\n\n/**\n * Identifies the SDK to Inodra on every request, alongside the API key.\n * Sent on REST, GraphQL, SSE (headers) and gRPC (metadata). Browsers cannot\n * attach headers to WebSocket upgrades, so the Warp WS client omits it.\n */\nexport const SDK_HEADER_NAME = \"x-inodra-sdk\";\nexport const SDK_HEADER_VALUE = `inodra-sdk-ts/${SDK_VERSION}`;\n"],"mappings":";AAsCO,SAAS,YAAY,MAAgC;AAC3D,MAAI,OAAO,SAAS,UAAU;AAC7B,WAAO,WAAW,kBAAkB,IAAI,CAAC;AAAA,EAC1C;AACA,MAAI,YAAY,MAAM;AACrB,WAAO,WAAW,kBAAkB,KAAK,MAAM,CAAC;AAAA,EACjD;AACA,MAAI,kBAAkB,MAAM;AAC3B,WAAO,WAAW;AAAA,MACjB,SAAS,EAAE,eAAe,UAAU,KAAK,YAAY,GAAG;AAAA,IACzD,CAAC;AAAA,EACF;AACA,SAAO;AAAA,IACN,aAAa,YAAY,KAAK,eAAe;AAAA,IAC7C,mBAAmB,MAAM;AAAA,EAC1B;AACD;AAMO,SAAS,gBACf,SACA,SACe;AACf,MAAI,QAAQ,SAAS,QAAW;AAC/B,WAAO,YAAY,QAAQ,IAAI;AAAA,EAChC;AACA,MAAI,QAAQ,QAAQ;AACnB,WAAO,YAAY,QAAQ,MAAM;AAAA,EAClC;AACA,QAAM,IAAI,MAAM,GAAG,OAAO,0CAA0C;AACrE;AAOO,SAAS,kBACf,SACA,SACyB;AACzB,QAAM,cAAc,gBAAgB,SAAS,OAAO,EAAE,kBAAkB;AACxE,MAAI,CAAC,aAAa;AACjB,UAAM,IAAI;AAAA,MACT,GAAG,OAAO;AAAA,IACX;AAAA,EACD;AACA,SAAO,YAAY;AACpB;AAEA,SAAS,kBAAkB,QAAiC;AAC3D,MAAI,CAAC,QAAQ;AACZ,UAAM,IAAI,MAAM,gDAAgD;AAAA,EACjE;AACA,SAAO;AAAA,IACN,SAAS,EAAE,aAAa,OAAO;AAAA,IAC/B,aAAa,EAAE,SAAS,OAAO;AAAA,EAChC;AACD;AAEA,SAAS,WAAW,aAA4C;AAC/D,SAAO;AAAA,IACN,aAAa,YAAY;AAAA,IACzB,mBAAmB,MAAM;AAAA,EAC1B;AACD;;;ACrGO,IAAM,mBAAmB;AAAA,EAC/B,SAAS;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA;AAAA,IAET,MAAM;AAAA;AAAA,IAEN,SAAS;AAAA,IACT,QAAQ;AAAA,EACT;AAAA,EACA,SAAS;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA,IACT,MAAM;AAAA,IACN,SAAS;AAAA,IACT,QAAQ;AAAA,EACT;AACD;AAKO,SAAS,YAAY,SAAgC;AAC3D,SAAO,iBAAiB,OAAO,EAAE;AAClC;AAEO,SAAS,WAAW,SAAgC;AAC1D,SAAO,iBAAiB,OAAO,EAAE;AAClC;AAGO,SAAS,YAAY,SAAgC;AAC3D,SAAO,iBAAiB,OAAO,EAAE;AAClC;AAGO,SAAS,SAAS,SAAgC;AACxD,SAAO,iBAAiB,OAAO,EAAE;AAClC;AAEO,SAAS,cACf,SACA,gBACS;AACT,SAAO,GAAG,iBAAiB,OAAO,EAAE,IAAI,SAAS,cAAc;AAChE;AAEO,SAAS,iBACf,SACA,gBACS;AACT,SAAO,GAAG,iBAAiB,OAAO,EAAE,MAAM,SAAS,cAAc;AAClE;;;ACzDO,IAAM,cAAc;AAOpB,IAAM,kBAAkB;AACxB,IAAM,mBAAmB,iBAAiB,WAAW;","names":[]}

package/dist/chunk-ZSW3EWGF.js

@@ -0,0 +1,539 @@
+import {
+  SDK_HEADER_NAME,
+  SDK_HEADER_VALUE,
+  authFromOptions,
+  warpStreamUrl,
+  warpWebSocketUrl
+} from "./chunk-U6D5LGNF.js";
+
+// src/warp/iterate.ts
+async function* iterateStream(stream, options = {}) {
+  const queue = [];
+  let notify;
+  let closed = false;
+  let failure;
+  const unsubscribes = [
+    stream.on("message", (event) => {
+      queue.push(event);
+      notify?.();
+    }),
+    stream.on("close", ({ reason }) => {
+      closed = true;
+      if (reason !== "client closed") {
+        failure = new Error(`Warp stream closed: ${reason}`);
+      }
+      notify?.();
+    })
+  ];
+  try {
+    for (; ; ) {
+      while (queue.length > 0) {
+        yield queue.shift();
+      }
+      if (closed) {
+        if (failure) {
+          throw failure;
+        }
+        return;
+      }
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = void 0;
+    }
+  } finally {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+    if (options.closeOnReturn ?? true) {
+      stream.close();
+    }
+  }
+}
+
+// src/warp/emitter.ts
+var Emitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => set?.delete(handler);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  /** Returns false if any handler threw. */
+  emit(event, payload) {
+    let ok = true;
+    for (const handler of this.handlers.get(event) ?? []) {
+      try {
+        handler(payload);
+      } catch {
+        ok = false;
+      }
+    }
+    return ok;
+  }
+};
+
+// src/warp/sse-parser.ts
+var SseParser = class {
+  buffer = "";
+  eventName = "";
+  dataLines = [];
+  id;
+  retryMs;
+  feed(chunk) {
+    this.buffer += chunk;
+    const messages = [];
+    for (; ; ) {
+      const newline = this.buffer.search(/\r\n|\r|\n/);
+      if (newline === -1) {
+        break;
+      }
+      const line = this.buffer.slice(0, newline);
+      const sep = this.buffer.slice(newline, newline + 2);
+      this.buffer = this.buffer.slice(newline + (sep === "\r\n" ? 2 : 1));
+      if (line === "") {
+        const message = this.flush();
+        if (message) {
+          messages.push(message);
+        }
+        continue;
+      }
+      this.parseLine(line);
+    }
+    return messages;
+  }
+  parseLine(line) {
+    if (line.startsWith(":")) {
+      return;
+    }
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) {
+      value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        this.eventName = value;
+        break;
+      case "data":
+        this.dataLines.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) {
+          this.id = value;
+        }
+        break;
+      case "retry": {
+        const ms = Number(value);
+        if (Number.isInteger(ms) && ms >= 0) {
+          this.retryMs = ms;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  flush() {
+    if (this.dataLines.length === 0 && this.eventName === "") {
+      const retryOnly = this.retryMs;
+      this.retryMs = void 0;
+      return retryOnly === void 0 ? void 0 : { event: "", data: "", retryMs: retryOnly };
+    }
+    const message = {
+      event: this.eventName || "message",
+      data: this.dataLines.join("\n"),
+      id: this.id,
+      retryMs: this.retryMs
+    };
+    this.eventName = "";
+    this.dataLines = [];
+    this.retryMs = void 0;
+    return message;
+  }
+};
+
+// src/warp/types.ts
+var CONTROL_EVENTS = /* @__PURE__ */ new Set(["connected", "error", "quota_exceeded"]);
+function backoffDelayMs(attempt) {
+  return Math.min(1e3 * 2 ** (attempt - 1), 3e4) + Math.random() * 250;
+}
+
+// src/warp/sse.ts
+var WarpSseStream = class extends Emitter {
+  lastEventId;
+  options;
+  auth;
+  url;
+  fetchImpl;
+  abort;
+  reconnectAttempt = 0;
+  serverRetryMs;
+  closed = false;
+  closeEmitted = false;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.auth = authFromOptions(options, "WarpSseStream");
+    const base = options.url ?? warpStreamUrl(options.network ?? "mainnet", options.subscriptionId);
+    if (options.mode !== void 0) {
+      const url = new URL(base);
+      url.searchParams.set("mode", options.mode);
+      this.url = url.toString();
+    } else {
+      this.url = base;
+    }
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.lastEventId = options.lastEventId;
+  }
+  connect() {
+    if (this.abort) {
+      return;
+    }
+    this.closed = false;
+    this.closeEmitted = false;
+    this.abort = new AbortController();
+    void this.run(this.abort.signal);
+  }
+  close() {
+    const wasActive = this.abort !== void 0;
+    this.closed = true;
+    this.abort?.abort();
+    this.abort = void 0;
+    if (wasActive) {
+      this.emitClose("client closed");
+    }
+  }
+  /** Emit "close" exactly once per connection lifecycle. */
+  emitClose(reason) {
+    if (this.closeEmitted) {
+      return;
+    }
+    this.closeEmitted = true;
+    this.emit("close", { reason });
+  }
+  /** Iterate data events; ends when the stream closes (throws unless client-initiated). */
+  [Symbol.asyncIterator]() {
+    return iterateStream(this);
+  }
+  async run(signal) {
+    for (; ; ) {
+      try {
+        await this.consume(signal);
+        if (this.closed || signal.aborted) {
+          return;
+        }
+      } catch (error) {
+        if (this.closed || signal.aborted) {
+          return;
+        }
+        if (error instanceof TerminalStreamError) {
+          this.emit("error", error);
+          this.emitClose(error.message);
+          this.close();
+          return;
+        }
+        this.emit(
+          "error",
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      if (!(this.options.reconnect ?? true)) {
+        this.emitClose("disconnected");
+        this.close();
+        return;
+      }
+      this.reconnectAttempt += 1;
+      if (this.reconnectAttempt > (this.options.maxReconnectAttempts ?? 10)) {
+        this.emitClose("max reconnect attempts exceeded");
+        this.close();
+        return;
+      }
+      const delayMs = this.serverRetryMs ?? backoffDelayMs(this.reconnectAttempt);
+      this.emit("reconnecting", { attempt: this.reconnectAttempt, delayMs });
+      await sleep(delayMs);
+      if (this.closed || signal.aborted) {
+        return;
+      }
+    }
+  }
+  async consume(signal) {
+    const { headers: authHeaders } = await this.auth.credentials();
+    const headers = {
+      accept: "text/event-stream",
+      ...authHeaders,
+      [SDK_HEADER_NAME]: SDK_HEADER_VALUE
+    };
+    if (this.lastEventId !== void 0) {
+      headers["Last-Event-ID"] = this.lastEventId;
+    }
+    const response = await this.fetchImpl(this.url, { headers, signal });
+    if (!response.ok || !response.body) {
+      const retryable = response.status >= 500;
+      const message = `SSE connection failed with status ${response.status}`;
+      if (retryable) {
+        throw new Error(message);
+      }
+      throw new TerminalStreamError(message);
+    }
+    const parser = new SseParser();
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      for (const message of parser.feed(decoder.decode(value, { stream: true }))) {
+        if (message.retryMs !== void 0) {
+          this.serverRetryMs = message.retryMs;
+        }
+        if (message.event === "" && message.data === "") {
+          continue;
+        }
+        this.dispatch(message.event, message.id, message.data);
+      }
+    }
+  }
+  dispatch(event, id, raw) {
+    let data = raw;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+    }
+    if (id !== void 0) {
+      this.lastEventId = id;
+    }
+    switch (event) {
+      case "connected":
+        this.reconnectAttempt = 0;
+        this.emit("connected", data);
+        return;
+      case "quota_exceeded":
+        this.emit("quota_exceeded", data);
+        this.emitClose("quota_exceeded");
+        this.close();
+        return;
+      case "error": {
+        const message = typeof data === "object" && data !== null && "error" in data ? String(data.error) : raw;
+        this.emit("error", new Error(message));
+        return;
+      }
+      default:
+        if (!CONTROL_EVENTS.has(event)) {
+          this.emit("message", { type: event, id, data });
+        }
+    }
+  }
+};
+var TerminalStreamError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/warp/ws.ts
+var WarpWebSocketStream = class extends Emitter {
+  lastEventId;
+  options;
+  auth;
+  wsCtor;
+  ws;
+  reconnectAttempt = 0;
+  closed = false;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.auth = authFromOptions(options, "WarpWebSocketStream");
+    const ctor = options.webSocket ?? globalThis.WebSocket;
+    if (!ctor) {
+      throw new Error(
+        "No WebSocket implementation available \u2014 pass one via the webSocket option"
+      );
+    }
+    this.wsCtor = ctor;
+    this.lastEventId = options.lastEventId;
+  }
+  connect() {
+    if (this.ws) {
+      return;
+    }
+    this.closed = false;
+    this.open();
+  }
+  close() {
+    this.closed = true;
+    this.ws?.close(1e3, "client closed");
+    this.ws = void 0;
+  }
+  /** Acknowledge an event by ID (only needed with autoAck: false). */
+  ack(id) {
+    this.ws?.send(JSON.stringify({ type: "ack", id }));
+  }
+  /** Iterate data events; ends when the stream closes (throws unless client-initiated). */
+  [Symbol.asyncIterator]() {
+    return iterateStream(this);
+  }
+  buildUrl(authParams) {
+    const base = this.options.url ?? warpWebSocketUrl(
+      this.options.network ?? "mainnet",
+      this.options.subscriptionId
+    );
+    const url = new URL(base);
+    for (const [key, value] of Object.entries(authParams)) {
+      url.searchParams.set(key, value);
+    }
+    if (this.options.mode !== void 0) {
+      url.searchParams.set("mode", this.options.mode);
+    }
+    if (this.lastEventId !== void 0) {
+      url.searchParams.set("lastEventId", this.lastEventId);
+    }
+    return url.toString();
+  }
+  open() {
+    const credentials = this.auth.staticCredentials();
+    if (credentials) {
+      this.openWith(credentials.queryParams);
+      return;
+    }
+    void this.auth.credentials().then(
+      (resolved) => {
+        if (!this.closed && !this.ws) {
+          this.openWith(resolved.queryParams);
+        }
+      },
+      (error) => {
+        this.failTerminally(
+          error instanceof Error ? error : new Error(String(error)),
+          "credential resolution failed"
+        );
+      }
+    );
+  }
+  failTerminally(error, reason) {
+    this.closed = true;
+    this.emit("error", error);
+    this.emit("close", { reason });
+  }
+  openWith(authParams) {
+    if (!authParams) {
+      this.failTerminally(
+        new Error(
+          "These credentials cannot authenticate a WebSocket (no header support on upgrades) \u2014 use an API key or the SSE stream"
+        ),
+        "unsupported credentials"
+      );
+      return;
+    }
+    const ws = new this.wsCtor(this.buildUrl(authParams));
+    this.ws = ws;
+    ws.addEventListener("message", (event) => {
+      this.handleMessage(event);
+    });
+    ws.addEventListener("error", () => {
+      this.emit("error", new Error("WebSocket transport error"));
+    });
+    ws.addEventListener("close", (event) => {
+      if (this.ws !== ws) {
+        return;
+      }
+      this.ws = void 0;
+      this.handleClose(event.code, event.reason);
+    });
+  }
+  handleMessage(event) {
+    let parsed;
+    try {
+      parsed = JSON.parse(
+        typeof event.data === "string" ? event.data : String(event.data)
+      );
+    } catch {
+      this.emit("error", new Error("Received malformed WebSocket message"));
+      return;
+    }
+    const type = typeof parsed.event === "string" ? parsed.event : "message";
+    const id = typeof parsed.id === "string" ? parsed.id : void 0;
+    switch (type) {
+      case "connected":
+        this.reconnectAttempt = 0;
+        this.emit("connected", parsed.data);
+        return;
+      case "quota_exceeded":
+        this.emit("quota_exceeded", parsed.data);
+        return;
+      // server closes with 1008; handleClose makes it terminal
+      case "error": {
+        const message = typeof parsed.data === "object" && parsed.data !== null && "error" in parsed.data ? String(parsed.data.error) : "Server error";
+        this.emit("error", new Error(message));
+        return;
+      }
+      default: {
+        if (id !== void 0) {
+          this.lastEventId = id;
+        }
+        const handlersSucceeded = this.emit("message", {
+          type,
+          id,
+          data: parsed.data
+        });
+        if ((this.options.autoAck ?? true) && id !== void 0) {
+          if (handlersSucceeded) {
+            this.ack(id);
+          } else {
+            this.emit(
+              "error",
+              new Error(
+                `Message handler threw; event ${id} not acked and will be redelivered`
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+  handleClose(code, reason) {
+    if (this.closed) {
+      this.emit("close", { reason: "client closed" });
+      return;
+    }
+    if (code === 1008) {
+      this.emit("close", { reason: reason || "policy violation" });
+      this.closed = true;
+      return;
+    }
+    if (!(this.options.reconnect ?? true)) {
+      this.emit("close", { reason: reason || "disconnected" });
+      this.closed = true;
+      return;
+    }
+    this.reconnectAttempt += 1;
+    if (this.reconnectAttempt > (this.options.maxReconnectAttempts ?? 10)) {
+      this.emit("close", { reason: "max reconnect attempts exceeded" });
+      this.closed = true;
+      return;
+    }
+    const delayMs = backoffDelayMs(this.reconnectAttempt);
+    this.emit("reconnecting", { attempt: this.reconnectAttempt, delayMs });
+    setTimeout(() => {
+      if (!this.closed && !this.ws) {
+        this.open();
+      }
+    }, delayMs);
+  }
+};
+
+export {
+  iterateStream,
+  WarpSseStream,
+  WarpWebSocketStream
+};
+//# sourceMappingURL=chunk-ZSW3EWGF.js.map