@liberfi.io/react-predict 0.1.1

package/dist/index.js

@@ -0,0 +1,1536 @@
+'use strict';
+
+var utils = require('@liberfi.io/utils');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var reactQuery = require('@tanstack/react-query');
+
+// src/client/client.ts
+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);
+}
+var PredictContext = react.createContext(null);
+function PredictProvider({
+  client,
+  wsClient,
+  children
+}) {
+  const ws = wsClient ?? null;
+  const value = react.useMemo(() => ({ client, wsClient: ws }), [client, ws]);
+  return /* @__PURE__ */ jsxRuntime.jsx(PredictContext.Provider, { value, children });
+}
+
+// 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();
+}
+var PolymarketContext = react.createContext(
+  null
+);
+function PolymarketProvider({ children }) {
+  const [credentials, setCredentials] = react.useState(
+    null
+  );
+  const [isAuthenticating, setIsAuthenticating] = react.useState(false);
+  const [authError, setAuthError] = react.useState(null);
+  const lastAuthAddressRef = react.useRef(null);
+  const authenticate = react.useCallback(
+    async (signer) => {
+      if (lastAuthAddressRef.current === signer.address && credentials !== null) {
+        return;
+      }
+      setIsAuthenticating(true);
+      setAuthError(null);
+      try {
+        const timestamp = Math.floor(Date.now() / 1e3).toString();
+        const nonce = 0;
+        const message = buildClobAuthMessage({
+          address: signer.address,
+          timestamp,
+          nonce
+        });
+        const signature = await signer.signTypedData(
+          CLOB_AUTH_DOMAIN,
+          CLOB_AUTH_TYPES,
+          message
+        );
+        const { apiKey, secret, passphrase } = await derivePolymarketApiKey(
+          signer.address,
+          signature,
+          timestamp,
+          nonce
+        );
+        lastAuthAddressRef.current = signer.address;
+        setCredentials({ apiKey, secret, passphrase, address: signer.address });
+      } catch (err) {
+        setAuthError(
+          err instanceof Error ? err : new Error("Polymarket authentication failed")
+        );
+        lastAuthAddressRef.current = null;
+      } finally {
+        setIsAuthenticating(false);
+      }
+    },
+    [credentials]
+  );
+  const clearCredentials = react.useCallback(() => {
+    setCredentials(null);
+    lastAuthAddressRef.current = null;
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    PolymarketContext.Provider,
+    {
+      value: {
+        credentials,
+        isAuthenticating,
+        authError,
+        authenticate,
+        clearCredentials
+      },
+      children
+    }
+  );
+}
+function usePredictClient() {
+  const context = react.useContext(PredictContext);
+  if (!context) {
+    throw new Error("usePredictClient must be used within a PredictProvider");
+  }
+  return context.client;
+}
+function eventsQueryKey(params) {
+  return ["predict", "events", params ?? {}];
+}
+async function fetchEvents(client, params) {
+  return client.listEvents(params);
+}
+function useEvents(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: eventsQueryKey(params),
+    queryFn: () => client.listEvents(params),
+    ...queryOptions
+  });
+}
+
+// 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);
+}
+
+// src/hooks/predict/useEvent.ts
+function useEvent(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: eventQueryKey(params.slug, params.source),
+    queryFn: () => fetchEvent(client, params.slug, params.source),
+    enabled: Boolean(params.slug),
+    ...queryOptions
+  });
+}
+function useInfiniteEvents(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useInfiniteQuery({
+    queryKey: infiniteEventsQueryKey(params),
+    queryFn: ({ pageParam }) => fetchEventsPage(client, {
+      ...params,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    ...queryOptions
+  });
+}
+function searchEventsQueryKey(params) {
+  return ["predict", "search", params];
+}
+function useSearchEvents(params, queryOptions) {
+  const client = usePredictClient();
+  const apiParams = react.useMemo(
+    () => ({
+      search: params.keyword,
+      limit: params.limit ?? 20,
+      status: params.status ?? "open",
+      source: params.source,
+      with_markets: params.with_markets ?? false
+    }),
+    [
+      params.keyword,
+      params.limit,
+      params.status,
+      params.source,
+      params.with_markets
+    ]
+  );
+  return reactQuery.useInfiniteQuery({
+    queryKey: searchEventsQueryKey(apiParams),
+    queryFn: ({ pageParam }) => client.listEvents({
+      ...apiParams,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? !!params.keyword
+  });
+}
+function similarEventsQueryKey(slug, source, params) {
+  return ["predict", "similar-events", slug, source, params];
+}
+function useSimilarEvents(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const apiParams = {
+    limit: params.limit,
+    same_source: params.same_source
+  };
+  return reactQuery.useQuery({
+    queryKey: similarEventsQueryKey(params.slug, params.source, apiParams),
+    queryFn: () => client.getSimilarEvents(params.slug, params.source, apiParams),
+    enabled: Boolean(params.slug),
+    staleTime: 5 * 6e4,
+    ...queryOptions
+  });
+}
+function marketQueryKey(slug, source) {
+  return ["predict", "market", slug, source];
+}
+async function fetchMarket(client, slug, source) {
+  return client.getMarket(slug, source);
+}
+function useMarket(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: marketQueryKey(params.slug, params.source),
+    queryFn: () => fetchMarket(client, params.slug, params.source),
+    enabled: Boolean(params.slug),
+    ...queryOptions
+  });
+}
+function priceHistoryQueryKey(slug, source, range) {
+  return ["predict", "price-history", slug, source, range];
+}
+function usePriceHistory(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: priceHistoryQueryKey(params.slug, params.source, params.range),
+    queryFn: () => client.getPriceHistory(params.slug, params.source, params.range),
+    enabled: Boolean(params.slug),
+    staleTime: 6e4,
+    ...queryOptions
+  });
+}
+
+// src/hooks/predict/useMarketHistory.ts
+var ChartRange = {
+  ONE_DAY: "1d",
+  ONE_WEEK: "1w",
+  ONE_MONTH: "1m",
+  ALL: "all"
+};
+var RANGE_MAP = {
+  [ChartRange.ONE_DAY]: "1d",
+  [ChartRange.ONE_WEEK]: "1w",
+  [ChartRange.ONE_MONTH]: "1m",
+  [ChartRange.ALL]: "all"
+};
+function useMarketHistory(markets, range = ChartRange.ALL) {
+  const client = usePredictClient();
+  const apiRange = RANGE_MAP[range];
+  const queries = reactQuery.useQueries({
+    queries: markets.map((market) => ({
+      queryKey: priceHistoryQueryKey(market.slug, market.source, apiRange),
+      queryFn: () => client.getPriceHistory(market.slug, market.source, apiRange),
+      staleTime: 6e4,
+      enabled: Boolean(market.slug)
+    }))
+  });
+  const isLoading = queries.some((q) => q.isLoading);
+  const series = react.useMemo(() => {
+    return markets.map((market, idx) => {
+      const result = queries[idx];
+      const points = result?.data?.points ?? [];
+      if (points.length > 0) {
+        return {
+          marketSlug: market.slug,
+          label: market.outcomes?.[0]?.label ?? market.question,
+          data: points.map((pt) => ({
+            timestamp: pt.t * 1e3,
+            price: pt.p
+          }))
+        };
+      }
+      const yesOutcome = market.outcomes?.find((o) => o.label.toLowerCase() === "yes") ?? market.outcomes?.[0];
+      const currentPrice = yesOutcome?.price ?? 0.5;
+      const now = Date.now();
+      const dayMs = 864e5;
+      return {
+        marketSlug: market.slug,
+        label: market.outcomes?.[0]?.label ?? market.question,
+        data: [
+          { timestamp: now - 7 * dayMs, price: currentPrice },
+          { timestamp: now, price: currentPrice }
+        ]
+      };
+    });
+  }, [markets, queries]);
+  return { series, isLoading };
+}
+function orderbookQueryKey(slug, source) {
+  return ["predict", "orderbook", slug, source];
+}
+function useOrderbook(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: orderbookQueryKey(params.slug, params.source),
+    queryFn: () => client.getOrderbook(params.slug, params.source),
+    enabled: Boolean(params.slug),
+    refetchInterval: 5e3,
+    ...queryOptions
+  });
+}
+function marketTradesQueryKey(slug, params) {
+  return ["predict", "market-trades", slug, params];
+}
+function useMarketTrades(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const apiParams = {
+    source: params.source,
+    limit: params.limit,
+    cursor: params.cursor,
+    side: params.side
+  };
+  return reactQuery.useQuery({
+    queryKey: marketTradesQueryKey(params.slug, apiParams),
+    queryFn: () => client.listMarketTrades(params.slug, apiParams),
+    enabled: Boolean(params.slug),
+    ...queryOptions
+  });
+}
+function candlesticksQueryKey(slug, params) {
+  return ["predict", "candlesticks", slug, params];
+}
+function useCandlesticks(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const apiParams = {
+    interval: params.interval,
+    limit: params.limit
+  };
+  return reactQuery.useQuery({
+    queryKey: candlesticksQueryKey(params.slug, apiParams),
+    queryFn: () => client.listCandlesticks(params.slug, apiParams),
+    enabled: Boolean(params.slug),
+    staleTime: 6e4,
+    ...queryOptions
+  });
+}
+function positionsQueryKey(user, source) {
+  return ["predict", "positions", source ?? "all", user];
+}
+function usePositions(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: positionsQueryKey(params.user, params.source),
+    queryFn: () => client.getPositions(params.user, params.source),
+    enabled: Boolean(params.user),
+    staleTime: 1e4,
+    ...queryOptions
+  });
+}
+function balanceQueryKey(source, user) {
+  return ["predict", "balance", source, user];
+}
+function useBalance(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: balanceQueryKey(params.source, params.user),
+    queryFn: () => client.getBalance(params.source, params.user),
+    enabled: Boolean(params.user && params.source),
+    staleTime: 1e4,
+    ...queryOptions
+  });
+}
+function ordersQueryKey(params) {
+  return ["predict", "orders", params];
+}
+function useOrders(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: ordersQueryKey(params),
+    queryFn: () => client.listOrders(params),
+    enabled: Boolean(params.wallet_address),
+    ...queryOptions
+  });
+}
+function orderQueryKey(id, source) {
+  return ["predict", "order", id, source];
+}
+function useOrder(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: orderQueryKey(params.id, params.source),
+    queryFn: () => client.getOrder(params.id, params.source),
+    enabled: Boolean(params.id),
+    refetchInterval: 1e3,
+    ...queryOptions
+  });
+}
+function useCancelOrder(mutationOptions = {}) {
+  const client = usePredictClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (vars) => client.cancelOrder(vars.id, vars.source),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
+    },
+    ...mutationOptions
+  });
+}
+function tradesQueryKey(params) {
+  return ["predict", "trades-by-wallet", params];
+}
+function useTrades(params, queryOptions = {}) {
+  const client = usePredictClient();
+  return reactQuery.useQuery({
+    queryKey: tradesQueryKey(params),
+    queryFn: () => client.listTrades(params),
+    enabled: Boolean(params.wallet),
+    ...queryOptions
+  });
+}
+function dflowQuoteQueryKey(params) {
+  return ["predict", "dflow-quote", params];
+}
+function useDFlowQuote(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const enabled = Boolean(params.inputMint) && Boolean(params.outputMint) && Boolean(params.userPublicKey) && params.amount !== "0" && params.amount !== "";
+  return reactQuery.useQuery({
+    queryKey: dflowQuoteQueryKey(params),
+    queryFn: () => client.createDFlowQuote(params),
+    enabled,
+    staleTime: 1e4,
+    ...queryOptions
+  });
+}
+function useDFlowSubmit(mutationOptions = {}) {
+  const client = usePredictClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (body) => client.submitDFlowTransaction(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
+      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
+    },
+    ...mutationOptions
+  });
+}
+function usePredictWsClient() {
+  const context = react.useContext(PredictContext);
+  if (!context) {
+    throw new Error("usePredictWsClient must be used within a PredictProvider");
+  }
+  const { wsClient } = context;
+  const [wsStatus, setWsStatus] = react.useState(
+    wsClient?.getStatus() ?? "disconnected"
+  );
+  react.useEffect(() => {
+    if (!wsClient) {
+      setWsStatus("disconnected");
+      return;
+    }
+    setWsStatus(wsClient.getStatus());
+    return wsClient.onStatusChange(setWsStatus);
+  }, [wsClient]);
+  return {
+    wsClient,
+    wsStatus,
+    isWsConnected: wsStatus === "connected"
+  };
+}
+function usePricesSubscription({
+  wsClient,
+  slugs,
+  enabled = true,
+  onUpdate
+}) {
+  const [prices, setPrices] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const [isSubscribed, setIsSubscribed] = react.useState(false);
+  const onUpdateRef = react.useRef(onUpdate);
+  onUpdateRef.current = onUpdate;
+  const slugsKey = slugs.join(",");
+  const handleUpdate = react.useCallback((msg) => {
+    setPrices((prev) => {
+      const next = new Map(prev);
+      next.set(msg.data.market_slug, msg.data);
+      return next;
+    });
+    onUpdateRef.current?.(msg);
+  }, []);
+  react.useEffect(() => {
+    if (!wsClient || !enabled || slugs.length === 0) {
+      setIsSubscribed(false);
+      return;
+    }
+    const unsub = wsClient.subscribePrices(slugs, handleUpdate);
+    setIsSubscribed(true);
+    return () => {
+      unsub();
+      setIsSubscribed(false);
+    };
+  }, [wsClient, enabled, slugsKey, handleUpdate]);
+  return { prices, isSubscribed };
+}
+function useOrderbookSubscription({
+  wsClient,
+  slug,
+  enabled = true,
+  onUpdate
+}) {
+  const [orderbook, setOrderbook] = react.useState(null);
+  const [isSubscribed, setIsSubscribed] = react.useState(false);
+  const onUpdateRef = react.useRef(onUpdate);
+  onUpdateRef.current = onUpdate;
+  const handleUpdate = react.useCallback(
+    (msg) => {
+      if (msg.data.market_slug === slug) {
+        setOrderbook(msg.data);
+        onUpdateRef.current?.(msg);
+      }
+    },
+    [slug]
+  );
+  react.useEffect(() => {
+    if (!wsClient || !enabled || !slug) {
+      setIsSubscribed(false);
+      return;
+    }
+    setOrderbook(null);
+    const unsub = wsClient.subscribeOrderbook([slug], handleUpdate);
+    setIsSubscribed(true);
+    return () => {
+      unsub();
+      setIsSubscribed(false);
+    };
+  }, [wsClient, enabled, slug, handleUpdate]);
+  return { orderbook, isSubscribed };
+}
+var DEFAULT_MAX_HISTORY = 100;
+function useTradesSubscription({
+  wsClient,
+  slug,
+  enabled = true,
+  maxHistory = DEFAULT_MAX_HISTORY,
+  onUpdate
+}) {
+  const [trades, setTrades] = react.useState([]);
+  const [isSubscribed, setIsSubscribed] = react.useState(false);
+  const onUpdateRef = react.useRef(onUpdate);
+  onUpdateRef.current = onUpdate;
+  const maxRef = react.useRef(maxHistory);
+  maxRef.current = maxHistory;
+  const handleUpdate = react.useCallback(
+    (msg) => {
+      if (msg.data.market_slug === slug) {
+        setTrades((prev) => {
+          const next = [msg.data, ...prev];
+          return next.length > maxRef.current ? next.slice(0, maxRef.current) : next;
+        });
+        onUpdateRef.current?.(msg);
+      }
+    },
+    [slug]
+  );
+  const clearHistory = react.useCallback(() => {
+    setTrades([]);
+  }, []);
+  react.useEffect(() => {
+    if (!wsClient || !enabled || !slug) {
+      setIsSubscribed(false);
+      return;
+    }
+    setTrades([]);
+    const unsub = wsClient.subscribeTrades([slug], handleUpdate);
+    setIsSubscribed(true);
+    return () => {
+      unsub();
+      setIsSubscribed(false);
+    };
+  }, [wsClient, enabled, slug, handleUpdate]);
+  return { trades, isSubscribed, clearHistory };
+}
+var REST_POLL_INTERVAL = 5e3;
+function useRealtimeOrderbook(params, queryOptions = {}) {
+  const { wsClient } = usePredictWsClient();
+  const queryClient = reactQuery.useQueryClient();
+  const subParams = {
+    wsClient,
+    slug: params.slug,
+    enabled: Boolean(params.slug)
+  };
+  const { isSubscribed } = useOrderbookSubscription(subParams);
+  const qk = orderbookQueryKey(params.slug, params.source);
+  const qkRef = react.useRef(qk);
+  qkRef.current = qk;
+  react.useEffect(() => {
+    if (!wsClient || !params.slug) return;
+    const unsub = wsClient.subscribeOrderbook([params.slug], (msg) => {
+      const ob = {
+        market_id: msg.data.market_slug,
+        bids: msg.data.bids,
+        asks: msg.data.asks,
+        spread: msg.data.spread
+      };
+      queryClient.setQueryData(qkRef.current, ob);
+    });
+    return unsub;
+  }, [wsClient, params.slug, queryClient]);
+  return useOrderbook(params, {
+    refetchInterval: isSubscribed ? false : REST_POLL_INTERVAL,
+    ...queryOptions
+  });
+}
+
+// src/hooks/predict/useRealtimePrices.ts
+function useRealtimePrices({
+  slugs,
+  enabled = true,
+  onUpdate
+}) {
+  const { wsClient } = usePredictWsClient();
+  return usePricesSubscription({
+    wsClient,
+    slugs,
+    enabled,
+    onUpdate
+  });
+}
+function useRealtimeTrades({
+  slug,
+  enabled = true,
+  maxHistory,
+  onUpdate,
+  syncToQueryCache = true
+}) {
+  const { wsClient } = usePredictWsClient();
+  const queryClient = reactQuery.useQueryClient();
+  const slugRef = react.useRef(slug);
+  slugRef.current = slug;
+  react.useEffect(() => {
+    if (!wsClient || !slug || !enabled || !syncToQueryCache) return;
+    const unsub = wsClient.subscribeTrades([slug], (msg) => {
+      const trade = msg.data;
+      const prefix = ["predict", "market-trades", slugRef.current];
+      queryClient.setQueriesData(
+        { queryKey: prefix },
+        (old) => {
+          if (!old) return old;
+          const syntheticTrade = {
+            id: trade.trade_id ?? `ws-${msg.ts}`,
+            source: "dflow",
+            side: trade.side,
+            outcome: trade.outcome ?? "",
+            outcome_index: 0,
+            price: trade.price,
+            size: trade.size,
+            usd_size: trade.size,
+            timestamp: Math.floor(msg.ts / 1e3),
+            tx_hash: "",
+            wallet: "",
+            type: "TRADE"
+          };
+          return {
+            ...old,
+            items: [syntheticTrade, ...old.items]
+          };
+        }
+      );
+    });
+    return unsub;
+  }, [wsClient, slug, enabled, syncToQueryCache, queryClient]);
+  return useTradesSubscription({
+    wsClient,
+    slug,
+    enabled,
+    maxHistory,
+    onUpdate
+  });
+}
+function usePolymarket() {
+  const context = react.useContext(PolymarketContext);
+  if (!context) {
+    throw new Error("usePolymarket must be used within a PolymarketProvider");
+  }
+  return context;
+}
+
+// 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"
+  };
+}
+
+// src/hooks/polymarket/useCreatePolymarketOrder.ts
+function useCreatePolymarketOrder(mutationOptions = {}) {
+  const client = usePredictClient();
+  const { credentials, authenticate } = usePolymarket();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      input,
+      signer
+    }) => {
+      const creds = credentials;
+      if (!creds) {
+        await authenticate(signer);
+        if (!creds) {
+          throw new Error(
+            "Polymarket authentication failed. Cannot create order without credentials."
+          );
+        }
+      }
+      const domain = buildCtfExchangeDomain(input.negRisk ?? false);
+      const orderMessage = buildOrderMessage({
+        ...input,
+        signerAddress: signer.address,
+        signatureType: signer.signatureType
+      });
+      const signature = await signer.signTypedData(
+        domain,
+        CTF_ORDER_TYPES,
+        orderMessage
+      );
+      const signedOrder = buildSignedOrder({
+        ...input,
+        signerAddress: signer.address,
+        signatureType: signer.signatureType,
+        signature
+      });
+      const body = JSON.stringify(signedOrder);
+      const headers = await buildPolymarketL2Headers(creds.address, {
+        apiKey: creds.apiKey,
+        secret: creds.secret,
+        passphrase: creds.passphrase,
+        method: "POST",
+        requestPath: "/api/v1/orders/polymarket",
+        body
+      });
+      return client.createPolymarketOrder(
+        signedOrder,
+        headers
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
+      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
+    },
+    ...mutationOptions
+  });
+}
+
+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.ChartRange = ChartRange;
+exports.NEG_RISK_CTF_EXCHANGE_ADDRESS = NEG_RISK_CTF_EXCHANGE_ADDRESS;
+exports.ORDER_TYPE = ORDER_TYPE;
+exports.POLYGON_CHAIN_ID = POLYGON_CHAIN_ID;
+exports.PolymarketContext = PolymarketContext;
+exports.PolymarketProvider = PolymarketProvider;
+exports.PredictClient = PredictClient;
+exports.PredictContext = PredictContext;
+exports.PredictProvider = PredictProvider;
+exports.PredictWsClient = PredictWsClient;
+exports.SIDE = SIDE;
+exports.USDC_ADDRESS = USDC_ADDRESS;
+exports.balanceQueryKey = balanceQueryKey;
+exports.buildClobAuthMessage = buildClobAuthMessage;
+exports.buildCtfExchangeDomain = buildCtfExchangeDomain;
+exports.buildOrderMessage = buildOrderMessage;
+exports.buildPolymarketL2Headers = buildPolymarketL2Headers;
+exports.buildSignedOrder = buildSignedOrder;
+exports.candlesticksQueryKey = candlesticksQueryKey;
+exports.createPredictClient = createPredictClient;
+exports.createPredictWsClient = createPredictWsClient;
+exports.derivePolymarketApiKey = derivePolymarketApiKey;
+exports.dflowQuoteQueryKey = dflowQuoteQueryKey;
+exports.eventQueryKey = eventQueryKey;
+exports.eventsQueryKey = eventsQueryKey;
+exports.fetchEvent = fetchEvent;
+exports.fetchEvents = fetchEvents;
+exports.fetchEventsPage = fetchEventsPage;
+exports.fetchMarket = fetchMarket;
+exports.hmacSha256Base64 = hmacSha256Base64;
+exports.infiniteEventsQueryKey = infiniteEventsQueryKey;
+exports.marketQueryKey = marketQueryKey;
+exports.marketTradesQueryKey = marketTradesQueryKey;
+exports.orderQueryKey = orderQueryKey;
+exports.orderbookQueryKey = orderbookQueryKey;
+exports.ordersQueryKey = ordersQueryKey;
+exports.positionsQueryKey = positionsQueryKey;
+exports.priceHistoryQueryKey = priceHistoryQueryKey;
+exports.resolveEventsParams = resolveEventsParams;
+exports.resolveTagSlug = resolveTagSlug;
+exports.similarEventsQueryKey = similarEventsQueryKey;
+exports.tradesQueryKey = tradesQueryKey;
+exports.useBalance = useBalance;
+exports.useCancelOrder = useCancelOrder;
+exports.useCandlesticks = useCandlesticks;
+exports.useCreatePolymarketOrder = useCreatePolymarketOrder;
+exports.useDFlowQuote = useDFlowQuote;
+exports.useDFlowSubmit = useDFlowSubmit;
+exports.useEvent = useEvent;
+exports.useEvents = useEvents;
+exports.useInfiniteEvents = useInfiniteEvents;
+exports.useMarket = useMarket;
+exports.useMarketHistory = useMarketHistory;
+exports.useMarketTrades = useMarketTrades;
+exports.useOrder = useOrder;
+exports.useOrderbook = useOrderbook;
+exports.useOrderbookSubscription = useOrderbookSubscription;
+exports.useOrders = useOrders;
+exports.usePolymarket = usePolymarket;
+exports.usePositions = usePositions;
+exports.usePredictClient = usePredictClient;
+exports.usePredictWsClient = usePredictWsClient;
+exports.usePriceHistory = usePriceHistory;
+exports.usePricesSubscription = usePricesSubscription;
+exports.useRealtimeOrderbook = useRealtimeOrderbook;
+exports.useRealtimePrices = useRealtimePrices;
+exports.useRealtimeTrades = useRealtimeTrades;
+exports.useSearchEvents = useSearchEvents;
+exports.useSimilarEvents = useSimilarEvents;
+exports.useTrades = useTrades;
+exports.useTradesSubscription = useTradesSubscription;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map