@agg-build/hooks 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2010 @@
+import {
+  AggAuthContext,
+  AggBalanceProvider,
+  AggClientContext,
+  AggProvider,
+  AggUiProvider,
+  CHART_TIME_RANGES,
+  CONFIRMED_MATCH_STATUSES,
+  DEFAULT_AGG_ROOT_CLASS_NAME,
+  EventListStateProvider,
+  MarketStatus,
+  MatchStatus,
+  MatchType,
+  Venue,
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues,
+  applyOrderbookDepth,
+  computeClosedPositionTotals,
+  createMarketChartData,
+  createMarketLiveState,
+  createMarketOrderbookDataFromState,
+  createMarketOrderbookDataFromVenueOrderbooks,
+  defaultAggUiConfig,
+  executionKeys,
+  getBuilder,
+  getDepositAddress,
+  getOrCreateBuilder,
+  getWalletAddressFromUserProfile,
+  invalidateBalanceQueries,
+  invalidatePositionQueries,
+  marketDataKeys,
+  marketOrderbookDataToResponse,
+  mergeMarketChartData,
+  optimizedImageUrl,
+  parseEmail,
+  parseEmailStrict,
+  resolveAggUiLabels,
+  resolveDefaultMarket,
+  resolveEventTradingState,
+  resolveMarketTradingState,
+  resolveMarketWinningOutcome,
+  resolveOrderEligibility,
+  resolveTradingStateKind,
+  sortVenues,
+  tradingReducer,
+  useAggAuthContext,
+  useAggAuthState,
+  useAggBalance,
+  useAggBalanceContext,
+  useAggBalanceState,
+  useAggClient,
+  useAggLabels,
+  useAggUiConfig,
+  useAggWebSocket,
+  useAggWebSocketConnectionState,
+  useDepositAddresses,
+  useEventListState,
+  useEventTradingContext,
+  useExecuteManaged,
+  useExecutionProgress,
+  useLabels,
+  useManagedBalances,
+  useOnBalanceUpdate,
+  useOnOrderSubmitted,
+  useOnRedeemEvent,
+  usePositions,
+  useQuoteManaged,
+  useRampQuotes,
+  useRampSession,
+  useRedeem,
+  useRedeemEligibleCount,
+  useSdkLabels,
+  useSdkUiConfig,
+  useSyncBalances,
+  useWithdrawManaged
+} from "./chunk-CDPQERUC.mjs";
+
+// src/index.ts
+import { QueryClient as QueryClient4, QueryClientProvider, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { TurnstileChallengeError } from "@agg-build/sdk";
+
+// src/use-geo-block.ts
+import { useContext } from "react";
+var DEFAULT_STATE = {
+  isLocationBlocked: false,
+  isTradingBlocked: false,
+  isDepositBlocked: false
+};
+function useGeoBlock() {
+  var _a, _b;
+  const authContext = useContext(AggAuthContext);
+  if (process.env.NEXT_PUBLIC_GEO_BLOCK_DISABLE === "true") return DEFAULT_STATE;
+  const isBlocked = (_b = (_a = authContext == null ? void 0 : authContext.user) == null ? void 0 : _a.isLocationBlocked) != null ? _b : false;
+  if (!isBlocked) return DEFAULT_STATE;
+  return {
+    isLocationBlocked: true,
+    isTradingBlocked: true,
+    isDepositBlocked: true
+  };
+}
+
+// src/use-agg-auth.ts
+import { useCallback } from "react";
+function useAggAuth(options = {}) {
+  const {
+    isAuthenticated,
+    user,
+    isLoading,
+    error,
+    signIn: signInWithProvider,
+    signOut
+  } = useAggAuthContext();
+  const signIn = useCallback(
+    (statement) => __async(null, null, function* () {
+      if (!options.signMessage) {
+        throw new Error(
+          "signMessage is required to call signIn. Pass wallet options to useAggAuth()."
+        );
+      }
+      if (!options.address) {
+        throw new Error("address is required to call signIn. Pass wallet options to useAggAuth().");
+      }
+      yield signInWithProvider({
+        signMessage: options.signMessage,
+        address: options.address,
+        chainId: options.chainId,
+        chain: options.chain,
+        statement
+      });
+    }),
+    [options.address, options.chain, options.chainId, options.signMessage, signInWithProvider]
+  );
+  return { isAuthenticated, user, signIn, signOut, isLoading, error };
+}
+
+// src/use-link-account.ts
+import { useCallback as useCallback2, useState } from "react";
+function useLinkAccount() {
+  const client = useAggClient();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const run = (fn) => {
+    setIsLoading(true);
+    setError(null);
+    return fn().catch((e) => {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    }).finally(() => setIsLoading(false));
+  };
+  const startLink = useCallback2(
+    (body) => run(() => client.linkAccount(body)),
+    [client]
+  );
+  const confirmLink = useCallback2(
+    (token) => run(() => client.linkAccountConfirm(token)),
+    [client]
+  );
+  return { startLink, confirmLink, isLoading, error };
+}
+
+// src/auth-chooser-events.ts
+var AUTH_CHOOSER_OPEN_EVENT = "agg-auth:open-chooser";
+var requestAggAuthChooserOpen = () => {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new Event(AUTH_CHOOSER_OPEN_EVENT));
+};
+
+// src/use-categories.ts
+import { useInfiniteQuery } from "@tanstack/react-query";
+function useCategories(options) {
+  var _a, _b, _c, _d;
+  const client = useAggClient();
+  const enabled = (_a = options == null ? void 0 : options.enabled) != null ? _a : true;
+  const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 20;
+  const query = useInfiniteQuery({
+    queryKey: ["categories", limit],
+    queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+      const res = yield client.getCategories({
+        limit,
+        cursor: pageParam
+      });
+      return res;
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      var _a2;
+      return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
+    },
+    enabled
+  });
+  const categories = (_d = (_c = query.data) == null ? void 0 : _c.pages.flatMap((p) => p.data)) != null ? _d : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    categories,
+    hasNextPage
+  });
+}
+
+// src/use-debounced-value.ts
+import { useEffect, useState as useState2 } from "react";
+function useDebouncedValue(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState2(value);
+  useEffect(() => {
+    const timeoutId = window.setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/use-execution-orders.ts
+import { useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
+function useExecutionOrders(options = {}) {
+  var _a, _b;
+  const client = useAggClient();
+  const { status, limit = 50, enabled = true, refetchIntervalMs = false } = options;
+  const query = useInfiniteQuery2({
+    queryKey: ["execution-orders", status != null ? status : "all", limit],
+    queryFn: ({ pageParam }) => client.getExecutionOrders({
+      status,
+      limit,
+      cursor: pageParam
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      var _a2;
+      return lastPage.hasMore ? (_a2 = lastPage.nextCursor) != null ? _a2 : void 0 : void 0;
+    },
+    enabled,
+    refetchInterval: refetchIntervalMs
+  });
+  const orders = (_b = (_a = query.data) == null ? void 0 : _a.pages.flatMap((page) => page.data)) != null ? _b : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    orders,
+    hasNextPage
+  });
+}
+
+// src/use-user-activity.ts
+import { useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
+function useUserActivity(options = {}) {
+  var _a, _b;
+  const client = useAggClient();
+  const { type, limit = 50, enabled = true } = options;
+  const query = useInfiniteQuery3({
+    queryKey: ["user-activity", type != null ? type : "all", limit],
+    queryFn: ({ pageParam }) => client.getUserActivity({
+      type,
+      limit,
+      cursor: pageParam
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      var _a2;
+      return lastPage.hasMore ? (_a2 = lastPage.nextCursor) != null ? _a2 : void 0 : void 0;
+    },
+    enabled
+  });
+  const activities = (_b = (_a = query.data) == null ? void 0 : _a.pages.flatMap((page) => page.data)) != null ? _b : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    activities,
+    hasNextPage
+  });
+}
+
+// src/use-external-id.ts
+import { useCallback as useCallback3, useState as useState3 } from "react";
+function useExternalId(options = {}) {
+  const client = useAggClient();
+  const { onSuccess, onError: onErrorCb } = options;
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const linkExternalId = useCallback3(
+    (assertion) => __async(null, null, function* () {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const profile = yield client.linkExternalId(assertion);
+        onSuccess == null ? void 0 : onSuccess(profile);
+        return profile;
+      } catch (err) {
+        const resolvedError = err instanceof Error ? err : new Error(String(err));
+        setError(resolvedError);
+        onErrorCb == null ? void 0 : onErrorCb(resolvedError);
+        throw resolvedError;
+      } finally {
+        setIsLoading(false);
+      }
+    }),
+    [client, onErrorCb, onSuccess]
+  );
+  return { linkExternalId, isLoading, error };
+}
+
+// src/use-execution-positions.ts
+import { useInfiniteQuery as useInfiniteQuery4 } from "@tanstack/react-query";
+function useExecutionPositions(options = {}) {
+  var _a, _b;
+  const client = useAggClient();
+  const { limit = 50, status, enabled = true } = options;
+  const query = useInfiniteQuery4({
+    queryKey: executionKeys.positions(null, limit, status != null ? status : null),
+    queryFn: ({ pageParam }) => client.getExecutionPositions({
+      limit,
+      status,
+      cursor: pageParam
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      var _a2;
+      return lastPage.hasMore ? (_a2 = lastPage.nextCursor) != null ? _a2 : void 0 : void 0;
+    },
+    enabled
+  });
+  const positions = (_b = (_a = query.data) == null ? void 0 : _a.pages.flatMap((page) => page.data)) != null ? _b : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    positions,
+    hasNextPage
+  });
+}
+
+// src/use-live-candle-overlay.ts
+import { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+
+// src/use-live-candles.ts
+import { useMemo as useMemo3 } from "react";
+import { mergeCandles, mergeClosedCandles } from "@agg-build/sdk";
+
+// src/use-market-chart.ts
+import { keepPreviousData, useQueries } from "@tanstack/react-query";
+
+// src/market-data/subscription.ts
+import { useEffect as useEffect2, useMemo } from "react";
+function useMarketDataSubscription({
+  marketId,
+  additionalMarketIds,
+  enabled = true,
+  orderbook = true,
+  trades = false
+}) {
+  const ws = useAggWebSocket();
+  const allIds = useMemo(() => {
+    const ids = /* @__PURE__ */ new Set();
+    if (marketId) ids.add(marketId);
+    if (additionalMarketIds) {
+      for (const id of additionalMarketIds) {
+        if (id) ids.add(id);
+      }
+    }
+    return [...ids];
+  }, [marketId, additionalMarketIds]);
+  const stableKey = allIds.join("|");
+  useEffect2(() => {
+    if (!ws || !allIds.length || !enabled || !orderbook && !trades) return;
+    const unsubscribers = [];
+    for (const id of allIds) {
+      if (orderbook) {
+        const unsub = ws.subscribe(id, "orderbook");
+        unsubscribers.push(unsub);
+      }
+      if (trades) {
+        const unsub = ws.subscribe(id, "trades");
+        unsubscribers.push(unsub);
+      }
+    }
+    return () => {
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+    };
+  }, [enabled, stableKey, orderbook, trades, ws]);
+}
+
+// src/use-market-chart.ts
+function useMarketChart(options) {
+  var _a, _b, _c;
+  const client = useAggClient();
+  const isConnected = useAggWebSocketConnectionState();
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const {
+    marketId,
+    venueMarketIds,
+    interval = "5m",
+    startTs = null,
+    endTs = null,
+    countBack = null,
+    enabled = true,
+    live
+  } = options;
+  const liveEnabled = live != null ? live : enableLiveUpdates;
+  const outcomeIds = (() => {
+    const ids = /* @__PURE__ */ new Set();
+    if (marketId) {
+      ids.add(marketId);
+    }
+    if (venueMarketIds) {
+      for (const venueMarketId of venueMarketIds) {
+        if (venueMarketId) {
+          ids.add(venueMarketId);
+        }
+      }
+    }
+    return [...ids];
+  })();
+  const primaryOutcomeId = (_a = outcomeIds[0]) != null ? _a : null;
+  const isQueryEnabled = enabled && outcomeIds.length > 0 && endTs != null && (startTs != null || countBack != null);
+  useMarketDataSubscription({
+    marketId: primaryOutcomeId,
+    additionalMarketIds: outcomeIds.slice(1),
+    enabled: Boolean(isQueryEnabled && liveEnabled),
+    orderbook: true,
+    trades: true
+  });
+  const queries = useQueries({
+    queries: outcomeIds.map((outcomeId) => ({
+      queryKey: marketDataKeys.chart(outcomeId, interval, startTs, endTs, countBack),
+      queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
+        const response = yield client.getChartBars(
+          {
+            venueMarketOutcomeId: outcomeId,
+            resolution: interval,
+            from: startTs != null ? startTs : void 0,
+            to: endTs,
+            countBack: countBack != null ? countBack : void 0
+          },
+          { signal }
+        );
+        return createMarketChartData({
+          marketId: outcomeId,
+          interval,
+          startTs,
+          endTs,
+          response
+        });
+      }),
+      enabled: isQueryEnabled,
+      staleTime: 3e4,
+      gcTime: 5 * 6e4,
+      refetchOnWindowFocus: false,
+      retry: 1,
+      placeholderData: keepPreviousData
+    }))
+  });
+  const successfulDatasets = queries.flatMap((query) => {
+    return query.data ? [query.data] : [];
+  });
+  const data = primaryOutcomeId && successfulDatasets.length > 0 ? mergeMarketChartData({
+    marketId: primaryOutcomeId,
+    interval,
+    startTs,
+    endTs,
+    datasets: successfulDatasets
+  }) : null;
+  const hasPendingQuery = queries.some((query) => query.isLoading);
+  const firstError = (_c = (_b = queries.find((query) => query.error != null)) == null ? void 0 : _b.error) != null ? _c : null;
+  const error = data == null && !hasPendingQuery ? firstError instanceof Error ? firstError : firstError ? new Error(String(firstError)) : null : null;
+  const isLoading = Boolean(isQueryEnabled && data == null && hasPendingQuery);
+  return {
+    data,
+    isLoading,
+    error,
+    isLive: Boolean(liveEnabled && primaryOutcomeId && isConnected),
+    refetch: () => __async(null, null, function* () {
+      return Promise.all(queries.map((query) => query.refetch()));
+    })
+  };
+}
+
+// src/use-live-market-stores.ts
+import { useEffect as useEffect3, useMemo as useMemo2, useReducer, useRef } from "react";
+function useLiveMarketStores(venueMarketIds) {
+  const ws = useAggWebSocket();
+  const [, forceRender] = useReducer((c) => c + 1, 0);
+  const subsRef = useRef(/* @__PURE__ */ new Map());
+  const stableKey = useMemo2(() => venueMarketIds.slice().sort().join("|"), [venueMarketIds]);
+  useEffect3(() => {
+    if (!ws || venueMarketIds.length === 0) return;
+    const current = subsRef.current;
+    const desired = new Set(venueMarketIds);
+    for (const [id, sub] of current) {
+      if (!desired.has(id)) {
+        sub.unsub();
+        sub.unlisten();
+        current.delete(id);
+      }
+    }
+    for (const id of desired) {
+      if (!current.has(id)) {
+        const builder = getOrCreateBuilder(id);
+        const unsub = ws.subscribe(id, "orderbook");
+        const unlisten = builder.onChange(forceRender);
+        current.set(id, { unsub, unlisten });
+      }
+    }
+    return () => {
+      for (const [, sub] of current) {
+        sub.unsub();
+        sub.unlisten();
+      }
+      current.clear();
+    };
+  }, [ws, stableKey]);
+  return venueMarketIds.map((id) => getOrCreateBuilder(id));
+}
+
+// src/use-live-candles.ts
+function candleToLive(c, source) {
+  return { time: c.openTime, o: c.o, h: c.h, l: c.l, c: c.c, v: c.v, source };
+}
+function useLiveCandles(options) {
+  var _a;
+  const { market, interval = "5m", mode = "venue", startTs, endTs } = options;
+  const venueMarketIds = useMemo3(() => {
+    if (!market) return [];
+    if (mode === "venue") return [market.id];
+    const ids = [market.id];
+    if (market.matchedVenueMarkets) {
+      for (const m of market.matchedVenueMarkets) {
+        ids.push(m.id);
+      }
+    }
+    return ids;
+  }, [market, mode]);
+  const builders = useLiveMarketStores(venueMarketIds);
+  const restMarketId = (_a = market == null ? void 0 : market.marketId) != null ? _a : null;
+  const { data: chartData, isLoading } = useMarketChart({
+    marketId: restMarketId,
+    interval,
+    startTs: startTs != null ? startTs : null,
+    endTs: endTs != null ? endTs : null,
+    enabled: !!restMarketId && startTs != null && endTs != null
+  });
+  const liveData = useMemo3(() => {
+    if (builders.length === 0) return { closed: [], forming: null };
+    if (mode === "venue" || builders.length === 1) {
+      return {
+        closed: builders[0].getClosed(interval),
+        forming: builders[0].getForming(interval)
+      };
+    }
+    return {
+      closed: mergeClosedCandles(builders.map((b) => b.getClosed(interval))),
+      forming: mergeCandles(builders.map((b) => b.getForming(interval)))
+    };
+  }, [builders, interval, mode]);
+  const candles = useMemo3(() => {
+    const byTime = /* @__PURE__ */ new Map();
+    if (chartData) {
+      const venueEntries = Object.values(chartData.venues);
+      for (const venueData of venueEntries) {
+        for (const c of venueData.candles) {
+          byTime.set(c.time, {
+            time: c.time,
+            o: c.open,
+            h: c.high,
+            l: c.low,
+            c: c.close,
+            v: c.volume,
+            source: "rest"
+          });
+        }
+      }
+    }
+    for (const c of liveData.closed) {
+      byTime.set(c.openTime, candleToLive(c, "live"));
+    }
+    const merged = Array.from(byTime.values());
+    merged.sort((a, b) => a.time - b.time);
+    return merged;
+  }, [chartData, liveData.closed]);
+  const liveCandle = useMemo3(() => {
+    if (!liveData.forming) return null;
+    return candleToLive(liveData.forming, "live");
+  }, [liveData.forming]);
+  return { candles, liveCandle, isLoading };
+}
+
+// src/use-live-candle-overlay.ts
+function timeRangeToInterval(range) {
+  switch (range) {
+    case "1H":
+      return "1m";
+    case "6H":
+      return "5m";
+    case "1D":
+      return "5m";
+    case "1W":
+      return "1h";
+    case "1M":
+      return "1h";
+    case "ALL":
+      return "1h";
+    default:
+      return "5m";
+  }
+}
+function useLiveCandleOverlay(options) {
+  var _a, _b;
+  const {
+    market,
+    interval = "5m",
+    mode = "venue",
+    startTs,
+    endTs,
+    enabled = true,
+    scale = 100
+  } = options;
+  const {
+    candles: rawCandles,
+    liveCandle: rawLive,
+    isLoading
+  } = useLiveCandles({
+    market: enabled ? market : null,
+    interval,
+    mode,
+    startTs,
+    endTs
+  });
+  const scaleCandle = useCallback4(
+    (candle) => ({
+      time: candle.time,
+      open: candle.o * scale,
+      high: candle.h * scale,
+      low: candle.l * scale,
+      close: candle.c * scale,
+      v: candle.v
+    }),
+    [scale]
+  );
+  const scaledCandles = useMemo4(() => rawCandles.map(scaleCandle), [rawCandles, scaleCandle]);
+  const liveCandle = useMemo4(() => rawLive ? scaleCandle(rawLive) : null, [rawLive, scaleCandle]);
+  return {
+    liveCandle,
+    scaledCandles,
+    lineValue: (_b = liveCandle == null ? void 0 : liveCandle.close) != null ? _b : (_a = scaledCandles[scaledCandles.length - 1]) == null ? void 0 : _a.close,
+    live: liveCandle != null,
+    isLoading
+  };
+}
+
+// src/use-event-orderbook-data.ts
+import { useEffect as useEffect4, useMemo as useMemo5 } from "react";
+function extractSelectedOutcomeIds(selectedMarket) {
+  var _a, _b, _c;
+  if (!selectedMarket) return [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const outcome of (_a = selectedMarket.venueMarketOutcomes) != null ? _a : []) {
+    if (outcome.id) ids.add(outcome.id);
+  }
+  for (const matched of (_b = selectedMarket.matchedVenueMarkets) != null ? _b : []) {
+    for (const outcome of (_c = matched.venueMarketOutcomes) != null ? _c : []) {
+      if (outcome.id) ids.add(outcome.id);
+    }
+  }
+  return [...ids].sort();
+}
+function useEventOrderbookData(venueMarkets, selectedMarketId) {
+  const ws = useAggWebSocket();
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const selectedMarket = useMemo5(() => {
+    var _a;
+    if (!selectedMarketId || !(venueMarkets == null ? void 0 : venueMarkets.length)) return null;
+    return (_a = venueMarkets.find((m) => m.id === selectedMarketId)) != null ? _a : null;
+  }, [venueMarkets, selectedMarketId]);
+  const selectedOutcomeIds = useMemo5(
+    () => extractSelectedOutcomeIds(selectedMarket),
+    [selectedMarket]
+  );
+  const selectedKey = selectedOutcomeIds.join("|");
+  useEffect4(() => {
+    if (!ws || !enableLiveUpdates || !selectedOutcomeIds.length) return;
+    const unsubscribers = selectedOutcomeIds.map((id) => ws.subscribe(id, "orderbook"));
+    return () => {
+      for (const unsub of unsubscribers) unsub();
+    };
+  }, [ws, selectedKey, enableLiveUpdates]);
+}
+
+// src/use-live-market.ts
+import { useQuery } from "@tanstack/react-query";
+function outcomeOrderbookToState(response, marketId) {
+  var _a, _b, _c, _d;
+  const { venue, orderbook, midpoint, spread, seq, checksum, timestamp, venueMarketOutcomeId } = response;
+  const attribute = (l) => ({
+    price: l.price,
+    size: l.size,
+    venues: { [venue]: l.size }
+  });
+  const venueLevels = (l) => ({
+    price: l.price,
+    size: l.size
+  });
+  return {
+    marketId,
+    outcomeId: venueMarketOutcomeId,
+    bids: orderbook.bids.map(attribute),
+    asks: orderbook.asks.map(attribute),
+    venueOrderbooks: {
+      [venue]: {
+        bids: orderbook.bids.map(venueLevels),
+        asks: orderbook.asks.map(venueLevels)
+      }
+    },
+    venues: {
+      [venue]: {
+        bestBid: (_b = (_a = orderbook.bids[0]) == null ? void 0 : _a.price) != null ? _b : null,
+        bestAsk: (_d = (_c = orderbook.asks[0]) == null ? void 0 : _c.price) != null ? _d : null
+      }
+    },
+    midpoint,
+    spread,
+    seq,
+    checksum,
+    timestamp
+  };
+}
+function useLiveMarket(canonicalMarketId) {
+  var _a, _b;
+  const client = useAggClient();
+  const isConnected = useAggWebSocketConnectionState();
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const isLiveSubscriptionEnabled = Boolean(canonicalMarketId && enableLiveUpdates);
+  useMarketDataSubscription({
+    marketId: canonicalMarketId,
+    enabled: isLiveSubscriptionEnabled,
+    orderbook: true
+  });
+  const query = useQuery({
+    queryKey: marketDataKeys.live(canonicalMarketId != null ? canonicalMarketId : "__disabled__"),
+    queryFn: () => __async(null, null, function* () {
+      return createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__");
+    }),
+    enabled: false,
+    staleTime: Infinity,
+    gcTime: 5 * 6e4,
+    initialData: () => createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__", {
+      isConnected: Boolean(isLiveSubscriptionEnabled && isConnected)
+    })
+  });
+  const seedQuery = useQuery({
+    queryKey: ["live-market-seed", canonicalMarketId],
+    queryFn: ({ signal }) => canonicalMarketId ? client.getOutcomeOrderbook(canonicalMarketId, { signal }) : Promise.resolve(null),
+    enabled: Boolean(canonicalMarketId),
+    staleTime: 5e3,
+    gcTime: 6e4,
+    refetchOnWindowFocus: false,
+    retry: 1
+  });
+  const data = (_a = query.data) != null ? _a : createMarketLiveState(canonicalMarketId != null ? canonicalMarketId : "__disabled__");
+  const orderbook = (_b = data.orderbook) != null ? _b : canonicalMarketId && seedQuery.data ? outcomeOrderbookToState(seedQuery.data, canonicalMarketId) : null;
+  return {
+    orderbook,
+    trades: data.trades,
+    isConnected: isLiveSubscriptionEnabled ? data.isConnected : false,
+    integrity: data.integrity
+  };
+}
+
+// src/use-live-outcome-prices.ts
+import { useMemo as useMemo6, useRef as useRef2 } from "react";
+import { useQueries as useQueries2 } from "@tanstack/react-query";
+var EMPTY_PRICES = /* @__PURE__ */ new Map();
+var buildMidpointFingerprint = (outcomeIds, queries) => {
+  var _a, _b, _c;
+  const parts = [];
+  for (let i = 0; i < outcomeIds.length; i++) {
+    const midpoint = (_c = (_b = (_a = queries[i]) == null ? void 0 : _a.data) == null ? void 0 : _b.orderbook) == null ? void 0 : _c.midpoint;
+    parts.push(`${outcomeIds[i]}:${midpoint != null ? midpoint : "_"}`);
+  }
+  return parts.join("|");
+};
+function useLiveOutcomePrices(venueMarkets) {
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const outcomeIds = useMemo6(() => {
+    var _a;
+    if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const vm of venueMarkets) {
+      for (const outcome of (_a = vm.venueMarketOutcomes) != null ? _a : []) {
+        if (outcome.id) ids.add(outcome.id);
+      }
+    }
+    return [...ids].sort();
+  }, [venueMarkets]);
+  const queries = useQueries2({
+    queries: outcomeIds.map((id) => ({
+      queryKey: marketDataKeys.live(id),
+      queryFn: () => createMarketLiveState(id),
+      enabled: false,
+      staleTime: Infinity,
+      gcTime: 5 * 6e4,
+      initialData: () => createMarketLiveState(id)
+    }))
+  });
+  const fingerprint = buildMidpointFingerprint(outcomeIds, queries);
+  const prevRef = useRef2({
+    fingerprint: "",
+    prices: EMPTY_PRICES
+  });
+  const data = useMemo6(() => {
+    var _a, _b, _c, _d;
+    if (!(venueMarkets == null ? void 0 : venueMarkets.length)) return EMPTY_PRICES;
+    if (fingerprint === prevRef.current.fingerprint) {
+      return prevRef.current.prices;
+    }
+    const prices = /* @__PURE__ */ new Map();
+    const liveByOutcomeId = /* @__PURE__ */ new Map();
+    for (let i = 0; i < outcomeIds.length; i++) {
+      const state = (_a = queries[i]) == null ? void 0 : _a.data;
+      liveByOutcomeId.set(outcomeIds[i], (_c = (_b = state == null ? void 0 : state.orderbook) == null ? void 0 : _b.midpoint) != null ? _c : null);
+    }
+    for (const vm of venueMarkets) {
+      for (const outcome of (_d = vm.venueMarketOutcomes) != null ? _d : []) {
+        if (!enableLiveUpdates) {
+          prices.set(outcome.id, outcome.price);
+          continue;
+        }
+        const liveMidpoint = liveByOutcomeId.get(outcome.id);
+        prices.set(outcome.id, liveMidpoint != null ? liveMidpoint : outcome.price);
+      }
+    }
+    prevRef.current = { fingerprint, prices };
+    return prices;
+  }, [venueMarkets, enableLiveUpdates, fingerprint, outcomeIds, queries]);
+  return data;
+}
+function findLivePriceById(livePrices, id) {
+  return livePrices.get(id);
+}
+
+// src/use-live-trades.ts
+function useLiveTrades(canonicalMarketId) {
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const { trades } = useLiveMarket(canonicalMarketId);
+  useMarketDataSubscription({
+    marketId: canonicalMarketId,
+    enabled: Boolean(canonicalMarketId && enableLiveUpdates),
+    orderbook: false,
+    trades: true
+  });
+  return trades;
+}
+
+// src/use-midpoints.ts
+import { useMemo as useMemo7 } from "react";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+var normalizeVenueMarketIds = (venueMarkets) => {
+  return [...new Set((venueMarkets != null ? venueMarkets : []).map((market) => market.id).filter(Boolean))].sort(
+    (left, right) => left.localeCompare(right)
+  );
+};
+function useMidpoints(venueMarkets) {
+  const client = useAggClient();
+  const ids = useMemo7(() => normalizeVenueMarketIds(venueMarkets), [venueMarkets]);
+  const { data, isLoading } = useQuery2({
+    queryKey: ["midpoints", ids],
+    queryFn: () => client.getMidpoints(ids),
+    enabled: ids.length > 0,
+    staleTime: Infinity,
+    gcTime: 30 * 6e4,
+    refetchOnMount: false,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false
+  });
+  const prices = useMemo7(() => {
+    var _a, _b, _c, _d;
+    const map = /* @__PURE__ */ new Map();
+    if (!(data == null ? void 0 : data.data) || !venueMarkets) return map;
+    for (const item of data.data) {
+      if ((_a = item.outcomes) == null ? void 0 : _a.length) {
+        for (const o of item.outcomes) {
+          if (o.midpoint != null) {
+            map.set(o.venueMarketOutcomeId, o.midpoint);
+          }
+        }
+        if ((_b = item.matched) == null ? void 0 : _b.length) {
+          for (const m of item.matched) {
+            if (m.midpoint != null) {
+              const market = venueMarkets.find((vm) => vm.id === item.venueMarketId);
+              if (!market) continue;
+              for (const outcome of market.venueMarketOutcomes) {
+                const existing = map.get(outcome.id);
+                const isYes = ((_c = outcome.label) == null ? void 0 : _c.toLowerCase()) === "yes";
+                const matchedPrice = isYes ? m.midpoint : 1 - m.midpoint;
+                if (existing == null || isYes && matchedPrice > existing || !isYes && matchedPrice < existing) {
+                  map.set(outcome.id, matchedPrice);
+                }
+              }
+            }
+          }
+        }
+        continue;
+      }
+      if (item.midpoint != null) {
+        const market = venueMarkets.find((vm) => vm.id === item.venueMarketId);
+        if (!market) continue;
+        for (const outcome of market.venueMarketOutcomes) {
+          const isYes = ((_d = outcome.label) == null ? void 0 : _d.toLowerCase()) === "yes";
+          map.set(outcome.id, isYes ? item.midpoint : 1 - item.midpoint);
+        }
+      }
+    }
+    return map;
+  }, [data, venueMarkets]);
+  return { prices, isLoading: isLoading && ids.length > 0 };
+}
+
+// src/use-market-orderbook.ts
+import { useQueries as useQueries3, useQueryClient } from "@tanstack/react-query";
+function useMarketOrderbook(options) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const queryClient = useQueryClient();
+  const ws = useAggWebSocket();
+  const isConnected = useAggWebSocketConnectionState();
+  const {
+    features: { enableLiveUpdates }
+  } = useAggUiConfig();
+  const { marketId, depth, enabled = true, venueOutcomes, live } = options;
+  const liveEnabled = live != null ? live : enableLiveUpdates;
+  const outcomeIds = venueOutcomes == null ? void 0 : venueOutcomes.map((v) => v.venueMarketOutcomeId).filter(Boolean);
+  const subscriptionIds = (outcomeIds == null ? void 0 : outcomeIds.length) ? [...new Set(outcomeIds)] : marketId ? [marketId] : [];
+  const selectedOutcomeId = (_a = subscriptionIds[0]) != null ? _a : null;
+  useMarketDataSubscription({
+    marketId: selectedOutcomeId,
+    additionalMarketIds: subscriptionIds.slice(1),
+    enabled: enabled && !!selectedOutcomeId,
+    orderbook: true
+  });
+  const liveQueries = useQueries3({
+    queries: subscriptionIds.map((subscriptionId) => ({
+      queryKey: marketDataKeys.live(subscriptionId),
+      queryFn: () => createMarketLiveState(subscriptionId),
+      staleTime: Infinity,
+      gcTime: 5 * 6e4,
+      refetchOnMount: false,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false
+    }))
+  });
+  const liveStates = subscriptionIds.map((subscriptionId, index) => {
+    var _a2, _b2;
+    return (_b2 = (_a2 = liveQueries[index]) == null ? void 0 : _a2.data) != null ? _b2 : createMarketLiveState(subscriptionId);
+  });
+  const primaryOrderbook = (_c = (_b = liveStates[0]) == null ? void 0 : _b.orderbook) != null ? _c : null;
+  const primarySnapshotVersion = (_e = (_d = liveStates[0]) == null ? void 0 : _d.orderbookSnapshotVersion) != null ? _e : 0;
+  const data = primaryOrderbook ? applyOrderbookDepth(
+    createMarketOrderbookDataFromState(primaryOrderbook, {
+      snapshotVersion: primarySnapshotVersion
+    }),
+    depth
+  ) : null;
+  const dataById = Object.fromEntries(
+    liveStates.flatMap((liveState, index) => {
+      if (!liveState.orderbook) return [];
+      return [
+        [
+          subscriptionIds[index],
+          applyOrderbookDepth(
+            createMarketOrderbookDataFromState(liveState.orderbook, {
+              snapshotVersion: liveState.orderbookSnapshotVersion
+            }),
+            depth
+          )
+        ]
+      ];
+    })
+  );
+  const hasAnyOrderbook = liveStates.some((liveState) => liveState.orderbook != null);
+  const liveOrderbookErrorMessage = enabled && liveEnabled && !hasAnyOrderbook ? (_g = (_f = liveStates.find(
+    (liveState) => typeof liveState.orderbookError === "string" && liveState.orderbookError.length > 0
+  )) == null ? void 0 : _f.orderbookError) != null ? _g : null : null;
+  return {
+    data,
+    dataById,
+    isLoading: enabled && liveEnabled && !hasAnyOrderbook && isConnected && liveOrderbookErrorMessage == null,
+    error: liveOrderbookErrorMessage ? new Error(liveOrderbookErrorMessage) : null,
+    isLive: Boolean(liveEnabled && selectedOutcomeId && isConnected),
+    refetch: () => __async(null, null, function* () {
+      if (!enabled) return;
+      if (subscriptionIds.length === 0) return;
+      subscriptionIds.forEach((subscriptionId) => {
+        queryClient.setQueryData(
+          marketDataKeys.live(subscriptionId),
+          (previous) => __spreadProps(__spreadValues({}, previous != null ? previous : createMarketLiveState(subscriptionId)), {
+            orderbookError: null
+          })
+        );
+      });
+      ws == null ? void 0 : ws.resnapshot(subscriptionIds);
+    })
+  };
+}
+
+// src/use-order-book.ts
+import { keepPreviousData as keepPreviousData2, useQuery as useQuery3 } from "@tanstack/react-query";
+function useOrderBook(options) {
+  const client = useAggClient();
+  const { orderbooks, enabled = true, canonicalMarketId } = options;
+  const requestedVenueMarketIds = [...new Set(orderbooks.map(({ market }) => market.id))];
+  const canonicalResult = useMarketOrderbook({
+    marketId: canonicalMarketId != null ? canonicalMarketId : null,
+    enabled: enabled && !!canonicalMarketId && orderbooks.length > 0,
+    venueOutcomes: canonicalMarketId ? orderbooks.map(({ market, outcome }) => ({
+      venue: market.venue,
+      venueMarketOutcomeId: outcome.id
+    })) : void 0
+  });
+  const batchedResult = useQuery3({
+    queryKey: requestedVenueMarketIds.length ? ["orderbooks", requestedVenueMarketIds, null] : ["orderbooks", "__disabled__", null],
+    queryFn: ({ signal }) => client.getOrderbooks(
+      {
+        venueMarketIds: requestedVenueMarketIds
+      },
+      { signal }
+    ),
+    enabled: enabled && !canonicalMarketId && requestedVenueMarketIds.length > 0,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    refetchOnWindowFocus: false,
+    retry: 1,
+    placeholderData: keepPreviousData2
+  });
+  const data = (() => {
+    var _a, _b;
+    if (canonicalMarketId) {
+      const canonicalData = canonicalResult.data;
+      if (!canonicalData) return void 0;
+      const merged2 = orderbooks.flatMap(({ market, outcome }) => {
+        const venueBook = canonicalData.venueOrderbooks[market.venue];
+        if (!venueBook) return [];
+        return [
+          {
+            market,
+            outcome,
+            orderbook: {
+              bids: venueBook.bids,
+              asks: venueBook.asks
+            }
+          }
+        ];
+      });
+      return merged2.length === orderbooks.length ? merged2 : void 0;
+    }
+    const liveBooksByMarketId = new Map(
+      ((_b = (_a = batchedResult.data) == null ? void 0 : _a.data) != null ? _b : []).filter((item) => item.status === "ok").map((item) => [item.venueMarketId, item])
+    );
+    const merged = orderbooks.flatMap(({ market, outcome }, index) => {
+      var _a2;
+      void index;
+      const item = liveBooksByMarketId.get(market.id);
+      const orderbook = (_a2 = item == null ? void 0 : item.venueOrderbooks[market.venue]) == null ? void 0 : _a2.orderbook;
+      if (!orderbook) return [];
+      return [
+        {
+          market,
+          outcome,
+          orderbook
+        }
+      ];
+    });
+    return merged.length === orderbooks.length ? merged : void 0;
+  })();
+  const aggregated = canonicalResult.data ? marketOrderbookDataToResponse(canonicalResult.data) : null;
+  const error = canonicalMarketId ? canonicalResult.error : batchedResult.error;
+  return {
+    data,
+    isLoading: canonicalMarketId ? canonicalResult.isLoading : batchedResult.isLoading,
+    error: error instanceof Error ? error : error ? new Error(String(error)) : null,
+    results: [batchedResult],
+    aggregated,
+    isLive: canonicalResult.isLive
+  };
+}
+
+// src/use-orderbook-quote.ts
+import { keepPreviousData as keepPreviousData3, useQuery as useQuery4 } from "@tanstack/react-query";
+var QUOTE_DEBOUNCE_MS = 300;
+var createUnavailableOrderbookError = (message, code, retryable) => {
+  const error = new Error(message);
+  error.status = 404;
+  if (code) error.code = code;
+  if (retryable !== void 0) error.retryable = retryable;
+  return error;
+};
+var quoteVenueOrderbooks = ({
+  marketId,
+  side,
+  requestedSize,
+  venueOrderbooks
+}) => {
+  var _a;
+  const marketData = createMarketOrderbookDataFromVenueOrderbooks({
+    marketId,
+    venueOrderbooks
+  });
+  const levels = side === "buy" ? marketData.orderbook.asks : marketData.orderbook.bids;
+  let remaining = requestedSize;
+  const fillsByVenue = /* @__PURE__ */ new Map();
+  for (const level of levels) {
+    if (remaining <= 0) break;
+    for (const [venue, venueSize] of Object.entries(level.venues)) {
+      if (remaining <= 0) break;
+      const fillSize = Math.min(remaining, venueSize);
+      const fillCost = fillSize * level.price;
+      remaining -= fillSize;
+      const existing = (_a = fillsByVenue.get(venue)) != null ? _a : { size: 0, cost: 0 };
+      existing.size += fillSize;
+      existing.cost += fillCost;
+      fillsByVenue.set(venue, existing);
+    }
+  }
+  const filledSize = requestedSize - Math.max(0, remaining);
+  const totalCost = [...fillsByVenue.values()].reduce((sum, fill) => sum + fill.cost, 0);
+  const avgPrice = filledSize > 0 ? totalCost / filledSize : null;
+  const slippage = avgPrice !== null && marketData.midpoint !== null ? side === "buy" ? avgPrice - marketData.midpoint : marketData.midpoint - avgPrice : null;
+  return {
+    marketId,
+    side,
+    requestedSize,
+    filledSize,
+    avgPrice,
+    totalCost,
+    slippage,
+    fills: [...fillsByVenue.entries()].map(([venue, fill]) => ({
+      venue,
+      size: fill.size,
+      avgPrice: fill.size > 0 ? fill.cost / fill.size : 0,
+      cost: fill.cost
+    }))
+  };
+};
+function useOrderbookQuote(options) {
+  var _a;
+  const client = useAggClient();
+  const { marketId, side, size, enabled = true } = options;
+  const debouncedSize = useDebouncedValue(size, QUOTE_DEBOUNCE_MS);
+  const shouldFetch = enabled && !!marketId && debouncedSize > 0;
+  const query = useQuery4({
+    queryKey: marketId ? marketDataKeys.orderbookQuote(marketId, side, debouncedSize) : ["market-data", "orderbook-quote", "__disabled__"],
+    queryFn: () => __async(null, null, function* () {
+      var _a2, _b, _c, _d;
+      const response = yield client.getOrderbooks({
+        venueMarketIds: [marketId]
+      });
+      const item = response.data.find((entry) => entry.venueMarketId === marketId);
+      if (!item) {
+        throw createUnavailableOrderbookError(`No orderbook payload returned for ${marketId}.`);
+      }
+      if (item.status !== "ok") {
+        throw createUnavailableOrderbookError(
+          (_b = (_a2 = item.error) == null ? void 0 : _a2.message) != null ? _b : `No live orderbook is available for ${marketId}.`,
+          (_c = item.error) == null ? void 0 : _c.code,
+          (_d = item.error) == null ? void 0 : _d.retryable
+        );
+      }
+      return quoteVenueOrderbooks({
+        marketId,
+        side,
+        requestedSize: debouncedSize,
+        venueOrderbooks: Object.fromEntries(
+          Object.entries(item.venueOrderbooks).map(([venue, entry]) => [venue, entry.orderbook])
+        )
+      });
+    }),
+    enabled: shouldFetch && debouncedSize > 0,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    retry: 1,
+    placeholderData: keepPreviousData3
+  });
+  return {
+    data: (_a = query.data) != null ? _a : null,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error instanceof Error ? query.error : query.error ? new Error(String(query.error)) : null
+  };
+}
+
+// src/use-orders.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+function useOrders(options = {}) {
+  var _a, _b, _c, _d;
+  const client = useAggClient();
+  const { userId, status, limit = 50, offset = 0, enabled = true } = options;
+  const query = useQuery5({
+    queryKey: ["orders", userId != null ? userId : "me", status != null ? status : "all", limit, offset],
+    queryFn: () => client.getOrders({
+      userId,
+      status,
+      limit,
+      offset
+    }),
+    enabled
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    orders: (_b = (_a = query.data) == null ? void 0 : _a.orders) != null ? _b : [],
+    total: (_d = (_c = query.data) == null ? void 0 : _c.total) != null ? _d : 0
+  });
+}
+
+// src/use-search.ts
+import {
+  QueryClient,
+  QueryClientContext,
+  keepPreviousData as keepPreviousData4,
+  useInfiniteQuery as useInfiniteQuery5
+} from "@tanstack/react-query";
+import { useContext as useContext2, useEffect as useEffect5, useState as useState4 } from "react";
+function useSearch(options) {
+  var _a, _b, _c;
+  const client = useContext2(AggClientContext);
+  const queryClient = useContext2(QueryClientContext);
+  const [fallbackQueryClient] = useState4(() => new QueryClient());
+  const { q, type, categoryIds, limit = 20, enabled = true } = options;
+  const isEnabled = enabled && q.length > 0;
+  useEffect5(() => {
+    if (queryClient) return void 0;
+    fallbackQueryClient.mount();
+    return () => {
+      fallbackQueryClient.unmount();
+    };
+  }, [fallbackQueryClient, queryClient]);
+  if (isEnabled && !client) {
+    throw new Error("useSearch must be used within an <AggProvider>");
+  }
+  const query = useInfiniteQuery5(
+    {
+      queryKey: ["search", q, type, (_a = categoryIds == null ? void 0 : categoryIds.join(",")) != null ? _a : "", limit],
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+        if (!client) {
+          throw new Error("useSearch must be used within an <AggProvider>");
+        }
+        const res = yield client.search({
+          q,
+          type,
+          categoryIds,
+          limit,
+          cursor: pageParam
+        });
+        return res;
+      }),
+      initialPageParam: void 0,
+      getNextPageParam: (lastPage) => {
+        var _a2;
+        if (!lastPage.hasMore) return void 0;
+        return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
+      },
+      placeholderData: keepPreviousData4,
+      enabled: isEnabled && !!client
+    },
+    queryClient != null ? queryClient : fallbackQueryClient
+  );
+  const data = (_c = (_b = query.data) == null ? void 0 : _b.pages.flatMap((page) => page.data)) != null ? _c : [];
+  return {
+    data,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    hasNextPage: !!query.hasNextPage,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage,
+    isPlaceholderData: query.isPlaceholderData
+  };
+}
+
+// src/use-smart-route.ts
+import { useQuery as useQuery6, keepPreviousData as keepPreviousData5 } from "@tanstack/react-query";
+function useSmartRoute(options) {
+  var _a, _b;
+  const client = useAggClient();
+  const {
+    venueMarketOutcomeId,
+    venueMarketId,
+    outcomeId,
+    side,
+    tradeSide,
+    maxSpend,
+    sellShares,
+    chainBalances,
+    slipCapBps,
+    compareVenues,
+    enabled = true
+  } = options;
+  const resolvedVenueMarketOutcomeId = (_a = venueMarketOutcomeId != null ? venueMarketOutcomeId : venueMarketId) != null ? _a : outcomeId;
+  const query = useQuery6({
+    queryKey: [
+      "smart-route",
+      resolvedVenueMarketOutcomeId,
+      side != null ? side : null,
+      tradeSide != null ? tradeSide : null,
+      maxSpend != null ? maxSpend : null,
+      sellShares != null ? sellShares : null,
+      chainBalances ? JSON.stringify(chainBalances) : null,
+      slipCapBps != null ? slipCapBps : null,
+      compareVenues != null ? compareVenues : false
+    ],
+    queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
+      return client.getSmartRoute(
+        {
+          venueMarketOutcomeId: resolvedVenueMarketOutcomeId,
+          side: side != null ? side : void 0,
+          tradeSide: tradeSide != null ? tradeSide : void 0,
+          maxSpend,
+          sellShares,
+          chainBalances,
+          slipCapBps,
+          compareVenues
+        },
+        { signal }
+      );
+    }),
+    enabled: enabled && !!resolvedVenueMarketOutcomeId && ((maxSpend != null ? maxSpend : 0) > 0 || (sellShares != null ? sellShares : 0) > 0),
+    staleTime: 1e4,
+    gcTime: 6e4,
+    refetchOnWindowFocus: false,
+    retry: 1,
+    placeholderData: keepPreviousData5
+  });
+  const error = query.error;
+  return {
+    data: (_b = query.data) != null ? _b : null,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: error instanceof Error ? error : error ? new Error(String(error)) : null,
+    refetch: query.refetch
+  };
+}
+
+// src/use-user-holdings.ts
+import { useInfiniteQuery as useInfiniteQuery6 } from "@tanstack/react-query";
+function useUserHoldings(options) {
+  var _a, _b;
+  const client = useAggClient();
+  const { venue, venueMarketId, venueEventId, enabled = true } = options;
+  const query = useInfiniteQuery6({
+    queryKey: ["user-holdings", venue, venueMarketId, venueEventId],
+    queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+      return client.getUserHoldings({
+        venue,
+        venueMarketId,
+        venueEventId,
+        cursor: pageParam
+      });
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      var _a2;
+      return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
+    },
+    enabled
+  });
+  const holdings = (_b = (_a = query.data) == null ? void 0 : _a.pages.flatMap((p) => p.data)) != null ? _b : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    holdings,
+    hasNextPage
+  });
+}
+
+// src/use-enriched-venue-event.ts
+import { useMemo as useMemo8 } from "react";
+
+// src/use-venue-event.ts
+import { useQuery as useQuery7 } from "@tanstack/react-query";
+function useVenueEvent(options) {
+  var _a;
+  const client = useAggClient();
+  const { eventId, enabled = true } = options;
+  const query = useQuery7({
+    queryKey: ["venue-event", eventId],
+    queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
+      return client.getVenueEventById(eventId, { signal });
+    }),
+    enabled: enabled && !!eventId,
+    staleTime: 5 * 6e4,
+    gcTime: 5 * 6e4,
+    refetchOnWindowFocus: true,
+    refetchOnReconnect: true,
+    refetchOnMount: true,
+    retry: 1
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    event: (_a = query.data) != null ? _a : void 0
+  });
+}
+
+// src/use-venue-markets.ts
+import { QueryClient as QueryClient2, QueryClientContext as QueryClientContext2, useInfiniteQuery as useInfiniteQuery7 } from "@tanstack/react-query";
+import { useContext as useContext3, useEffect as useEffect6, useState as useState5 } from "react";
+function useVenueMarkets(options) {
+  var _a, _b, _c, _d, _e;
+  const client = useContext3(AggClientContext);
+  const queryClient = useContext3(QueryClientContext2);
+  const [fallbackQueryClient] = useState5(() => new QueryClient2());
+  const venue = options == null ? void 0 : options.venue;
+  const venueEventId = options == null ? void 0 : options.venueEventId;
+  const search = options == null ? void 0 : options.search;
+  const matchStatus = options == null ? void 0 : options.matchStatus;
+  const status = options == null ? void 0 : options.status;
+  const categoryIds = options == null ? void 0 : options.categoryIds;
+  const enabled = (_a = options == null ? void 0 : options.enabled) != null ? _a : true;
+  const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 20;
+  const sortBy = options == null ? void 0 : options.sortBy;
+  const sortDir = options == null ? void 0 : options.sortDir;
+  useEffect6(() => {
+    if (queryClient) return void 0;
+    fallbackQueryClient.mount();
+    return () => {
+      fallbackQueryClient.unmount();
+    };
+  }, [fallbackQueryClient, queryClient]);
+  if (enabled && !client) {
+    throw new Error("useVenueMarkets must be used within an <AggProvider>");
+  }
+  const query = useInfiniteQuery7(
+    {
+      queryKey: [
+        "venue-markets",
+        venue != null ? venue : "",
+        venueEventId != null ? venueEventId : "",
+        search != null ? search : "",
+        matchStatus != null ? matchStatus : "",
+        status != null ? status : "",
+        (_c = categoryIds == null ? void 0 : categoryIds.join(",")) != null ? _c : "",
+        limit,
+        sortBy != null ? sortBy : "",
+        sortDir != null ? sortDir : ""
+      ],
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+        if (!client) {
+          throw new Error("useVenueMarkets must be used within an <AggProvider>");
+        }
+        const res = yield client.getVenueMarkets({
+          venue,
+          venueEventId,
+          search,
+          matchStatus,
+          status,
+          categoryIds,
+          limit,
+          cursor: pageParam,
+          sortBy,
+          sortDir
+        });
+        return res;
+      }),
+      initialPageParam: void 0,
+      getNextPageParam: (lastPage) => {
+        var _a2;
+        if (!lastPage.hasMore) return void 0;
+        return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
+      },
+      enabled: enabled && !!client
+    },
+    queryClient != null ? queryClient : fallbackQueryClient
+  );
+  const markets = (_e = (_d = query.data) == null ? void 0 : _d.pages.flatMap((page) => page.data)) != null ? _e : [];
+  const hasNextPage = !!query.hasNextPage;
+  return __spreadProps(__spreadValues({}, query), {
+    markets,
+    hasNextPage
+  });
+}
+
+// src/use-enriched-venue-event.ts
+function mergeEventWithFullMarkets(event, fullMarkets) {
+  if (fullMarkets.length === 0) return event;
+  const fullById = new Map(fullMarkets.map((m) => [m.id, m]));
+  const mergedMarkets = event.venueMarkets.map((minimal) => {
+    var _a;
+    return (_a = fullById.get(minimal.id)) != null ? _a : minimal;
+  });
+  return __spreadProps(__spreadValues({}, event), { venueMarkets: mergedMarkets });
+}
+function useEnrichedVenueEvent(options) {
+  var _b;
+  const _a = useVenueEvent(options), { event, isLoading, error } = _a, rest = __objRest(_a, ["event", "isLoading", "error"]);
+  const { markets, isLoading: isEnriching } = useVenueMarkets({
+    venueEventId: options.eventId,
+    enabled: ((_b = options.enabled) != null ? _b : true) && !!event,
+    status: "open" /* open */,
+    sortBy: "yesPrice",
+    sortDir: "desc"
+  });
+  const enrichedEvent = useMemo8(() => {
+    if (!event) return void 0;
+    if (markets.length === 0) return event;
+    return mergeEventWithFullMarkets(event, markets);
+  }, [event, markets]);
+  return __spreadProps(__spreadValues({}, rest), {
+    event: enrichedEvent,
+    isLoading,
+    isEnriching,
+    error
+  });
+}
+
+// src/use-venue-events.ts
+import {
+  QueryClient as QueryClient3,
+  QueryClientContext as QueryClientContext3,
+  keepPreviousData as keepPreviousData6,
+  useInfiniteQuery as useInfiniteQuery8
+} from "@tanstack/react-query";
+import { useContext as useContext4, useEffect as useEffect7, useMemo as useMemo9, useRef as useRef3, useState as useState6 } from "react";
+function useVenueEvents(options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const client = useContext4(AggClientContext);
+  const queryClient = useContext4(QueryClientContext3);
+  const [fallbackQueryClient] = useState6(() => new QueryClient3());
+  const venues = options == null ? void 0 : options.venues;
+  const search = options == null ? void 0 : options.search;
+  const categoryIds = options == null ? void 0 : options.categoryIds;
+  const matchStatus = (_a = options == null ? void 0 : options.matchStatus) != null ? _a : [];
+  const enabled = (_b = options == null ? void 0 : options.enabled) != null ? _b : true;
+  const limit = (_c = options == null ? void 0 : options.limit) != null ? _c : 20;
+  const status = options == null ? void 0 : options.status;
+  const sortBy = options == null ? void 0 : options.sortBy;
+  const sortDir = options == null ? void 0 : options.sortDir;
+  const queryKeyScope = (_d = options == null ? void 0 : options.queryKeyScope) != null ? _d : "events";
+  const minYesPrice = options == null ? void 0 : options.minYesPrice;
+  const maxYesPrice = options == null ? void 0 : options.maxYesPrice;
+  const endDateFrom = options == null ? void 0 : options.endDateFrom;
+  const initialPages = options == null ? void 0 : options.initialPages;
+  useEffect7(() => {
+    if (queryClient) return void 0;
+    fallbackQueryClient.mount();
+    return () => {
+      fallbackQueryClient.unmount();
+    };
+  }, [fallbackQueryClient, queryClient]);
+  if (enabled && !client) {
+    throw new Error("useVenueEvents must be used within an <AggProvider>");
+  }
+  const query = useInfiniteQuery8(
+    {
+      queryKey: [
+        queryKeyScope,
+        venues != null ? venues : [],
+        search != null ? search : "",
+        (_e = categoryIds == null ? void 0 : categoryIds.join(",")) != null ? _e : "",
+        (_f = matchStatus == null ? void 0 : matchStatus.join(",")) != null ? _f : "",
+        (_g = status == null ? void 0 : status.join(",")) != null ? _g : "",
+        sortBy != null ? sortBy : "",
+        sortDir != null ? sortDir : "",
+        minYesPrice != null ? minYesPrice : "",
+        maxYesPrice != null ? maxYesPrice : "",
+        endDateFrom != null ? endDateFrom : "",
+        limit
+      ],
+      queryFn: (_0) => __async(null, [_0], function* ({ pageParam }) {
+        if (!client) {
+          throw new Error("useVenueEvents must be used within an <AggProvider>");
+        }
+        const res = yield client.getVenueEvents({
+          venues,
+          search,
+          categoryIds,
+          matchStatus,
+          status,
+          sortBy,
+          sortDir,
+          limit,
+          minYesPrice,
+          maxYesPrice,
+          endDateFrom,
+          cursor: pageParam
+        });
+        return res;
+      }),
+      initialPageParam: void 0,
+      getNextPageParam: (lastPage) => {
+        var _a2;
+        if (!lastPage.hasMore) return void 0;
+        return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
+      },
+      placeholderData: keepPreviousData6,
+      enabled: enabled && !!client
+    },
+    queryClient != null ? queryClient : fallbackQueryClient
+  );
+  const prefetchedRef = useRef3(false);
+  useEffect7(() => {
+    var _a2, _b2;
+    if (prefetchedRef.current) return;
+    if (!initialPages || initialPages <= 1) return;
+    if (query.isLoading) return;
+    const pagesLoaded = (_b2 = (_a2 = query.data) == null ? void 0 : _a2.pages.length) != null ? _b2 : 0;
+    if (pagesLoaded >= initialPages || !query.hasNextPage) {
+      prefetchedRef.current = true;
+      return;
+    }
+    void query.fetchNextPage();
+  }, [
+    initialPages,
+    query.isLoading,
+    (_h = query.data) == null ? void 0 : _h.pages.length,
+    query.hasNextPage,
+    query.fetchNextPage
+  ]);
+  const events = useMemo9(
+    () => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = query.data) == null ? void 0 : _a2.pages.flatMap((page) => page.data)) != null ? _b2 : [];
+    },
+    [(_i = query.data) == null ? void 0 : _i.pages]
+  );
+  const hasNextPage = !!query.hasNextPage;
+  const loadedPageCount = (_k = (_j = query.data) == null ? void 0 : _j.pages.length) != null ? _k : 0;
+  return __spreadProps(__spreadValues({}, query), {
+    events,
+    hasNextPage,
+    loadedPageCount,
+    isPlaceholderData: query.isPlaceholderData
+  });
+}
+
+// src/use-venue-market-midpoints.ts
+import { keepPreviousData as keepPreviousData7, useQuery as useQuery8 } from "@tanstack/react-query";
+var MAX_VENUE_MARKET_IDS_PER_REQUEST = 200;
+var normalizeVenueMarketIds2 = (venueMarketIds) => {
+  return [
+    ...new Set(venueMarketIds.map((venueMarketId) => venueMarketId.trim()).filter(Boolean))
+  ].sort((left, right) => left.localeCompare(right));
+};
+var chunkVenueMarketIds = (venueMarketIds) => {
+  if (venueMarketIds.length === 0) return [];
+  const chunks = [];
+  for (let index = 0; index < venueMarketIds.length; index += MAX_VENUE_MARKET_IDS_PER_REQUEST) {
+    chunks.push(venueMarketIds.slice(index, index + MAX_VENUE_MARKET_IDS_PER_REQUEST));
+  }
+  return chunks;
+};
+var mergeMidpointResponses = (responses) => {
+  return {
+    data: responses.flatMap((response) => response.data)
+  };
+};
+var mapMidpointsByVenueMarketId = (rows) => {
+  const mappedMidpoints = /* @__PURE__ */ new Map();
+  rows.forEach((row) => {
+    mappedMidpoints.set(row.venueMarketId, row.midpoint);
+    row.matched.forEach((matchedRow) => {
+      if (mappedMidpoints.has(matchedRow.venueMarketId)) return;
+      mappedMidpoints.set(matchedRow.venueMarketId, matchedRow.midpoint);
+    });
+  });
+  return mappedMidpoints;
+};
+function useVenueMarketMidpoints(options) {
+  var _a, _b, _c;
+  const client = useAggClient();
+  const enabled = (_a = options.enabled) != null ? _a : true;
+  const requestedVenueMarketIds = normalizeVenueMarketIds2(options.venueMarketIds);
+  const query = useQuery8({
+    queryKey: requestedVenueMarketIds.length ? ["venue-market-midpoints", requestedVenueMarketIds] : ["venue-market-midpoints", "__disabled__"],
+    queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
+      const venueMarketIdChunks = chunkVenueMarketIds(requestedVenueMarketIds);
+      if (venueMarketIdChunks.length === 0) {
+        return { data: [] };
+      }
+      const chunkResponses = yield Promise.all(
+        venueMarketIdChunks.map((venueMarketIds) => {
+          return client.getMidpoints({ venueMarketIds }, { signal });
+        })
+      );
+      return mergeMidpointResponses(chunkResponses);
+    }),
+    enabled: enabled && requestedVenueMarketIds.length > 0,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    refetchOnWindowFocus: false,
+    retry: 1,
+    placeholderData: keepPreviousData7
+  });
+  const midpointRows = (_c = (_b = query.data) == null ? void 0 : _b.data) != null ? _c : [];
+  const midpointsByVenueMarketId = mapMidpointsByVenueMarketId(midpointRows);
+  return __spreadProps(__spreadValues({}, query), {
+    midpointRows,
+    midpointsByVenueMarketId,
+    requestedVenueMarketIds
+  });
+}
+
+// src/utils/compute-price-gaps.ts
+var MIN_PRICE_GAP_PCT = 3;
+function computePriceGaps(input) {
+  var _a;
+  const { markets, midpointsByVenueMarketId } = input;
+  const result = /* @__PURE__ */ new Map();
+  for (const market of markets) {
+    const ownMidpoint = midpointsByVenueMarketId.get(market.id);
+    if (ownMidpoint == null || ownMidpoint <= 0) continue;
+    const siblings = (_a = market.matchedVenueMarkets) != null ? _a : [];
+    if (siblings.length === 0) continue;
+    let maxGap = 0;
+    for (const sibling of siblings) {
+      const siblingMidpoint = midpointsByVenueMarketId.get(sibling.id);
+      if (siblingMidpoint == null || siblingMidpoint <= 0) continue;
+      const gap = Math.abs(ownMidpoint - siblingMidpoint) / ownMidpoint * 100;
+      if (gap > maxGap) maxGap = gap;
+    }
+    if (maxGap >= MIN_PRICE_GAP_PCT) result.set(market.id, maxGap);
+  }
+  return result;
+}
+
+// src/use-viewport-midpoints.ts
+import { useEffect as useEffect8, useMemo as useMemo10, useRef as useRef4, useState as useState7 } from "react";
+var resolveUncachedVisibleMarketIds = (visibleMarkets, cache, inFlightIds) => {
+  const idsToFetch = [];
+  for (const market of visibleMarkets) {
+    if (inFlightIds.has(market.id)) continue;
+    if (cache.has(market.id)) continue;
+    idsToFetch.push(market.id);
+  }
+  return idsToFetch;
+};
+var buildCachedMidpointEntries = (requestedVenueMarketIds, rows) => {
+  var _a, _b;
+  const rowsByVenueMarketId = new Map(rows.map((item) => [item.venueMarketId, item]));
+  const nextCacheEntries = /* @__PURE__ */ new Map();
+  for (const venueMarketId of requestedVenueMarketIds) {
+    const item = rowsByVenueMarketId.get(venueMarketId);
+    nextCacheEntries.set(venueMarketId, {
+      midpoint: (_a = item == null ? void 0 : item.midpoint) != null ? _a : null,
+      matched: ((_b = item == null ? void 0 : item.matched) != null ? _b : []).map((matched) => {
+        var _a2;
+        return {
+          venueMarketId: matched.venueMarketId,
+          midpoint: (_a2 = matched.midpoint) != null ? _a2 : null
+        };
+      })
+    });
+  }
+  return nextCacheEntries;
+};
+function useViewportMidpoints(visibleMarkets) {
+  const client = useAggClient();
+  const [cache, setCache] = useState7(() => /* @__PURE__ */ new Map());
+  const inFlightRef = useRef4(/* @__PURE__ */ new Set());
+  const visibleRef = useRef4(visibleMarkets);
+  visibleRef.current = visibleMarkets;
+  const visibleFp = useMemo10(
+    () => [...new Set(visibleMarkets.map((m) => m.id))].sort().join("|"),
+    [visibleMarkets]
+  );
+  useEffect8(() => {
+    const toFetch = resolveUncachedVisibleMarketIds(visibleRef.current, cache, inFlightRef.current);
+    if (!toFetch.length) return;
+    let cancelled = false;
+    for (const id of toFetch) inFlightRef.current.add(id);
+    client.getMidpoints(toFetch).then((resp) => {
+      var _a;
+      if (cancelled) return;
+      const nextCacheEntries = buildCachedMidpointEntries(toFetch, (_a = resp.data) != null ? _a : []);
+      setCache((prev) => {
+        const next = new Map(prev);
+        for (const [venueMarketId, entry] of nextCacheEntries) {
+          next.set(venueMarketId, entry);
+        }
+        return next;
+      });
+    }).catch(() => {
+    }).finally(() => {
+      for (const id of toFetch) inFlightRef.current.delete(id);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [visibleFp, cache]);
+  const prices = useMemo10(() => {
+    var _a;
+    const map = /* @__PURE__ */ new Map();
+    for (const market of visibleMarkets) {
+      const entry = cache.get(market.id);
+      if (!entry) continue;
+      const candidates = [];
+      if (entry.midpoint != null) candidates.push(entry.midpoint);
+      for (const m of entry.matched) if (m.midpoint != null) candidates.push(m.midpoint);
+      if (!candidates.length) continue;
+      const mid = Math.max(...candidates);
+      for (const outcome of market.venueMarketOutcomes) {
+        const isYes = ((_a = outcome.label) == null ? void 0 : _a.toLowerCase()) === "yes";
+        map.set(outcome.id, isYes ? mid : 1 - mid);
+      }
+    }
+    return map;
+  }, [cache, visibleMarkets]);
+  return { prices };
+}
+
+// src/use-visible-ids.ts
+import { useCallback as useCallback5, useEffect as useEffect9, useRef as useRef5, useState as useState8 } from "react";
+function useVisibleIds(options = {}) {
+  const { rootMargin = "0px", threshold = 0 } = options;
+  const [visibleIds, setVisibleIds] = useState8(() => /* @__PURE__ */ new Set());
+  const observerRef = useRef5(null);
+  const elementsRef = useRef5(/* @__PURE__ */ new Map());
+  const elementIdRef = useRef5(/* @__PURE__ */ new WeakMap());
+  const callbackRefsRef = useRef5(/* @__PURE__ */ new Map());
+  useEffect9(() => {
+    if (typeof IntersectionObserver === "undefined") return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        setVisibleIds((prev) => {
+          let changed = false;
+          const next = new Set(prev);
+          for (const entry of entries) {
+            const id = elementIdRef.current.get(entry.target);
+            if (!id) continue;
+            if (entry.isIntersecting) {
+              if (!next.has(id)) {
+                next.add(id);
+                changed = true;
+              }
+            } else if (next.has(id)) {
+              next.delete(id);
+              changed = true;
+            }
+          }
+          return changed ? next : prev;
+        });
+      },
+      { rootMargin, threshold }
+    );
+    observerRef.current = observer;
+    for (const el of elementsRef.current.values()) observer.observe(el);
+    return () => {
+      observer.disconnect();
+      observerRef.current = null;
+    };
+  }, [rootMargin, threshold]);
+  const register = useCallback5((id) => {
+    const existing = callbackRefsRef.current.get(id);
+    if (existing) return existing;
+    const callback = (el) => {
+      var _a, _b;
+      const prev = elementsRef.current.get(id);
+      if (prev === el) return;
+      if (prev) {
+        (_a = observerRef.current) == null ? void 0 : _a.unobserve(prev);
+        elementIdRef.current.delete(prev);
+        elementsRef.current.delete(id);
+        setVisibleIds((curr) => {
+          if (!curr.has(id)) return curr;
+          const next = new Set(curr);
+          next.delete(id);
+          return next;
+        });
+      }
+      if (el) {
+        elementsRef.current.set(id, el);
+        elementIdRef.current.set(el, id);
+        (_b = observerRef.current) == null ? void 0 : _b.observe(el);
+      } else {
+        callbackRefsRef.current.delete(id);
+      }
+    };
+    callbackRefsRef.current.set(id, callback);
+    return callback;
+  }, []);
+  return { visibleIds, register };
+}
+
+// src/use-app-config.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+var FIVE_MINUTES = 5 * 60 * 1e3;
+function useAppConfig() {
+  var _a, _b, _c, _d, _e, _f;
+  const client = useAggClient();
+  const query = useQuery9({
+    queryKey: ["agg", "app-config"],
+    queryFn: () => client.getAppConfig(),
+    staleTime: FIVE_MINUTES
+  });
+  return {
+    disabledVenues: (_b = (_a = query.data) == null ? void 0 : _a.disabledVenues) != null ? _b : [],
+    disabledCategoryPresets: (_d = (_c = query.data) == null ? void 0 : _c.disabledCategoryPresets) != null ? _d : [],
+    earlyAccessEnabled: (_f = (_e = query.data) == null ? void 0 : _e.earlyAccessEnabled) != null ? _f : false,
+    isLoading: query.isLoading,
+    error: query.error
+  };
+}
+export {
+  AUTH_CHOOSER_OPEN_EVENT,
+  AggBalanceProvider,
+  AggProvider,
+  AggProvider as AggSdkProvider,
+  AggUiProvider,
+  CHART_TIME_RANGES,
+  CONFIRMED_MATCH_STATUSES,
+  DEFAULT_AGG_ROOT_CLASS_NAME,
+  EventListStateProvider,
+  MarketStatus,
+  MatchStatus,
+  MatchType,
+  QueryClient4 as QueryClient,
+  QueryClientProvider,
+  TurnstileChallengeError,
+  Venue,
+  computeClosedPositionTotals,
+  computePriceGaps,
+  defaultAggUiConfig,
+  defaultAggUiConfig as defaultSdkUiConfig,
+  executionKeys,
+  findLivePriceById,
+  getBuilder,
+  getDepositAddress,
+  getOrCreateBuilder,
+  getWalletAddressFromUserProfile,
+  invalidateBalanceQueries,
+  invalidatePositionQueries,
+  optimizedImageUrl,
+  parseEmail,
+  parseEmailStrict,
+  requestAggAuthChooserOpen,
+  resolveAggUiLabels,
+  resolveDefaultMarket as resolveDefaultTradingMarket,
+  resolveEventTradingState,
+  resolveMarketTradingState,
+  resolveMarketWinningOutcome,
+  resolveOrderEligibility,
+  resolveTradingStateKind,
+  sortVenues,
+  timeRangeToInterval,
+  tradingReducer,
+  useAggAuth,
+  useAggAuthContext,
+  useAggAuthState,
+  useAggBalance,
+  useAggBalanceContext,
+  useAggBalanceState,
+  useAggClient,
+  useAggLabels,
+  useAggUiConfig,
+  useAggWebSocket,
+  useAppConfig,
+  useCategories,
+  useDebouncedValue,
+  useDepositAddresses,
+  useEnrichedVenueEvent,
+  useEventListState,
+  useEventOrderbookData,
+  useEventTradingContext,
+  useExecuteManaged,
+  useExecutionOrders,
+  useExecutionPositions,
+  useExecutionProgress,
+  useExternalId,
+  useGeoBlock,
+  useLabels,
+  useLinkAccount,
+  useLiveCandleOverlay,
+  useLiveCandles,
+  useLiveMarket,
+  useLiveMarketStores,
+  useLiveOutcomePrices,
+  useLiveTrades,
+  useManagedBalances,
+  useMarketChart,
+  useMarketOrderbook,
+  useMidpoints,
+  useOnBalanceUpdate,
+  useOnOrderSubmitted,
+  useOnRedeemEvent,
+  useOrderBook,
+  useOrderbookQuote,
+  useOrders,
+  usePositions,
+  useQueryClient2 as useQueryClient,
+  useQuoteManaged,
+  useRampQuotes,
+  useRampSession,
+  useRedeem,
+  useRedeemEligibleCount,
+  useSdkLabels,
+  useSdkUiConfig,
+  useSearch,
+  useSmartRoute,
+  useSyncBalances,
+  useUserActivity,
+  useUserHoldings,
+  useVenueEvent,
+  useVenueEvents,
+  useVenueMarketMidpoints,
+  useVenueMarkets,
+  useViewportMidpoints,
+  useVisibleIds,
+  useWithdrawManaged
+};