@agg-build/hooks 4.0.1 → 4.5.0

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import {
   useRampQuotes,
   useRampSession
-} from "./chunk-BR6NZSXN.mjs";
+} from "./chunk-O4RM4KKO.mjs";
 import {
   useWithdrawEstimate,
   useWithdrawFlow,
   useWithdrawPreview,
   useWithdrawalLifecycle
-} from "./chunk-AZYAQIZB.mjs";
+} from "./chunk-IHMZHA2W.mjs";
 import {
   AggAuthContext,
   AggBalanceProvider,
@@ -97,7 +97,7 @@ import {
   useSyncBalances,
   useWithdrawManaged,
   userActivityQueryKeys
-} from "./chunk-SC6X5TL4.mjs";
+} from "./chunk-LVOL27OZ.mjs";
 
 // src/index.ts
 import { QueryClient as QueryClient4, QueryClientProvider, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
@@ -220,7 +220,7 @@ function useLinkAccount() {
     [client]
   );
   const confirmLink = useCallback2(
-    (token) => run(() => client.linkAccountConfirm(token)),
+    (input) => run(() => client.linkAccountConfirm(input)),
     [client]
   );
   return { startLink, confirmLink, isLoading, error };
@@ -323,6 +323,7 @@ function useExecutionOrders(options = {}) {
   const client = useAggClient();
   const {
     status,
+    orderType,
     orderId,
     quoteId,
     mode,
@@ -338,11 +339,13 @@ function useExecutionOrders(options = {}) {
       status != null ? status : "all",
       quoteId != null ? quoteId : null,
       orderId != null ? orderId : null,
+      ...orderType ? [orderType] : [],
       ...mode ? [mode] : [],
       limit
     ],
     queryFn: ({ pageParam }) => client.getExecutionOrders(__spreadProps(__spreadValues({
       status,
+      orderType,
       orderId,
       quoteId
     }, mode ? { mode } : {}), {
@@ -2294,7 +2297,7 @@ var getIsDocumentVisible = () => {
   return document.visibilityState !== "hidden";
 };
 function useSmartRoute(options) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e, _f;
   const client = useAggClient();
   const {
     venueMarketOutcomeId,
@@ -2309,6 +2312,7 @@ function useSmartRoute(options) {
     slipCapBps,
     compareVenues,
     sellCacheScope,
+    balanceCacheScope,
     deepEstimate,
     enabled = true,
     staleTimeMs = SMART_ROUTE_STALE_TIME_MS,
@@ -2330,7 +2334,8 @@ function useSmartRoute(options) {
       slipCapBps != null ? slipCapBps : null,
       compareVenues != null ? compareVenues : false,
       deepEstimate != null ? deepEstimate : false,
-      ...tradeSide === "sell" ? [(_b = sellCacheScope == null ? void 0 : sellCacheScope.accountId) != null ? _b : null, (_c = sellCacheScope == null ? void 0 : sellCacheScope.positionVersion) != null ? _c : null] : []
+      ...balanceCacheScope ? [(_b = balanceCacheScope.accountId) != null ? _b : null, (_c = balanceCacheScope.balanceVersion) != null ? _c : null] : [],
+      ...tradeSide === "sell" ? [(_d = sellCacheScope == null ? void 0 : sellCacheScope.accountId) != null ? _d : null, (_e = sellCacheScope == null ? void 0 : sellCacheScope.positionVersion) != null ? _e : null] : []
     ],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       return client.getSmartRoute(
@@ -2387,7 +2392,7 @@ function useSmartRoute(options) {
     }
   }
   return {
-    data: (_d = query.data) != null ? _d : null,
+    data: (_f = query.data) != null ? _f : null,
     isLoading: query.isLoading,
     isFetching: query.isFetching,
     error: error instanceof Error ? error : error ? new Error(String(error)) : null,
@@ -2397,7 +2402,7 @@ function useSmartRoute(options) {
 }
 
 // src/use-limit-order-venue-quotes.ts
-import { keepPreviousData as keepPreviousData7, useQueries as useQueries6 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData7, useQueries as useQueries6, useQuery as useQuery8 } from "@tanstack/react-query";
 var getIsDocumentVisible2 = () => {
   if (typeof document === "undefined") return true;
   return document.visibilityState !== "hidden";
@@ -2410,6 +2415,27 @@ var getUniqueVenueRequests = (requests) => {
   }
   return [...requestsByVenue.values()].sort((left, right) => left.venue.localeCompare(right.venue));
 };
+var resolveLimitOrderTickSizesByVenue = (response) => {
+  var _a, _b;
+  const tickSizes = /* @__PURE__ */ new Map();
+  const setTickSize = (venue, tickSize) => {
+    if (tickSizes.has(venue)) return;
+    if (typeof tickSize !== "number" || !Number.isFinite(tickSize) || tickSize <= 0) return;
+    tickSizes.set(venue, tickSize);
+  };
+  for (const item of (_a = response == null ? void 0 : response.data) != null ? _a : []) {
+    for (const [venue, entry] of Object.entries(item.venueOrderbooks)) {
+      setTickSize(venue, (_b = entry.tick) != null ? _b : entry.tickSize);
+    }
+    for (const market of item.matchedMarkets) {
+      setTickSize(market.venue, market.tickSize);
+    }
+    if (item.requestedMarket) {
+      setTickSize(item.requestedMarket.venue, item.requestedMarket.tickSize);
+    }
+  }
+  return tickSizes;
+};
 var useLimitOrderVenueQuotes = (options) => {
   var _a, _b;
   const client = useAggClient();
@@ -2431,6 +2457,15 @@ var useLimitOrderVenueQuotes = (options) => {
   const hasRequiredAccount = tradeSide === "buy" || Boolean(accountId);
   const queryEnabled = enabled && hasValidInput && hasRequiredAccount;
   const serializedChainBalances = chainBalances ? JSON.stringify(chainBalances) : null;
+  const tickMetadataQuery = useQuery8({
+    queryKey: ["orderbooks", marketId != null ? marketId : "__disabled__", "limit-order-ticks"],
+    queryFn: ({ signal }) => client.getOrderbooks({ venueMarketIds: [marketId] }, { signal }),
+    enabled: enabled && Boolean(marketId),
+    staleTime: 6e4,
+    gcTime: 5 * 6e4,
+    refetchOnWindowFocus: false,
+    retry: 1
+  });
   const queries = useQueries6({
     queries: uniqueRequests.map((request) => ({
       queryKey: [
@@ -2485,12 +2520,15 @@ var useLimitOrderVenueQuotes = (options) => {
       retry: 1
     }))
   });
+  const tickSizesByVenue = resolveLimitOrderTickSizesByVenue(tickMetadataQuery.data);
   const quotes = queries.map((query, index) => {
-    var _a2;
+    var _a2, _b2;
     const queryError = query.error;
+    const request = uniqueRequests[index];
     return {
-      request: uniqueRequests[index],
+      request,
       data: (_a2 = query.data) != null ? _a2 : null,
+      tickSize: (_b2 = tickSizesByVenue.get(request.venue)) != null ? _b2 : null,
       isLoading: query.isLoading,
       isFetching: query.isFetching,
       error: queryError instanceof Error ? queryError : queryError ? new Error(String(queryError)) : null,
@@ -2502,7 +2540,10 @@ var useLimitOrderVenueQuotes = (options) => {
     isLoading: quotes.some((quote) => quote.isLoading),
     isFetching: quotes.some((quote) => quote.isFetching),
     error: (_b = (_a = quotes.find((quote) => quote.error)) == null ? void 0 : _a.error) != null ? _b : null,
-    refetch: () => Promise.all(quotes.map((quote) => quote.refetch()))
+    refetch: () => Promise.all([
+      ...marketId ? [tickMetadataQuery.refetch()] : [],
+      ...quotes.map((quote) => quote.refetch())
+    ])
   };
 };
 
@@ -2655,25 +2696,566 @@ function useUserHoldings(options) {
 import { useMemo as useMemo10 } from "react";
 
 // src/use-venue-event.ts
-import { useQuery as useQuery8 } from "@tanstack/react-query";
+import { useQuery as useQuery10 } from "@tanstack/react-query";
+
+// src/use-recurring-crypto-markets.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+var RESOLVING_POLL_INTERVAL_MS = 15e3;
+var FALLBACK_VENUE_EVENT_PAGE_LIMIT = 100;
+var FALLBACK_VENUE_EVENT_MAX_PAGES = 5;
+var FALLBACK_TARGET_WINDOW_COUNT = 5;
+var RECURRING_MARKET_STATUSES = [
+  "open" /* open */,
+  "closed" /* closed */,
+  "resolved" /* resolved */,
+  "unopened" /* unopened */,
+  "paused" /* paused */
+];
+var RECURRING_DURATION_MS = {
+  PT5M: 5 * 6e4,
+  PT15M: 15 * 6e4,
+  PT1H: 60 * 6e4,
+  P1D: 24 * 60 * 6e4
+};
+var RECURRING_SLUG_DURATION = {
+  "5m": "PT5M",
+  "15m": "PT15M",
+  "1h": "PT1H",
+  "1d": "P1D"
+};
+var RECURRING_DURATION_AGG_KEY_SEGMENT = {
+  PT5M: "5m",
+  PT15M: "15m",
+  PT1H: "1h"
+};
+var RECURRING_CRYPTO_SLUG_PATTERN = /^([a-z0-9]+)-updown-(5m|15m|1h|1d)-(\d+)$/i;
+var RECURRING_CRYPTO_AGG_KEY_PATTERN = /^agg_ud_([a-z0-9]+)_(5m|15m|1h)_(\d{2})(\d{2})(\d{2})T(\d{2})(\d{2})$/i;
+var RECURRING_CRYPTO_DAILY_AGG_KEY_PATTERN = /^agg_ud_([a-z0-9]+)_1d_(\d{2})(\d{2})(\d{2})$/i;
+var isRecurringCryptoDuration = (value) => value != null && Object.prototype.hasOwnProperty.call(RECURRING_DURATION_MS, value);
+var parseTimestamp = (value) => {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+};
+var hasCryptoCategory = (event) => event.categories.some(
+  ({ category }) => [category.name, category.displayName].some((value) => (value == null ? void 0 : value.trim().toLowerCase()) === "crypto")
+);
+var resolveWindowStartFromEnd = (event, duration) => {
+  var _a, _b;
+  const end = (_b = (_a = parseTimestamp(event.endDate)) != null ? _a : event.venueMarkets.map((market) => parseTimestamp(market.endDate)).find((value) => value != null)) != null ? _b : null;
+  if (end != null) return end - RECURRING_DURATION_MS[duration];
+  return parseTimestamp(event.startDate);
+};
+var parseAggKeyWindowStart = (match) => {
+  const year = 2e3 + Number(match[3]);
+  const monthIndex = Number(match[4]) - 1;
+  const day = Number(match[5]);
+  const hour = Number(match[6]);
+  const minute = Number(match[7]);
+  const timestamp = Date.UTC(year, monthIndex, day, hour, minute);
+  const parsed = new Date(timestamp);
+  if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== monthIndex || parsed.getUTCDate() !== day || parsed.getUTCHours() !== hour || parsed.getUTCMinutes() !== minute) {
+    return null;
+  }
+  return timestamp;
+};
+var resolveRecurringCryptoIdentity = (event) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const slugMatch = (_a = event.slug) == null ? void 0 : _a.match(RECURRING_CRYPTO_SLUG_PATTERN);
+  if (slugMatch && hasCryptoCategory(event)) {
+    const [, asset, durationSegment, epochSeconds] = slugMatch;
+    const duration = RECURRING_SLUG_DURATION[durationSegment.toLowerCase()];
+    const parsedEpochSeconds = Number(epochSeconds);
+    const windowStart = parsedEpochSeconds * 1e3;
+    if (duration && Number.isSafeInteger(parsedEpochSeconds) && Number.isFinite(windowStart)) {
+      return { asset: asset.toUpperCase(), duration, windowStart };
+    }
+  }
+  const aggKeyMatch = (_b = event.aggKey) == null ? void 0 : _b.match(RECURRING_CRYPTO_AGG_KEY_PATTERN);
+  if (aggKeyMatch) {
+    const [, asset, durationSegment] = aggKeyMatch;
+    const duration = RECURRING_SLUG_DURATION[durationSegment.toLowerCase()];
+    const windowStart = parseAggKeyWindowStart(aggKeyMatch);
+    if (duration && windowStart != null) {
+      return { asset: asset.toUpperCase(), duration, windowStart };
+    }
+  }
+  const dailyAggKeyMatch = (_c = event.aggKey) == null ? void 0 : _c.match(RECURRING_CRYPTO_DAILY_AGG_KEY_PATTERN);
+  if (dailyAggKeyMatch) {
+    return {
+      asset: dailyAggKeyMatch[1].toUpperCase(),
+      duration: "P1D",
+      windowStart: resolveWindowStartFromEnd(event, "P1D")
+    };
+  }
+  if (!isRecurringCryptoDuration(event.recurrence)) return null;
+  return {
+    asset: (_g = (_f = (_d = slugMatch == null ? void 0 : slugMatch[1]) == null ? void 0 : _d.toUpperCase()) != null ? _f : (_e = aggKeyMatch == null ? void 0 : aggKeyMatch[1]) == null ? void 0 : _e.toUpperCase()) != null ? _g : null,
+    duration: event.recurrence,
+    windowStart: resolveWindowStartFromEnd(event, event.recurrence)
+  };
+};
+var mergeWindowMarkets = (current, incoming) => {
+  const marketsById = new Map(
+    current.map((market) => [
+      `${market.venue}:${market.venueEventId}:${market.venueMarketId}`,
+      market
+    ])
+  );
+  incoming.forEach((market) => {
+    marketsById.set(`${market.venue}:${market.venueEventId}:${market.venueMarketId}`, market);
+  });
+  return [...marketsById.values()];
+};
+var mergeRecurringCryptoWindows = (windows) => {
+  const windowsById = /* @__PURE__ */ new Map();
+  windows.forEach((windowMarket) => {
+    const existing = windowsById.get(windowMarket.id);
+    if (!existing) {
+      windowsById.set(windowMarket.id, windowMarket);
+      return;
+    }
+    windowsById.set(windowMarket.id, __spreadProps(__spreadValues(__spreadValues({}, existing), windowMarket), {
+      markets: mergeWindowMarkets(existing.markets, windowMarket.markets)
+    }));
+  });
+  return [...windowsById.values()].sort(
+    (left, right) => {
+      var _a, _b;
+      return ((_a = parseTimestamp(left.windowStart)) != null ? _a : 0) - ((_b = parseTimestamp(right.windowStart)) != null ? _b : 0);
+    }
+  );
+};
+var selectNavigableMarket = (markets, event) => {
+  var _a, _b, _c;
+  const navigableMarkets = markets.filter((market) => market.priceSource === "snag");
+  return (_c = (_b = (_a = navigableMarkets.find((market) => market.venueEventId === event.id)) != null ? _a : navigableMarkets.find((market) => market.venue === event.venue)) != null ? _b : navigableMarkets[0]) != null ? _c : null;
+};
+var resolveRecurringCryptoTimeline = (windows, event, now) => {
+  var _a, _b, _c;
+  const all = mergeRecurringCryptoWindows(windows).flatMap((windowMarket) => {
+    const windowStart = parseTimestamp(windowMarket.windowStart);
+    const windowEnd = parseTimestamp(windowMarket.windowEnd);
+    const market = selectNavigableMarket(windowMarket.markets, event);
+    if (windowStart == null || windowEnd == null || windowEnd <= windowStart || !market) return [];
+    return [
+      {
+        id: windowMarket.id,
+        asset: windowMarket.asset,
+        duration: windowMarket.duration,
+        windowStart: windowMarket.windowStart,
+        windowEnd: windowMarket.windowEnd,
+        status: market.status,
+        venueEventId: market.venueEventId,
+        venueMarketId: market.venueMarketId,
+        venue: market.venue
+      }
+    ];
+  });
+  const viewed = (_a = all.find((market) => market.venueEventId === event.id)) != null ? _a : null;
+  const live = (_b = all.find((market) => {
+    const startsAt = parseTimestamp(market.windowStart);
+    const endsAt = parseTimestamp(market.windowEnd);
+    return market.status === "open" /* open */ && startsAt != null && endsAt != null && startsAt <= now && now < endsAt;
+  })) != null ? _b : null;
+  const endedMarkets = all.filter(
+    (market) => {
+      var _a2;
+      return ((_a2 = parseTimestamp(market.windowEnd)) != null ? _a2 : Infinity) <= now;
+    }
+  );
+  const ended = (_c = endedMarkets[endedMarkets.length - 1]) != null ? _c : null;
+  const upcoming = all.filter((market) => {
+    var _a2;
+    return ((_a2 = parseTimestamp(market.windowStart)) != null ? _a2 : -Infinity) > now;
+  }).slice(0, 3);
+  const defaultVisible = [ended, live, ...upcoming].filter(
+    (market, index, values) => market != null && values.findIndex((candidate) => (candidate == null ? void 0 : candidate.id) === market.id) === index
+  );
+  let visible = defaultVisible;
+  if (viewed && !defaultVisible.some((market) => market.id === viewed.id)) {
+    const viewedStart = Date.parse(viewed.windowStart);
+    const viewedEnd = Date.parse(viewed.windowEnd);
+    const marketToReplace = viewedEnd <= now ? ended : viewedStart > now ? upcoming[upcoming.length - 1] : ended != null ? ended : upcoming[upcoming.length - 1];
+    visible = [
+      ...defaultVisible.filter((market) => market.id !== (marketToReplace == null ? void 0 : marketToReplace.id)),
+      viewed
+    ].sort(
+      (left, right) => {
+        var _a2, _b2;
+        return ((_a2 = parseTimestamp(left.windowStart)) != null ? _a2 : 0) - ((_b2 = parseTimestamp(right.windowStart)) != null ? _b2 : 0);
+      }
+    );
+  }
+  return { all, visible, ended, live, upcoming, viewed };
+};
+var fetchRecurringCryptoPage = (client, options, signal) => __async(null, null, function* () {
+  var _a;
+  return client.listRecurringCryptoMarkets(__spreadProps(__spreadValues({}, options), {
+    status: (_a = options.status) != null ? _a : RECURRING_MARKET_STATUSES,
+    includeOrderbookPrices: false,
+    includeReferencePrices: false,
+    includeDirectVenueMarkets: options.includeDirectVenueMarkets,
+    limit: 100,
+    signal
+  }));
+});
+var createEmptyPriceComparison = () => ({
+  count: 0,
+  min: null,
+  max: null,
+  spread: null,
+  spreadBps: null,
+  byVenue: []
+});
+var normalizeFallbackVenueEvent = (candidate, identity) => {
+  var _a, _b, _c, _d;
+  const candidateIdentity = resolveRecurringCryptoIdentity(candidate);
+  const venueMarket = candidate.venueMarkets[0];
+  if (!(candidateIdentity == null ? void 0 : candidateIdentity.asset) || !identity.asset || candidateIdentity.asset !== identity.asset || candidateIdentity.duration !== identity.duration || candidateIdentity.windowStart == null || !venueMarket) {
+    return null;
+  }
+  const status = (_b = (_a = candidate.status) != null ? _a : venueMarket.status) != null ? _b : "unopened" /* unopened */;
+  const windowStart = candidateIdentity.windowStart;
+  return {
+    id: `${candidateIdentity.asset}:${candidateIdentity.duration}:${new Date(windowStart).toISOString()}`,
+    asset: candidateIdentity.asset,
+    quoteAsset: "USD",
+    duration: candidateIdentity.duration,
+    windowStart: new Date(windowStart).toISOString(),
+    windowEnd: new Date(windowStart + RECURRING_DURATION_MS[identity.duration]).toISOString(),
+    status,
+    markets: [
+      {
+        venue: candidate.venue,
+        venueEventId: candidate.id,
+        venueMarketId: venueMarket.id,
+        externalEventId: candidate.externalIdentifier,
+        externalMarketId: venueMarket.externalIdentifier,
+        question: venueMarket.question,
+        status,
+        priceSource: "snag",
+        routeable: false,
+        splitOrdersAllowed: false,
+        outcomes: ((_c = venueMarket.venueMarketOutcomes) != null ? _c : []).map((outcome) => {
+          var _a2, _b2;
+          return {
+            venueMarketOutcomeId: outcome.id,
+            externalOutcomeId: (_a2 = outcome.externalIdentifier) != null ? _a2 : null,
+            routeable: false,
+            splitOrdersAllowed: false,
+            label: outcome.label,
+            title: (_b2 = outcome.title) != null ? _b2 : null,
+            midpoint: null,
+            bestBid: null,
+            bestAsk: null,
+            markSource: null,
+            lastKnownPrice: null,
+            orderbookDepth: null
+          };
+        }),
+        metrics: {
+          volume: (_d = venueMarket.volume) != null ? _d : null,
+          volume24h: null,
+          openInterest: null,
+          liquidity: null,
+          spread: null
+        },
+        resolution: {
+          sourceName: null,
+          sourceUrl: null,
+          sourceDomain: null,
+          rawCriteria: null,
+          confidence: "missing"
+        },
+        referencePrice: {
+          asset: candidateIdentity.asset,
+          quoteAsset: "USD",
+          raw: null,
+          decimals: null,
+          normalized: null,
+          timestamp: null,
+          provider: null,
+          providerMarketId: null,
+          confidence: "missing"
+        }
+      }
+    ],
+    comparisons: {
+      referencePrice: createEmptyPriceComparison(),
+      outcomePrices: {
+        up: createEmptyPriceComparison(),
+        down: createEmptyPriceComparison()
+      }
+    }
+  };
+};
+var formatCanonicalRecurringAggKey = (asset, duration, windowStart) => {
+  const durationSegment = RECURRING_DURATION_AGG_KEY_SEGMENT[duration];
+  if (!durationSegment) return null;
+  const date = new Date(windowStart);
+  if (Number.isNaN(date.getTime())) return null;
+  const twoDigits = (value) => String(value).padStart(2, "0");
+  const timestamp = [
+    twoDigits(date.getUTCFullYear() % 100),
+    twoDigits(date.getUTCMonth() + 1),
+    twoDigits(date.getUTCDate()),
+    "T",
+    twoDigits(date.getUTCHours()),
+    twoDigits(date.getUTCMinutes())
+  ].join("");
+  return `agg_ud_${asset.toLowerCase()}_${durationSegment}_${timestamp}`;
+};
+var fetchCanonicalAggKeyWindows = (client, event, identity, signal, now) => __async(null, null, function* () {
+  var _a;
+  const aggKeyMatch = (_a = event.aggKey) == null ? void 0 : _a.match(RECURRING_CRYPTO_AGG_KEY_PATTERN);
+  const asset = identity.asset;
+  if (!aggKeyMatch || !asset) return [];
+  const durationMs = RECURRING_DURATION_MS[identity.duration];
+  const currentWindowStart = Math.floor(now / durationMs) * durationMs;
+  const windowStarts = /* @__PURE__ */ new Set([
+    currentWindowStart - durationMs,
+    currentWindowStart,
+    currentWindowStart + durationMs,
+    currentWindowStart + durationMs * 2,
+    currentWindowStart + durationMs * 3,
+    identity.windowStart
+  ]);
+  const aggKeys = [...windowStarts].flatMap((windowStart) => {
+    if (windowStart == null) return [];
+    const aggKey = formatCanonicalRecurringAggKey(asset, identity.duration, windowStart);
+    return aggKey ? [aggKey] : [];
+  });
+  if (!aggKeys.length) return [];
+  const response = yield client.getVenueEvents({
+    venues: [event.venue],
+    aggKey: aggKeys,
+    limit: 100,
+    signal
+  });
+  return mergeRecurringCryptoWindows(
+    response.data.flatMap((candidate) => {
+      const normalized = normalizeFallbackVenueEvent(candidate, identity);
+      return normalized ? [normalized] : [];
+    })
+  );
+});
+var fetchFallbackVenueEventWindows = (client, event, identity, signal, now) => __async(null, null, function* () {
+  var _a;
+  const durationMs = RECURRING_DURATION_MS[identity.duration];
+  const categoryIds = event.categories.filter(
+    ({ category }) => [category.name, category.displayName].some(
+      (value) => (value == null ? void 0 : value.trim().toLowerCase()) === "crypto"
+    )
+  ).map(({ category }) => category.id);
+  const windowStarts = /* @__PURE__ */ new Set([((_a = identity.windowStart) != null ? _a : now) - durationMs, now - durationMs * 2]);
+  const responses = yield Promise.all(
+    [...windowStarts].map((windowStart) => __async(null, null, function* () {
+      var _a2;
+      const windows = [];
+      const seenCursors = /* @__PURE__ */ new Set();
+      let cursor;
+      for (let page = 0; page < FALLBACK_VENUE_EVENT_MAX_PAGES; page += 1) {
+        const response = yield client.getVenueEvents({
+          venues: [event.venue],
+          categoryIds,
+          status: RECURRING_MARKET_STATUSES,
+          sortBy: "endDate",
+          sortDir: "asc",
+          endDateFrom: new Date(windowStart).toISOString(),
+          limit: FALLBACK_VENUE_EVENT_PAGE_LIMIT,
+          cursor,
+          signal
+        });
+        response.data.forEach((candidate) => {
+          const normalized = normalizeFallbackVenueEvent(
+            candidate,
+            identity
+          );
+          if (normalized) windows.push(normalized);
+        });
+        if (mergeRecurringCryptoWindows(windows).length >= FALLBACK_TARGET_WINDOW_COUNT) break;
+        const nextCursor = response.hasMore ? (_a2 = response.nextCursor) != null ? _a2 : void 0 : void 0;
+        if (!nextCursor || seenCursors.has(nextCursor)) break;
+        seenCursors.add(nextCursor);
+        cursor = nextCursor;
+      }
+      return windows;
+    }))
+  );
+  return mergeRecurringCryptoWindows(responses.flat());
+});
+var fetchRecurringCryptoMarkets = (_0, _1, _2, ..._3) => __async(null, [_0, _1, _2, ..._3], function* (client, event, signal, now = Date.now()) {
+  var _a, _b;
+  const identity = resolveRecurringCryptoIdentity(event);
+  if (!identity) return [];
+  const { asset, duration, windowStart: anchorStart } = identity;
+  const queryAssets = ((_a = event.aggKey) == null ? void 0 : _a.match(RECURRING_CRYPTO_DAILY_AGG_KEY_PATTERN)) ? void 0 : asset ? [asset] : void 0;
+  const canonicalAggKeyWindowsPromise = fetchCanonicalAggKeyWindows(
+    client,
+    event,
+    identity,
+    signal,
+    now
+  ).catch(() => []);
+  const anchorOptions = anchorStart == null ? {
+    assets: queryAssets,
+    durations: [duration],
+    venues: [event.venue],
+    window: "current",
+    includeDirectVenueMarkets: duration === "P1D"
+  } : {
+    assets: queryAssets,
+    durations: [duration],
+    venues: [event.venue],
+    windowStartFrom: new Date(anchorStart - 1e3).toISOString(),
+    windowStartTo: new Date(anchorStart + 1e3).toISOString(),
+    includeDirectVenueMarkets: duration === "P1D"
+  };
+  let anchorResponse = yield fetchRecurringCryptoPage(client, anchorOptions, signal);
+  let anchor = anchorResponse.data.find(
+    (windowMarket) => windowMarket.markets.some((market) => market.venueEventId === event.id)
+  );
+  let timelineVenues = [event.venue];
+  let canonicalAggKeyWindows = null;
+  if (!anchor) {
+    canonicalAggKeyWindows = yield canonicalAggKeyWindowsPromise;
+    if (canonicalAggKeyWindows.some(
+      (windowMarket) => windowMarket.markets.some((market) => market.venueEventId === event.id)
+    )) {
+      return canonicalAggKeyWindows;
+    }
+  }
+  if (!anchor && asset && anchorStart != null) {
+    const unscopedAnchorResponse = yield fetchRecurringCryptoPage(
+      client,
+      __spreadProps(__spreadValues({}, anchorOptions), { venues: void 0 }),
+      signal
+    );
+    const matchingWindow = unscopedAnchorResponse.data.find(
+      (windowMarket) => windowMarket.asset === asset && windowMarket.duration === duration && parseTimestamp(windowMarket.windowStart) === anchorStart
+    );
+    const viewedWindow = normalizeFallbackVenueEvent(event, identity);
+    if (matchingWindow && viewedWindow) {
+      anchorResponse = unscopedAnchorResponse;
+      anchor = __spreadProps(__spreadValues({}, matchingWindow), {
+        markets: mergeWindowMarkets(matchingWindow.markets, viewedWindow.markets)
+      });
+      timelineVenues = void 0;
+    }
+  }
+  if (!anchor) {
+    return fetchFallbackVenueEventWindows(client, event, identity, signal, now);
+  }
+  const timelineStart = now - RECURRING_DURATION_MS[duration] * 2;
+  const windows = [
+    anchor,
+    ...anchorResponse.data.filter(
+      (windowMarket) => windowMarket.asset === anchor.asset && windowMarket.duration === duration
+    )
+  ];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  do {
+    const response = yield fetchRecurringCryptoPage(
+      client,
+      {
+        assets: [anchor.asset],
+        durations: [duration],
+        venues: timelineVenues,
+        windowStartFrom: new Date(timelineStart).toISOString(),
+        includeDirectVenueMarkets: duration === "P1D",
+        cursor
+      },
+      signal
+    );
+    windows.push(...response.data);
+    const nextCursor = response.hasMore ? (_b = response.nextCursor) != null ? _b : void 0 : void 0;
+    if (!nextCursor || seenCursors.has(nextCursor)) break;
+    seenCursors.add(nextCursor);
+    cursor = nextCursor;
+  } while (cursor);
+  windows.push(...canonicalAggKeyWindows != null ? canonicalAggKeyWindows : yield canonicalAggKeyWindowsPromise);
+  return mergeRecurringCryptoWindows(windows);
+});
+var recurringCryptoTransitionPollInterval = (windows, event, now = Date.now()) => {
+  var _a, _b;
+  if (!windows) return false;
+  const timeline = resolveRecurringCryptoTimeline(windows, event, now);
+  const viewedEnd = parseTimestamp((_b = (_a = timeline.viewed) == null ? void 0 : _a.windowEnd) != null ? _b : event.endDate);
+  return viewedEnd != null && viewedEnd <= now && !timeline.live ? RESOLVING_POLL_INTERVAL_MS : false;
+};
+var useRecurringCryptoMarkets = ({
+  event,
+  enabled = true
+}) => {
+  var _a;
+  const client = useAggClient();
+  const identity = event ? resolveRecurringCryptoIdentity(event) : null;
+  const isEnabled = enabled && event != null && identity != null;
+  const query = useQuery9({
+    queryKey: [
+      "recurring-crypto-markets",
+      event == null ? void 0 : event.id,
+      identity == null ? void 0 : identity.asset,
+      identity == null ? void 0 : identity.duration,
+      identity == null ? void 0 : identity.windowStart,
+      event == null ? void 0 : event.venue
+    ],
+    queryFn: ({ signal }) => fetchRecurringCryptoMarkets(client, event, signal),
+    enabled: isEnabled,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    refetchOnWindowFocus: true,
+    refetchOnReconnect: true,
+    refetchOnMount: true,
+    refetchInterval: (queryState) => event ? recurringCryptoTransitionPollInterval(
+      queryState.state.data,
+      event
+    ) : false,
+    retry: 1
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    windows: (_a = query.data) != null ? _a : [],
+    isRecurringCryptoMarket: isEnabled
+  });
+};
+
+// src/use-venue-event.ts
 var RESOLUTION_POLL_MS = 15e3;
 var RESOLUTION_POLL_MAX_PAST_END_MS = 60 * 6e4;
 function resolutionPollInterval(event) {
-  var _a;
-  if (!((_a = event == null ? void 0 : event.venueMarkets) == null ? void 0 : _a.length)) return false;
+  if (!event) return false;
   const now = Date.now();
+  const isRecurringCryptoMarket = resolveRecurringCryptoIdentity(event) != null;
+  if (isRecurringCryptoMarket && event.status === "resolved" /* resolved */) return false;
+  if (isRecurringCryptoMarket && event.status === "closed" /* closed */) {
+    return RESOLUTION_POLL_MS;
+  }
+  const eventEndsAt = event.endDate ? Date.parse(event.endDate) : Number.NaN;
+  if (isRecurringCryptoMarket && event.status === "paused" /* paused */ && Number.isFinite(eventEndsAt) && eventEndsAt <= now) {
+    return RESOLUTION_POLL_MS;
+  }
   const shouldPoll = event.venueMarkets.some((market) => {
-    if (market.status !== "open" /* open */ || !market.endDate) return false;
+    if (!market.endDate) return false;
     const endsAt = new Date(market.endDate).getTime();
+    if (isRecurringCryptoMarket && (market.status === "closed" /* closed */ || market.status === "paused" /* paused */) && Number.isFinite(endsAt) && endsAt <= now) {
+      return true;
+    }
+    if (market.status !== "open" /* open */) return false;
     return Number.isFinite(endsAt) && now > endsAt && now < endsAt + RESOLUTION_POLL_MAX_PAST_END_MS;
   });
-  return shouldPoll ? RESOLUTION_POLL_MS : false;
+  if (shouldPoll) return RESOLUTION_POLL_MS;
+  if (!isRecurringCryptoMarket || event.status !== "open" /* open */) return false;
+  if (!Number.isFinite(eventEndsAt)) return false;
+  if (now <= eventEndsAt || now >= eventEndsAt + RESOLUTION_POLL_MAX_PAST_END_MS) return false;
+  return RESOLUTION_POLL_MS;
 }
 function useVenueEvent(options) {
   var _a;
   const client = useAggClient();
   const { eventId, enabled = true } = options;
-  const query = useQuery8({
+  const query = useQuery10({
     queryKey: ["venue-event", eventId],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       return client.getVenueEventById(eventId, { signal });
@@ -2973,8 +3555,48 @@ function useVenueEvents(options) {
   });
 }
 
+// src/use-sports-live.ts
+import { useQuery as useQuery11 } from "@tanstack/react-query";
+var SPORTS_LIVE_POLL_INTERVAL_MS = 5e3;
+var SPORTS_SCHEDULED_POLL_INTERVAL_MS = 3e4;
+var sportsLiveQueryKey = (sortedEventIds) => ["sports-live", ...sortedEventIds];
+var sportsLiveRefetchInterval = (response) => {
+  if (!response) return false;
+  if (response.data.some((state) => state.status === "live" || state.status === "paused")) {
+    return SPORTS_LIVE_POLL_INTERVAL_MS;
+  }
+  if (response.data.some((state) => state.status === "scheduled")) {
+    return SPORTS_SCHEDULED_POLL_INTERVAL_MS;
+  }
+  return false;
+};
+var useSportsLive = (eventIds, enabled = true) => {
+  var _a, _b, _c, _d;
+  const client = useAggClient();
+  const sortedEventIds = [
+    ...new Set(eventIds.map((eventId) => eventId.trim()).filter(Boolean))
+  ].sort();
+  const query = useQuery11({
+    queryKey: sportsLiveQueryKey(sortedEventIds),
+    queryFn: ({ signal }) => client.getSportsLive(sortedEventIds, { signal }),
+    enabled: enabled && sortedEventIds.length > 0,
+    refetchInterval: (queryState) => sportsLiveRefetchInterval(queryState.state.data),
+    refetchIntervalInBackground: false,
+    refetchOnWindowFocus: true
+  });
+  const states = (_b = (_a = query.data) == null ? void 0 : _a.data) != null ? _b : [];
+  const stateByEventId = new Map(
+    states.map((state) => [state.eventId, state])
+  );
+  return __spreadProps(__spreadValues({}, query), {
+    states,
+    stateByEventId,
+    missingEventIds: (_d = (_c = query.data) == null ? void 0 : _c.missingEventIds) != null ? _d : []
+  });
+};
+
 // src/use-venue-market-midpoints.ts
-import { keepPreviousData as keepPreviousData9, useQuery as useQuery9 } from "@tanstack/react-query";
+import { keepPreviousData as keepPreviousData9, useQuery as useQuery12 } from "@tanstack/react-query";
 var normalizeVenueMarketIds2 = (venueMarketIds) => {
   return [
     ...new Set(venueMarketIds.map((venueMarketId) => venueMarketId.trim()).filter(Boolean))
@@ -3013,7 +3635,7 @@ function useVenueMarketMidpoints(options) {
   const enabled = (_a = options.enabled) != null ? _a : true;
   const requestedVenueMarketIds = normalizeVenueMarketIds2(options.venueMarketIds);
   const maxMidpointIdsPerRequest = (_b = options.maxMidpointIdsPerRequest) != null ? _b : configuredMaxMidpointIdsPerRequest;
-  const query = useQuery9({
+  const query = useQuery12({
     queryKey: requestedVenueMarketIds.length ? ["venue-market-midpoints", requestedVenueMarketIds, maxMidpointIdsPerRequest] : ["venue-market-midpoints", "__disabled__"],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       if (requestedVenueMarketIds.length === 0) {
@@ -3280,12 +3902,12 @@ function useVisibleIds(options = {}) {
 }
 
 // src/use-app-config.ts
-import { useQuery as useQuery10, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { useQuery as useQuery13, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
 var FIVE_MINUTES = 5 * 60 * 1e3;
 var APP_CONFIG_QUERY_KEY = ["agg", "app-config"];
 function useAppConfig() {
   const client = useAggClient();
-  const query = useQuery10({
+  const query = useQuery13({
     queryKey: APP_CONFIG_QUERY_KEY,
     queryFn: () => client.getAppConfig(),
     staleTime: FIVE_MINUTES
@@ -3298,7 +3920,7 @@ function useAppConfig() {
 }
 function useCachedAppConfig() {
   const queryClient = useQueryClient2();
-  const query = useQuery10({
+  const query = useQuery13({
     queryKey: APP_CONFIG_QUERY_KEY,
     enabled: false,
     initialData: () => queryClient.getQueryData(APP_CONFIG_QUERY_KEY),
@@ -3339,6 +3961,8 @@ export {
   QueryClient4 as QueryClient,
   QueryClientProvider,
   RedeemRejectedError,
+  SPORTS_LIVE_POLL_INTERVAL_MS,
+  SPORTS_SCHEDULED_POLL_INTERVAL_MS,
   TradeSide,
   TurnstileChallengeError,
   Venue,
@@ -3349,6 +3973,7 @@ export {
   defaultAggUiConfig as defaultSdkUiConfig,
   executionKeys,
   extractOutcomeBestCandidate,
+  fetchRecurringCryptoMarkets,
   findLivePriceById,
   getBuilder,
   getDepositAddress,
@@ -3364,11 +3989,13 @@ export {
   invalidateUserMoneyState,
   isVenueDisabledByConfig,
   mergeBestPricesPreferringLive,
+  mergeRecurringCryptoWindows,
   normalizeVenueId,
   optimizedImageUrl,
   parseEmail,
   parseEmailStrict,
   rangeToSeconds,
+  recurringCryptoTransitionPollInterval,
   requestAggAuthChooserOpen,
   resolveAggUiLabels,
   resolveDefaultMarket as resolveDefaultTradingMarket,
@@ -3376,9 +4003,13 @@ export {
   resolveMarketTradingState,
   resolveMarketWinningOutcome,
   resolveOrderEligibility,
+  resolveRecurringCryptoIdentity,
+  resolveRecurringCryptoTimeline,
   resolveRollingWindow,
   resolveTradingStateKind,
   sortVenues,
+  sportsLiveQueryKey,
+  sportsLiveRefetchInterval,
   timeRangeToInterval,
   tradingReducer,
   useAggAuth,
@@ -3441,6 +4072,7 @@ export {
   useQueryClient3 as useQueryClient,
   useRampQuotes,
   useRampSession,
+  useRecurringCryptoMarkets,
   useRedeem,
   useRedeemEligibleCount,
   useRedeemLifecycle,
@@ -3450,6 +4082,7 @@ export {
   useSdkUiConfig,
   useSearch,
   useSmartRoute,
+  useSportsLive,
   useSyncBalances,
   useUserActivity,
   useUserHoldings,