@agg-build/hooks 1.0.0 → 1.0.1

package/README.md

@@ -393,7 +393,7 @@ Optional (only needed for wallet-based sign-in / deposits):
 ## Links
 
 - Documentation — <https://docs.agg.market/>
-- Demo app — <https://demo.agg.market/>
+- Demo app — <https://agg.market/>
 - Vanilla SDK — [`@agg-build/sdk`](https://www.npmjs.com/package/@agg-build/sdk)
 - Trading UI — [`@agg-build/ui`](https://www.npmjs.com/package/@agg-build/ui)
 - Connect / sign-in UX — [`@agg-build/auth`](https://www.npmjs.com/package/@agg-build/auth)

package/dist/{chunk-CDPQERUC.mjs → chunk-BWXNOWAS.mjs}

@@ -320,6 +320,8 @@ var enUsLabels = {
       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: {
@@ -356,9 +358,55 @@ var enUsLabels = {
     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",
@@ -382,7 +430,10 @@ var enUsLabels = {
       }
     },
     summary: {
-      amountReceived: "Amount received",
+      // 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"
     }
   },
@@ -399,12 +450,16 @@ var enUsLabels = {
   userProfile: {
     activity: {
       depositType: "Deposit",
-      withdrawalType: "Withdraw",
+      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: {
@@ -1690,6 +1745,20 @@ function useOnRedeemEvent(callback) {
     return listeners.addRedeemEventListener(handler);
   }, [listeners, hasCallback]);
 }
+function useOnWithdrawalLifecycle(callback) {
+  const listeners = useContext4(AggWsUserEventContext);
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  const hasCallback = callback !== null;
+  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]);
+}
 function AggWebSocketProvider({ children }) {
   const client = useAggClient();
   const { enableWebsocketsLogs } = useAggUiConfig();
@@ -1710,6 +1779,9 @@ function AggWebSocketProvider({ children }) {
   const balanceUpdateListenersRef = useRef2(/* @__PURE__ */ new Set());
   const orderEventListenersRef = useRef2(/* @__PURE__ */ new Set());
   const redeemEventListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const withdrawalLifecycleListenersRef = useRef2(
+    /* @__PURE__ */ new Set()
+  );
   const userEventListeners = useMemo2(
     () => ({
       addOrderSubmittedListener: (cb) => {
@@ -1735,6 +1807,12 @@ function AggWebSocketProvider({ children }) {
         return () => {
           redeemEventListenersRef.current.delete(cb);
         };
+      },
+      addWithdrawalLifecycleListener: (cb) => {
+        withdrawalLifecycleListenersRef.current.add(cb);
+        return () => {
+          withdrawalLifecycleListenersRef.current.delete(cb);
+        };
       }
     }),
     []
@@ -1909,6 +1987,14 @@ function AggWebSocketProvider({ children }) {
           listener(msg);
         }
       },
+      onWithdrawalLifecycle: (msg) => {
+        if (isClientAuthenticated) {
+          invalidateBalanceCaches();
+        }
+        for (const listener of withdrawalLifecycleListenersRef.current) {
+          listener(msg);
+        }
+      },
       onError: (msg) => {
         const outcomeId = resolveSnapshotUnavailableOutcomeId(msg.message);
         if (!outcomeId) return;
@@ -2989,33 +3075,11 @@ var AggProvider = ({ client, config, children }) => {
   return /* @__PURE__ */ jsx8(AggClientProvider, { client, children: /* @__PURE__ */ jsx8(AggUiProvider, { config, children: /* @__PURE__ */ jsx8(EventListStateProvider, { children: /* @__PURE__ */ jsx8(AggWebSocketProvider, { children: /* @__PURE__ */ jsx8(AggAuthProvider, { children: /* @__PURE__ */ jsx8(AggBalanceProvider, { children }) }) }) }) }) });
 };
 
-// src/use-ramp-quotes.ts
-import { useMutation } from "@tanstack/react-query";
-function useRampQuotes() {
-  const client = useAggClient();
-  return useMutation({
-    mutationFn: (params) => __async(null, null, function* () {
-      return client.getRampQuotes(params);
-    })
-  });
-}
-
-// src/use-ramp-session.ts
-import { useMutation as useMutation2 } from "@tanstack/react-query";
-function useRampSession() {
-  const client = useAggClient();
-  return useMutation2({
-    mutationFn: (params) => __async(null, null, function* () {
-      return client.createRampSession(params);
-    })
-  });
-}
-
 // src/execution/use-quote-managed.ts
-import { useMutation as useMutation3 } from "@tanstack/react-query";
+import { useMutation } from "@tanstack/react-query";
 function useQuoteManaged(options) {
   const client = useAggClient();
-  return useMutation3({
+  return useMutation({
     mutationFn: (params) => client.quoteManaged(params),
     onSuccess: options == null ? void 0 : options.onSuccess,
     onError: options == null ? void 0 : options.onError
@@ -3023,11 +3087,11 @@ function useQuoteManaged(options) {
 }
 
 // src/execution/use-execute-managed.ts
-import { useMutation as useMutation4, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+import { useMutation as useMutation2, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
 function useExecuteManaged(options) {
   const client = useAggClient();
   const queryClient = useQueryClient3();
-  return useMutation4({
+  return useMutation2({
     mutationFn: (params) => client.executeManaged(params),
     onSuccess: (data) => {
       var _a;
@@ -3041,11 +3105,11 @@ function useExecuteManaged(options) {
 }
 
 // src/execution/use-withdraw-managed.ts
-import { useMutation as useMutation5, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+import { useMutation as useMutation3, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
 function useWithdrawManaged(options) {
   const client = useAggClient();
   const queryClient = useQueryClient4();
-  return useMutation5({
+  return useMutation3({
     mutationFn: (params) => client.withdrawManaged(params),
     onSuccess: (data) => {
       var _a;
@@ -3153,11 +3217,11 @@ function useDepositAddresses(options) {
 }
 
 // src/execution/use-sync-balances.ts
-import { useMutation as useMutation6, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+import { useMutation as useMutation4, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
 function useSyncBalances(options) {
   const client = useAggClient();
   const queryClient = useQueryClient5();
-  return useMutation6({
+  return useMutation4({
     mutationFn: () => client.syncManagedBalances(),
     onSuccess: () => {
       var _a;
@@ -3465,11 +3529,11 @@ var computeClosedPositionTotals = (group) => {
 };
 
 // src/execution/use-redeem.ts
-import { useMutation as useMutation7, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+import { useMutation as useMutation5, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
 var useRedeem = () => {
   const client = useAggClient();
   const queryClient = useQueryClient6();
-  return useMutation7({
+  return useMutation5({
     mutationFn: (body) => client.redeem(body),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: executionKeys.positionsPrefix() });
@@ -3571,6 +3635,7 @@ export {
   useAggWebSocketConnectionState,
   useOnOrderSubmitted,
   useOnBalanceUpdate,
+  useOnWithdrawalLifecycle,
   DEFAULT_AGG_ROOT_CLASS_NAME,
   CHART_TIME_RANGES,
   resolveTradingStateKind,
@@ -3583,8 +3648,6 @@ export {
   useEventTradingContext,
   AggUiProvider,
   AggProvider,
-  useRampQuotes,
-  useRampSession,
   useQuoteManaged,
   useExecuteManaged,
   useWithdrawManaged,

package/dist/chunk-PALQVBAQ.mjs

@@ -0,0 +1,31 @@
+import {
+  __async,
+  useAggClient
+} from "./chunk-BWXNOWAS.mjs";
+
+// src/use-ramp-quotes.ts
+import { useMutation } from "@tanstack/react-query";
+function useRampQuotes() {
+  const client = useAggClient();
+  return useMutation({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.getRampQuotes(params);
+    })
+  });
+}
+
+// src/use-ramp-session.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useRampSession() {
+  const client = useAggClient();
+  return useMutation2({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.createRampSession(params);
+    })
+  });
+}
+
+export {
+  useRampQuotes,
+  useRampSession
+};

package/dist/chunk-QXBQRWFF.mjs

@@ -0,0 +1,389 @@
+import {
+  __async,
+  invalidateBalanceQueries,
+  useAggBalanceState,
+  useAggClient,
+  useAggWebSocket,
+  useAggWebSocketConnectionState,
+  useDepositAddresses,
+  useManagedBalances,
+  useOnWithdrawalLifecycle,
+  useSyncBalances,
+  useWithdrawManaged
+} from "./chunk-BWXNOWAS.mjs";
+
+// src/withdraw/use-withdraw-flow.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+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();
+  useEffect(() => {
+    if (!open) return;
+    syncBalances.mutate(void 0, {
+      onError: () => {
+      }
+    });
+  }, [open]);
+  const [withdrawDestination, setWithdrawDestination] = useState("");
+  const [withdrawAmount, setWithdrawAmount] = useState("");
+  const [withdrawToken, setWithdrawToken] = useState("USDC");
+  const [withdrawNetwork, setWithdrawNetwork] = useState("");
+  const [withdrawSummary, setWithdrawSummary] = useState(DEFAULT_WITHDRAW_SUMMARY);
+  const [withdrawalId, setWithdrawalId] = useState(null);
+  const networkOptions = 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) || "";
+  useEffect(() => {
+    if (!networkOptions.length) return;
+    if (!withdrawNetwork || !networkOptions.some((option) => option.value === withdrawNetwork)) {
+      setWithdrawNetwork(networkOptions[0].value);
+    }
+  }, [networkOptions, withdrawNetwork]);
+  const tokenOptions = 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) || "";
+  useEffect(() => {
+    if (!tokenOptions.length) return;
+    if (!tokenOptions.some((option) => option.value === withdrawToken)) {
+      setWithdrawToken(tokenOptions[0].value);
+    }
+  }, [tokenOptions, withdrawToken]);
+  const selectedCashEntry = useMemo(
+    () => balances == null ? void 0 : balances.cash.find((cashEntry) => cashEntry.tokenSymbol === resolvedWithdrawToken),
+    [balances, resolvedWithdrawToken]
+  );
+  const selectedTokenDecimals = 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 = useMemo(() => {
+    if (!selectedCashEntry) return "0";
+    return formatRawTokenAmount(selectedCashEntry.totalRaw, selectedCashEntry.decimals);
+  }, [selectedCashEntry]);
+  const balanceDisplay = useMemo(() => {
+    if (!selectedCashEntry) return `0.00 ${resolvedWithdrawToken || withdrawToken}`;
+    return `${formatRawTokenAmountForDisplay(
+      selectedCashEntry.totalRaw,
+      selectedCashEntry.decimals
+    )} ${resolvedWithdrawToken}`;
+  }, [resolvedWithdrawToken, selectedCashEntry, withdrawToken]);
+  const resetFlowState = useCallback(() => {
+    setWithdrawDestination("");
+    setWithdrawAmount("");
+    setWithdrawToken("USDC");
+    setWithdrawNetwork("");
+    setWithdrawSummary(DEFAULT_WITHDRAW_SUMMARY);
+    setWithdrawalId(null);
+  }, []);
+  const handleWithdrawOpenChange = useCallback(
+    (isOpen) => {
+      if (!isOpen) resetFlowState();
+      onOpenChange(isOpen);
+    },
+    [onOpenChange, resetFlowState]
+  );
+  useEffect(() => {
+    if (!open) resetFlowState();
+  }, [open, resetFlowState]);
+  const handleWithdrawProvider = 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: useCallback(() => {
+      setWithdrawAmount(exactBalance === "0" ? "0" : exactBalance);
+    }, [exactBalance]),
+    onSelectWithdrawProvider: useCallback(
+      (_providerId) => __async(null, null, function* () {
+        return handleWithdrawProvider();
+      }),
+      [handleWithdrawProvider]
+    ),
+    onDoneWithdraw: useCallback(() => handleWithdrawOpenChange(false), [handleWithdrawOpenChange])
+  };
+}
+
+// src/withdraw/use-withdrawal-lifecycle.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+import { useQueryClient } from "@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 = useQueryClient();
+  const [state, setState] = useState2(INITIAL_STATE);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const balanceRefetchedForRef = useRef(null);
+  useEffect2(() => {
+    setState(INITIAL_STATE);
+  }, [withdrawalId]);
+  useEffect2(() => {
+    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 = useMemo2(() => {
+    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);
+  useEffect2(() => {
+    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 = useCallback2(() => setState(INITIAL_STATE), []);
+  return { state, reset };
+}
+
+export {
+  useWithdrawFlow,
+  useWithdrawalLifecycle
+};