@alpha-arcade/sdk 0.3.1 → 0.3.6

package/dist/index.js

@@ -2103,6 +2103,7 @@ var calculateMatchingOrders = (orderbook, isBuying, isYes, quantity, price, slip
 
 // src/constants.ts
 var DEFAULT_API_BASE_URL = "https://platform.alphaarcade.com/api";
+var DEFAULT_WSS_BASE_URL = "wss://wss.platform.alphaarcade.com";
 var DEFAULT_MARKET_CREATOR_ADDRESS = "5P5Y6HTWUNG2E3VXBQDZN3ENZD3JPAIR5PKT3LOYJAPAUKOLFD6KANYTRY";
 
 // src/modules/orderbook.ts
@@ -2243,6 +2244,18 @@ var getWalletOrdersFromApi = async (config, walletAddress) => {
   }
   return allOrders;
 };
+var getFullOrderbookFromApi = async (config, marketId) => {
+  if (!config.apiKey) {
+    throw new Error("apiKey is required for API-based orderbook fetching. Retrieve an API key from the Alpha Arcade platform via the Account page and pass it to the client.");
+  }
+  const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+  const url = `${baseUrl}/get-full-orderbook?marketId=${encodeURIComponent(marketId)}`;
+  const response = await fetch(url, { headers: { "x-api-key": config.apiKey } });
+  if (!response.ok) {
+    throw new Error(`Alpha API error: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+};
 
 // src/modules/trading.ts
 var extractEscrowAppId = async (algodClient, indexerClient, targetTxId) => {
@@ -3067,12 +3080,18 @@ var getMarketFromApi = async (config, marketId) => {
   }
   return market;
 };
+var hasRewardLiquidity = (market) => {
+  if ((market.totalRewards ?? 0) > 0 || (market.totalPregameRewards ?? 0) > 0) {
+    return true;
+  }
+  return (market.options ?? []).some((option) => (option.totalRewards ?? 0) > 0 || (option.totalPregameRewards ?? 0) > 0);
+};
 var getRewardMarkets = async (config) => {
   if (!config.apiKey) {
     throw new Error("apiKey is required for API-based market fetching. Retrieve an API key from the Alpha Arcade platform via the Account page and pass it to the client.");
   }
   const markets = await getLiveMarketsFromApi(config);
-  return markets.filter((m) => m.totalRewards && m.totalRewards > 0);
+  return markets.filter((market) => hasRewardLiquidity(market));
 };
 var getLiveMarkets = async (config) => {
   if (config.apiKey) {
@@ -3249,6 +3268,19 @@ var AlphaClient = class {
   async getOrderbook(marketAppId) {
     return getOrderbook(this.config, marketAppId);
   }
+  /**
+   * Fetches the full processed orderbook snapshot for a market from the Alpha REST API.
+   *
+   * Returns the same shape as websocket `orderbook_changed.orderbook`: a record keyed by
+   * `marketAppId`, where each value includes aggregated bids/asks plus detailed yes/no orders.
+   * Requires `apiKey`.
+   *
+   * @param marketId - The Alpha market UUID
+   * @returns Full processed market orderbook keyed by marketAppId
+   */
+  async getFullOrderbookFromApi(marketId) {
+    return getFullOrderbookFromApi(this.config, marketId);
+  }
   /**
    * Gets open orders for a specific wallet on a market.
    *
@@ -3344,6 +3376,310 @@ var AlphaClient = class {
   }
 };
 
-export { AlphaClient, DEFAULT_API_BASE_URL, DEFAULT_MARKET_CREATOR_ADDRESS, calculateFee, calculateFeeFromTotal, calculateMatchingOrders, checkAssetOptIn, decodeGlobalState, getEscrowGlobalState, getLiveMarketsFromApi, getMarketFromApi, getMarketGlobalState, getMarketOnChain, getMarketsOnChain };
+// src/websocket.ts
+var WS_OPEN = 1;
+var resolveWebSocket = (provided) => {
+  if (provided) return provided;
+  if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
+    return globalThis.WebSocket;
+  }
+  throw new Error(
+    'No WebSocket implementation found. On Node.js < 22, install the "ws" package and pass it: new AlphaWebSocket({ WebSocket: require("ws") })'
+  );
+};
+var AlphaWebSocket = class {
+  url;
+  reconnectEnabled;
+  maxReconnectAttempts;
+  heartbeatIntervalMs;
+  WebSocketImpl;
+  ws = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  lastOrderbookVersionBySubscription = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  intentionallyClosed = false;
+  connectPromise = null;
+  constructor(config) {
+    this.url = config?.url ?? DEFAULT_WSS_BASE_URL;
+    this.reconnectEnabled = config?.reconnect ?? true;
+    this.maxReconnectAttempts = config?.maxReconnectAttempts ?? Infinity;
+    this.heartbeatIntervalMs = config?.heartbeatIntervalMs ?? 6e4;
+    this.WebSocketImpl = resolveWebSocket(config?.WebSocket);
+  }
+  /** Whether the WebSocket is currently open and connected */
+  get connected() {
+    return this.ws?.readyState === WS_OPEN;
+  }
+  // ============================================
+  // Subscribe Methods
+  // ============================================
+  /**
+   * Subscribe to live market probability updates (incremental diffs).
+   * @returns An unsubscribe function
+   */
+  subscribeLiveMarkets(callback) {
+    return this.subscribe("get-live-markets", {}, "markets_changed", callback);
+  }
+  /**
+   * Subscribe to change events for a single market.
+   * @param slug - The market slug
+   * @returns An unsubscribe function
+   */
+  subscribeMarket(slug, callback) {
+    return this.subscribe("get-market", { slug }, "market_changed", callback);
+  }
+  /**
+   * Subscribe to full orderbook snapshots (~5s interval on changes).
+   * @param slug - The market slug
+   * @returns An unsubscribe function
+   */
+  subscribeOrderbook(slug, callback) {
+    return this.subscribe("get-orderbook", { slug }, "orderbook_changed", callback);
+  }
+  /**
+   * Subscribe to wallet order updates.
+   * @param wallet - The wallet address
+   * @returns An unsubscribe function
+   */
+  subscribeWalletOrders(wallet, callback) {
+    return this.subscribe("get-wallet-orders", { wallet }, "wallet_orders_changed", callback);
+  }
+  // ============================================
+  // Control Methods
+  // ============================================
+  /** Query the server for the list of active subscriptions on this connection */
+  listSubscriptions() {
+    return this.sendRequest({ method: "LIST_SUBSCRIPTIONS" });
+  }
+  /** Query a server property (e.g. "heartbeat", "limits") */
+  getProperty(property) {
+    return this.sendRequest({ method: "GET_PROPERTY", params: [property] });
+  }
+  // ============================================
+  // Lifecycle
+  // ============================================
+  /** Open the WebSocket connection. Called automatically on first subscribe. */
+  connect() {
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = this.doConnect();
+    return this.connectPromise;
+  }
+  /** Close the connection and clean up all resources */
+  close() {
+    this.intentionallyClosed = true;
+    this.clearTimers();
+    this.subscriptions.clear();
+    for (const [, req] of this.pendingRequests) {
+      clearTimeout(req.timer);
+      req.reject(new Error("WebSocket closed"));
+    }
+    this.pendingRequests.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connectPromise = null;
+  }
+  // ============================================
+  // Internal
+  // ============================================
+  buildStreamKey(stream, params) {
+    const parts = [stream, ...Object.entries(params).sort().map(([k, v]) => `${k}=${v}`)];
+    return parts.join("&");
+  }
+  buildQueryString() {
+    const subs = [...this.subscriptions.values()];
+    if (subs.length === 0) return "";
+    const first = subs[0];
+    const params = new URLSearchParams({ stream: first.stream, ...first.params });
+    return "?" + params.toString();
+  }
+  subscribe(stream, params, eventType, callback) {
+    const key = this.buildStreamKey(stream, params);
+    this.subscriptions.set(key, { stream, params, callback, eventType });
+    if (this.connected) {
+      this.sendSubscribe(stream, params);
+    } else {
+      this.connect();
+    }
+    return () => {
+      this.subscriptions.delete(key);
+      this.lastOrderbookVersionBySubscription.delete(key);
+      if (this.connected) {
+        this.sendUnsubscribe(stream, params);
+      }
+    };
+  }
+  async doConnect() {
+    this.intentionallyClosed = false;
+    return new Promise((resolve, reject) => {
+      const qs = this.buildQueryString();
+      const ws = new this.WebSocketImpl(this.url + qs);
+      ws.onopen = () => {
+        this.ws = ws;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        const subs = [...this.subscriptions.values()];
+        for (const sub of subs) {
+          this.sendSubscribe(sub.stream, sub.params);
+        }
+        resolve();
+      };
+      ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      ws.onclose = () => {
+        this.ws = null;
+        this.connectPromise = null;
+        this.stopHeartbeat();
+        if (!this.intentionallyClosed) {
+          this.scheduleReconnect();
+        }
+      };
+      ws.onerror = (err) => {
+        if (!this.ws) {
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "ping") {
+      this.send({ method: "PONG" });
+      return;
+    }
+    const responseId = typeof msg.id === "string" ? msg.id : typeof msg.requestId === "string" ? msg.requestId : null;
+    if (responseId && this.pendingRequests.has(responseId)) {
+      const req = this.pendingRequests.get(responseId);
+      this.pendingRequests.delete(responseId);
+      clearTimeout(req.timer);
+      req.resolve(msg);
+      return;
+    }
+    const eventType = msg.type;
+    if (!eventType) return;
+    for (const [key, sub] of this.subscriptions.entries()) {
+      if (!this.matchesSubscriptionMessage(sub, msg)) {
+        continue;
+      }
+      if (!this.shouldDispatchSubscriptionMessage(key, sub, msg)) {
+        continue;
+      }
+      try {
+        sub.callback(msg);
+      } catch {
+      }
+    }
+  }
+  matchesSubscriptionMessage(sub, msg) {
+    if (sub.eventType !== msg.type) return false;
+    if (msg.type === "orderbook_changed") {
+      const messageMarketId = typeof msg.marketId === "string" ? msg.marketId : "";
+      const messageSlug = typeof msg.slug === "string" ? msg.slug : "";
+      const subscriptionMarketId = typeof sub.params.marketId === "string" ? sub.params.marketId : "";
+      const subscriptionSlug = typeof sub.params.slug === "string" ? sub.params.slug : "";
+      if (subscriptionMarketId) return subscriptionMarketId === messageMarketId;
+      if (subscriptionSlug && messageSlug) return subscriptionSlug === messageSlug;
+      if (subscriptionSlug || subscriptionMarketId) return false;
+    }
+    if (msg.type === "wallet_orders_changed") {
+      const messageWallet = typeof msg.wallet === "string" ? msg.wallet : "";
+      const subscriptionWallet = typeof sub.params.wallet === "string" ? sub.params.wallet : "";
+      if (subscriptionWallet) return subscriptionWallet === messageWallet;
+      return false;
+    }
+    return true;
+  }
+  shouldDispatchSubscriptionMessage(key, sub, msg) {
+    if (sub.eventType !== "orderbook_changed") {
+      return true;
+    }
+    const version = Number(msg.version ?? 0);
+    if (!Number.isFinite(version)) {
+      return true;
+    }
+    const lastVersion = this.lastOrderbookVersionBySubscription.get(key) ?? 0;
+    if (version < lastVersion) {
+      return false;
+    }
+    this.lastOrderbookVersionBySubscription.set(key, version);
+    return true;
+  }
+  sendSubscribe(stream, params) {
+    this.send({ method: "SUBSCRIBE", params: [{ stream, ...params }] });
+  }
+  sendUnsubscribe(stream, params) {
+    this.send({ method: "UNSUBSCRIBE", params: [{ stream, ...params }] });
+  }
+  sendRequest(payload, timeoutMs = 1e4) {
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Request timed out"));
+      }, timeoutMs);
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+      if (!this.connected) {
+        this.connect().then(() => {
+          this.send({ ...payload, id: requestId });
+        }).catch(reject);
+      } else {
+        this.send({ ...payload, id: requestId });
+      }
+    });
+  }
+  send(data) {
+    if (this.ws?.readyState === WS_OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  // ============================================
+  // Heartbeat
+  // ============================================
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.send({ method: "PING" });
+    }, this.heartbeatIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ============================================
+  // Reconnect
+  // ============================================
+  scheduleReconnect() {
+    if (!this.reconnectEnabled) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 3e4);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  clearTimers() {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+export { AlphaClient, AlphaWebSocket, DEFAULT_API_BASE_URL, DEFAULT_MARKET_CREATOR_ADDRESS, DEFAULT_WSS_BASE_URL, calculateFee, calculateFeeFromTotal, calculateMatchingOrders, checkAssetOptIn, decodeGlobalState, getEscrowGlobalState, getLiveMarketsFromApi, getMarketFromApi, getMarketGlobalState, getMarketOnChain, getMarketsOnChain };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map