@agg-build/hooks 1.0.0 → 1.0.1

package/dist/withdraw.js

@@ -0,0 +1,1402 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/withdraw/index.ts
+var withdraw_exports = {};
+__export(withdraw_exports, {
+  useDepositAddresses: () => useDepositAddresses,
+  useManagedBalances: () => useManagedBalances,
+  useWithdrawFlow: () => useWithdrawFlow,
+  useWithdrawManaged: () => useWithdrawManaged,
+  useWithdrawalLifecycle: () => useWithdrawalLifecycle
+});
+module.exports = __toCommonJS(withdraw_exports);
+
+// src/withdraw/use-withdraw-flow.ts
+var import_react5 = require("react");
+
+// src/core/providers/contexts.ts
+var import_react = require("react");
+
+// src/core/ui-config/labels.ts
+var enUsLabels = {
+  common: {
+    close: "Close",
+    loading: "Loading",
+    retry: "Retry",
+    errorPrefix: "Error",
+    tabsAria: "Tabs",
+    hiddenTabsAria: "Hidden tabs",
+    selectAria: "Select",
+    lineChartAria: "Line chart",
+    candlestickChartAria: "Candlestick chart",
+    lineChartSeriesSwitchAria: "Chart series switch",
+    lineChartSeriesOptionAria: (seriesLabel) => `Show ${seriesLabel} series`,
+    chartTypeSwitchAria: "Chart type switch",
+    lineChartType: "Line",
+    candlestickChartType: "Candlestick"
+  },
+  venues: {
+    polymarket: "Polymarket",
+    kalshi: "Kalshi",
+    opinion: "Opinion",
+    predict: "Predict",
+    limitless: "Limitless",
+    probable: "Probable",
+    myriad: "Myriad",
+    hyperliquid: "Hyperliquid"
+  },
+  auth: {
+    connect: (connectorName) => connectorName ? `Sign in with ${connectorName}` : "Sign in",
+    signIn: "Sign in",
+    signingIn: "Signing in...",
+    signInStatement: "Sign in to AGG",
+    emailAddress: "Email address",
+    continue: "Continue",
+    emailUnavailable: "Email sign-in is currently unavailable.",
+    signInWithMethod: (methodLabel) => `Sign in with ${methodLabel}`,
+    socialWalletNotice: "A wallet will automatically be created for you when signing up with a social account.",
+    learnMore: "Learn more",
+    dividerOr: "OR",
+    connectWallet: "Connect wallet",
+    terms: "Terms",
+    privacyPolicy: "Privacy Policy",
+    legalNoticePrefix: "By signing in, you agree to our",
+    legalNoticeSeparator: "&",
+    deposit: "Deposit",
+    depositGeoBlocked: "Deposits are not available in your region.",
+    balances: "Balances",
+    viewAll: "View All",
+    loadingBalances: "Loading balances...",
+    myProfile: "My Profile",
+    withdraw: "Withdraw",
+    disconnect: "Disconnect",
+    claimWinnings: "Claim Now",
+    claimableWinningsBadge: (count) => `${count} claimable winning${count === 1 ? "" : "s"}`,
+    claimableWinningsTooltip: (count) => `${count} position${count === 1 ? "" : "s"} ready to claim`,
+    walletMenuFor: (profileLabel) => `Profile menu for ${profileLabel}`
+  },
+  deposit: {
+    title: "Deposit",
+    back: "Go back",
+    balancePrefix: "Balance:",
+    balanceLabel: "Balance",
+    done: "Done",
+    methods: {
+      walletTitle: (walletLabel) => `Use your wallet (${walletLabel})`,
+      walletDescription: "Deposit instantly from your connected wallet",
+      cryptoTitle: "Send crypto",
+      cryptoDescription: "Transfer from any wallet or exchange",
+      cardTitle: "Deposit with card",
+      cardDescription: "Buy crypto instantly with your card"
+    },
+    walletFlow: {
+      title: "Use your wallet",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      amountLabel: "Amount",
+      max: "Max",
+      feePrefix: "Fee ~",
+      confirm: "Confirm Deposit"
+    },
+    sendCrypto: {
+      title: "Send crypto",
+      tokenLabel: "Supported token",
+      networkLabel: "Supported network",
+      depositAddressLabel: "Your deposit address",
+      copy: "Copy",
+      copied: "Copied!",
+      minDepositPrefix: "Min deposit",
+      warning: "Send only the selected token on the selected network. Wrong token or network may results in permanently lost funds.",
+      qrPlaceholder: "QR code placeholder",
+      addressLoadingTitle: "Preparing your deposit address...",
+      addressLoadingDescription: "We're generating your address, this usually takes a few seconds."
+    },
+    cardFlow: {
+      title: "Buy crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      minRequired: (amount) => `Min required: ${amount}`,
+      minAmountError: (amount) => `Enter at least ${amount} to continue`,
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Purchase complete",
+      successDescription: "Your USDC has been successfully added to your balance.",
+      pendingTitle: (provider) => `Complete your payment on ${provider}`,
+      pendingDescription: "Once your transaction is finished, your balance may take a few minutes to update. The deposit will appear in your activity once it's successful.",
+      pendingWalletAddressHelp: "Some providers may ask for a wallet address during checkout, use this one to receive your deposit:",
+      pendingCopyAddress: "Copy deposit address",
+      viewActivity: "View Activity",
+      chooseAnotherProvider: "Choose another provider",
+      summary: {
+        provider: "Provider",
+        fees: "Fees"
+      },
+      loadingQuotes: "Finding the best rates...",
+      errorLoadingQuotesTitle: "Failed to load quotes",
+      errorLoadingQuotesDescription: "Please try again.",
+      retry: "Retry",
+      noQuotes: "No quotes available for this configuration.",
+      widgetTitle: "Complete Purchase"
+    },
+    processingTitle: "Processing deposit",
+    processingSteps: {
+      submitting: "Waiting for wallet confirmation",
+      submitted: "Wallet confirmed",
+      confirming: "Processing transaction\u2026",
+      updatingBalance: "Updating balance",
+      fundsAvailable: "Funds available"
+    },
+    successTitle: "Deposit complete",
+    successDescription: "Your USDC has been successfully added to your balance.",
+    summary: {
+      amountReceived: "Amount received",
+      network: "Network",
+      fromWallet: "From wallet",
+      gasFee: "Gas fee"
+    }
+  },
+  withdraw: {
+    title: "Withdraw",
+    back: "Go back",
+    done: "Done",
+    balancePrefix: "Balance:",
+    methods: {
+      walletTitle: "Withdraw to wallet",
+      walletDescription: "Withdraw funds instantly to your crypto wallet",
+      cardTitle: "Withdraw with card",
+      cardDescription: "Withdraw funds to your card"
+    },
+    walletFlow: {
+      title: "Withdraw to wallet",
+      recipientAddressLabel: "Recipient address",
+      amountLabel: "Amount",
+      max: "Max",
+      tokenLabel: "Receive token",
+      networkLabel: "Receive network",
+      confirm: "Confirm withdrawal",
+      successTitle: "Withdrawal submitted",
+      successDescription: (tokenSymbol) => `Your ${tokenSymbol} withdrawal is being processed and will arrive shortly.`,
+      // Terminal-state copy. The success step swaps `successTitle` /
+      // `successDescription` for these once the lifecycle has reached a
+      // terminal status — otherwise a finished withdrawal would keep showing
+      // "submitted / processing" forever and force the user to hard-refresh.
+      successTitleCompleted: "Withdrawal complete",
+      successDescriptionCompleted: (tokenSymbol) => `Your ${tokenSymbol} withdrawal has been delivered.`,
+      successTitlePartial: "Withdrawal partially completed",
+      successDescriptionPartial: (tokenSymbol) => `Some legs of your ${tokenSymbol} withdrawal completed; see details below.`,
+      successTitleFailed: "Withdrawal failed",
+      successDescriptionFailed: (tokenSymbol) => `Your ${tokenSymbol} withdrawal could not be completed.`,
+      summary: {
+        // The response is `pricingStatus: "unquoted"` — we don't know net
+        // output until on-chain settlement. Calling this "Amount received"
+        // would imply receipt before the lifecycle has confirmed. Keep it
+        // honest as the submitted amount until the multi-stable quote
+        // layer (PR-E) populates `expected.outputRaw`.
+        amountReceived: "Amount",
+        network: "Network",
+        toWallet: "To wallet",
+        fees: "Fees"
+      },
+      lifecycle: {
+        pending: "Submitted \u2014 preparing your withdrawal\u2026",
+        bridging: "Bridging funds across chains\u2026",
+        transferring: "Transferring to your wallet\u2026",
+        completed: "Withdrawal complete.",
+        partial: "Withdrawal partially completed \u2014 see details below.",
+        failed: "Withdrawal failed.",
+        steps: {
+          bridge: (sourceChainName, destChainName) => `Bridging from ${sourceChainName} to ${destChainName}`,
+          transfer: (destChainName) => `Transferring on ${destChainName}`
+        }
+      }
+    },
+    cardFlow: {
+      title: "Sell crypto",
+      amountLabel: "Amount",
+      currencyLabel: "Currency",
+      tokenLabel: "Token",
+      networkLabel: "Network",
+      destinationWalletLabel: "Destination wallet",
+      getQuotes: "Get Quotes",
+      selectProviderTitle: "Select provider",
+      feeLabel: "Fee",
+      providerBadges: {
+        best: "BEST",
+        lowKyc: "LOW KYC"
+      },
+      successTitle: "Withdrawal complete",
+      successDescription: "Your USDC has been successfully sent to your wallet.",
+      summary: {
+        provider: "Provider",
+        toWallet: "To wallet",
+        fees: "Fees"
+      }
+    },
+    summary: {
+      // Lifecycle-honest: until quoting is live (PR-E) the response is
+      // `pricingStatus: "unquoted"` so this is the submitted amount, not
+      // a guaranteed net output.
+      amountReceived: "Amount",
+      network: "Network"
+    }
+  },
+  markets: {
+    emptyNoOpen: "No open markets available.",
+    emptyResolved: "This event has been resolved."
+  },
+  home: {
+    trending: "Trending",
+    topMarkets: "Top Markets",
+    newMarkets: "New Markets",
+    categoryTabsAria: "Home page category tabs"
+  },
+  userProfile: {
+    activity: {
+      depositType: "Deposit",
+      withdrawalType: "Withdrawal",
+      depositTitles: {
+        connectedWallet: "Deposit from connected wallet",
+        externalWallet: "Deposit from external wallet",
+        card: "Deposit with card"
+      },
+      // Activity-row title for any withdrawal regardless of lifecycle
+      // state (pending / completed / failed) — render the asset rather
+      // than implying success. The ActivityRow renders a separate status
+      // chip when the row is failed.
+      withdrawalTitle: (tokenSymbol) => `Withdraw ${tokenSymbol}`
+    },
+    positions: {
+      totalTradedHeader: "Total traded",
+      amountWonHeader: "Amount won",
+      claimHeader: "Claim",
+      claim: "Claim",
+      claimed: "Claimed",
+      pending: "Pending",
+      won: "Won",
+      lost: "Lost",
+      resolved: "Resolved",
+      marketClosed: "Market closed",
+      closed: "Closed"
+    }
+  },
+  eventList: {
+    matchedTab: "Matched",
+    loading: (title) => `Loading ${title}`,
+    tabsAria: (title) => `${title} tabs`,
+    emptyAria: "No events found",
+    emptyTitle: "No Events Found",
+    emptyDescription: "We couldn't find any events matching your filters.\nTry adjusting them or check back later.",
+    empty: "No events found for this tab.",
+    errorTitle: "Something went wrong",
+    errorDescription: "We're having trouble loading data right now.\nTry refreshing or check back later.",
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved"
+  },
+  search: {
+    placeholder: "Search...",
+    inputAria: "Search markets",
+    resultsAria: "Search results",
+    resultAria: (title) => `View ${title}`,
+    resultsSummary: (countLabel, query) => `${countLabel} search results for "${query}"`,
+    seeAllResults: "See all results",
+    loadingResults: "Loading search results",
+    noResultsTitle: "No markets found",
+    noResultsDescription: "Check your spelling or try a broader search term."
+  },
+  eventItem: {
+    loading: "Loading market tile",
+    unavailableAria: "Market tile unavailable",
+    unavailableTitle: "Market unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    arbitrage: "Arbitrage",
+    priceGap: "Price Gap",
+    volumeSuffix: "Vol.",
+    marketSingular: "Market",
+    marketPlural: "Markets",
+    venueSingular: "Venue",
+    venuePlural: "Venues"
+  },
+  eventItemDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Event not found",
+    notFoundTitle: "Event Not Found",
+    notFoundDescription: "We couldn't find this event or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this event.",
+    historicalLineChartAria: (title) => `${title} historical line chart`,
+    outcomeSelectorAria: "Outcome selector",
+    yes: "Yes",
+    no: "No",
+    allTimeRange: "All",
+    volumeSuffix: "Vol.",
+    marketSelectPlaceholder: "Select market",
+    marketSelectSearchPlaceholder: "Search markets...",
+    marketSelectEmpty: "No markets found"
+  },
+  settlementSummary: {
+    title: "Settlement",
+    readFullDetails: "Read full details",
+    showLess: "Show less"
+  },
+  marketDetails: {
+    loading: "Loading market details",
+    unavailableAria: "Market details unavailable",
+    unavailableTitle: "Market details unavailable",
+    unavailableDescription: "We could not load this market right now.",
+    notFoundAria: "Market not found",
+    notFoundTitle: "Market Not Found",
+    notFoundDescription: "We couldn't find this market or it may no longer exist.",
+    chartUnavailableAria: "Chart unavailable",
+    chartUnavailableTitle: "Chart Unavailable",
+    chartUnavailableDescription: "We couldn't load live chart data for this market.",
+    orderBookEmptyAria: "No orders yet",
+    orderBookEmptyTitle: "No orders yet",
+    orderBookEmptyDescription: "Be the first to set the price on this market.",
+    orderBookResolvedAria: "Market resolved",
+    orderBookResolvedTitle: "Market Resolved",
+    orderBookResolvedDescription: "This market has been resolved and is no longer trading.",
+    orderBookUnavailableAria: "Orderbook unavailable",
+    orderBookUnavailableTitle: "Orderbook Unavailable",
+    orderBookUnavailableDescription: "We couldn't load live order data for this market.",
+    marketOutcomesAria: "Market outcomes",
+    tabsAria: "Market details tabs",
+    toggleOpenDetailsAria: (title) => `Open details for ${title}`,
+    toggleCloseDetailsAria: (title) => `Close details for ${title}`,
+    loadingOrderbookAria: "Loading orderbook",
+    loadingOrderbookLabel: "Loading orderbook...",
+    asks: "Asks",
+    bids: "Bids",
+    spread: "Spread",
+    midPrice: "Mid",
+    tradePrefix: "Trade",
+    priceColumn: "Price",
+    sharesColumn: "Shares",
+    totalColumn: "Total",
+    lastPrice: "Last",
+    graphAria: (title) => `${title} price history`,
+    outcomeSelectorAria: "Outcome selector",
+    showOutcomeAria: (label) => `Show ${label} outcome`,
+    viewResolved: "View resolved",
+    hideResolved: "Hide resolved",
+    volumeUnavailable: "Volume unavailable",
+    tabs: {
+      orderBook: "Order Book",
+      graph: "Graph",
+      other: "Other"
+    },
+    meta: {
+      status: "Status",
+      created: "Created",
+      opens: "Opens",
+      closes: "Closes",
+      markets: "Markets",
+      unknown: "Unknown",
+      venueSingular: "Venue",
+      venuePlural: "Venues",
+      volumeSuffix: "Vol."
+    }
+  },
+  trading: {
+    settlementSection: "Settlement",
+    settlementDifferencesTitle: "Key differences across venues",
+    settlementLoading: "Loading settlement",
+    settlementDetailsAria: (venueLabel) => `${venueLabel} settlement details`,
+    settlementShowMoreAria: (ctaLabel, venueLabel) => `${ctaLabel} for ${venueLabel}`,
+    settlementDescriptionLabel: "Description",
+    settlementRulesPrimaryLabel: "Resolution rules",
+    settlementRulesSecondaryLabel: "Additional rules",
+    disclaimer: "By trading, you agree to the Terms of Use of each exchange.",
+    geoBlockTermsLink: "Terms of Use",
+    geoBlockGenericMessage: "Trading is not available in your region. See ",
+    geoBlockVenueMessage: (venueLabel) => `Trading on ${venueLabel} is not available in your region. See `,
+    geoBlockMessageSuffix: " for more information.",
+    geoBlockModalAriaLabel: "Geo-restricted location",
+    geoBlockModalTitle: "Trading is not available in your current location",
+    geoBlockModalDescription: "You appear to be located in a restricted jurisdiction. You can still browse markets in view-only mode or return when you're in a supported region.",
+    geoBlockModalConfirm: "Confirm",
+    averagePrice: (value) => `${(value * 100).toLocaleString("en-US", {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    })}\xA2 avg. price`,
+    balance: (value) => `Balance ${value}`,
+    shares: (value) => `${value.toLocaleString("en-US", {
+      minimumFractionDigits: Number.isInteger(value) ? 0 : 2,
+      maximumFractionDigits: 6
+    })} shares`,
+    slippage: (value) => `Slippage: ${value}%`,
+    editSlippage: (value) => `Edit ${value}`,
+    collapseSlippage: (value) => `Collapse ${value}`,
+    resetSlippage: "Auto",
+    slippageWarning: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageLow: (value) => `Slippage below ${value}% may prevent your order from executing.`,
+    slippageHigh: (value) => `Slippage above ${value}% increases the chance of an unfavorable trade.`,
+    showAdditionalVenues: (count) => `Show ${count} more venue${count === 1 ? "" : "s"}`,
+    hideAdditionalVenues: "Hide additional venues",
+    quoteExpired: "Quote expired. Please refresh.",
+    orderSubmitted: "Order submitted",
+    orderPending: "Your order is being processed...",
+    orderFailed: "Order failed. Please try again.",
+    orderDisabledEventResolved: "This event has been resolved.",
+    orderDisabledEventClosed: "This event is no longer accepting orders.",
+    orderDisabledEventPaused: "Trading is temporarily paused for this event.",
+    orderDisabledEventUnopened: "Trading has not opened yet for this event.",
+    orderDisabledEventUnavailable: "Trading is currently unavailable.",
+    orderDisabledMarketResolved: "This market has been resolved.",
+    orderDisabledMarketClosed: "This market is no longer accepting orders.",
+    orderDisabledMarketPaused: "Trading is temporarily paused for this market.",
+    orderDisabledMarketUnopened: "Trading has not opened yet for this market.",
+    orderDisabledMarketUnavailable: "Trading is currently unavailable for this market.",
+    orderDisabledNoMarket: "Select a market to place an order.",
+    orderDisabledNoOutcome: "Select an outcome to place an order.",
+    orderDisabledNoEvent: "No event selected.",
+    insufficientBalance: "Insufficient balance",
+    refreshQuote: "Refresh Quote",
+    confirmOrder: "Confirm Order",
+    withdrawSubmitted: "Withdrawal submitted",
+    withdrawProcessing: "Your withdrawal is being processed...",
+    estimatedCost: (value) => `Est. cost ${value}`,
+    partialFill: (filledSize, requestedSize) => `Only ${filledSize} of ${requestedSize} shares available at this price.`,
+    insufficientLiquidity: "Not enough liquidity available for this order size.",
+    noMarketSelected: "Select a market to place an order.",
+    noOrderbooks: "No live orderbooks are available for this market right now.",
+    quoteUnavailable: "Quote temporarily unavailable. Please try again.",
+    selectedVenueUnavailable: "The venue you selected is no longer available on this route. Review the updated options and try again.",
+    engineUnavailable: "The routing engine is temporarily unavailable. Please try again in a moment.",
+    insufficientInputAmount: "Trade amount is too small to cover bridging and execution costs. Increase your spend or deposit funds on the destination chain.",
+    minOrderSizeViolated: "Order size is below the venue minimum. Increase your spend.",
+    minimumOrderAmount: (amount) => `Minimum order is $${amount}`,
+    insufficientPosition: (totalShares) => `You only have ${totalShares} shares available to sell.`,
+    insufficientPositionGeneric: "You don't have enough shares to sell.",
+    insufficientSellDepth: "Not enough bid liquidity on the matched venues for this sell amount.",
+    noBidsAboveMinPrice: "No venue bids above the minimum price.",
+    signInRequired: "Sign in to get a routed quote",
+    kycRequired: "Verify to trade Kalshi",
+    kycNotVerifiedTooltip: "You have not been verified yet",
+    kycVerifyModalTitle: "Verify Your Identity",
+    kycVerifyModalDescription: "To start trading on Kalshi, you'll need to complete identity verification through dFlow. It only takes a few minutes and helps us stay compliant with regulations.",
+    kycStartVerification: "Start Verification",
+    kycDoItLater: "Do It Later",
+    kycSuccessTitle: "Verification successful",
+    kycSuccessDescription: "Your identity has been confirmed and you now have full access to trade on Kalshi markets.",
+    kycSuccessDone: "Done",
+    outcome: (label) => `Outcome: ${label}`,
+    smartRouting: "Smart Routing",
+    orderSplitting: "Order Splitting",
+    splitOrderDescription: "We split your order for the best price:",
+    viewAllRoutes: (count) => `View all (${count})`,
+    hideRoutes: "Hide routes",
+    venueUnavailableInRegion: "Unavailable in your region",
+    toWin: (tab) => tab === "buy" ? "To win" : "Payout",
+    buyingOutcome: (label) => `Buying ${label}`,
+    sellingOutcome: (label) => `Selling ${label}`,
+    findingBestRoute: "Finding the best route...",
+    submittingOrderProgress: "Submitting order...",
+    orderSubmittedProgress: (orderId) => `Order #${orderId.replace(/^#/, "")} submitted`,
+    executingOnVenue: (venueLabel) => `Executing on ${venueLabel}...`,
+    confirmTransactionInWallet: "Confirm the transaction in your wallet",
+    executionConfirmed: "Execution confirmed",
+    orderSuccessTitle: "Order placed",
+    orderSuccessDescription: "Your order has been submitted successfully.",
+    orderFailureTitle: "Order failed",
+    orderFailureDescription: (message) => message || "Something went wrong. Please try again.",
+    orderDone: "Done",
+    orderNewTrade: "New Trade",
+    orderShare: "Share",
+    orderRetry: "Try again",
+    orderContinue: "Continue",
+    orderDismiss: "Dismiss",
+    orderRetryVenue: (venueLabel) => `Retry ${venueLabel}`,
+    orderPartialFillStatus: (venueLabel) => `${venueLabel} order partially filled`,
+    orderVenueUnavailableStatus: (venueLabel) => `${venueLabel} unavailable, your funds have not been charged.`,
+    orderMarketResolvedStatus: (venueLabel) => `Market resolved on ${venueLabel} and is no longer accepting orders.`,
+    orderSummaryShares: "Shares",
+    orderSummaryAvgPrice: "Avg. price",
+    orderSummaryEstCost: "Est. cost",
+    orderSummaryVenue: "Venue",
+    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",
+    resolvedEarningsTitle: "Your Earnings",
+    resolvedSharesLabel: "Shares",
+    resolvedTotalPayoutLabel: "Total payout",
+    claimWinnings: "Claim Winnings",
+    boughtOutcomeAtPrice: (label, priceLabel) => `Bought ${label} at ${priceLabel}`,
+    soldOutcomeAtPrice: (label, priceLabel) => `Sold ${label} at ${priceLabel}`,
+    potentialReturnBonus: (value) => `+${value} Better Payout`,
+    withSmartRouting: "with Smart Routing",
+    buy: "Buy",
+    sell: "Sell",
+    amount: (side) => `${side === "buy" ? "Amount" : "Shares"}`
+  },
+  onboarding: {
+    modal: {
+      title: "Onboarding",
+      stepHowItWorks: "How it works",
+      stepProfileSetup: "Set up your profile",
+      stepConnectAccounts: "Connect accounts"
+    },
+    howItWorks: {
+      title: "How it works",
+      continue: "Continue",
+      features: {
+        createAccount: {
+          title: "Create Your Account",
+          description: "Add a few basic details to set up your account and personalize your experience on the platform."
+        },
+        linkAccounts: {
+          title: "Link Trading Accounts",
+          description: "Connect supported exchanges to unlock additional markets and liquidity. Trade across decentralized markets in one interface."
+        },
+        bestPrices: {
+          title: "Best Prices Always",
+          description: "Our real-time aggregated orderbook lets you shop lines across exchanges and automatically splits predictions to optimize trades."
+        },
+        stayInControl: {
+          title: "You Stay in Control",
+          description: "All trades are executed on the original platform. We never custody funds or move money on your behalf."
+        }
+      }
+    },
+    profileSetup: {
+      title: "Set up your profile",
+      uploadProfilePictureAria: "Upload profile picture",
+      profilePreviewAlt: "Profile preview",
+      usernameLabel: "Username",
+      usernamePlaceholder: "e.g. CryptoJohn",
+      continue: "Continue"
+    },
+    connectAccounts: {
+      title: "Connect Accounts",
+      connect: "Connect",
+      connectAccount: "Connect Account",
+      continue: "Continue",
+      onchainTitle: "Onchain exchanges",
+      onchainMobileTitle: (additionalVenueCount) => `Polymarket +${additionalVenueCount} venues`,
+      onchainDescription: "Trade multiple venues with one signature.",
+      onchainMobileDescription: "Trade multiple exchanges with one signature",
+      kalshiTitle: "US regulated exchanges",
+      kalshiMobileTitle: "Kalshi",
+      kalshiDescription: "Trade on regulated markets via Kalshi.",
+      kalshiMobileDescription: "Connect your Kalshi account"
+    },
+    connectOnchainModal: {
+      ariaLabel: "Connect Onchain Exchanges",
+      title: "Connect Onchain Exchanges",
+      description: "Sign in with your wallet to trade across supported\nonchain prediction markets.",
+      supportedVenuesLabel: "Supported venues:",
+      connect: "Sign In with Wallet",
+      cancel: "Cancel",
+      fallbackError: "Signature declined. Please try again."
+    },
+    connectKalshiModal: {
+      ariaLabel: "Connect Kalshi Account",
+      title: "Connect Kalshi Account",
+      description: "You'll generate an API key in Kalshi profile and add it to connect your account. These keys are used only to execute trades on your behalf.",
+      stepOne: {
+        label: "Step 1",
+        title: "Generate a Read/Write API Key in Kalshi",
+        instructions: {
+          signIn: "1. Sign in to your Kalshi account.",
+          goToProfilePrefix: "2. Go to your",
+          profileText: "Profile",
+          goToProfileSeparator: ":",
+          profileUrl: "https://kalshi.com/account/profile",
+          clickCreateKeyPrefix: "3. Click",
+          createKeyText: "Create Key",
+          clickCreateKeySuffix: ".",
+          selectPermissionsPrefix: "4. Select",
+          readWriteText: "Read/Write",
+          selectPermissionsSuffix: " permissions.",
+          createKey: "5. Create the key."
+        },
+        footerLineOne: "Kalshi will display your API Key ID and Private Key.",
+        footerLineTwo: "You'll need both for the next step."
+      },
+      stepTwo: {
+        label: "Step 2",
+        title: "Paste Your Kalshi API Credentials",
+        description: "These credentials are encrypted and used only to execute trades on your behalf. We can't access your funds directly.",
+        apiKeyIdLabel: "API Key ID",
+        apiKeyIdPlaceholder: "a3f9c1b2-7d4e-4c91-9f2a-8b6e1d3c5a77",
+        privateKeyLabel: "Private Key",
+        privateKeyPlaceholder: "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC..."
+      },
+      help: {
+        label: "Having trouble?",
+        docsLinkLabel: "View Kalshi docs",
+        tutorialLinkLabel: "Watch tutorial video"
+      },
+      actions: {
+        cancel: "Cancel",
+        verifyConnection: "Verify Connection"
+      },
+      fallbackError: "Verification failed. Please check your credentials and try again."
+    }
+  },
+  eventMarketPage: {
+    unavailableAria: "Event market page unavailable",
+    unavailableTitle: "Something went wrong",
+    unavailableDescription: "We're having trouble loading this event right now.\nTry refreshing or check back later.",
+    loadingSettlementQuestion: "Loading settlement",
+    loadingSettlementDifferencesTitle: "Loading settlement",
+    loadingSettlementPlaceholder: "Loading",
+    tradingResolvedBadge: "Resolved",
+    tradingResolvedTitle: "Market resolved",
+    tradingResolvedDescription: "Trading has ended for this event. You can review the final result.",
+    tradingClosedBadge: "Closed",
+    tradingClosedTitle: "Trading closed",
+    tradingClosedDescription: "This event is no longer accepting new orders.",
+    tradingPausedBadge: "Paused",
+    tradingPausedTitle: "Trading paused",
+    tradingPausedDescription: "Trading is temporarily unavailable for this event.",
+    tradingUnopenedBadge: "Upcoming",
+    tradingUnopenedTitle: "Trading not open yet",
+    tradingUnopenedDescription: "This event is listed, but trading has not opened yet.",
+    tradingUnavailableBadge: "Unavailable",
+    tradingUnavailableTitle: "Trading unavailable",
+    tradingUnavailableDescription: "Trading is currently unavailable for this event.",
+    resolvedAt: (dateLabel) => `Resolved ${dateLabel}`,
+    closedAt: (dateLabel) => `Closed ${dateLabel}`,
+    opensAt: (dateLabel) => `Opens ${dateLabel}`,
+    winningOutcome: (label) => `Winning outcome: ${label}`,
+    resolvedOutcome: (label) => `Resolved: ${label}`,
+    marketDetailsAriaByDate: (dateLabel) => `Market details for ${dateLabel}`,
+    marketDetailsAriaByQuestion: (question) => `Market details for ${question}`
+  },
+  header: {
+    bannerAria: "Site header",
+    logoAria: "Home"
+  }
+};
+var defaultAggUiLabelsByLocale = {
+  "en-US": enUsLabels,
+  en: enUsLabels
+};
+var resolveAggUiLabels = (locale) => {
+  var _a;
+  if (defaultAggUiLabelsByLocale[locale]) {
+    return defaultAggUiLabelsByLocale[locale];
+  }
+  const baseLocale = locale.split("-")[0];
+  return (_a = defaultAggUiLabelsByLocale[baseLocale]) != null ? _a : enUsLabels;
+};
+
+// src/core/ui-config/utils.ts
+var DEFAULT_LOCALE = "en-US";
+var createFormatters = (locale) => {
+  const number = new Intl.NumberFormat(locale, {
+    maximumFractionDigits: 2
+  });
+  const percent = new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  });
+  const currency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    maximumFractionDigits: 2
+  });
+  const compactCurrency = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    maximumFractionDigits: 0
+  });
+  const date = new Intl.DateTimeFormat(locale, {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  });
+  return {
+    formatNumber: (value) => number.format(value),
+    formatPercent: (value) => percent.format(value),
+    formatCurrency: (value) => currency.format(value),
+    formatCompactCurrency: (value) => compactCurrency.format(value),
+    formatDate: (value) => date.format(value)
+  };
+};
+var defaultFormatters = createFormatters(DEFAULT_LOCALE);
+var defaultAggUiSearchConfig = {
+  value: "",
+  result: null,
+  isShowingAllResults: false
+};
+var defaultAggUiConfig = {
+  enableLogs: false,
+  enableWebsocketsLogs: false,
+  general: {
+    locale: DEFAULT_LOCALE,
+    theme: "light",
+    rootClassName: "",
+    labels: resolveAggUiLabels(DEFAULT_LOCALE)
+  },
+  features: {
+    enableAnimations: true,
+    enableLiveUpdates: true,
+    enableGradients: false
+  },
+  market: {
+    arbitrageThreshold: 0
+  },
+  chart: {
+    defaultChartTimeRange: "1D",
+    selectedChartTimeRange: "1D",
+    setSelectedChartTimeRange: () => {
+    }
+  },
+  formatting: defaultFormatters,
+  search: defaultAggUiSearchConfig
+};
+
+// src/core/providers/contexts.ts
+var AggClientContext = (0, import_react.createContext)(null);
+var AggUiContext = (0, import_react.createContext)(defaultAggUiConfig);
+var AggLabelsContext = (0, import_react.createContext)(defaultAggUiConfig.general.labels);
+var AggAuthContext = (0, import_react.createContext)(null);
+var AggBalanceContext = (0, import_react.createContext)(null);
+
+// src/execution/query-keys.ts
+var executionKeys = {
+  all: () => ["execution"],
+  balances: () => ["execution", "balances"],
+  positions: (cursor, limit, status) => ["execution", "positions", cursor != null ? cursor : null, limit != null ? limit : null, status != null ? status : null],
+  positionsPrefix: () => ["execution", "positions"],
+  claimableClosedPositionsCount: () => ["execution", "positions", "claimable-count"],
+  orders: (status, cursor, limit) => ["execution", "orders", status != null ? status : null, cursor != null ? cursor : null, limit != null ? limit : null],
+  ordersPrefix: () => ["execution", "orders"],
+  depositAddresses: () => ["execution", "deposit-addresses"]
+};
+
+// src/execution/balance-invalidation.ts
+var balanceQueryKeys = {
+  execution: () => executionKeys.balances(),
+  // Kept as an alias for backward compatibility with existing callers.
+  // The balance provider now uses the same canonical execution balances key.
+  provider: () => executionKeys.balances(),
+  venue: (venuesKey) => ["venue-balances", venuesKey],
+  venuePrefix: () => ["venue-balances"]
+};
+var invalidateBalanceQueries = (queryClient, options) => {
+  var _a;
+  const refetchType = (_a = options == null ? void 0 : options.refetchType) != null ? _a : "active";
+  const executionKey = balanceQueryKeys.execution();
+  const providerKey = balanceQueryKeys.provider();
+  queryClient.invalidateQueries({
+    queryKey: executionKey,
+    refetchType
+  });
+  const isProviderKeyDistinct = providerKey.length !== executionKey.length || providerKey.some((segment, index) => segment !== executionKey[index]);
+  if (isProviderKeyDistinct) {
+    queryClient.invalidateQueries({
+      queryKey: providerKey,
+      refetchType
+    });
+  }
+  queryClient.invalidateQueries({
+    queryKey: balanceQueryKeys.venuePrefix(),
+    refetchType
+  });
+};
+
+// src/core/providers/ws-provider.tsx
+var import_react3 = require("react");
+var import_react_query = require("@tanstack/react-query");
+
+// src/core/providers/hooks.ts
+var import_react2 = require("react");
+var useAggClient = () => {
+  const client = (0, import_react2.useContext)(AggClientContext);
+  if (!client) {
+    throw new Error("useAggClient must be used within an <AggProvider>");
+  }
+  return client;
+};
+var useAggBalanceContext = () => {
+  const context = (0, import_react2.useContext)(AggBalanceContext);
+  if (!context) {
+    throw new Error("useAggBalanceContext must be used within an <AggProvider>");
+  }
+  return context;
+};
+var useAggBalanceState = useAggBalanceContext;
+
+// src/core/providers/ws-provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AggWebSocketContext = (0, import_react3.createContext)(null);
+var AggWebSocketConnectionContext = (0, import_react3.createContext)(false);
+var AggWsUserEventContext = (0, import_react3.createContext)(null);
+function useAggWebSocket() {
+  return (0, import_react3.useContext)(AggWebSocketContext);
+}
+function useAggWebSocketConnectionState() {
+  return (0, import_react3.useContext)(AggWebSocketConnectionContext);
+}
+function useOnWithdrawalLifecycle(callback) {
+  const listeners = (0, import_react3.useContext)(AggWsUserEventContext);
+  const callbackRef = (0, import_react3.useRef)(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  (0, import_react3.useEffect)(() => {
+    if (!listeners || !callbackRef.current) return;
+    const handler = (msg) => {
+      var _a;
+      (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, msg);
+    };
+    return listeners.addWithdrawalLifecycleListener(handler);
+  }, [listeners, hasCallback]);
+}
+
+// src/execution/use-withdraw-managed.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useWithdrawManaged(options) {
+  const client = useAggClient();
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: (params) => client.withdrawManaged(params),
+    onSuccess: (data) => {
+      var _a;
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/execution/use-managed-balances.ts
+var import_react_query3 = require("@tanstack/react-query");
+function useManagedBalances(options) {
+  const client = useAggClient();
+  const { enabled = true } = options != null ? options : {};
+  const query = (0, import_react_query3.useQuery)({
+    queryKey: executionKeys.balances(),
+    queryFn: () => client.getManagedBalances(),
+    enabled,
+    staleTime: 1e4,
+    gcTime: 5 * 6e4,
+    retry: 1
+  });
+  return __spreadProps(__spreadValues({}, query), {
+    balances: query.data
+  });
+}
+
+// src/execution/use-deposit-addresses.ts
+var import_react4 = require("react");
+var import_react_query4 = require("@tanstack/react-query");
+var SVM_CHAIN_IDS = /* @__PURE__ */ new Set([792703809]);
+function getDepositAddress(chainId, data) {
+  return chainId !== void 0 && SVM_CHAIN_IDS.has(chainId) ? data.svmAddress : data.evmAddress;
+}
+function useDepositAddresses(options) {
+  var _a;
+  const client = useAggClient();
+  const {
+    enabled = true,
+    poll = true,
+    refetchIntervalMs = 5e3,
+    timeoutMs = 6e4
+  } = options != null ? options : {};
+  const [isTimedOut, setIsTimedOut] = (0, import_react4.useState)(false);
+  const timeoutRef = (0, import_react4.useRef)(null);
+  (0, import_react4.useEffect)(() => {
+    if (!enabled || !poll) return void 0;
+    setIsTimedOut(false);
+    timeoutRef.current = setTimeout(() => setIsTimedOut(true), timeoutMs);
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, [enabled, poll, timeoutMs]);
+  const query = (0, import_react_query4.useQuery)({
+    queryKey: executionKeys.depositAddresses(),
+    queryFn: () => client.getDepositAddresses(),
+    enabled,
+    staleTime: 6e4,
+    gcTime: 5 * 6e4,
+    retry: 1,
+    refetchInterval: (q) => {
+      if (!poll || isTimedOut) return false;
+      const data = q.state.data;
+      if ((data == null ? void 0 : data.ready) === true) return false;
+      return refetchIntervalMs;
+    }
+  });
+  const isReady = ((_a = query.data) == null ? void 0 : _a.ready) === true;
+  const readyData = isReady ? query.data : void 0;
+  const evmAddress = (0, import_react4.useMemo)(() => readyData == null ? void 0 : readyData.evmAddress, [readyData]);
+  const svmAddress = (0, import_react4.useMemo)(() => readyData == null ? void 0 : readyData.svmAddress, [readyData]);
+  const supportedChains = (0, import_react4.useMemo)(() => readyData == null ? void 0 : readyData.supportedChains, [readyData]);
+  return __spreadProps(__spreadValues({}, query), {
+    isReady,
+    isTimedOut,
+    evmAddress,
+    svmAddress,
+    supportedChains,
+    depositAddresses: query.data,
+    /** Resolve the correct address (EVM or SVM) for a given chainId. */
+    getAddress: (chainId) => readyData ? getDepositAddress(chainId, readyData) : void 0
+  });
+}
+
+// src/execution/use-sync-balances.ts
+var import_react_query5 = require("@tanstack/react-query");
+function useSyncBalances(options) {
+  const client = useAggClient();
+  const queryClient = (0, import_react_query5.useQueryClient)();
+  return (0, import_react_query5.useMutation)({
+    mutationFn: () => client.syncManagedBalances(),
+    onSuccess: () => {
+      var _a;
+      invalidateBalanceQueries(queryClient);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options);
+    },
+    onError: options == null ? void 0 : options.onError
+  });
+}
+
+// src/withdraw/use-withdraw-flow.ts
+var EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+var SOLANA_ADDRESS_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var SOLANA_CHAIN_ID = 792703809;
+var WITHDRAWAL_SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  // Ethereum
+  137,
+  // Polygon
+  42161,
+  // Arbitrum
+  8453,
+  // Base
+  56,
+  // BNB
+  SOLANA_CHAIN_ID
+]);
+var isValidDestinationAddress = (address, chainId) => {
+  if (chainId === SOLANA_CHAIN_ID) return SOLANA_ADDRESS_REGEX.test(address);
+  return EVM_ADDRESS_REGEX.test(address);
+};
+var DEFAULT_WITHDRAW_SUMMARY = {
+  amountReceived: "",
+  network: "",
+  toWallet: "",
+  fees: "\u2014"
+};
+var formatRawTokenAmount = (rawAmount, decimals) => {
+  if (!rawAmount) return "0";
+  const raw = BigInt(rawAmount);
+  const divisor = BigInt(`1${"0".repeat(decimals)}`);
+  const whole = raw / divisor;
+  const remainder = raw % divisor;
+  if (remainder === BigInt(0)) return whole.toString();
+  return `${whole.toString()}.${remainder.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+var formatRawTokenAmountForDisplay = (rawAmount, decimals, fractionDigits = 2) => {
+  const [wholePart, fractionalPart = ""] = formatRawTokenAmount(rawAmount, decimals).split(".");
+  const normalizedFraction = fractionalPart.padEnd(fractionDigits, "0").slice(0, fractionDigits);
+  return `${wholePart}.${normalizedFraction}`;
+};
+var parseTokenAmountToRaw = (amount, decimals) => {
+  const normalizedAmount = amount.trim();
+  if (!normalizedAmount || !/^\d*(?:\.\d*)?$/.test(normalizedAmount)) {
+    return null;
+  }
+  const [wholePart = "0", fractionalPart = ""] = normalizedAmount.split(".");
+  if (fractionalPart.length > decimals) return null;
+  const normalizedWhole = wholePart === "" ? "0" : wholePart;
+  const normalizedFraction = fractionalPart.padEnd(decimals, "0");
+  try {
+    return `${BigInt(normalizedWhole)}${normalizedFraction}`.replace(/^0+(?=\d)/, "");
+  } catch (e) {
+    return null;
+  }
+};
+var shortenAddress = (address) => address.length > 12 ? `${address.slice(0, 6)}....${address.slice(-4)}` : address;
+function useWithdrawFlow(options) {
+  var _a, _b;
+  const { open, onOpenChange } = options;
+  const { totalBalance } = useAggBalanceState();
+  const { balances } = useManagedBalances({ enabled: open });
+  const { supportedChains } = useDepositAddresses({ enabled: open });
+  const withdrawMutation = useWithdrawManaged();
+  const syncBalances = useSyncBalances();
+  const ws = useAggWebSocket();
+  (0, import_react5.useEffect)(() => {
+    if (!open) return;
+    syncBalances.mutate(void 0, {
+      onError: () => {
+      }
+    });
+  }, [open]);
+  const [withdrawDestination, setWithdrawDestination] = (0, import_react5.useState)("");
+  const [withdrawAmount, setWithdrawAmount] = (0, import_react5.useState)("");
+  const [withdrawToken, setWithdrawToken] = (0, import_react5.useState)("USDC");
+  const [withdrawNetwork, setWithdrawNetwork] = (0, import_react5.useState)("");
+  const [withdrawSummary, setWithdrawSummary] = (0, import_react5.useState)(DEFAULT_WITHDRAW_SUMMARY);
+  const [withdrawalId, setWithdrawalId] = (0, import_react5.useState)(null);
+  const networkOptions = (0, import_react5.useMemo)(
+    () => (supportedChains != null ? supportedChains : []).filter((chain) => WITHDRAWAL_SUPPORTED_CHAIN_IDS.has(chain.chainId)).map((chain) => ({
+      value: String(chain.chainId),
+      label: chain.name
+    })),
+    [supportedChains]
+  );
+  const resolvedWithdrawNetwork = withdrawNetwork || ((_a = networkOptions[0]) == null ? void 0 : _a.value) || "";
+  (0, import_react5.useEffect)(() => {
+    if (!networkOptions.length) return;
+    if (!withdrawNetwork || !networkOptions.some((option) => option.value === withdrawNetwork)) {
+      setWithdrawNetwork(networkOptions[0].value);
+    }
+  }, [networkOptions, withdrawNetwork]);
+  const tokenOptions = (0, import_react5.useMemo)(() => {
+    var _a2, _b2, _c;
+    const selectedChainId = Number(resolvedWithdrawNetwork);
+    const supportedTokensForNetwork = (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === selectedChainId)) == null ? void 0 : _a2.tokens) != null ? _b2 : [];
+    const withdrawableSymbols = new Set(supportedTokensForNetwork.map((token) => token.symbol));
+    return ((_c = balances == null ? void 0 : balances.cash) != null ? _c : []).filter((cashEntry) => withdrawableSymbols.has(cashEntry.tokenSymbol)).map((cashEntry) => ({
+      value: cashEntry.tokenSymbol,
+      label: cashEntry.tokenSymbol
+    }));
+  }, [balances, resolvedWithdrawNetwork, supportedChains]);
+  const resolvedWithdrawToken = tokenOptions.some((option) => option.value === withdrawToken) ? withdrawToken : ((_b = tokenOptions[0]) == null ? void 0 : _b.value) || "";
+  (0, import_react5.useEffect)(() => {
+    if (!tokenOptions.length) return;
+    if (!tokenOptions.some((option) => option.value === withdrawToken)) {
+      setWithdrawToken(tokenOptions[0].value);
+    }
+  }, [tokenOptions, withdrawToken]);
+  const selectedCashEntry = (0, import_react5.useMemo)(
+    () => balances == null ? void 0 : balances.cash.find((cashEntry) => cashEntry.tokenSymbol === resolvedWithdrawToken),
+    [balances, resolvedWithdrawToken]
+  );
+  const selectedTokenDecimals = (0, import_react5.useMemo)(() => {
+    var _a2, _b2, _c, _d;
+    const selectedChainId = Number(resolvedWithdrawNetwork);
+    return (_d = (_c = (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === selectedChainId)) == null ? void 0 : _a2.tokens.find((token) => token.symbol === resolvedWithdrawToken)) == null ? void 0 : _b2.decimals) != null ? _c : selectedCashEntry == null ? void 0 : selectedCashEntry.decimals) != null ? _d : 6;
+  }, [
+    resolvedWithdrawNetwork,
+    resolvedWithdrawToken,
+    selectedCashEntry == null ? void 0 : selectedCashEntry.decimals,
+    supportedChains
+  ]);
+  const exactBalance = (0, import_react5.useMemo)(() => {
+    if (!selectedCashEntry) return "0";
+    return formatRawTokenAmount(selectedCashEntry.totalRaw, selectedCashEntry.decimals);
+  }, [selectedCashEntry]);
+  const balanceDisplay = (0, import_react5.useMemo)(() => {
+    if (!selectedCashEntry) return `0.00 ${resolvedWithdrawToken || withdrawToken}`;
+    return `${formatRawTokenAmountForDisplay(
+      selectedCashEntry.totalRaw,
+      selectedCashEntry.decimals
+    )} ${resolvedWithdrawToken}`;
+  }, [resolvedWithdrawToken, selectedCashEntry, withdrawToken]);
+  const resetFlowState = (0, import_react5.useCallback)(() => {
+    setWithdrawDestination("");
+    setWithdrawAmount("");
+    setWithdrawToken("USDC");
+    setWithdrawNetwork("");
+    setWithdrawSummary(DEFAULT_WITHDRAW_SUMMARY);
+    setWithdrawalId(null);
+  }, []);
+  const handleWithdrawOpenChange = (0, import_react5.useCallback)(
+    (isOpen) => {
+      if (!isOpen) resetFlowState();
+      onOpenChange(isOpen);
+    },
+    [onOpenChange, resetFlowState]
+  );
+  (0, import_react5.useEffect)(() => {
+    if (!open) resetFlowState();
+  }, [open, resetFlowState]);
+  const handleWithdrawProvider = (0, import_react5.useCallback)(() => __async(null, null, function* () {
+    var _a2, _b2;
+    const destinationChainId = Number(resolvedWithdrawNetwork);
+    const trimmedDestination = withdrawDestination.trim();
+    const amountRaw = parseTokenAmountToRaw(withdrawAmount, selectedTokenDecimals);
+    if (!amountRaw || BigInt(amountRaw) <= BigInt(0)) {
+      throw new Error("Enter a withdrawal amount greater than zero.");
+    }
+    if (!Number.isFinite(destinationChainId) || destinationChainId <= 0) {
+      throw new Error("Select a destination network.");
+    }
+    if (!isValidDestinationAddress(trimmedDestination, destinationChainId)) {
+      const expected = destinationChainId === SOLANA_CHAIN_ID ? "a Solana wallet address (base58, 32\u201344 chars)" : "an EVM destination address (0x\u2026 40 hex chars)";
+      throw new Error(`Enter ${expected}.`);
+    }
+    if (selectedCashEntry) {
+      const scaleBy = (n, exp) => {
+        if (exp <= 0) return n;
+        return n * BigInt(`1${"0".repeat(exp)}`);
+      };
+      const balanceInDestFrame = (() => {
+        const native = BigInt(selectedCashEntry.totalRaw);
+        if (selectedCashEntry.decimals === selectedTokenDecimals) return native;
+        if (selectedCashEntry.decimals > selectedTokenDecimals) {
+          return native / scaleBy(BigInt(1), selectedCashEntry.decimals - selectedTokenDecimals);
+        }
+        return scaleBy(native, selectedTokenDecimals - selectedCashEntry.decimals);
+      })();
+      if (BigInt(amountRaw) > balanceInDestFrame) {
+        throw new Error("Withdrawal amount exceeds your available balance.");
+      }
+    }
+    ws == null ? void 0 : ws.connect();
+    yield new Promise((resolve, reject) => {
+      withdrawMutation.mutate(
+        {
+          amountRaw,
+          tokenSymbol: resolvedWithdrawToken,
+          destinationAddress: trimmedDestination,
+          destinationChainId
+        },
+        {
+          onSuccess: (data) => {
+            setWithdrawalId(data.withdrawalId);
+            resolve();
+          },
+          onError: reject
+        }
+      );
+    });
+    setWithdrawSummary({
+      amountReceived: `${formatRawTokenAmountForDisplay(amountRaw, selectedTokenDecimals)} ${resolvedWithdrawToken}`,
+      network: (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === destinationChainId)) == null ? void 0 : _a2.name) != null ? _b2 : resolvedWithdrawNetwork,
+      toWallet: shortenAddress(trimmedDestination),
+      fees: "\u2014"
+    });
+  }), [
+    resolvedWithdrawNetwork,
+    resolvedWithdrawToken,
+    selectedCashEntry,
+    selectedTokenDecimals,
+    supportedChains,
+    withdrawAmount,
+    withdrawDestination,
+    withdrawMutation,
+    ws
+  ]);
+  return {
+    open,
+    onOpenChange: handleWithdrawOpenChange,
+    withdrawFlow: {
+      balance: totalBalance,
+      balanceDisplay,
+      amount: withdrawAmount,
+      destinationWallet: withdrawDestination,
+      tokenOptions,
+      networkOptions,
+      selectedToken: resolvedWithdrawToken,
+      selectedNetwork: resolvedWithdrawNetwork,
+      purchaseSummary: withdrawSummary,
+      withdrawalId
+    },
+    onWithdrawDestinationChange: setWithdrawDestination,
+    onWithdrawAmountChange: setWithdrawAmount,
+    onWithdrawTokenChange: setWithdrawToken,
+    onWithdrawNetworkChange: setWithdrawNetwork,
+    onMaxClick: (0, import_react5.useCallback)(() => {
+      setWithdrawAmount(exactBalance === "0" ? "0" : exactBalance);
+    }, [exactBalance]),
+    onSelectWithdrawProvider: (0, import_react5.useCallback)(
+      (_providerId) => __async(null, null, function* () {
+        return handleWithdrawProvider();
+      }),
+      [handleWithdrawProvider]
+    ),
+    onDoneWithdraw: (0, import_react5.useCallback)(() => handleWithdrawOpenChange(false), [handleWithdrawOpenChange])
+  };
+}
+
+// src/withdraw/use-withdrawal-lifecycle.ts
+var import_react6 = require("react");
+var import_react_query6 = require("@tanstack/react-query");
+var INITIAL_STATE = {
+  pending: true,
+  status: null,
+  terminal: false,
+  lastLeg: null,
+  legs: [],
+  errorMessage: null,
+  timestamp: null
+};
+var restLegToWsLeg = (leg) => ({
+  sourceChainId: leg.sourceChainId,
+  destChainId: leg.destChainId,
+  type: leg.type,
+  // The wire-level WS leg status enum and the REST leg status enum are the
+  // same union (planned/submitted/confirmed/failed). Keep the cast narrow to
+  // avoid pulling the SDK enum apart for a one-line bridge.
+  status: leg.status,
+  amountRaw: leg.amountRaw,
+  txHash: leg.txHash,
+  bridgeOperationId: leg.bridgeOperationId
+});
+var mergeLegs = (prev, snapshot, delta) => {
+  if (snapshot) return snapshot;
+  if (!delta) return prev;
+  const idx = prev.findIndex(
+    (l) => l.sourceChainId === delta.sourceChainId && l.destChainId === delta.destChainId && l.type === delta.type
+  );
+  if (idx === -1) return [...prev, delta];
+  const next = prev.slice();
+  next[idx] = delta;
+  return next;
+};
+var restToLifecycleState = (response) => {
+  var _a;
+  return {
+    pending: false,
+    status: response.status,
+    terminal: response.status === "completed" || response.status === "partial" || response.status === "failed",
+    lastLeg: null,
+    legs: response.legs.map(restLegToWsLeg),
+    errorMessage: (_a = response.errorMessage) != null ? _a : null,
+    // No server timestamp on the REST response — we use 0 as "older than any
+    // WS timestamp" so a subsequent WS event always wins. Callers that read
+    // `timestamp` should treat 0/null interchangeably as "unset".
+    timestamp: 0
+  };
+};
+function useWithdrawalLifecycle(withdrawalId) {
+  const client = useAggClient();
+  const wsConnected = useAggWebSocketConnectionState();
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  const [state, setState] = (0, import_react6.useState)(INITIAL_STATE);
+  const stateRef = (0, import_react6.useRef)(state);
+  stateRef.current = state;
+  const balanceRefetchedForRef = (0, import_react6.useRef)(null);
+  (0, import_react6.useEffect)(() => {
+    setState(INITIAL_STATE);
+  }, [withdrawalId]);
+  (0, import_react6.useEffect)(() => {
+    if (!withdrawalId) return;
+    let cancelled = false;
+    (() => __async(null, null, function* () {
+      try {
+        const response = yield client.getWithdrawalStatus(withdrawalId);
+        if (cancelled) return;
+        if (response.withdrawalId !== withdrawalId) return;
+        const current = stateRef.current;
+        const wsAlreadyWon = current.timestamp != null && current.timestamp > 0;
+        if (wsAlreadyWon) return;
+        setState(restToLifecycleState(response));
+      } catch (e) {
+      }
+    }))();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, withdrawalId, wsConnected]);
+  const handler = (0, import_react6.useMemo)(() => {
+    if (!withdrawalId) return null;
+    return (msg) => {
+      if (msg.withdrawalId !== withdrawalId) return;
+      setState((prev) => {
+        var _a, _b;
+        return {
+          pending: false,
+          status: msg.status,
+          terminal: msg.terminal,
+          lastLeg: (_a = msg.leg) != null ? _a : null,
+          // `legs[]` is the cumulative server-known truth. Snapshots
+          // (`pending` / terminal rollup) carry a full `legs[]` and replace
+          // it. Intermediate per-leg deltas carry only `leg` (no `legs[]`)
+          // — merge the delta into the existing array by
+          // (sourceChainId, destChainId, type) so the timeline UI doesn't
+          // collapse to empty between snapshots.
+          legs: mergeLegs(prev.legs, msg.legs, msg.leg),
+          errorMessage: (_b = msg.errorMessage) != null ? _b : null,
+          timestamp: msg.timestamp
+        };
+      });
+    };
+  }, [withdrawalId]);
+  useOnWithdrawalLifecycle(handler);
+  (0, import_react6.useEffect)(() => {
+    if (!withdrawalId) return;
+    if (!state.terminal) return;
+    if (balanceRefetchedForRef.current === withdrawalId) return;
+    balanceRefetchedForRef.current = withdrawalId;
+    invalidateBalanceQueries(queryClient);
+    client.syncManagedBalances().catch(() => {
+    });
+  }, [client, queryClient, state.terminal, withdrawalId]);
+  const reset = (0, import_react6.useCallback)(() => setState(INITIAL_STATE), []);
+  return { state, reset };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDepositAddresses,
+  useManagedBalances,
+  useWithdrawFlow,
+  useWithdrawManaged,
+  useWithdrawalLifecycle
+});