@k256/sdk 0.1.0

package/dist/ws/index.js

@@ -0,0 +1,889 @@
+// src/utils/base58.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  const digits = [0];
+  for (let i = 0; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let leadingZeros = "";
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
+    leadingZeros += "1";
+  }
+  return leadingZeros + digits.reverse().map((d) => BASE58_ALPHABET[d]).join("");
+}
+
+// src/ws/types.ts
+var MessageType = {
+  /** Single pool state update (bincode) */
+  PoolUpdate: 1,
+  /** Subscribe request (JSON) - Client → Server */
+  Subscribe: 2,
+  /** Subscription confirmed (JSON) - Server → Client */
+  Subscribed: 3,
+  /** Unsubscribe all - Client → Server */
+  Unsubscribe: 4,
+  /** Priority fee update (bincode) */
+  PriorityFees: 5,
+  /** Recent blockhash (bincode) */
+  Blockhash: 6,
+  /** Streaming quote update (bincode) */
+  Quote: 7,
+  /** Quote subscription confirmed (JSON) */
+  QuoteSubscribed: 8,
+  /** Subscribe to quote stream (JSON) - Client → Server */
+  SubscribeQuote: 9,
+  /** Unsubscribe from quote (JSON) - Client → Server */
+  UnsubscribeQuote: 10,
+  /** Ping keepalive - Client → Server */
+  Ping: 11,
+  /** Pong response (bincode u64 timestamp) */
+  Pong: 12,
+  /** Connection heartbeat with stats (JSON) */
+  Heartbeat: 13,
+  /** Batched pool updates for high throughput */
+  PoolUpdateBatch: 14,
+  /** Error message (UTF-8 string) */
+  Error: 255
+};
+
+// src/ws/decoder.ts
+function decodeMessage(data) {
+  const view = new DataView(data);
+  if (data.byteLength < 1) return null;
+  const msgType = view.getUint8(0);
+  const payload = data.slice(1);
+  const payloadView = new DataView(payload);
+  switch (msgType) {
+    case MessageType.Subscribed:
+    case MessageType.QuoteSubscribed:
+    case MessageType.Heartbeat: {
+      const decoder = new TextDecoder();
+      const text = decoder.decode(payload);
+      try {
+        let type;
+        if (msgType === MessageType.QuoteSubscribed) {
+          type = "quote_subscribed";
+        } else if (msgType === MessageType.Heartbeat) {
+          type = "heartbeat";
+        } else {
+          type = "subscribed";
+        }
+        return {
+          type,
+          data: JSON.parse(text)
+        };
+      } catch {
+        return { type: "error", data: { message: text } };
+      }
+    }
+    case MessageType.Error: {
+      const decoder = new TextDecoder();
+      const text = decoder.decode(payload);
+      return { type: "error", data: { message: text } };
+    }
+    case MessageType.PriorityFees: {
+      if (payload.byteLength < 24) return null;
+      const slot = Number(payloadView.getBigUint64(0, true));
+      const timestampMs = Number(payloadView.getBigUint64(8, true));
+      const recommended = Number(payloadView.getBigUint64(16, true));
+      const state = payload.byteLength > 24 ? payloadView.getUint8(24) : 1;
+      const isStale = payload.byteLength > 25 ? payloadView.getUint8(25) !== 0 : false;
+      let swapP50 = 0, swapP75 = 0, swapP90 = 0, swapP99 = 0;
+      if (payload.byteLength >= 58) {
+        swapP50 = Number(payloadView.getBigUint64(26, true));
+        swapP75 = Number(payloadView.getBigUint64(34, true));
+        swapP90 = Number(payloadView.getBigUint64(42, true));
+        swapP99 = Number(payloadView.getBigUint64(50, true));
+      }
+      let swapSamples = 0;
+      let landingP50Fee = 0, landingP75Fee = 0, landingP90Fee = 0, landingP99Fee = 0;
+      let top10Fee = 0, top25Fee = 0;
+      let spikeDetected = false, spikeFee = 0;
+      if (payload.byteLength >= 119) {
+        swapSamples = payloadView.getUint32(58, true);
+        landingP50Fee = Number(payloadView.getBigUint64(62, true));
+        landingP75Fee = Number(payloadView.getBigUint64(70, true));
+        landingP90Fee = Number(payloadView.getBigUint64(78, true));
+        landingP99Fee = Number(payloadView.getBigUint64(86, true));
+        top10Fee = Number(payloadView.getBigUint64(94, true));
+        top25Fee = Number(payloadView.getBigUint64(102, true));
+        spikeDetected = payloadView.getUint8(110) !== 0;
+        spikeFee = Number(payloadView.getBigUint64(111, true));
+      }
+      return {
+        type: "priority_fees",
+        data: {
+          slot,
+          timestampMs,
+          recommended,
+          state,
+          isStale,
+          swapP50,
+          swapP75,
+          swapP90,
+          swapP99,
+          swapSamples,
+          landingP50Fee,
+          landingP75Fee,
+          landingP90Fee,
+          landingP99Fee,
+          top10Fee,
+          top25Fee,
+          spikeDetected,
+          spikeFee
+        }
+      };
+    }
+    case MessageType.Blockhash: {
+      if (payload.byteLength < 65) return null;
+      const slot = Number(payloadView.getBigUint64(0, true));
+      const timestampMs = Number(payloadView.getBigUint64(8, true));
+      const blockhashBytes = new Uint8Array(payload, 16, 32);
+      const blockHeight = Number(payloadView.getBigUint64(48, true));
+      const lastValidBlockHeight = Number(payloadView.getBigUint64(56, true));
+      const isStale = payloadView.getUint8(64) !== 0;
+      return {
+        type: "blockhash",
+        data: {
+          slot,
+          timestampMs,
+          blockhash: base58Encode(blockhashBytes),
+          blockHeight,
+          lastValidBlockHeight,
+          isStale
+        }
+      };
+    }
+    case MessageType.PoolUpdate: {
+      return decodePoolUpdate(payload, payloadView);
+    }
+    case MessageType.PoolUpdateBatch: {
+      if (payload.byteLength < 2) return null;
+      const updates = decodePoolUpdateBatch(payload);
+      if (updates.length === 0) return null;
+      return updates[0];
+    }
+    case MessageType.Quote: {
+      return decodeQuote(payload, payloadView);
+    }
+    case MessageType.Pong: {
+      if (payload.byteLength < 8) return null;
+      return {
+        type: "pong",
+        data: {
+          timestampMs: Number(payloadView.getBigUint64(0, true))
+        }
+      };
+    }
+    default:
+      return null;
+  }
+}
+function decodePoolUpdateBatch(payload) {
+  const view = new DataView(payload);
+  if (payload.byteLength < 2) return [];
+  const count = view.getUint16(0, true);
+  const updates = [];
+  let offset = 2;
+  for (let i = 0; i < count && offset + 4 <= payload.byteLength; i++) {
+    const payloadLen = view.getUint32(offset, true);
+    offset += 4;
+    if (offset + payloadLen > payload.byteLength) break;
+    const updatePayload = payload.slice(offset, offset + payloadLen);
+    const updateView = new DataView(updatePayload);
+    const decoded = decodePoolUpdate(updatePayload, updateView);
+    if (decoded) {
+      updates.push(decoded);
+    }
+    offset += payloadLen;
+  }
+  return updates;
+}
+function decodePoolUpdate(payload, payloadView) {
+  if (payload.byteLength < 50) return null;
+  try {
+    let offset = 0;
+    const decoder = new TextDecoder();
+    const serializedStateLen = Number(payloadView.getBigUint64(offset, true));
+    offset += 8 + serializedStateLen;
+    if (payload.byteLength < offset + 24) return null;
+    const sequence = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const slot = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const writeVersion = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const protocolLen = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const protocolBytes = new Uint8Array(payload, offset, protocolLen);
+    const protocol = decoder.decode(protocolBytes);
+    offset += protocolLen;
+    const poolAddr = new Uint8Array(payload, offset, 32);
+    offset += 32;
+    const tokenMintCount = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const tokenMints = [];
+    for (let i = 0; i < tokenMintCount && offset + 32 <= payload.byteLength; i++) {
+      const mint = new Uint8Array(payload, offset, 32);
+      tokenMints.push(base58Encode(mint));
+      offset += 32;
+    }
+    const balanceCount = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const tokenBalances = [];
+    for (let i = 0; i < balanceCount && offset + 8 <= payload.byteLength; i++) {
+      tokenBalances.push(payloadView.getBigUint64(offset, true).toString());
+      offset += 8;
+    }
+    const decimalsCount = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const tokenDecimals = [];
+    for (let i = 0; i < decimalsCount && offset + 4 <= payload.byteLength; i++) {
+      tokenDecimals.push(payloadView.getInt32(offset, true));
+      offset += 4;
+    }
+    const isValid = offset < payload.byteLength ? payloadView.getUint8(offset) !== 0 : true;
+    offset += 1;
+    return {
+      type: "pool_update",
+      data: {
+        sequence,
+        slot,
+        writeVersion,
+        protocol,
+        poolAddress: base58Encode(poolAddr),
+        tokenMints,
+        tokenBalances,
+        tokenDecimals,
+        isValid
+      }
+    };
+  } catch {
+    return {
+      type: "pool_update",
+      data: {
+        sequence: 0,
+        slot: 0,
+        writeVersion: 0,
+        protocol: "unknown",
+        poolAddress: "",
+        tokenMints: [],
+        tokenBalances: [],
+        tokenDecimals: [],
+        isValid: false
+      }
+    };
+  }
+}
+function decodeQuote(payload, payloadView) {
+  if (payload.byteLength < 8) return null;
+  try {
+    let offset = 0;
+    const decoder = new TextDecoder();
+    const readString = () => {
+      const len = Number(payloadView.getBigUint64(offset, true));
+      offset += 8;
+      const bytes = new Uint8Array(payload, offset, len);
+      offset += len;
+      return decoder.decode(bytes);
+    };
+    const topicId = readString();
+    const timestampMs = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const sequence = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const inputMintBytes = new Uint8Array(payload, offset, 32);
+    offset += 32;
+    const outputMintBytes = new Uint8Array(payload, offset, 32);
+    offset += 32;
+    const inAmount = payloadView.getBigUint64(offset, true).toString();
+    offset += 8;
+    const outAmount = payloadView.getBigUint64(offset, true).toString();
+    offset += 8;
+    const priceImpactBps = payloadView.getInt32(offset, true);
+    offset += 4;
+    const contextSlot = Number(payloadView.getBigUint64(offset, true));
+    offset += 8;
+    const algorithm = readString();
+    const isImprovement = payloadView.getUint8(offset) !== 0;
+    offset += 1;
+    const isCached = payloadView.getUint8(offset) !== 0;
+    offset += 1;
+    const isStale = payloadView.getUint8(offset) !== 0;
+    offset += 1;
+    let routePlan = null;
+    if (offset + 8 <= payload.byteLength) {
+      const routePlanLen = Number(payloadView.getBigUint64(offset, true));
+      offset += 8;
+      if (routePlanLen > 0 && offset + routePlanLen <= payload.byteLength) {
+        const routePlanBytes = new Uint8Array(payload, offset, routePlanLen);
+        try {
+          routePlan = JSON.parse(decoder.decode(routePlanBytes));
+        } catch {
+        }
+      }
+    }
+    return {
+      type: "quote",
+      data: {
+        topicId,
+        timestampMs,
+        sequence,
+        inputMint: base58Encode(inputMintBytes),
+        outputMint: base58Encode(outputMintBytes),
+        inAmount,
+        outAmount,
+        priceImpactBps,
+        contextSlot,
+        algorithm,
+        isImprovement,
+        isCached,
+        isStale,
+        routePlan
+      }
+    };
+  } catch {
+    return {
+      type: "quote",
+      data: {
+        topicId: "",
+        timestampMs: 0,
+        sequence: 0,
+        inputMint: "",
+        outputMint: "",
+        inAmount: "0",
+        outAmount: "0",
+        priceImpactBps: 0,
+        contextSlot: 0,
+        algorithm: "",
+        isImprovement: false,
+        isCached: false,
+        isStale: false,
+        routePlan: null
+      }
+    };
+  }
+}
+
+// src/ws/client.ts
+var CloseCode = {
+  /** 1000: Normal closure - connection completed successfully */
+  NORMAL: 1e3,
+  /** 1001: Going away - server/client shutting down. Client: reconnect immediately */
+  GOING_AWAY: 1001,
+  /** 1002: Protocol error - invalid frame format. Client: fix client code */
+  PROTOCOL_ERROR: 1002,
+  /** 1003: Unsupported data - message type not supported */
+  UNSUPPORTED_DATA: 1003,
+  /** 1005: No status received (reserved, not sent over wire) */
+  NO_STATUS: 1005,
+  /** 1006: Abnormal closure - connection dropped without close frame */
+  ABNORMAL: 1006,
+  /** 1007: Invalid payload - malformed UTF-8 or data. Client: fix message format */
+  INVALID_PAYLOAD: 1007,
+  /** 1008: Policy violation - rate limit exceeded, auth failed. Client: check credentials/limits */
+  POLICY_VIOLATION: 1008,
+  /** 1009: Message too big - message exceeds size limits */
+  MESSAGE_TOO_BIG: 1009,
+  /** 1010: Missing extension - required extension not negotiated */
+  MISSING_EXTENSION: 1010,
+  /** 1011: Internal error - unexpected server error. Client: retry with backoff */
+  INTERNAL_ERROR: 1011,
+  /** 1012: Service restart - server is restarting. Client: reconnect after brief delay */
+  SERVICE_RESTART: 1012,
+  /** 1013: Try again later - server overloaded. Client: retry with backoff */
+  TRY_AGAIN_LATER: 1013,
+  /** 1014: Bad gateway - upstream connection failed */
+  BAD_GATEWAY: 1014,
+  /** 1015: TLS handshake failed (reserved, not sent over wire) */
+  TLS_HANDSHAKE: 1015
+};
+var K256WebSocketError = class extends Error {
+  constructor(code, message, closeCode, closeReason, cause) {
+    super(message);
+    this.code = code;
+    this.closeCode = closeCode;
+    this.closeReason = closeReason;
+    this.cause = cause;
+    this.name = "K256WebSocketError";
+  }
+  /** Check if error is recoverable (should trigger reconnect) */
+  get isRecoverable() {
+    switch (this.code) {
+      case "AUTH_FAILED":
+      case "RATE_LIMITED":
+        return false;
+      default:
+        return true;
+    }
+  }
+  /** Check if error is an auth failure */
+  get isAuthError() {
+    return this.code === "AUTH_FAILED" || this.closeCode === CloseCode.POLICY_VIOLATION;
+  }
+};
+var K256WebSocketClient = class {
+  ws = null;
+  config;
+  _state = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  pingTimer = null;
+  pongTimer = null;
+  heartbeatTimer = null;
+  lastPingTime = 0;
+  lastHeartbeatTime = 0;
+  pendingSubscription = null;
+  pendingQuoteSubscription = null;
+  isIntentionallyClosed = false;
+  /** Current connection state */
+  get state() {
+    return this._state;
+  }
+  /** Whether currently connected */
+  get isConnected() {
+    return this._state === "connected" && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Time since last heartbeat (ms) or null if no heartbeat received */
+  get timeSinceHeartbeat() {
+    return this.lastHeartbeatTime ? Date.now() - this.lastHeartbeatTime : null;
+  }
+  /** Current reconnect attempt number */
+  get currentReconnectAttempt() {
+    return this.reconnectAttempts;
+  }
+  constructor(config) {
+    this.config = {
+      url: "wss://gateway.k256.xyz/v1/ws",
+      mode: "binary",
+      autoReconnect: true,
+      reconnectDelayMs: 1e3,
+      maxReconnectDelayMs: 3e4,
+      maxReconnectAttempts: Infinity,
+      pingIntervalMs: 3e4,
+      pongTimeoutMs: 1e4,
+      heartbeatTimeoutMs: 15e3,
+      ...config
+    };
+  }
+  /**
+   * Connect to the WebSocket server
+   * @returns Promise that resolves when connected
+   */
+  async connect() {
+    if (this._state === "connected" || this._state === "connecting") {
+      return;
+    }
+    this.isIntentionallyClosed = false;
+    return this.doConnect();
+  }
+  /**
+   * Disconnect from the WebSocket server
+   * @param code - Close code (default: 1000 NORMAL)
+   * @param reason - Close reason
+   */
+  disconnect(code = CloseCode.NORMAL, reason = "Client disconnect") {
+    this.isIntentionallyClosed = true;
+    this.cleanup();
+    if (this.ws) {
+      try {
+        this.ws.close(code, reason);
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.setState("closed");
+  }
+  /**
+   * Subscribe to channels
+   */
+  subscribe(options) {
+    this.pendingSubscription = options;
+    if (!this.isConnected) {
+      return;
+    }
+    this.sendSubscription(options);
+  }
+  /**
+   * Subscribe to a quote stream
+   */
+  subscribeQuote(options) {
+    this.pendingQuoteSubscription = options;
+    if (!this.isConnected) {
+      return;
+    }
+    this.sendQuoteSubscription(options);
+  }
+  /**
+   * Unsubscribe from a quote stream
+   * @param topicId - Topic ID from quote_subscribed response
+   */
+  unsubscribeQuote(topicId) {
+    if (!this.isConnected) return;
+    const msg = JSON.stringify({ type: "unsubscribe_quote", topicId });
+    this.ws?.send(msg);
+  }
+  /**
+   * Unsubscribe from all channels
+   */
+  unsubscribe() {
+    this.pendingSubscription = null;
+    this.pendingQuoteSubscription = null;
+    if (!this.isConnected) return;
+    this.ws?.send(JSON.stringify({ type: "unsubscribe" }));
+  }
+  /**
+   * Send a ping to measure latency
+   */
+  ping() {
+    if (!this.isConnected) return;
+    const pingData = new Uint8Array([MessageType.Ping]);
+    this.lastPingTime = Date.now();
+    this.ws?.send(pingData);
+    this.startPongTimeout();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  async doConnect() {
+    return new Promise((resolve, reject) => {
+      this.setState("connecting");
+      const url = new URL(this.config.url);
+      url.searchParams.set("apiKey", this.config.apiKey);
+      try {
+        this.ws = new WebSocket(url.toString());
+        if (this.config.mode === "binary") {
+          this.ws.binaryType = "arraybuffer";
+        }
+        const connectTimeout = setTimeout(() => {
+          if (this.ws?.readyState !== WebSocket.OPEN) {
+            this.ws?.close();
+            const error = new K256WebSocketError(
+              "CONNECTION_FAILED",
+              "Connection timeout"
+            );
+            this.handleError(error);
+            reject(error);
+          }
+        }, 1e4);
+        this.ws.onopen = () => {
+          clearTimeout(connectTimeout);
+          this.setState("connected");
+          this.reconnectAttempts = 0;
+          this.lastHeartbeatTime = Date.now();
+          this.startPingInterval();
+          this.startHeartbeatTimeout();
+          if (this.pendingSubscription) {
+            this.sendSubscription(this.pendingSubscription);
+          }
+          if (this.pendingQuoteSubscription) {
+            this.sendQuoteSubscription(this.pendingQuoteSubscription);
+          }
+          this.config.onConnect?.();
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          clearTimeout(connectTimeout);
+          this.cleanup();
+          const wasClean = event.wasClean;
+          const code = event.code;
+          const reason = event.reason || this.getCloseReason(code);
+          this.config.onDisconnect?.(code, reason, wasClean);
+          if (!this.isIntentionallyClosed && this.config.autoReconnect) {
+            if (this.shouldReconnect(code)) {
+              this.scheduleReconnect();
+            } else {
+              const error = new K256WebSocketError(
+                this.getErrorCodeFromClose(code),
+                reason,
+                code,
+                reason
+              );
+              this.handleError(error);
+              this.setState("closed");
+            }
+          } else {
+            this.setState("disconnected");
+          }
+        };
+        this.ws.onerror = () => {
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        const wsError = new K256WebSocketError(
+          "CONNECTION_FAILED",
+          "Failed to create WebSocket",
+          void 0,
+          void 0,
+          error
+        );
+        this.handleError(wsError);
+        reject(wsError);
+      }
+    });
+  }
+  handleMessage(data) {
+    this.config.onRawMessage?.(data);
+    try {
+      let decoded = null;
+      if (data instanceof ArrayBuffer) {
+        decoded = decodeMessage(data);
+        if (decoded === null) {
+          const view = new DataView(data);
+          if (view.byteLength > 0 && view.getUint8(0) === MessageType.PoolUpdateBatch) {
+            const payload = data.slice(1);
+            const updates = decodePoolUpdateBatch(payload);
+            if (this.config.onPoolUpdateBatch) {
+              this.config.onPoolUpdateBatch(updates);
+            }
+            for (const update of updates) {
+              this.config.onPoolUpdate?.(update);
+              this.config.onMessage?.(update);
+            }
+            return;
+          }
+        }
+      } else {
+        const parsed = JSON.parse(data);
+        decoded = {
+          type: parsed.type,
+          data: parsed.data || parsed
+        };
+      }
+      if (!decoded) {
+        return;
+      }
+      this.config.onMessage?.(decoded);
+      switch (decoded.type) {
+        case "subscribed":
+          this.config.onSubscribed?.(decoded);
+          break;
+        case "pool_update":
+          this.config.onPoolUpdate?.(decoded);
+          break;
+        case "priority_fees":
+          this.config.onPriorityFees?.(decoded);
+          break;
+        case "blockhash":
+          this.config.onBlockhash?.(decoded);
+          break;
+        case "quote":
+          this.config.onQuote?.(decoded);
+          break;
+        case "quote_subscribed":
+          this.config.onQuoteSubscribed?.(decoded);
+          break;
+        case "heartbeat":
+          this.lastHeartbeatTime = Date.now();
+          this.resetHeartbeatTimeout();
+          this.config.onHeartbeat?.(decoded);
+          break;
+        case "pong":
+          this.clearPongTimeout();
+          const latencyMs = this.lastPingTime ? Date.now() - this.lastPingTime : 0;
+          this.config.onPong?.(latencyMs);
+          break;
+        case "error":
+          const errorData = decoded.data;
+          const error = new K256WebSocketError(
+            "SERVER_ERROR",
+            errorData.message
+          );
+          this.handleError(error);
+          break;
+      }
+    } catch (error) {
+      const wsError = new K256WebSocketError(
+        "INVALID_MESSAGE",
+        "Failed to decode message",
+        void 0,
+        void 0,
+        error
+      );
+      this.handleError(wsError);
+    }
+  }
+  sendSubscription(options) {
+    const msg = {
+      type: "subscribe",
+      channels: options.channels
+    };
+    if (this.config.mode === "json") {
+      msg.format = "json";
+    }
+    if (options.pools?.length) {
+      msg.pools = options.pools;
+    }
+    if (options.protocols?.length) {
+      msg.protocols = options.protocols;
+    }
+    if (options.tokenPairs?.length) {
+      msg.token_pairs = options.tokenPairs;
+    }
+    this.ws?.send(JSON.stringify(msg));
+  }
+  sendQuoteSubscription(options) {
+    const msg = {
+      type: "subscribe_quote",
+      inputMint: options.inputMint,
+      outputMint: options.outputMint,
+      amount: typeof options.amount === "string" ? parseInt(options.amount, 10) : options.amount,
+      slippageBps: options.slippageBps,
+      refreshIntervalMs: options.refreshIntervalMs ?? 1e3
+    };
+    this.ws?.send(JSON.stringify(msg));
+  }
+  setState(state) {
+    if (this._state !== state) {
+      const prevState = this._state;
+      this._state = state;
+      this.config.onStateChange?.(state, prevState);
+    }
+  }
+  handleError(error) {
+    this.config.onError?.(error);
+  }
+  cleanup() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  startPingInterval() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+    }
+    this.pingTimer = setInterval(() => {
+      this.ping();
+    }, this.config.pingIntervalMs);
+  }
+  startPongTimeout() {
+    this.clearPongTimeout();
+    this.pongTimer = setTimeout(() => {
+      const error = new K256WebSocketError(
+        "PING_TIMEOUT",
+        "Server did not respond to ping"
+      );
+      this.handleError(error);
+      this.ws?.close(CloseCode.GOING_AWAY, "Ping timeout");
+    }, this.config.pongTimeoutMs);
+  }
+  clearPongTimeout() {
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+  }
+  startHeartbeatTimeout() {
+    this.resetHeartbeatTimeout();
+  }
+  resetHeartbeatTimeout() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setTimeout(() => {
+      const error = new K256WebSocketError(
+        "HEARTBEAT_TIMEOUT",
+        "No heartbeat received from server"
+      );
+      this.handleError(error);
+    }, this.config.heartbeatTimeoutMs);
+  }
+  shouldReconnect(closeCode) {
+    if (closeCode === CloseCode.POLICY_VIOLATION) {
+      return false;
+    }
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      return false;
+    }
+    return true;
+  }
+  scheduleReconnect() {
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const baseDelay = Math.min(
+      this.config.reconnectDelayMs * Math.pow(2, this.reconnectAttempts - 1),
+      this.config.maxReconnectDelayMs
+    );
+    const jitter = Math.random() * 0.3 * baseDelay;
+    const delay = Math.floor(baseDelay + jitter);
+    this.config.onReconnecting?.(this.reconnectAttempts, delay);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.doConnect();
+      } catch {
+      }
+    }, delay);
+  }
+  getCloseReason(code) {
+    switch (code) {
+      case CloseCode.NORMAL:
+        return "Normal closure";
+      case CloseCode.GOING_AWAY:
+        return "Server shutting down";
+      case CloseCode.PROTOCOL_ERROR:
+        return "Protocol error";
+      case CloseCode.UNSUPPORTED_DATA:
+        return "Unsupported message type";
+      case CloseCode.ABNORMAL:
+        return "Connection lost unexpectedly";
+      case CloseCode.INVALID_PAYLOAD:
+        return "Invalid message data";
+      case CloseCode.POLICY_VIOLATION:
+        return "Authentication failed or rate limited";
+      case CloseCode.MESSAGE_TOO_BIG:
+        return "Message too large";
+      case CloseCode.INTERNAL_ERROR:
+        return "Server error";
+      case CloseCode.SERVICE_RESTART:
+        return "Server is restarting";
+      case CloseCode.TRY_AGAIN_LATER:
+        return "Server overloaded";
+      default:
+        return `Unknown close code: ${code}`;
+    }
+  }
+  getErrorCodeFromClose(code) {
+    switch (code) {
+      case CloseCode.POLICY_VIOLATION:
+        return "AUTH_FAILED";
+      case CloseCode.INTERNAL_ERROR:
+      case CloseCode.SERVICE_RESTART:
+      case CloseCode.TRY_AGAIN_LATER:
+        return "SERVER_ERROR";
+      case CloseCode.PROTOCOL_ERROR:
+      case CloseCode.UNSUPPORTED_DATA:
+      case CloseCode.INVALID_PAYLOAD:
+        return "PROTOCOL_ERROR";
+      default:
+        return "CONNECTION_LOST";
+    }
+  }
+};
+
+export { CloseCode, K256WebSocketClient, K256WebSocketError, MessageType, decodeMessage, decodePoolUpdateBatch };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map