@liberfi.io/react-predict 0.1.1

package/dist/server.js

@@ -0,0 +1,795 @@
+'use strict';
+
+require('@tanstack/react-query');
+var react = require('react');
+var utils = require('@liberfi.io/utils');
+
+// src/hooks/predict/events.params.ts
+var DEFAULT_PAGE_SIZE = 48;
+function resolveTagSlug(selection) {
+  if (!selection) return void 0;
+  return selection.tagSlug ?? selection.categorySlug ?? void 0;
+}
+function resolveEventsParams(input = {}) {
+  const {
+    tagSlugSelection,
+    limit = DEFAULT_PAGE_SIZE,
+    status = "open",
+    with_markets = true,
+    source,
+    sort_by,
+    sort_asc
+  } = input;
+  const tag_slug = resolveTagSlug(tagSlugSelection);
+  return {
+    limit,
+    status,
+    with_markets,
+    ...source ? { source } : {},
+    ...tag_slug ? { tag_slug } : {},
+    ...sort_by ? { sort_by } : {},
+    ...sort_asc !== void 0 ? { sort_asc } : {}
+  };
+}
+function infiniteEventsQueryKey(params) {
+  return ["predict", "events-infinite", params];
+}
+async function fetchEventsPage(client, params) {
+  return client.listEvents(params);
+}
+function eventQueryKey(slug, source) {
+  return ["predict", "event", slug, source];
+}
+async function fetchEvent(client, slug, source) {
+  return client.getEvent(slug, source);
+}
+react.createContext(null);
+
+// src/hooks/predict/useMarket.ts
+function marketQueryKey(slug, source) {
+  return ["predict", "market", slug, source];
+}
+async function fetchMarket(client, slug, source) {
+  return client.getMarket(slug, source);
+}
+function buildQuery(params) {
+  const qs = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      qs.set(key, String(value));
+    }
+  }
+  const str = qs.toString();
+  return str ? `?${str}` : "";
+}
+var PredictClient = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  /**
+   * List prediction events with optional filtering, sorting, and pagination.
+   *
+   * Maps to `GET /api/v1/events`.
+   *
+   * @param params - Optional query parameters (filter, sort, pagination).
+   * @returns A paginated page of events.
+   */
+  async listEvents(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/events${query}`;
+    return await utils.httpGet(url);
+  }
+  /**
+   * Fetch a single prediction event by its slug.
+   *
+   * Maps to `GET /api/v1/events/:slug?source=...`.
+   *
+   * @param slug - Canonical event slug (e.g. "will-trump-win-2024" for Polymarket
+   *               or "KXBTCD-25FEB-T68000" for DFlow).
+   * @param source - Upstream provider (`"dflow"` or `"polymarket"`).
+   * @returns The matching event.
+   * @throws When the server responds with 404 or any other non-2xx status.
+   */
+  async getEvent(slug, source) {
+    const query = source ? buildQuery({ source }) : "";
+    const url = `${this.endpoint}/api/v1/events/${encodeURIComponent(slug)}${query}`;
+    return await utils.httpGet(url);
+  }
+  /**
+   * Fetch events similar to the given slug.
+   *
+   * Maps to `GET /api/v1/events/:slug/similar?source=...`.
+   */
+  async getSimilarEvents(slug, source, params) {
+    const query = buildQuery({ source, ...params });
+    const url = `${this.endpoint}/api/v1/events/${encodeURIComponent(slug)}/similar${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Markets
+  // -------------------------------------------------------------------------
+  /**
+   * Fetch a single prediction market by its slug.
+   *
+   * Maps to `GET /api/v1/markets/:slug?source=...`.
+   *
+   * @param slug - Canonical market slug.
+   * @param source - Upstream provider (`"dflow"` or `"polymarket"`).
+   * @returns The matching market.
+   * @throws When the server responds with 404 or any other non-2xx status.
+   */
+  async getMarket(slug, source) {
+    const query = source ? buildQuery({ source }) : "";
+    const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `GET /api/v1/markets/:slug/orderbook?source=...`. */
+  async getOrderbook(slug, source) {
+    const query = buildQuery({ source });
+    const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}/orderbook${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `GET /api/v1/markets/:slug/trades?source=...`. */
+  async listMarketTrades(slug, params) {
+    const query = buildQuery(params);
+    const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}/trades${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `GET /api/v1/markets/:slug/price-history?source=...&range=...`. */
+  async getPriceHistory(slug, source, range) {
+    const query = buildQuery({ source, range });
+    const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}/price-history${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `GET /api/v1/markets/:slug/candlesticks?interval=...&limit=...`. */
+  async listCandlesticks(slug, params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}/candlesticks${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Positions
+  // -------------------------------------------------------------------------
+  /**
+   * Maps to `GET /api/v1/positions?source=...&user=...`.
+   *
+   * @param user - Wallet address.
+   * @param source - Provider source. Omit to aggregate all providers.
+   */
+  async getPositions(user, source) {
+    const query = buildQuery({ source, user });
+    const url = `${this.endpoint}/api/v1/positions${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Balance
+  // -------------------------------------------------------------------------
+  /**
+   * Get the on-chain USDC balance for a wallet.
+   *
+   * Maps to `GET /api/v1/balance?source=...&user=...`.
+   *
+   * @param source - Provider source (`"dflow"` for Solana, `"polymarket"` for Polygon).
+   * @param user - Wallet address.
+   */
+  async getBalance(source, user) {
+    const query = buildQuery({ source, user });
+    const url = `${this.endpoint}/api/v1/balance${query}`;
+    return await utils.httpGet(url);
+  }
+  // -------------------------------------------------------------------------
+  // Orders
+  // -------------------------------------------------------------------------
+  /** Maps to `GET /api/v1/orders?source=...&wallet_address=...`. */
+  async listOrders(params) {
+    const query = buildQuery(params);
+    const url = `${this.endpoint}/api/v1/orders${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `GET /api/v1/orders/:id?source=...`. */
+  async getOrder(id, source) {
+    const query = buildQuery({ source });
+    const url = `${this.endpoint}/api/v1/orders/${encodeURIComponent(id)}${query}`;
+    return await utils.httpGet(url);
+  }
+  /** Maps to `DELETE /api/v1/orders/:id?source=...`. */
+  async cancelOrder(id, source) {
+    const query = buildQuery({ source });
+    const url = `${this.endpoint}/api/v1/orders/${encodeURIComponent(id)}${query}`;
+    return await utils.httpDelete(url);
+  }
+  // -------------------------------------------------------------------------
+  // Polymarket trading
+  // -------------------------------------------------------------------------
+  /**
+   * Create a Polymarket limit order via the prediction-server proxy.
+   *
+   * Maps to `POST /api/v1/orders/polymarket`.
+   *
+   * The caller must attach Polymarket CLOB authentication headers:
+   * - `POLY_ADDRESS` — the EVM wallet address.
+   * - `POLY_SIGNATURE` — L1 signature or L2 API key.
+   * - `POLY_TIMESTAMP` — Unix milliseconds string.
+   * - `POLY_NONCE` — credential nonce (use `"0"` for in-session derived creds).
+   *
+   * @param input - Order parameters.
+   * @param headers - Polymarket CLOB auth headers (`POLY_*`).
+   */
+  async createPolymarketOrder(input, headers) {
+    const url = `${this.endpoint}/api/v1/orders/polymarket`;
+    return await utils.httpPost(url, input, { headers });
+  }
+  // -------------------------------------------------------------------------
+  // DFlow trading
+  // -------------------------------------------------------------------------
+  /** Maps to `POST /api/v1/orders/dflow/quote`. */
+  async createDFlowQuote(body) {
+    const url = `${this.endpoint}/api/v1/orders/dflow/quote`;
+    return await utils.httpPost(url, body);
+  }
+  /** Maps to `POST /api/v1/orders/dflow/submit`. */
+  async submitDFlowTransaction(body) {
+    const url = `${this.endpoint}/api/v1/orders/dflow/submit`;
+    return await utils.httpPost(url, body);
+  }
+  // -------------------------------------------------------------------------
+  // Trades by wallet
+  // -------------------------------------------------------------------------
+  /** Maps to `GET /api/v1/trades?source=...&wallet=...`. */
+  async listTrades(params) {
+    const query = buildQuery(params);
+    const url = `${this.endpoint}/api/v1/trades${query}`;
+    return await utils.httpGet(url);
+  }
+};
+function createPredictClient(endpoint) {
+  return new PredictClient(endpoint);
+}
+
+// src/client/ws.ts
+var DEFAULT_RECONNECT_BASE = 1e3;
+var DEFAULT_RECONNECT_MAX = 3e4;
+var DEFAULT_PING_INTERVAL = 2e4;
+var DEFAULT_PONG_TIMEOUT = 1e4;
+var PredictWsClient = class {
+  ws = null;
+  wsUrl;
+  autoReconnect;
+  reconnectBase;
+  reconnectMax;
+  pingMs;
+  pongTimeoutMs;
+  status = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  pingTimer = null;
+  pongTimer = null;
+  shouldReconnect = true;
+  listeners = {
+    connect: [],
+    disconnect: [],
+    reconnecting: [],
+    error: [],
+    status: [],
+    subscribed: [],
+    orderbook: [],
+    prices: [],
+    trades: []
+  };
+  subs = {
+    channels: /* @__PURE__ */ new Map([
+      ["orderbook", /* @__PURE__ */ new Set()],
+      ["prices", /* @__PURE__ */ new Set()],
+      ["trades", /* @__PURE__ */ new Set()]
+    ])
+  };
+  constructor(config) {
+    this.wsUrl = config.wsUrl;
+    this.autoReconnect = config.autoReconnect ?? true;
+    this.reconnectBase = config.reconnectIntervalBase ?? DEFAULT_RECONNECT_BASE;
+    this.reconnectMax = config.reconnectMaxInterval ?? DEFAULT_RECONNECT_MAX;
+    this.pingMs = config.pingInterval ?? DEFAULT_PING_INTERVAL;
+    this.pongTimeoutMs = config.pongTimeout ?? DEFAULT_PONG_TIMEOUT;
+    if (config.autoConnect !== false) {
+      this.connect();
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Connection management
+  // -------------------------------------------------------------------------
+  connect() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.shouldReconnect = true;
+    this.setStatus("connecting");
+    try {
+      this.ws = new WebSocket(this.wsUrl);
+      this.ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this.setStatus("connected");
+        this.emit("connect", void 0);
+        this.restoreSubscriptions();
+        this.startPing();
+      };
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      this.ws.onerror = () => {
+      };
+      this.ws.onclose = (event) => {
+        this.stopPing();
+        this.setStatus("disconnected");
+        this.emit("disconnect", { code: event.code, reason: event.reason });
+        if (this.shouldReconnect && this.autoReconnect) {
+          this.scheduleReconnect();
+        }
+      };
+    } catch {
+      if (this.shouldReconnect && this.autoReconnect) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopPing();
+    this.clearReconnectTimer();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setStatus("disconnected");
+  }
+  /** Disconnect and clear all subscription state and listeners. */
+  destroy() {
+    this.disconnect();
+    for (const ch of this.subs.channels.values()) ch.clear();
+    for (const key of Object.keys(this.listeners)) {
+      this.listeners[key].length = 0;
+    }
+  }
+  getStatus() {
+    return this.status;
+  }
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  // -------------------------------------------------------------------------
+  // Subscription — low-level (multi-channel, multi-slug)
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to one or more channels for the given market slugs.
+   * The server acknowledges with a `subscribed` message.
+   */
+  subscribe(channels, marketSlugs) {
+    for (const ch of channels) {
+      const set = this.subs.channels.get(ch);
+      for (const slug of marketSlugs) set.add(slug);
+    }
+    this.send({ type: "subscribe", channels, market_slugs: marketSlugs });
+  }
+  /**
+   * Unsubscribe from one or more channels for the given market slugs.
+   */
+  unsubscribe(channels, marketSlugs) {
+    for (const ch of channels) {
+      const set = this.subs.channels.get(ch);
+      for (const slug of marketSlugs) set.delete(slug);
+    }
+    this.send({ type: "unsubscribe", channels, market_slugs: marketSlugs });
+  }
+  // -------------------------------------------------------------------------
+  // Subscription — convenience (single channel)
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to price updates for the given slugs.
+   * Returns an unsubscribe function.
+   */
+  subscribePrices(slugs, onUpdate) {
+    this.subscribe(["prices"], slugs);
+    const off = this.on("prices", onUpdate);
+    return () => {
+      off();
+      this.unsubscribe(["prices"], slugs);
+    };
+  }
+  /**
+   * Subscribe to orderbook snapshots for the given slugs.
+   * Returns an unsubscribe function.
+   */
+  subscribeOrderbook(slugs, onUpdate) {
+    this.subscribe(["orderbook"], slugs);
+    const off = this.on("orderbook", onUpdate);
+    return () => {
+      off();
+      this.unsubscribe(["orderbook"], slugs);
+    };
+  }
+  /**
+   * Subscribe to trade events for the given slugs.
+   * Returns an unsubscribe function.
+   */
+  subscribeTrades(slugs, onUpdate) {
+    this.subscribe(["trades"], slugs);
+    const off = this.on("trades", onUpdate);
+    return () => {
+      off();
+      this.unsubscribe(["trades"], slugs);
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Status observation
+  // -------------------------------------------------------------------------
+  /** Register a callback for connection status changes. Returns unsubscribe. */
+  onStatusChange(cb) {
+    return this.on("status", cb);
+  }
+  /** Register a callback for server-sent errors. Returns unsubscribe. */
+  onError(cb) {
+    return this.on("error", cb);
+  }
+  // -------------------------------------------------------------------------
+  // Event emitter
+  // -------------------------------------------------------------------------
+  on(event, callback) {
+    const list = this.listeners[event];
+    list.push(callback);
+    return () => this.off(event, callback);
+  }
+  off(event, callback) {
+    const list = this.listeners[event];
+    const idx = list.indexOf(callback);
+    if (idx !== -1) list.splice(idx, 1);
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  emit(event, data) {
+    const list = this.listeners[event];
+    for (const cb of list) {
+      try {
+        cb(data);
+      } catch (e) {
+      }
+    }
+  }
+  send(msg) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    try {
+      this.ws.send(JSON.stringify(msg));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  setStatus(next) {
+    if (this.status !== next) {
+      this.status = next;
+      this.emit("status", next);
+    }
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type) {
+      switch (msg.type) {
+        case "pong":
+          this.clearPongTimer();
+          return;
+        case "subscribed":
+          this.emit("subscribed", {
+            channels: msg.channels,
+            market_slugs: msg.market_slugs
+          });
+          return;
+        case "error":
+          this.emit("error", {
+            code: msg.code,
+            message: msg.message
+          });
+          return;
+      }
+    }
+    if (msg.channel && msg.data) {
+      const dataMsg = msg;
+      switch (dataMsg.channel) {
+        case "orderbook":
+          this.emit("orderbook", dataMsg);
+          break;
+        case "prices":
+          this.emit("prices", dataMsg);
+          break;
+        case "trades":
+          this.emit("trades", dataMsg);
+          break;
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    const delay = Math.min(
+      this.reconnectBase * Math.pow(2, this.reconnectAttempts),
+      this.reconnectMax
+    );
+    this.setStatus("reconnecting");
+    this.emit("reconnecting", { attempt: this.reconnectAttempts + 1, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.reconnectAttempts++;
+      this.connect();
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  restoreSubscriptions() {
+    for (const [channel, slugs] of this.subs.channels.entries()) {
+      if (slugs.size > 0) {
+        this.send({
+          type: "subscribe",
+          channels: [channel],
+          market_slugs: Array.from(slugs)
+        });
+      }
+    }
+  }
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      this.send({ type: "ping" });
+      this.armPongTimeout();
+    }, this.pingMs);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.clearPongTimer();
+  }
+  /**
+   * Start a timer that fires if the server does not reply with pong
+   * within `pongTimeoutMs`. On timeout the socket is closed so
+   * the normal reconnect flow kicks in.
+   */
+  armPongTimeout() {
+    this.clearPongTimer();
+    this.pongTimer = setTimeout(() => {
+      this.pongTimer = null;
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.close(4e3, "pong timeout");
+      }
+    }, this.pongTimeoutMs);
+  }
+  clearPongTimer() {
+    if (this.pongTimer) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+  }
+};
+function createPredictWsClient(config) {
+  return new PredictWsClient(config);
+}
+
+// src/utils/polymarket-hmac.ts
+function encode(str) {
+  return new TextEncoder().encode(str);
+}
+function base64ToBytes(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+async function hmacSha256Base64(secretBase64, message) {
+  const keyBytes = base64ToBytes(secretBase64);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const msgBytes = encode(message);
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    cryptoKey,
+    msgBytes.buffer
+  );
+  return bytesToBase64(new Uint8Array(signature));
+}
+async function buildPolymarketL2Headers(address, input) {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const body = input.body ?? "";
+  const message = `${timestamp}${input.method}${input.requestPath}${body}`;
+  const signature = await hmacSha256Base64(input.secret, message);
+  return {
+    POLY_ADDRESS: address,
+    POLY_SIGNATURE: signature,
+    POLY_TIMESTAMP: timestamp,
+    POLY_API_KEY: input.apiKey,
+    POLY_PASSPHRASE: input.passphrase
+  };
+}
+var CLOB_AUTH_DOMAIN = {
+  name: "ClobAuthDomain",
+  version: "1",
+  chainId: 137
+};
+var CLOB_AUTH_TYPES = {
+  ClobAuth: [
+    { name: "address", type: "address" },
+    { name: "timestamp", type: "string" },
+    { name: "nonce", type: "uint256" },
+    { name: "message", type: "string" }
+  ]
+};
+function buildClobAuthMessage(input) {
+  return {
+    address: input.address,
+    timestamp: input.timestamp,
+    nonce: input.nonce,
+    message: "This message attests that I control the given wallet"
+  };
+}
+async function derivePolymarketApiKey(address, signature, timestamp, nonce) {
+  const res = await fetch(
+    `https://clob.polymarket.com/auth/derive-api-key?nonce=${nonce}`,
+    {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        POLY_ADDRESS: address,
+        POLY_SIGNATURE: signature,
+        POLY_TIMESTAMP: timestamp,
+        POLY_NONCE: String(nonce)
+      }
+    }
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => res.statusText);
+    throw new Error(
+      `Polymarket credential exchange failed (${res.status}): ${text}`
+    );
+  }
+  return res.json();
+}
+
+// src/utils/polymarket-order.ts
+var CTF_EXCHANGE_ADDRESS = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E";
+var NEG_RISK_CTF_EXCHANGE_ADDRESS = "0xC5d563A36AE78145C45a50134d48A1215220f80a";
+var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var POLYGON_CHAIN_ID = 137;
+function buildCtfExchangeDomain(negRisk = false) {
+  return {
+    name: "CTFExchange",
+    version: "1",
+    chainId: POLYGON_CHAIN_ID,
+    verifyingContract: negRisk ? NEG_RISK_CTF_EXCHANGE_ADDRESS : CTF_EXCHANGE_ADDRESS
+  };
+}
+var CTF_ORDER_TYPES = {
+  Order: [
+    { name: "salt", type: "uint256" },
+    { name: "maker", type: "address" },
+    { name: "signer", type: "address" },
+    { name: "taker", type: "address" },
+    { name: "tokenId", type: "uint256" },
+    { name: "makerAmount", type: "uint256" },
+    { name: "takerAmount", type: "uint256" },
+    { name: "expiration", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "feeRateBps", type: "uint256" },
+    { name: "side", type: "uint8" },
+    { name: "signatureType", type: "uint8" }
+  ]
+};
+var ORDER_TYPE = {
+  GTC: 0,
+  // Good-Till-Cancelled
+  FOK: 1,
+  // Fill-Or-Kill
+  GTD: 2,
+  // Good-Till-Date
+  FAK: 3
+  // Fill-And-Kill
+};
+var SIDE = { BUY: 0, SELL: 1 };
+var TICK_DECIMALS = {
+  "0.1": 1,
+  "0.01": 2,
+  "0.001": 3,
+  "0.0001": 4
+};
+function roundToTick(price, tickSize) {
+  const decimals = TICK_DECIMALS[tickSize] ?? 2;
+  return price.toFixed(decimals);
+}
+function toMicroUsdc(amount) {
+  return BigInt(Math.round(amount * 1e6));
+}
+function buildOrderMessage(input) {
+  const side = input.side === "BUY" ? SIDE.BUY : SIDE.SELL;
+  const priceStr = roundToTick(input.price, input.tickSize);
+  const priceNum = parseFloat(priceStr);
+  const sizeShares = toMicroUsdc(input.size);
+  const sizeUsdc = toMicroUsdc(input.size * priceNum);
+  const makerAmount = side === SIDE.BUY ? sizeUsdc.toString() : sizeShares.toString();
+  const takerAmount = side === SIDE.BUY ? sizeShares.toString() : sizeUsdc.toString();
+  const maker = input.funderAddress ?? input.signerAddress;
+  return {
+    salt: Math.floor(Math.random() * 1e15).toString(),
+    maker,
+    signer: input.signerAddress,
+    taker: "0x0000000000000000000000000000000000000000",
+    tokenId: input.tokenId,
+    makerAmount,
+    takerAmount,
+    expiration: String(input.expiration ?? 0),
+    nonce: "0",
+    feeRateBps: "0",
+    side,
+    signatureType: input.signatureType
+  };
+}
+function buildSignedOrder(input) {
+  const message = buildOrderMessage(input);
+  return {
+    ...message,
+    signature: input.signature,
+    orderType: input.orderType ?? "GTC"
+  };
+}
+
+exports.CLOB_AUTH_DOMAIN = CLOB_AUTH_DOMAIN;
+exports.CLOB_AUTH_TYPES = CLOB_AUTH_TYPES;
+exports.CTF_EXCHANGE_ADDRESS = CTF_EXCHANGE_ADDRESS;
+exports.CTF_ORDER_TYPES = CTF_ORDER_TYPES;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.NEG_RISK_CTF_EXCHANGE_ADDRESS = NEG_RISK_CTF_EXCHANGE_ADDRESS;
+exports.ORDER_TYPE = ORDER_TYPE;
+exports.POLYGON_CHAIN_ID = POLYGON_CHAIN_ID;
+exports.PredictClient = PredictClient;
+exports.PredictWsClient = PredictWsClient;
+exports.SIDE = SIDE;
+exports.USDC_ADDRESS = USDC_ADDRESS;
+exports.buildClobAuthMessage = buildClobAuthMessage;
+exports.buildCtfExchangeDomain = buildCtfExchangeDomain;
+exports.buildOrderMessage = buildOrderMessage;
+exports.buildPolymarketL2Headers = buildPolymarketL2Headers;
+exports.buildSignedOrder = buildSignedOrder;
+exports.createPredictClient = createPredictClient;
+exports.createPredictWsClient = createPredictWsClient;
+exports.derivePolymarketApiKey = derivePolymarketApiKey;
+exports.eventQueryKey = eventQueryKey;
+exports.fetchEvent = fetchEvent;
+exports.fetchEventsPage = fetchEventsPage;
+exports.fetchMarket = fetchMarket;
+exports.hmacSha256Base64 = hmacSha256Base64;
+exports.infiniteEventsQueryKey = infiniteEventsQueryKey;
+exports.marketQueryKey = marketQueryKey;
+exports.resolveEventsParams = resolveEventsParams;
+exports.resolveTagSlug = resolveTagSlug;
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map