@agg-build/hooks 4.0.1 → 4.4.0

package/dist/index.js

@@ -84,9 +84,11 @@ __export(src_exports, {
   MarketStatus: () => MarketStatus,
   MatchStatus: () => MatchStatus,
   MatchType: () => MatchType,
-  QueryClient: () => import_react_query44.QueryClient,
-  QueryClientProvider: () => import_react_query44.QueryClientProvider,
+  QueryClient: () => import_react_query46.QueryClient,
+  QueryClientProvider: () => import_react_query46.QueryClientProvider,
   RedeemRejectedError: () => RedeemRejectedError,
+  SPORTS_LIVE_POLL_INTERVAL_MS: () => SPORTS_LIVE_POLL_INTERVAL_MS,
+  SPORTS_SCHEDULED_POLL_INTERVAL_MS: () => SPORTS_SCHEDULED_POLL_INTERVAL_MS,
   TradeSide: () => TradeSide,
   TurnstileChallengeError: () => import_sdk4.TurnstileChallengeError,
   Venue: () => Venue,
@@ -97,6 +99,7 @@ __export(src_exports, {
   defaultSdkUiConfig: () => defaultAggUiConfig,
   executionKeys: () => executionKeys,
   extractOutcomeBestCandidate: () => extractOutcomeBestCandidate,
+  fetchRecurringCryptoMarkets: () => fetchRecurringCryptoMarkets,
   findLivePriceById: () => findLivePriceById,
   getBuilder: () => getBuilder,
   getDepositAddress: () => getDepositAddress,
@@ -112,11 +115,13 @@ __export(src_exports, {
   invalidateUserMoneyState: () => invalidateUserMoneyState,
   isVenueDisabledByConfig: () => isVenueDisabledByConfig,
   mergeBestPricesPreferringLive: () => mergeBestPricesPreferringLive,
+  mergeRecurringCryptoWindows: () => mergeRecurringCryptoWindows,
   normalizeVenueId: () => normalizeVenueId,
   optimizedImageUrl: () => optimizedImageUrl,
   parseEmail: () => parseEmail,
   parseEmailStrict: () => parseEmailStrict,
   rangeToSeconds: () => rangeToSeconds,
+  recurringCryptoTransitionPollInterval: () => recurringCryptoTransitionPollInterval,
   requestAggAuthChooserOpen: () => requestAggAuthChooserOpen,
   resolveAggUiLabels: () => resolveAggUiLabels,
   resolveDefaultTradingMarket: () => resolveDefaultMarket,
@@ -124,9 +129,13 @@ __export(src_exports, {
   resolveMarketTradingState: () => resolveMarketTradingState,
   resolveMarketWinningOutcome: () => resolveMarketWinningOutcome,
   resolveOrderEligibility: () => resolveOrderEligibility,
+  resolveRecurringCryptoIdentity: () => resolveRecurringCryptoIdentity,
+  resolveRecurringCryptoTimeline: () => resolveRecurringCryptoTimeline,
   resolveRollingWindow: () => resolveRollingWindow,
   resolveTradingStateKind: () => resolveTradingStateKind,
   sortVenues: () => sortVenues,
+  sportsLiveQueryKey: () => sportsLiveQueryKey,
+  sportsLiveRefetchInterval: () => sportsLiveRefetchInterval,
   timeRangeToInterval: () => timeRangeToInterval,
   tradingReducer: () => tradingReducer,
   useAggAuth: () => useAggAuth,
@@ -186,9 +195,10 @@ __export(src_exports, {
   useOrders: () => useOrders,
   usePlaceLimitOrder: () => usePlaceLimitOrder,
   usePositions: () => usePositions,
-  useQueryClient: () => import_react_query44.useQueryClient,
+  useQueryClient: () => import_react_query46.useQueryClient,
   useRampQuotes: () => useRampQuotes,
   useRampSession: () => useRampSession,
+  useRecurringCryptoMarkets: () => useRecurringCryptoMarkets,
   useRedeem: () => useRedeem,
   useRedeemEligibleCount: () => useRedeemEligibleCount,
   useRedeemLifecycle: () => useRedeemLifecycle,
@@ -198,6 +208,7 @@ __export(src_exports, {
   useSdkUiConfig: () => useSdkUiConfig,
   useSearch: () => useSearch,
   useSmartRoute: () => useSmartRoute,
+  useSportsLive: () => useSportsLive,
   useSyncBalances: () => useSyncBalances,
   useUserActivity: () => useUserActivity,
   useUserHoldings: () => useUserHoldings,
@@ -229,9 +240,11 @@ var Venue = /* @__PURE__ */ ((Venue2) => {
   Venue2["probable"] = "probable";
   Venue2["myriad"] = "myriad";
   Venue2["hyperliquid"] = "hyperliquid";
+  Venue2["novig"] = "novig";
   return Venue2;
 })(Venue || {});
 var ACTIVE_VENUES = [
+  "kalshi" /* kalshi */,
   "polymarket" /* polymarket */,
   "limitless" /* limitless */,
   "opinion" /* opinion */,
@@ -240,7 +253,7 @@ var ACTIVE_VENUES = [
   "myriad" /* myriad */,
   "hyperliquid" /* hyperliquid */
 ];
-var INACTIVE_VENUES = ["kalshi" /* kalshi */];
+var INACTIVE_VENUES = ["novig" /* novig */];
 var ACTIVE_VENUE_SET = new Set(ACTIVE_VENUES);
 var INACTIVE_VENUE_SET = new Set(INACTIVE_VENUES);
 
@@ -353,7 +366,7 @@ var getVenueOrder = (venue) => {
 var sortVenues = (venues) => [...venues].sort((a, b) => getVenueOrder(a) - getVenueOrder(b));
 
 // src/index.ts
-var import_react_query44 = require("@tanstack/react-query");
+var import_react_query46 = require("@tanstack/react-query");
 
 // src/candle-store.ts
 var import_sdk = require("@agg-build/sdk");
@@ -586,7 +599,8 @@ var enUsLabels = {
     limitless: "Limitless",
     probable: "Probable",
     myriad: "Myriad",
-    hyperliquid: "Hyperliquid"
+    hyperliquid: "Hyperliquid",
+    novig: "Novig"
   },
   auth: {
     connect: (connectorName) => connectorName ? `Sign in with ${connectorName}` : "Sign in",
@@ -867,7 +881,7 @@ var enUsLabels = {
   userProfile: {
     tabs: {
       positions: "Positions",
-      openOrders: "Open orders",
+      openOrders: "Open limit orders",
       activity: "Activity"
     },
     balance: {
@@ -970,6 +984,7 @@ var enUsLabels = {
       goodTilCanceled: "Good 'til canceled",
       expired: "Expired",
       cancel: "Cancel",
+      pending: "Pending",
       cancelOrderAria: (orderId) => `Cancel order ${orderId}`,
       loading: "Loading open orders",
       loadingMore: "Loading more open orders",
@@ -1048,7 +1063,19 @@ var enUsLabels = {
     volumeSuffix: "Vol.",
     marketSelectPlaceholder: "Select market",
     marketSelectSearchPlaceholder: "Search markets...",
-    marketSelectEmpty: "No markets found"
+    marketSelectEmpty: "No markets found",
+    moreMarkets: "More",
+    liveMarket: "Live"
+  },
+  sportsLive: {
+    scoreAria: (firstName, firstScore, secondName, secondScore, status) => `${firstName} ${firstScore}, ${secondName} ${secondScore}, ${status}`,
+    scheduled: "Scheduled",
+    live: "Live",
+    paused: "Paused",
+    finished: "Final",
+    cancelled: "Cancelled",
+    postponed: "Postponed",
+    unknown: "Status unavailable"
   },
   settlementSummary: {
     title: "Settlement differences",
@@ -1095,6 +1122,7 @@ var enUsLabels = {
     showOutcomeAria: (label) => `Show ${label} outcome`,
     viewResolved: "View resolved",
     hideResolved: "Hide resolved",
+    resolvingBadge: "Resolving",
     resolvingTitle: "Resolving market\u2026",
     resolvingDescription: "This market has closed. We're waiting for final settlement data and will update the result once it's confirmed on-chain.",
     volumeUnavailable: "Volume unavailable",
@@ -1175,7 +1203,9 @@ var enUsLabels = {
     orderDisabledNoOutcome: "Select an outcome to place an order.",
     orderDisabledNoEvent: "No event selected.",
     insufficientBalance: "Insufficient balance",
-    lowLiquidityWarning: "This market has low liquidity, which may impact execution price for larger orders.",
+    insufficientBalanceDetails: "Insufficient balance details",
+    lowLiquidityWarning: "Your avg. price is higher than the market price due to your order size and available market liquidity.",
+    lowLiquiditySellWarning: "Your avg. price is lower than the market price due to your order size and available market liquidity.",
     refreshQuote: "Refresh Quote",
     confirmOrder: "Confirm Order",
     withdrawSubmitted: "Withdrawal submitted",
@@ -1251,6 +1281,12 @@ var enUsLabels = {
     limitPrice: "Limit price",
     limitPriceInputAria: "Limit price in cents",
     limitPriceInvalid: "Limit price must be greater than 0 and less than 100.",
+    limitPriceAdjusted: (venueLabels, tickSizeCents, originalPriceLabel, side, adjustedPriceLabel) => {
+      const venues = venueLabels.length <= 1 ? venueLabels.join("") : venueLabels.length === 2 ? `${venueLabels[0]} and ${venueLabels[1]}` : `${venueLabels.slice(0, -1).join(", ")} and ${venueLabels[venueLabels.length - 1]}`;
+      const increment = tickSizeCents === 1 ? "whole cents" : `${tickSizeCents.toLocaleString("en-US", { maximumFractionDigits: 4 })}\xA2 increments`;
+      const direction = side === "buy" ? "down" : "up";
+      return `${venues} price in ${increment}, so your ${originalPriceLabel} ${side} rounds ${direction} to ${adjustedPriceLabel}`;
+    },
     limitPriceDecreaseAria: "Decrease limit price",
     limitPriceIncreaseAria: "Increase limit price",
     expiration: "Expiration",
@@ -1294,9 +1330,23 @@ var enUsLabels = {
     updatingRoute: "Updating route\u2026",
     refreshingQuotes: "Refreshing quotes\u2026",
     checkingBalance: "Checking balance",
+    executingOrder: "Executing order...",
     submittingOrderProgress: "Submitting order...",
+    executionOrderSubmitted: "Order submitted",
     orderSubmittedProgress: (orderId) => `Order #${orderId.replace(/^#/, "")} submitted`,
     executingOnVenue: (venueLabel) => `Executing on ${venueLabel}...`,
+    venueOrder: (venueLabel) => `${venueLabel} order`,
+    settingUpBridge: "Setting up bridging...",
+    bridgeSetupComplete: "Bridge setup complete",
+    bridgingFundsProgress: "Bridging funds...",
+    bridgeComplete: "Bridge complete",
+    bridgingFunds: (amount, sourceChain, destinationChain, tokenSymbol = "USDC") => `Bridging ${amount} ${tokenSymbol} from ${sourceChain} to ${destinationChain}...`,
+    fundsBridged: (amount, sourceChain, destinationChain, tokenSymbol = "USDC") => `Bridged ${amount} ${tokenSymbol} from ${sourceChain} to ${destinationChain}`,
+    depositingFunds: (amount, tokenSymbol, destinationChain) => `Depositing ${amount} ${tokenSymbol} to ${destinationChain}...`,
+    fundsDeposited: (amount, tokenSymbol, destinationChain) => `Deposited ${amount} ${tokenSymbol} to ${destinationChain}`,
+    fillingOnVenue: (venueLabel) => `Filling on ${venueLabel}...`,
+    venueFilledAtPriceWithAmount: (venueLabel, amountLabel, priceLabel) => `${venueLabel} filled ${amountLabel} at ${priceLabel}`,
+    executionShares: (value) => `${value} shares`,
     confirmTransactionInWallet: "Confirm the transaction in your wallet",
     executionConfirmed: "Execution confirmed",
     orderSuccessTitle: "Order placed",
@@ -1304,7 +1354,7 @@ var enUsLabels = {
     orderFailureTitle: "Order failed",
     orderFailureDescription: (message) => message || "Something went wrong. Please try again.",
     orderDone: "Done",
-    orderNewTrade: "New Trade",
+    orderNewTrade: "New trade",
     orderShare: "Share",
     orderRetry: "Try again",
     orderContinue: "Continue",
@@ -1317,12 +1367,20 @@ var enUsLabels = {
     orderSummaryAvgPrice: "Avg. price",
     orderSummaryEstCost: "Est. cost",
     orderSummaryVenue: "Venue",
+    orderAmountFilled: "Amount filled",
+    orderAmountFilledOf: (requestedAmount) => `of ${requestedAmount}`,
+    orderPayout: "Payout",
+    orderFullyFilled: "Order fully filled",
+    orderPartiallyFilled: "Order partially filled",
+    orderAveragePrice: (priceLabel) => `avg. ${priceLabel}`,
     orderComplete: "Order complete",
     orderFilledAtPrice: (venueLabel, priceLabel) => `${venueLabel} order filled at ${priceLabel}`,
     orderFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order filled at ${priceLabel} (${amountLabel})`,
     orderPartiallyFilledAtPriceWithAmount: (venueLabel, priceLabel, amountLabel) => `${venueLabel} order partially filled at ${priceLabel} (${amountLabel})`,
     orderSkip: "Skip",
     orderRetryRemaining: "Retry remaining",
+    orderTryRemaining: (remainingLabel) => `Try remaining ${remainingLabel}`,
+    orderClose: "Close",
     resolvedEarningsTitle: "Your Earnings",
     resolvedResolutionDateLabel: "Resolution date",
     resolvedSharesLabel: "Shares",
@@ -1331,6 +1389,7 @@ var enUsLabels = {
     boughtOutcomeAtPrice: (label, priceLabel) => `Bought ${label} at ${priceLabel}`,
     soldOutcomeAtPrice: (label, priceLabel) => `Sold ${label} at ${priceLabel}`,
     potentialReturnBonus: (value) => `+${value} Better Payout`,
+    potentialReturnBetter: (value) => `+${value} Better`,
     withSmartRouting: "with Smart Routing",
     buy: "Buy",
     sell: "Sell",
@@ -1475,6 +1534,9 @@ var enUsLabels = {
     resolvedOutcome: (label) => `Resolved: ${label}`,
     marketDetailsAriaByDate: (dateLabel) => `Market details for ${dateLabel}`,
     marketDetailsAriaByQuestion: (question) => `Market details for ${question}`,
+    recurringCountdownAria: (countdown) => `Current market ends in ${countdown}`,
+    goToLive: "Go to live",
+    liveMarketUnavailable: "A live market is not available yet",
     sports: {
       summaryAria: "Sports event summary",
       sectionTabsAria: "Sports market sections",
@@ -2301,6 +2363,7 @@ function AggBalanceProvider({ children }) {
     if (!isAuthenticated) {
       return {
         managedBalances,
+        dataUpdatedAt: 0,
         totalBalance: 0,
         availableBalance: 0,
         reservedBalance: 0,
@@ -2319,6 +2382,7 @@ function AggBalanceProvider({ children }) {
     const error = balancesError instanceof Error ? balancesError : balancesError ? new Error(String(balancesError)) : null;
     return {
       managedBalances,
+      dataUpdatedAt: balancesQuery.dataUpdatedAt,
       totalBalance,
       availableBalance,
       reservedBalance,
@@ -2344,6 +2408,7 @@ function AggBalanceProvider({ children }) {
     kalshiBalance,
     kalshiPortfolioValue,
     managedBalances,
+    balancesQuery.dataUpdatedAt,
     positionsBalanceTotal,
     refetch,
     refetchConnectionStatus,
@@ -4142,7 +4207,7 @@ function useQueryClientCheck() {
     if (!hasWarnedMissingQueryClient) {
       hasWarnedMissingQueryClient = true;
       console.error(
-        "[agg] AggProvider requires a QueryClientProvider ancestor. Either wrap AggProvider in a <QueryClientProvider>, or use <AggProviders> which includes one automatically."
+        "[agg] AggProvider requires a QueryClientProvider ancestor. Wrap AggProvider in a <QueryClientProvider client={queryClient}>."
       );
     }
   }
@@ -4151,7 +4216,7 @@ var AggProvider = ({ client, config, children }) => {
   useQueryClientCheck();
   if (!client) {
     throw new Error(
-      "AggProvider requires a valid AggClient instance. Pass one via the 'client' prop, or use <AggProviders> which handles setup automatically."
+      "AggProvider requires a valid AggClient instance. Create one with createAggClient() and pass it via the 'client' prop."
     );
   }
   return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AggClientProvider, { client, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AggUiProvider, { config, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(EventListStateProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AggWebSocketProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AggAuthProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AggBalanceProvider, { children }) }) }) }) }) });
@@ -4386,6 +4451,118 @@ function mapOrderStatusToTerminalEvent(status) {
   if (status === "failed" || status === "cancelled" || status === "expired") return "failed";
   return null;
 }
+var mergeTerminalOrderEvents = (currentEvents, incomingEvents) => {
+  const mergedByOrderId = new Map(currentEvents.map((event) => [event.orderId, event]));
+  for (const incomingEvent of incomingEvents) {
+    const currentEvent = mergedByOrderId.get(incomingEvent.orderId);
+    if (!currentEvent) {
+      mergedByOrderId.set(incomingEvent.orderId, incomingEvent);
+      continue;
+    }
+    if (currentEvent.event === "filled") continue;
+    if (incomingEvent.event === "filled" || incomingEvent.timestamp >= currentEvent.timestamp) {
+      mergedByOrderId.set(incomingEvent.orderId, incomingEvent);
+    }
+  }
+  return [...mergedByOrderId.values()].sort((left, right) => left.timestamp - right.timestamp);
+};
+var EXECUTION_STEP_STATUS_RANK = {
+  pending: 0,
+  in_progress: 1,
+  failed: 2,
+  completed: 3,
+  skipped: 3
+};
+var getExecutionStepIdentity = (step) => [step.groupId, step.sequence, step.stepType, ...step.orderIds].join(":");
+var getExecutionGroupAttempt = (steps) => steps.reduce((highestAttempt, step) => Math.max(highestAttempt, step.attempt), 0);
+var groupExecutionStepsByGroupId = (steps) => {
+  var _a;
+  const groupedSteps = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    const existingSteps = (_a = groupedSteps.get(step.groupId)) != null ? _a : [];
+    existingSteps.push(step);
+    groupedSteps.set(step.groupId, existingSteps);
+  }
+  return groupedSteps;
+};
+var pickExecutionGroupPresentation = (step) => __spreadValues({
+  groupStatus: step.groupStatus,
+  label: step.label
+}, step.bridge ? { bridge: step.bridge } : {});
+var mergeExecutionStepProgress = (previous, incoming) => {
+  var _a, _b;
+  const previousByGroupId = groupExecutionStepsByGroupId(previous);
+  const incomingByGroupId = groupExecutionStepsByGroupId(incoming);
+  const mergedByIdentity = new Map(previous.map((step) => [getExecutionStepIdentity(step), step]));
+  for (const step of incoming) {
+    const identity = getExecutionStepIdentity(step);
+    const current = mergedByIdentity.get(identity);
+    if (!current || step.attempt > current.attempt) {
+      mergedByIdentity.set(identity, step);
+      continue;
+    }
+    if (step.attempt < current.attempt) continue;
+    if (EXECUTION_STEP_STATUS_RANK[step.status] < EXECUTION_STEP_STATUS_RANK[current.status]) {
+      continue;
+    }
+    mergedByIdentity.set(identity, step);
+  }
+  const groupPresentation = /* @__PURE__ */ new Map();
+  const groupIds = /* @__PURE__ */ new Set([...previousByGroupId.keys(), ...incomingByGroupId.keys()]);
+  for (const groupId of groupIds) {
+    const previousGroup = (_a = previousByGroupId.get(groupId)) != null ? _a : [];
+    const incomingGroup = (_b = incomingByGroupId.get(groupId)) != null ? _b : [];
+    const previousStep = previousGroup[0];
+    const incomingStep = incomingGroup[0];
+    if (!previousStep && incomingStep) {
+      groupPresentation.set(groupId, pickExecutionGroupPresentation(incomingStep));
+      continue;
+    }
+    if (!incomingStep && previousStep) {
+      groupPresentation.set(groupId, pickExecutionGroupPresentation(previousStep));
+      continue;
+    }
+    if (!previousStep || !incomingStep) continue;
+    const isNewerAttempt = getExecutionGroupAttempt(incomingGroup) > getExecutionGroupAttempt(previousGroup);
+    const shouldUseIncoming = isNewerAttempt || EXECUTION_STEP_STATUS_RANK[incomingStep.groupStatus] >= EXECUTION_STEP_STATUS_RANK[previousStep.groupStatus];
+    groupPresentation.set(
+      groupId,
+      pickExecutionGroupPresentation(shouldUseIncoming ? incomingStep : previousStep)
+    );
+  }
+  return Array.from(mergedByIdentity.values()).map((step) => __spreadValues(__spreadValues({}, step), groupPresentation.get(step.groupId))).sort((left, right) => {
+    if (left.sequence !== right.sequence) return left.sequence - right.sequence;
+    return getExecutionStepIdentity(left).localeCompare(getExecutionStepIdentity(right));
+  });
+};
+var mergeRawExecutionStepProgress = (previous, incoming) => {
+  const mergedBySequence = new Map(previous.map((step) => [step.sequence, step]));
+  for (const step of incoming) {
+    const current = mergedBySequence.get(step.sequence);
+    if (!current || step.attempt > current.attempt) {
+      mergedBySequence.set(step.sequence, step);
+      continue;
+    }
+    if (step.attempt < current.attempt) continue;
+    if (EXECUTION_STEP_STATUS_RANK[step.status] < EXECUTION_STEP_STATUS_RANK[current.status]) {
+      continue;
+    }
+    mergedBySequence.set(step.sequence, step);
+  }
+  return Array.from(mergedBySequence.values()).sort(
+    (left, right) => left.sequence - right.sequence
+  );
+};
+var mergeExecutionStatusOrders = (previous, incoming) => {
+  const mergedByOrderId = new Map(previous.map((order) => [order.orderId, order]));
+  for (const order of incoming) {
+    const current = mergedByOrderId.get(order.orderId);
+    if (!current || new Date(order.updatedAt).getTime() >= new Date(current.updatedAt).getTime()) {
+      mergedByOrderId.set(order.orderId, order);
+    }
+  }
+  return Array.from(mergedByOrderId.values());
+};
 function useExecutionProgress({
   orderIds,
   quoteId,
@@ -4397,6 +4574,9 @@ function useExecutionProgress({
   const [latestBalance, setLatestBalance] = (0, import_react10.useState)(null);
   const [dagProgress, setDagProgress] = (0, import_react10.useState)(null);
   const [terminalOrderEvents, setTerminalOrderEvents] = (0, import_react10.useState)([]);
+  const [executionSteps, setExecutionSteps] = (0, import_react10.useState)([]);
+  const [rawExecutionSteps, setRawExecutionSteps] = (0, import_react10.useState)([]);
+  const [executionOrders, setExecutionOrders] = (0, import_react10.useState)([]);
   const orderIdSetRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
   const submittedOrderVenueByIdRef = (0, import_react10.useRef)(/* @__PURE__ */ new Map());
   (0, import_react10.useEffect)(() => {
@@ -4409,9 +4589,21 @@ function useExecutionProgress({
       setLatestBalance(null);
       setDagProgress(null);
       setTerminalOrderEvents([]);
+      setExecutionSteps([]);
+      setRawExecutionSteps([]);
+      setExecutionOrders([]);
       submittedOrderVenueByIdRef.current = /* @__PURE__ */ new Map();
     } else if (!enabled) {
       setPhase("idle");
+      if (!orderIds || orderIds.length === 0) {
+        setSubmittedOrders([]);
+        setLatestBalance(null);
+        setDagProgress(null);
+        setTerminalOrderEvents([]);
+        setExecutionSteps([]);
+        setRawExecutionSteps([]);
+        setExecutionOrders([]);
+      }
       submittedOrderVenueByIdRef.current = /* @__PURE__ */ new Map();
     }
   }, [enabled, orderIds]);
@@ -4463,13 +4655,7 @@ function useExecutionProgress({
         errorReason: (_a = msg.errorReason) != null ? _a : fallbackErrorReason,
         timestamp: msg.timestamp
       };
-      setTerminalOrderEvents((prev) => {
-        const nextEvents = [
-          ...prev.filter((terminalEvent) => terminalEvent.orderId !== msg.orderId),
-          nextTerminalEvent
-        ];
-        return nextEvents.sort((left, right) => left.timestamp - right.timestamp);
-      });
+      setTerminalOrderEvents((previous) => mergeTerminalOrderEvents(previous, [nextTerminalEvent]));
       return;
     }
     if (event === "dag_started") {
@@ -4489,20 +4675,53 @@ function useExecutionProgress({
         status: "running",
         errorReason: null
       });
+      setRawExecutionSteps(
+        (previous) => mergeRawExecutionStepProgress(
+          previous,
+          Object.entries(initialStepTypes).map(([sequence, stepType]) => ({
+            sequence: Number(sequence),
+            stepType,
+            status: "pending",
+            attempt: 0,
+            startedAt: null,
+            completedAt: null,
+            errorReason: null
+          }))
+        )
+      );
       return;
     }
-    if (event === "step_started") {
+    if (event === "step_started" || event === "step_retrying") {
       setDagProgress((prev) => {
         var _a2, _b2;
         if (!prev) return prev;
         const seq = (_a2 = msg.sequence) != null ? _a2 : prev.currentSequence;
-        const stepType = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
+        const stepType2 = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
         return __spreadProps(__spreadValues({}, prev), {
           currentSequence: seq,
-          currentStepType: stepType,
-          stepTypes: stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+          currentStepType: stepType2,
+          stepTypes: stepType2 != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType2 }) : prev.stepTypes
         });
       });
+      const { sequence, stepType } = msg;
+      if (sequence != null && stepType) {
+        setRawExecutionSteps(
+          (previous) => {
+            var _a2, _b2, _c2;
+            return mergeRawExecutionStepProgress(previous, [
+              {
+                sequence,
+                stepType,
+                status: "in_progress",
+                attempt: (_c2 = (_b2 = msg.attempt) != null ? _b2 : (_a2 = previous.find((step) => step.sequence === sequence)) == null ? void 0 : _a2.attempt) != null ? _c2 : 0,
+                startedAt: new Date(msg.timestamp).toISOString(),
+                completedAt: null,
+                errorReason: null
+              }
+            ]);
+          }
+        );
+      }
       return;
     }
     if (event === "step_waiting") {
@@ -4510,25 +4729,64 @@ function useExecutionProgress({
         var _a2, _b2;
         if (!prev) return prev;
         const seq = (_a2 = msg.sequence) != null ? _a2 : prev.currentSequence;
-        const stepType = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
+        const stepType2 = (_b2 = msg.stepType) != null ? _b2 : prev.currentStepType;
         return __spreadProps(__spreadValues({}, prev), {
           currentSequence: seq,
-          currentStepType: stepType,
-          stepTypes: stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+          currentStepType: stepType2,
+          stepTypes: stepType2 != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType2 }) : prev.stepTypes
         });
       });
+      const { sequence, stepType } = msg;
+      if (sequence != null && stepType) {
+        setRawExecutionSteps(
+          (previous) => {
+            var _a2, _b2, _c2;
+            return mergeRawExecutionStepProgress(previous, [
+              {
+                sequence,
+                stepType,
+                status: "in_progress",
+                attempt: (_c2 = (_b2 = msg.attempt) != null ? _b2 : (_a2 = previous.find((step) => step.sequence === sequence)) == null ? void 0 : _a2.attempt) != null ? _c2 : 0,
+                startedAt: new Date(msg.timestamp).toISOString(),
+                completedAt: null,
+                errorReason: null
+              }
+            ]);
+          }
+        );
+      }
       return;
     }
     if (event === "step_completed") {
       setDagProgress((prev) => {
         if (!prev) return prev;
         const seq = msg.sequence;
-        const stepType = msg.stepType;
+        const stepType2 = msg.stepType;
         return __spreadProps(__spreadValues({}, prev), {
           completedSequences: seq != null ? [...prev.completedSequences, seq] : prev.completedSequences,
-          stepTypes: seq != null && stepType != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType }) : prev.stepTypes
+          stepTypes: seq != null && stepType2 != null ? __spreadProps(__spreadValues({}, prev.stepTypes), { [seq]: stepType2 }) : prev.stepTypes
         });
       });
+      const { sequence, stepType } = msg;
+      if (sequence != null && stepType) {
+        const completedAt = new Date(msg.timestamp).toISOString();
+        setRawExecutionSteps(
+          (previous) => {
+            var _a2, _b2, _c2;
+            return mergeRawExecutionStepProgress(previous, [
+              {
+                sequence,
+                stepType,
+                status: "completed",
+                attempt: (_c2 = (_b2 = msg.attempt) != null ? _b2 : (_a2 = previous.find((step) => step.sequence === sequence)) == null ? void 0 : _a2.attempt) != null ? _c2 : 0,
+                startedAt: null,
+                completedAt,
+                errorReason: null
+              }
+            ]);
+          }
+        );
+      }
       return;
     }
     if (event === "dag_completed") {
@@ -4557,6 +4815,25 @@ function useExecutionProgress({
     };
     if (event === "step_failed") {
       setDagProgress((prev) => buildFailedProgress(prev));
+      const { sequence, stepType } = msg;
+      if (sequence != null && stepType) {
+        setRawExecutionSteps(
+          (previous) => {
+            var _a2, _b2, _c2, _d;
+            return mergeRawExecutionStepProgress(previous, [
+              {
+                sequence,
+                stepType,
+                status: "failed",
+                attempt: (_c2 = (_b2 = msg.attempt) != null ? _b2 : (_a2 = previous.find((step) => step.sequence === sequence)) == null ? void 0 : _a2.attempt) != null ? _c2 : 0,
+                startedAt: null,
+                completedAt: new Date(msg.timestamp).toISOString(),
+                errorReason: (_d = msg.errorReason) != null ? _d : null
+              }
+            ]);
+          }
+        );
+      }
       return;
     }
     if (event === "dag_failed") {
@@ -4565,7 +4842,7 @@ function useExecutionProgress({
     }
   }, []);
   const isStatusPolling = enabled && !!quoteId;
-  const isListening = !isStatusPolling && enabled && !!orderIds && orderIds.length > 0;
+  const isListening = enabled && !!orderIds && orderIds.length > 0;
   useOnOrderSubmitted(isListening ? handleOrderSubmitted : null);
   useOnBalanceUpdate(isListening ? handleBalanceUpdate : null);
   useOnOrderEvent(isListening ? handleOrderEvent : null);
@@ -4611,19 +4888,25 @@ function useExecutionProgress({
           timestamp: new Date(order.updatedAt).getTime() || fallbackTimestamp
         };
       }).filter((order) => order != null);
-      if (!status.terminal || terminalEvents.length > 0 || !["failed", "cancelled", "expired"].includes(status.overallState)) {
+      if (!status.terminal) {
         return terminalEvents;
       }
-      return fallbackOrderIds.map((orderId) => {
-        var _a;
-        return {
-          orderId,
-          venue: "",
-          event: "failed",
-          errorReason: (_a = status.errorReason) != null ? _a : "Execution failed.",
-          timestamp: fallbackTimestamp
-        };
-      });
+      const coveredOrderIds = new Set(terminalEvents.map((event) => event.orderId));
+      const fallbackEvent = status.overallState === "filled" ? "filled" : status.overallState === "partially_filled" ? "partial_fill" : ["failed", "cancelled", "expired"].includes(status.overallState) ? "failed" : null;
+      if (!fallbackEvent) return terminalEvents;
+      return [
+        ...terminalEvents,
+        ...fallbackOrderIds.filter((orderId) => !coveredOrderIds.has(orderId)).map((orderId) => {
+          var _a;
+          return {
+            orderId,
+            venue: "",
+            event: fallbackEvent,
+            errorReason: fallbackEvent === "failed" ? (_a = status.errorReason) != null ? _a : "Execution failed." : void 0,
+            timestamp: fallbackTimestamp
+          };
+        })
+      ];
     },
     []
   );
@@ -4691,6 +4974,7 @@ function useExecutionProgress({
           setPhase("order_submitted");
         }
         setSubmittedOrders(buildSubmittedOrdersFromStatus(status.orders));
+        setExecutionOrders((previous) => mergeExecutionStatusOrders(previous, status.orders));
         if (status.dagProgress) {
           setDagProgress(__spreadProps(__spreadValues({}, status.dagProgress), {
             stepTypes: Object.fromEntries(
@@ -4715,13 +4999,30 @@ function useExecutionProgress({
             };
           });
         }
+        setExecutionSteps((previous) => mergeExecutionStepProgress(previous, status.steps));
+        setRawExecutionSteps(
+          (previous) => mergeRawExecutionStepProgress(
+            previous,
+            status.steps.map((step) => ({
+              sequence: step.sequence,
+              stepType: step.stepType,
+              status: step.status,
+              attempt: step.attempt,
+              startedAt: step.startedAt,
+              completedAt: step.completedAt,
+              errorReason: step.errorReason
+            }))
+          )
+        );
         const fallbackTimestamp = Date.now();
         const nextTerminalEvents = buildTerminalEventsFromStatus(
           status,
           resolvedOrderIds,
           fallbackTimestamp
         );
-        setTerminalOrderEvents(nextTerminalEvents);
+        setTerminalOrderEvents(
+          (previous) => mergeTerminalOrderEvents(previous, nextTerminalEvents)
+        );
         if (status.terminal) {
           stopPolling();
           return;
@@ -4816,17 +5117,7 @@ function useExecutionProgress({
           });
         }
         if (terminalEvents.length > 0) {
-          setTerminalOrderEvents((prev) => {
-            const nextById = /* @__PURE__ */ new Map();
-            for (const ev of prev) nextById.set(ev.orderId, ev);
-            for (const ev of terminalEvents) {
-              const existing = nextById.get(ev.orderId);
-              if (!existing || existing.timestamp < ev.timestamp) {
-                nextById.set(ev.orderId, ev);
-              }
-            }
-            return Array.from(nextById.values()).sort((l, r) => l.timestamp - r.timestamp);
-          });
+          setTerminalOrderEvents((previous) => mergeTerminalOrderEvents(previous, terminalEvents));
         }
         const covered = /* @__PURE__ */ new Set([
           ...terminalOrderIdsRef.current,
@@ -4848,7 +5139,16 @@ function useExecutionProgress({
       stopPolling();
     };
   }, [client, isListening, isStatusPolling, mode, orderIds]);
-  return { phase, submittedOrders, latestBalance, dagProgress, terminalOrderEvents };
+  return {
+    phase,
+    submittedOrders,
+    latestBalance,
+    dagProgress,
+    terminalOrderEvents,
+    executionSteps,
+    rawExecutionSteps,
+    executionOrders
+  };
 }
 
 // src/execution/use-balance-refill-policies.ts
@@ -5851,6 +6151,7 @@ function useExecutionOrders(options = {}) {
   const client = useAggClient();
   const {
     status,
+    orderType,
     orderId,
     quoteId,
     mode,
@@ -5866,11 +6167,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 } : {}), {
@@ -7817,7 +8120,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,
@@ -7832,6 +8135,7 @@ function useSmartRoute(options) {
     slipCapBps,
     compareVenues,
     sellCacheScope,
+    balanceCacheScope,
     deepEstimate,
     enabled = true,
     staleTimeMs = SMART_ROUTE_STALE_TIME_MS,
@@ -7853,7 +8157,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(
@@ -7910,7 +8215,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,
@@ -7933,6 +8238,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();
@@ -7954,6 +8280,15 @@ var useLimitOrderVenueQuotes = (options) => {
   const hasRequiredAccount = tradeSide === "buy" || Boolean(accountId);
   const queryEnabled = enabled && hasValidInput && hasRequiredAccount;
   const serializedChainBalances = chainBalances ? JSON.stringify(chainBalances) : null;
+  const tickMetadataQuery = (0, import_react_query36.useQuery)({
+    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 = (0, import_react_query36.useQueries)({
     queries: uniqueRequests.map((request) => ({
       queryKey: [
@@ -8008,12 +8343,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,
@@ -8025,7 +8363,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())
+    ])
   };
 };
 
@@ -8178,25 +8519,566 @@ function useUserHoldings(options) {
 var import_react34 = require("react");
 
 // src/use-venue-event.ts
+var import_react_query40 = require("@tanstack/react-query");
+
+// src/use-recurring-crypto-markets.ts
 var import_react_query39 = require("@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 = (0, import_react_query39.useQuery)({
+    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 = (0, import_react_query39.useQuery)({
+  const query = (0, import_react_query40.useQuery)({
     queryKey: ["venue-event", eventId],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       return client.getVenueEventById(eventId, { signal });
@@ -8216,13 +9098,13 @@ function useVenueEvent(options) {
 }
 
 // src/use-venue-markets.ts
-var import_react_query40 = require("@tanstack/react-query");
+var import_react_query41 = require("@tanstack/react-query");
 var import_react33 = require("react");
 function useVenueMarkets(options) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const client = (0, import_react33.useContext)(AggClientContext);
-  const queryClient = (0, import_react33.useContext)(import_react_query40.QueryClientContext);
-  const [fallbackQueryClient] = (0, import_react33.useState)(() => new import_react_query40.QueryClient());
+  const queryClient = (0, import_react33.useContext)(import_react_query41.QueryClientContext);
+  const [fallbackQueryClient] = (0, import_react33.useState)(() => new import_react_query41.QueryClient());
   const venue = options == null ? void 0 : options.venue;
   const venueEventId = options == null ? void 0 : options.venueEventId;
   const search = options == null ? void 0 : options.search;
@@ -8249,7 +9131,7 @@ function useVenueMarkets(options) {
   if (enabled && !client) {
     throw new Error("useVenueMarkets must be used within an <AggProvider>");
   }
-  const query = (0, import_react_query40.useInfiniteQuery)(
+  const query = (0, import_react_query41.useInfiniteQuery)(
     {
       queryKey: [
         "venue-markets",
@@ -8370,13 +9252,13 @@ function useEnrichedVenueEvent(options) {
 }
 
 // src/use-venue-events.ts
-var import_react_query41 = require("@tanstack/react-query");
+var import_react_query42 = require("@tanstack/react-query");
 var import_react35 = require("react");
 function useVenueEvents(options) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const client = (0, import_react35.useContext)(AggClientContext);
-  const queryClient = (0, import_react35.useContext)(import_react_query41.QueryClientContext);
-  const [fallbackQueryClient] = (0, import_react35.useState)(() => new import_react_query41.QueryClient());
+  const queryClient = (0, import_react35.useContext)(import_react_query42.QueryClientContext);
+  const [fallbackQueryClient] = (0, import_react35.useState)(() => new import_react_query42.QueryClient());
   const venues = options == null ? void 0 : options.venues;
   const search = options == null ? void 0 : options.search;
   const categoryIds = options == null ? void 0 : options.categoryIds;
@@ -8403,7 +9285,7 @@ function useVenueEvents(options) {
   if (enabled && !client) {
     throw new Error("useVenueEvents must be used within an <AggProvider>");
   }
-  const query = (0, import_react_query41.useInfiniteQuery)(
+  const query = (0, import_react_query42.useInfiniteQuery)(
     {
       queryKey: [
         queryKeyScope,
@@ -8450,7 +9332,7 @@ function useVenueEvents(options) {
         return (_a2 = lastPage.nextCursor) != null ? _a2 : void 0;
       },
       // TODO: RMIK - Comment out to show skeletons on category switch
-      placeholderData: import_react_query41.keepPreviousData,
+      placeholderData: import_react_query42.keepPreviousData,
       enabled: enabled && !!client
     },
     queryClient != null ? queryClient : fallbackQueryClient
@@ -8491,8 +9373,48 @@ function useVenueEvents(options) {
   });
 }
 
+// src/use-sports-live.ts
+var import_react_query43 = require("@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 = (0, import_react_query43.useQuery)({
+    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
-var import_react_query42 = require("@tanstack/react-query");
+var import_react_query44 = require("@tanstack/react-query");
 var normalizeVenueMarketIds2 = (venueMarketIds) => {
   return [
     ...new Set(venueMarketIds.map((venueMarketId) => venueMarketId.trim()).filter(Boolean))
@@ -8531,7 +9453,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 = (0, import_react_query42.useQuery)({
+  const query = (0, import_react_query44.useQuery)({
     queryKey: requestedVenueMarketIds.length ? ["venue-market-midpoints", requestedVenueMarketIds, maxMidpointIdsPerRequest] : ["venue-market-midpoints", "__disabled__"],
     queryFn: (_0) => __async(null, [_0], function* ({ signal }) {
       if (requestedVenueMarketIds.length === 0) {
@@ -8547,7 +9469,7 @@ function useVenueMarketMidpoints(options) {
     gcTime: 5 * 6e4,
     refetchOnWindowFocus: false,
     retry: 1,
-    placeholderData: import_react_query42.keepPreviousData
+    placeholderData: import_react_query44.keepPreviousData
   });
   const midpointRows = (_d = (_c = query.data) == null ? void 0 : _c.data) != null ? _d : [];
   const midpointsByVenueMarketId = mapMidpointsByVenueMarketId(midpointRows);
@@ -8798,12 +9720,12 @@ function useVisibleIds(options = {}) {
 }
 
 // src/use-app-config.ts
-var import_react_query43 = require("@tanstack/react-query");
+var import_react_query45 = require("@tanstack/react-query");
 var FIVE_MINUTES = 5 * 60 * 1e3;
 var APP_CONFIG_QUERY_KEY = ["agg", "app-config"];
 function useAppConfig() {
   const client = useAggClient();
-  const query = (0, import_react_query43.useQuery)({
+  const query = (0, import_react_query45.useQuery)({
     queryKey: APP_CONFIG_QUERY_KEY,
     queryFn: () => client.getAppConfig(),
     staleTime: FIVE_MINUTES
@@ -8815,8 +9737,8 @@ function useAppConfig() {
   });
 }
 function useCachedAppConfig() {
-  const queryClient = (0, import_react_query43.useQueryClient)();
-  const query = (0, import_react_query43.useQuery)({
+  const queryClient = (0, import_react_query45.useQueryClient)();
+  const query = (0, import_react_query45.useQuery)({
     queryKey: APP_CONFIG_QUERY_KEY,
     enabled: false,
     initialData: () => queryClient.getQueryData(APP_CONFIG_QUERY_KEY),
@@ -8858,6 +9780,8 @@ var toAppConfigResult = (query) => {
   QueryClient,
   QueryClientProvider,
   RedeemRejectedError,
+  SPORTS_LIVE_POLL_INTERVAL_MS,
+  SPORTS_SCHEDULED_POLL_INTERVAL_MS,
   TradeSide,
   TurnstileChallengeError,
   Venue,
@@ -8868,6 +9792,7 @@ var toAppConfigResult = (query) => {
   defaultSdkUiConfig,
   executionKeys,
   extractOutcomeBestCandidate,
+  fetchRecurringCryptoMarkets,
   findLivePriceById,
   getBuilder,
   getDepositAddress,
@@ -8883,11 +9808,13 @@ var toAppConfigResult = (query) => {
   invalidateUserMoneyState,
   isVenueDisabledByConfig,
   mergeBestPricesPreferringLive,
+  mergeRecurringCryptoWindows,
   normalizeVenueId,
   optimizedImageUrl,
   parseEmail,
   parseEmailStrict,
   rangeToSeconds,
+  recurringCryptoTransitionPollInterval,
   requestAggAuthChooserOpen,
   resolveAggUiLabels,
   resolveDefaultTradingMarket,
@@ -8895,9 +9822,13 @@ var toAppConfigResult = (query) => {
   resolveMarketTradingState,
   resolveMarketWinningOutcome,
   resolveOrderEligibility,
+  resolveRecurringCryptoIdentity,
+  resolveRecurringCryptoTimeline,
   resolveRollingWindow,
   resolveTradingStateKind,
   sortVenues,
+  sportsLiveQueryKey,
+  sportsLiveRefetchInterval,
   timeRangeToInterval,
   tradingReducer,
   useAggAuth,
@@ -8960,6 +9891,7 @@ var toAppConfigResult = (query) => {
   useQueryClient,
   useRampQuotes,
   useRampSession,
+  useRecurringCryptoMarkets,
   useRedeem,
   useRedeemEligibleCount,
   useRedeemLifecycle,
@@ -8969,6 +9901,7 @@ var toAppConfigResult = (query) => {
   useSdkUiConfig,
   useSearch,
   useSmartRoute,
+  useSportsLive,
   useSyncBalances,
   useUserActivity,
   useUserHoldings,