@structbuild/sdk 0.1.2

package/dist/index.js

@@ -0,0 +1,866 @@
+// src/errors.ts
+class StructError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StructError";
+  }
+}
+
+class HttpError extends StructError {
+  status;
+  statusText;
+  body;
+  responseHeaders;
+  constructor(status, statusText, body, responseHeaders) {
+    super(`HTTP ${status}: ${statusText}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.responseHeaders = responseHeaders;
+  }
+}
+
+class NetworkError extends StructError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NetworkError";
+  }
+}
+
+class TimeoutError extends StructError {
+  constructor(timeout) {
+    super(`Request timed out after ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+
+class WebSocketError extends StructError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WebSocketError";
+  }
+}
+
+class WebSocketClosedError extends WebSocketError {
+  code;
+  reason;
+  constructor(code, reason) {
+    super(`WebSocket closed: ${code} ${reason}`);
+    this.name = "WebSocketClosedError";
+    this.code = code;
+    this.reason = reason;
+  }
+}
+
+// src/http.ts
+var DEFAULT_TIMEOUT = 30000;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_INITIAL_DELAY_MS = 1000;
+var DEFAULT_MAX_DELAY_MS = 30000;
+var RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+
+class HttpClient {
+  baseUrl;
+  defaultHeaders;
+  timeout;
+  retry;
+  onRequest;
+  onResponse;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retry = config.retry;
+    this.onRequest = config.onRequest;
+    this.onResponse = config.onResponse;
+  }
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async request(method, path, options) {
+    const maxRetries = this.retry ? this.retry.maxRetries ?? DEFAULT_MAX_RETRIES : 0;
+    const initialDelay = this.retry?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+    const maxDelay = this.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    let lastError;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      if (attempt > 0 && lastError !== undefined) {
+        const retryAfter = lastError instanceof HttpError ? this.parseRetryAfter(lastError) : undefined;
+        const exponentialDelay = Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);
+        const delay = retryAfter ?? exponentialDelay;
+        await this.sleep(delay, options?.signal);
+      }
+      try {
+        return await this.executeRequest(method, path, options);
+      } catch (error) {
+        if (attempt < maxRetries && this.shouldRetry(error)) {
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new NetworkError("Request failed after retries");
+  }
+  async executeRequest(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = { ...this.defaultHeaders, ...options?.headers };
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const signal = options?.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+    try {
+      if (this.onRequest) {
+        try {
+          await this.onRequest({ method, url, headers });
+        } catch {}
+      }
+      const startTime = performance.now();
+      const response = await fetch(url, { method, headers, signal });
+      if (this.onResponse) {
+        try {
+          await this.onResponse({
+            method,
+            url,
+            status: response.status,
+            headers: response.headers,
+            durationMs: performance.now() - startTime
+          });
+        } catch {}
+      }
+      if (!response.ok) {
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = await response.text();
+        }
+        throw new HttpError(response.status, response.statusText, body, response.headers);
+      }
+      return await this.parseApiResponse(response, method);
+    } catch (error) {
+      if (error instanceof HttpError)
+        throw error;
+      if (error instanceof SyntaxError || error instanceof TypeError) {
+        throw new StructError("Failed to parse HTTP response body", { cause: error });
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        if (options?.signal?.aborted)
+          throw error;
+        throw new TimeoutError(this.timeout);
+      }
+      throw new NetworkError("Network request failed", { cause: error });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  shouldRetry(error) {
+    if (error instanceof HttpError) {
+      return RETRYABLE_STATUSES.has(error.status);
+    }
+    return error instanceof NetworkError || error instanceof TimeoutError;
+  }
+  async parseApiResponse(response, method) {
+    if (method === "HEAD" || response.status === 204 || response.status === 205) {
+      return { data: undefined, message: null, success: true };
+    }
+    const text = await response.text();
+    if (text.length === 0) {
+      return { data: undefined, message: null, success: true };
+    }
+    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (!contentType.includes("json")) {
+      return { data: text, message: null, success: true };
+    }
+    const body = JSON.parse(text);
+    if (body && typeof body === "object" && "success" in body && "data" in body) {
+      return {
+        data: body.data,
+        message: body.message ?? null,
+        success: body.success,
+        info: body.info
+      };
+    }
+    return { data: body, message: null, success: true };
+  }
+  parseRetryAfter(error) {
+    const header = error.responseHeaders?.get("retry-after");
+    if (!header)
+      return;
+    const seconds = Number(header);
+    if (!Number.isNaN(seconds) && seconds > 0)
+      return seconds * 1000;
+    const date = Date.parse(header);
+    if (!Number.isNaN(date)) {
+      const delay = date - Date.now();
+      return delay > 0 ? delay : undefined;
+    }
+    return;
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason);
+        return;
+      }
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+}
+
+// src/namespaces/base.ts
+class Namespace {
+  http;
+  defaultVenue;
+  constructor(http, defaultVenue) {
+    this.http = http;
+    this.defaultVenue = defaultVenue;
+  }
+  get(venue, path, options) {
+    return this.http.get(`/${venue ?? this.defaultVenue}${path}`, options);
+  }
+}
+// src/namespaces/holders.ts
+class HoldersNamespace extends Namespace {
+  async getMarketHolders(params, venue) {
+    const { conditionId, ...query } = params;
+    return this.get(venue, `/holders/markets/${encodeURIComponent(conditionId)}`, { params: query });
+  }
+  async getEventHolders(params, venue) {
+    const { eventSlug, ...query } = params;
+    return this.get(venue, `/holders/events/${encodeURIComponent(eventSlug)}`, { params: query });
+  }
+  async getPositionHolders(params, venue) {
+    const { positionId, ...query } = params;
+    return this.get(venue, `/holders/positions/${encodeURIComponent(positionId)}`, { params: query });
+  }
+  async getMarketHoldersHistory(params, venue) {
+    const { conditionId, ...query } = params;
+    return this.get(venue, `/holders/markets/${encodeURIComponent(conditionId)}/history`, { params: query });
+  }
+  async getEventHoldersHistory(params, venue) {
+    const { eventSlug, ...query } = params;
+    return this.get(venue, `/holders/events/${encodeURIComponent(eventSlug)}/history`, { params: query });
+  }
+  async getPositionHoldersHistory(params, venue) {
+    const { positionId, ...query } = params;
+    return this.get(venue, `/holders/positions/${encodeURIComponent(positionId)}/history`, { params: query });
+  }
+}
+// src/namespaces/scoring.ts
+class ScoringNamespace extends Namespace {
+  async getTraderScore(params, venue) {
+    return this.get(venue, `/scoring/trader/${encodeURIComponent(params.address)}`);
+  }
+  async getSmartMoneyLeaderboard(params, venue) {
+    return this.get(venue, "/scoring/leaderboard/smart-money", { params: { ...params } });
+  }
+  async getInsiderLeaderboard(params, venue) {
+    return this.get(venue, "/scoring/leaderboard/insiders", { params: { ...params } });
+  }
+  async getBots(params, venue) {
+    return this.get(venue, "/scoring/bots", { params: { ...params } });
+  }
+}
+// src/namespaces/tags.ts
+class TagsNamespace extends Namespace {
+  async getTags(params, venue) {
+    return this.get(venue, "/tags", { params: { ...params } });
+  }
+  async getTag(params, venue) {
+    return this.get(venue, `/tags/${encodeURIComponent(params.identifier)}`);
+  }
+}
+// src/namespaces/events.ts
+class EventsNamespace extends Namespace {
+  async getEvent(params, venue) {
+    const { id, ...query } = params;
+    return this.get(venue, `/events/${encodeURIComponent(id)}`, { params: query });
+  }
+  async getEventBySlug(params, venue) {
+    const { slug, ...query } = params;
+    return this.get(venue, `/events/slug/${encodeURIComponent(slug)}`, { params: query });
+  }
+  async getEvents(params, venue) {
+    return this.get(venue, "/events", { params: { ...params } });
+  }
+  async getEventMetrics(params, venue) {
+    return this.get(venue, "/events/metrics", { params: { ...params } });
+  }
+}
+// src/namespaces/markets.ts
+class MarketsNamespace extends Namespace {
+  async getMarkets(params, venue) {
+    return this.get(venue, "/market", { params: { ...params } });
+  }
+  async getMarket(params, venue) {
+    return this.get(venue, `/market/${encodeURIComponent(params.conditionId)}`);
+  }
+  async getMarketBySlug(params, venue) {
+    return this.get(venue, `/market/slug/${encodeURIComponent(params.slug)}`);
+  }
+  async getMarketMetrics(params, venue) {
+    return this.get(venue, "/market/metrics", { params: { ...params } });
+  }
+  async getTrades(params, venue) {
+    return this.get(venue, "/market/trades", { params: { ...params } });
+  }
+  async getCandlestick(params, venue) {
+    return this.get(venue, "/market/candlestick", { params: { ...params } });
+  }
+  async getPositionCandlestick(params, venue) {
+    return this.get(venue, "/market/position/candlestick", { params: { ...params } });
+  }
+  async getPositionMetrics(params, venue) {
+    return this.get(venue, "/market/position/metrics", { params: { ...params } });
+  }
+  async getPositionVolumeChart(params, venue) {
+    return this.get(venue, "/market/position/volume-chart", { params: { ...params } });
+  }
+  async getMarketVolumeChart(params, venue) {
+    return this.get(venue, "/market/volume-chart", { params: { ...params } });
+  }
+}
+// src/namespaces/series.ts
+class SeriesNamespace extends Namespace {
+  async getSeriesList(params, venue) {
+    return this.get(venue, "/series", { params: { ...params } });
+  }
+  async getSeriesDetail(params, venue) {
+    const { identifier, ...query } = params;
+    return this.get(venue, `/series/${encodeURIComponent(identifier)}`, { params: query });
+  }
+  async getSeriesEvents(params, venue) {
+    const { identifier, ...query } = params;
+    return this.get(venue, `/series/${encodeURIComponent(identifier)}/events`, { params: query });
+  }
+}
+// src/namespaces/trader.ts
+class TraderNamespace extends Namespace {
+  async getPortfolio(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/portfolio/${encodeURIComponent(address)}`, { params: query });
+  }
+  async getPortfolioPositions(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/positions/${encodeURIComponent(address)}`, { params: query });
+  }
+  async getTraderTrades(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/trades/${encodeURIComponent(address)}`, { params: query });
+  }
+  async getTraderProfile(params, venue) {
+    return this.get(venue, `/trader/profile/${encodeURIComponent(params.address)}`);
+  }
+  async getTraderProfilesBatch(params, venue) {
+    return this.get(venue, "/trader/profiles/batch", { params: { ...params } });
+  }
+  async getTraderVolumeChart(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/volume-chart/${encodeURIComponent(address)}`, { params: query });
+  }
+  async getTraderPnl(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/pnl/${encodeURIComponent(address)}`, { params: query });
+  }
+  async getTraderPositionPnl(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/pnl/${encodeURIComponent(address)}/positions`, { params: query });
+  }
+  async getTraderMarketPnl(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/pnl/${encodeURIComponent(address)}/markets`, { params: query });
+  }
+  async getTraderEventPnl(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/pnl/${encodeURIComponent(address)}/events`, { params: query });
+  }
+  async getTraderPnlCandles(params, venue) {
+    const { address, ...query } = params;
+    return this.get(venue, `/trader/pnl/${encodeURIComponent(address)}/candles`, { params: query });
+  }
+  async getGlobalPnl(params, venue) {
+    return this.get(venue, "/trader/global_pnl", { params: { ...params } });
+  }
+}
+// src/namespaces/bonds.ts
+class BondsNamespace extends Namespace {
+  async getBonds(params, venue) {
+    return this.get(venue, "/bonds", { params: { ...params } });
+  }
+}
+// src/namespaces/search.ts
+class SearchNamespace extends Namespace {
+  async search(params, venue) {
+    return this.get(venue, "/search", { params: { ...params } });
+  }
+}
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.struct.to/v1";
+
+class StructClient {
+  holders;
+  scoring;
+  tags;
+  events;
+  markets;
+  series;
+  trader;
+  bonds;
+  search;
+  constructor(config) {
+    const http = new HttpClient({
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      defaultHeaders: {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...config.headers
+      },
+      timeout: config.timeout,
+      retry: config.retry,
+      onRequest: config.onRequest,
+      onResponse: config.onResponse
+    });
+    const venue = config.venue ?? "polymarket";
+    this.holders = new HoldersNamespace(http, venue);
+    this.scoring = new ScoringNamespace(http, venue);
+    this.tags = new TagsNamespace(http, venue);
+    this.events = new EventsNamespace(http, venue);
+    this.markets = new MarketsNamespace(http, venue);
+    this.series = new SeriesNamespace(http, venue);
+    this.trader = new TraderNamespace(http, venue);
+    this.bonds = new BondsNamespace(http, venue);
+    this.search = new SearchNamespace(http, venue);
+  }
+}
+// src/ws-transport.ts
+var DEFAULT_INITIAL_DELAY_MS2 = 1000;
+var DEFAULT_MAX_DELAY_MS2 = 30000;
+
+class WebSocketTransport {
+  ws = null;
+  _state = "disconnected";
+  reconnectTimer = null;
+  reconnectAttempt = 0;
+  intentionalClose = false;
+  pendingMessages = [];
+  replayMessages = [];
+  url;
+  retry;
+  callbacks;
+  constructor(url, retry, callbacks) {
+    this.url = url;
+    this.retry = retry;
+    this.callbacks = callbacks;
+  }
+  get state() {
+    return this._state;
+  }
+  connect() {
+    if (this._state === "connected" || this._state === "connecting" || this._state === "reconnecting") {
+      return;
+    }
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.intentionalClose = false;
+    this.clearReconnectTimer();
+    this.setState("connecting");
+    this.createSocket();
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    this.clearReconnectTimer();
+    this.pendingMessages.length = 0;
+    this.replayMessages.length = 0;
+    if (this.ws) {
+      this.ws.close(1000, "client disconnect");
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  send(message) {
+    if (this._state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    } else {
+      this.pendingMessages.push(message);
+    }
+  }
+  addReplayMessage(message) {
+    this.replayMessages.push(message);
+  }
+  removeReplayMessages(predicate) {
+    for (let i = this.replayMessages.length - 1;i >= 0; i--) {
+      if (predicate(this.replayMessages[i])) {
+        this.replayMessages.splice(i, 1);
+      }
+    }
+  }
+  clearReplayMessages() {
+    this.replayMessages.length = 0;
+  }
+  createSocket() {
+    try {
+      this.ws = new WebSocket(this.url);
+    } catch (err) {
+      this.callbacks.onError(new WebSocketError("Failed to create WebSocket", { cause: err }));
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this._state = "connected";
+      this.reconnectAttempt = 0;
+      this.replaySubscriptions();
+      this.flushPendingMessages();
+      this.callbacks.onOpen();
+    };
+    this.ws.onclose = (event) => {
+      this.ws = null;
+      if (this.intentionalClose) {
+        this.setState("disconnected");
+        this.callbacks.onClose(event.code, event.reason);
+        return;
+      }
+      this.callbacks.onClose(event.code, event.reason);
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = () => {
+      this.callbacks.onError(new WebSocketError("WebSocket connection error"));
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(String(event.data));
+        this.callbacks.onMessage(data);
+      } catch {
+        this.callbacks.onError(new WebSocketError("Failed to parse WebSocket message"));
+      }
+    };
+  }
+  replaySubscriptions() {
+    for (const msg of this.replayMessages) {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(msg));
+      }
+    }
+  }
+  flushPendingMessages() {
+    while (this.pendingMessages.length > 0) {
+      const msg = this.pendingMessages.shift();
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify(msg));
+      }
+    }
+  }
+  scheduleReconnect() {
+    const maxRetries = this.retry.maxRetries ?? Infinity;
+    if (this.reconnectAttempt >= maxRetries) {
+      this.setState("disconnected");
+      this.callbacks.onError(new WebSocketClosedError(1006, "Max reconnection attempts reached"));
+      return;
+    }
+    this.setState("reconnecting");
+    this.reconnectAttempt++;
+    this.callbacks.onReconnecting(this.reconnectAttempt);
+    const initialDelay = this.retry.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS2;
+    const maxDelay = this.retry.maxDelayMs ?? DEFAULT_MAX_DELAY_MS2;
+    const exponentialDelay = Math.min(initialDelay * 2 ** (this.reconnectAttempt - 1), maxDelay);
+    const jitter = exponentialDelay * 0.2 * Math.random();
+    const delay = exponentialDelay + jitter;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.createSocket();
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  setState(state) {
+    this._state = state;
+  }
+}
+
+// src/ws.ts
+var DEFAULT_BASE_URL2 = "https://api.struct.to/v1";
+
+class StructWebSocket {
+  transport;
+  listeners = new Map;
+  activeMarkets = new Set;
+  activeMarketPositions = new Set;
+  activeWallets = new Set;
+  activeConditions = new Set;
+  activeSpecialRooms = new Set;
+  constructor(config) {
+    const httpBase = (config.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
+    const wsBase = httpBase.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+    const url = `${wsBase}?token=${encodeURIComponent(config.apiKey)}`;
+    this.transport = new WebSocketTransport(url, config.reconnect ?? {}, {
+      onOpen: () => this.handleOpen(),
+      onClose: (code, reason) => this.handleClose(code, reason),
+      onError: (error) => this.emit("error", error),
+      onMessage: (data) => this.handleMessage(data),
+      onReconnecting: (attempt) => this.emit("reconnecting", { attempt })
+    });
+  }
+  get state() {
+    return this.transport.state;
+  }
+  connect() {
+    this.transport.connect();
+  }
+  disconnect() {
+    this.activeMarkets.clear();
+    this.activeMarketPositions.clear();
+    this.activeWallets.clear();
+    this.activeConditions.clear();
+    this.activeSpecialRooms.clear();
+    this.transport.disconnect();
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  once(event, listener) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      listener(payload);
+    };
+    return this.on(event, wrapper);
+  }
+  subscribeMarket(conditionId) {
+    if (this.activeMarkets.has(conditionId))
+      return;
+    this.activeMarkets.add(conditionId);
+    const msg = this.marketSubscribeMessage(conditionId);
+    this.transport.addReplayMessage(msg);
+    this.transport.send(msg);
+  }
+  unsubscribeMarket(conditionId) {
+    if (!this.activeMarkets.has(conditionId))
+      return;
+    this.activeMarkets.delete(conditionId);
+    const msg = {
+      type: "unsubscribe_market",
+      room_id: `market_${conditionId}`,
+      message: {}
+    };
+    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === `market_${conditionId}`);
+    this.transport.send(msg);
+  }
+  subscribeMarketByPosition(positionId) {
+    if (this.activeMarketPositions.has(positionId))
+      return;
+    this.activeMarketPositions.add(positionId);
+    const msg = this.marketPositionSubscribeMessage(positionId);
+    this.transport.addReplayMessage(msg);
+    this.transport.send(msg);
+  }
+  unsubscribeMarketByPosition(positionId) {
+    if (!this.activeMarketPositions.has(positionId))
+      return;
+    this.activeMarketPositions.delete(positionId);
+    const msg = {
+      type: "unsubscribe_market",
+      room_id: `market_position_${positionId}`,
+      message: {}
+    };
+    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === `market_position_${positionId}`);
+    this.transport.send(msg);
+  }
+  trackWallets(addresses) {
+    const uniqueAddresses = [...new Set(addresses)];
+    const added = uniqueAddresses.filter((addr) => !this.activeWallets.has(addr));
+    if (added.length === 0)
+      return;
+    for (const addr of added)
+      this.activeWallets.add(addr);
+    const msg = this.walletTrackMessage("subscribe", added);
+    this.rebuildWalletReplay();
+    this.transport.send(msg);
+  }
+  untrackWallets(addresses) {
+    const uniqueAddresses = [...new Set(addresses)];
+    const removed = uniqueAddresses.filter((addr) => this.activeWallets.has(addr));
+    if (removed.length === 0)
+      return;
+    for (const addr of removed)
+      this.activeWallets.delete(addr);
+    const msg = this.walletTrackMessage("unsubscribe", removed);
+    this.rebuildWalletReplay();
+    this.transport.send(msg);
+  }
+  subscribeWhaleTrades() {
+    this.subscribeSpecialRoom("whale_trades");
+  }
+  unsubscribeWhaleTrades() {
+    this.unsubscribeSpecialRoom("whale_trades");
+  }
+  subscribeSmartMoneyTrades() {
+    this.subscribeSpecialRoom("smart_money_trades");
+  }
+  unsubscribeSmartMoneyTrades() {
+    this.unsubscribeSpecialRoom("smart_money_trades");
+  }
+  subscribeInsiderTrades() {
+    this.subscribeSpecialRoom("insider_trades");
+  }
+  unsubscribeInsiderTrades() {
+    this.unsubscribeSpecialRoom("insider_trades");
+  }
+  trackConditions(conditionIds) {
+    const uniqueConditionIds = [...new Set(conditionIds)];
+    const added = uniqueConditionIds.filter((id) => !this.activeConditions.has(id));
+    if (added.length === 0)
+      return;
+    for (const id of added)
+      this.activeConditions.add(id);
+    const msg = this.conditionsTrackMessage("subscribe", added);
+    this.rebuildConditionsReplay();
+    this.transport.send(msg);
+  }
+  untrackConditions(conditionIds) {
+    const uniqueConditionIds = [...new Set(conditionIds)];
+    const removed = uniqueConditionIds.filter((id) => this.activeConditions.has(id));
+    if (removed.length === 0)
+      return;
+    for (const id of removed)
+      this.activeConditions.delete(id);
+    const msg = this.conditionsTrackMessage("unsubscribe", removed);
+    this.rebuildConditionsReplay();
+    this.transport.send(msg);
+  }
+  handleOpen() {
+    this.emit("connected", undefined);
+  }
+  handleClose(code, reason) {
+    this.emit("disconnected", { code, reason });
+  }
+  handleMessage(raw) {
+    const msg = raw;
+    if (!msg || typeof msg !== "object")
+      return;
+    const roomId = msg.room_id ?? "";
+    const type = msg.type;
+    if (type === "market_trade" || roomId.startsWith("market_")) {
+      this.emit("market_trade", msg.data);
+    } else if (type === "whale_trade" || roomId === "whale_trades") {
+      this.emit("whale_trade", msg.data);
+    } else if (type === "smart_money_trade" || roomId === "smart_money_trades") {
+      this.emit("smart_money_trade", msg.data);
+    } else if (type === "insider_trade" || roomId === "insider_trades") {
+      this.emit("insider_trade", msg.data);
+    } else if (type === "wallet_tracking_alert") {
+      this.emit("wallet_tracking_alert", msg.data);
+    } else if (type === "conditions_tracking_alert") {
+      this.emit("conditions_tracking_alert", msg.data);
+    }
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        fn(payload);
+      } catch {}
+    }
+  }
+  marketSubscribeMessage(conditionId) {
+    return { type: "subscribe_market", room_id: `market_${conditionId}`, message: {} };
+  }
+  marketPositionSubscribeMessage(positionId) {
+    return { type: "subscribe_market", room_id: `market_position_${positionId}`, message: {} };
+  }
+  walletTrackMessage(action, addresses) {
+    return { type: "wallet_tracking", action, wallet_addresses: addresses };
+  }
+  conditionsTrackMessage(action, conditionIds) {
+    return { type: "conditions_tracking", action, condition_ids: conditionIds };
+  }
+  subscribeSpecialRoom(roomId) {
+    if (this.activeSpecialRooms.has(roomId))
+      return;
+    this.activeSpecialRooms.add(roomId);
+    const msg = { type: "subscribe_market", room_id: roomId, message: {} };
+    this.transport.addReplayMessage(msg);
+    this.transport.send(msg);
+  }
+  unsubscribeSpecialRoom(roomId) {
+    if (!this.activeSpecialRooms.has(roomId))
+      return;
+    this.activeSpecialRooms.delete(roomId);
+    const msg = { type: "unsubscribe_market", room_id: roomId, message: {} };
+    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === roomId);
+    this.transport.send(msg);
+  }
+  rebuildWalletReplay() {
+    this.transport.removeReplayMessages((m) => m.type === "wallet_tracking");
+    if (this.activeWallets.size > 0) {
+      this.transport.addReplayMessage(this.walletTrackMessage("subscribe", [...this.activeWallets]));
+    }
+  }
+  rebuildConditionsReplay() {
+    this.transport.removeReplayMessages((m) => m.type === "conditions_tracking");
+    if (this.activeConditions.size > 0) {
+      this.transport.addReplayMessage(this.conditionsTrackMessage("subscribe", [...this.activeConditions]));
+    }
+  }
+}
+// src/paginate.ts
+var DEFAULT_PAGE_SIZE = 100;
+async function* paginate(fetcher, params, pageSize = DEFAULT_PAGE_SIZE) {
+  let offset = 0;
+  while (true) {
+    const response = await fetcher({ ...params, limit: pageSize, offset });
+    for (const item of response.data) {
+      yield item;
+    }
+    if (response.data.length < pageSize) {
+      break;
+    }
+    offset += pageSize;
+  }
+}
+export {
+  paginate,
+  WebSocketError,
+  WebSocketClosedError,
+  TimeoutError,
+  StructWebSocket,
+  StructError,
+  StructClient,
+  NetworkError,
+  HttpError,
+  HttpClient
+};
+
+//# debugId=F77A56DA0E15D59664756E2164756E21
+//# sourceMappingURL=index.js.map