@rhinestone/deposit-modal 0.16.0 → 0.18.0

package/dist/{chunk-EA5CE2UZ.mjs → chunk-AIZKGFVA.mjs}

@@ -1,7 +1,3 @@
-import {
-  MODAL_VERSION,
-  serviceHeaders
-} from "./chunk-3HCCR54R.mjs";
 import {
   CHAIN_DISPLAY_ORDER,
   HYPERCORE_CHAIN_ID,
@@ -36,6 +32,10 @@ import {
   toEvmCaip2,
   tokenIconUrl
 } from "./chunk-EAGMY3QE.mjs";
+import {
+  MODAL_VERSION,
+  serviceHeaders
+} from "./chunk-3TEVMP76.mjs";
 
 // src/components/ui/Modal.tsx
 import {
@@ -650,12 +650,37 @@ function parseQuotePreview(raw) {
   );
   if (Math.abs(totalUsd - breakdownTotalUsd) > 1e-6) return null;
   const breakdown = Object.fromEntries(parsedEntries);
+  const timing = parseDepositTiming(obj.timing);
   return {
     settlementLayer: obj.settlementLayer,
     expiresAt: obj.expiresAt,
     estimatedFillTimeSeconds: obj.estimatedFillTimeSeconds,
     fees: { total: { usd: totalUsd }, breakdown },
-    output
+    output,
+    ...timing ? { timing } : {}
+  };
+}
+function parseDepositTiming(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const o = raw;
+  const seconds = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+  const expectedSeconds = seconds(o.expectedSeconds);
+  const softDelaySeconds = seconds(o.softDelaySeconds);
+  const escalatedDelaySeconds = seconds(o.escalatedDelaySeconds);
+  if (expectedSeconds === void 0 || softDelaySeconds === void 0 || escalatedDelaySeconds === void 0) {
+    return void 0;
+  }
+  return { expectedSeconds, softDelaySeconds, escalatedDelaySeconds };
+}
+function normalizeHistoryTiming(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return raw;
+  }
+  const { timing: rawTiming, ...row } = raw;
+  const timing = parseDepositTiming(rawTiming);
+  return {
+    ...row,
+    ...timing ? { timing } : {}
   };
 }
 function parseQuoteOutput(raw) {
@@ -711,6 +736,31 @@ function resolveAppFeeBps(appFees, sourceChainCaip2, sourceToken) {
   const bps = override ?? appFees?.feeBps ?? 0;
   return bps > 0 ? bps : 0;
 }
+function isRawAmount(value) {
+  return typeof value === "string" && /^\d+$/.test(value);
+}
+function isDepositPolicyRefusal(value) {
+  return typeof value === "object" && value !== null && "policyRefusal" in value;
+}
+var DEPOSIT_POLICY_REFUSAL_CODES = [
+  "TOKEN-3",
+  "BALANCE-3",
+  "BALANCE-4"
+];
+var DEPOSIT_PREFLIGHT_TIMEOUT_MS = 1e4;
+async function readPolicyRefusal(response) {
+  if (response.status !== 422) return null;
+  try {
+    const body = await response.json();
+    if (!body || typeof body.code !== "string" || !DEPOSIT_POLICY_REFUSAL_CODES.includes(body.code)) {
+      return null;
+    }
+    const message = typeof body.error === "string" && body.error !== "" ? body.error : "This deposit is not accepted.";
+    return { policyRefusal: { code: body.code, message } };
+  } catch {
+    return null;
+  }
+}
 var PermitDepositSubmitError = class extends Error {
   constructor(message, safeToTransfer) {
     super(message);
@@ -737,29 +787,60 @@ function createDepositService(baseUrl, options) {
     if (value.length <= 20) return value;
     return `${value.slice(0, 10)}...${value.slice(-8)}`;
   }
+  function withPreflightTimeout(label, fallback, run) {
+    const controller = new AbortController();
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        debugLog(debug, scope, `${label}:timeout`, {
+          timeoutMs: DEPOSIT_PREFLIGHT_TIMEOUT_MS
+        });
+        controller.abort();
+        resolve(fallback);
+      }, DEPOSIT_PREFLIGHT_TIMEOUT_MS);
+      run(controller.signal).then(
+        (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        () => {
+          clearTimeout(timer);
+          resolve(fallback);
+        }
+      );
+    });
+  }
   const PORTFOLIO_CACHE_TTL_MS = 3e4;
   const portfolioCache = /* @__PURE__ */ new Map();
   let topTokensPromise = null;
   let chainsPromise = null;
-  function parseTopTokens(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+  function parseDepositOptions(value) {
+    if (typeof value !== "object" || value === null) return null;
+    const { restricted, tokens: rawTokens } = value;
+    if (typeof restricted !== "boolean") return null;
+    if (typeof rawTokens !== "object" || rawTokens === null || Array.isArray(rawTokens)) {
       return null;
     }
-    const parsed = {};
-    for (const [chainKey, list] of Object.entries(value)) {
+    const tokens = {};
+    for (const [chainKey, list] of Object.entries(rawTokens)) {
       if (!Array.isArray(list)) return null;
-      const tokens = [];
+      const parsed = [];
       for (const entry of list) {
         if (typeof entry !== "object" || entry === null) return null;
-        const { symbol, address, decimals } = entry;
+        const { symbol, address, decimals, minAmount, maxAmount } = entry;
         if (typeof symbol !== "string" || typeof address !== "string" || typeof decimals !== "number") {
           return null;
         }
-        tokens.push({ symbol, address, decimals });
+        parsed.push({
+          symbol,
+          address,
+          decimals,
+          ...isRawAmount(minAmount) && { minAmount },
+          ...isRawAmount(maxAmount) && { maxAmount }
+        });
       }
-      parsed[chainKey] = tokens;
+      tokens[chainKey] = parsed;
     }
-    return parsed;
+    return { restricted, tokens };
   }
   async function requestTopTokens() {
     try {
@@ -771,21 +852,21 @@ function createDepositService(baseUrl, options) {
         debugLog(debug, scope, "getTopTokens:unavailable", {
           status: response.status
         });
-        return null;
+        return { ok: false };
       }
-      const data = await response.json();
-      const tokens = parseTopTokens(data.tokens);
-      if (!tokens) {
+      const options2 = parseDepositOptions(await response.json());
+      if (!options2) {
         debugLog(debug, scope, "getTopTokens:malformed");
-        return null;
+        return { ok: false };
       }
       debugLog(debug, scope, "getTopTokens:success", {
-        chains: Object.keys(tokens).length
+        chains: Object.keys(options2.tokens).length,
+        restricted: options2.restricted
       });
-      return tokens;
+      return { ok: true, options: options2 };
     } catch (error) {
       debugError(debug, scope, "getTopTokens:error", error);
-      return null;
+      return { ok: false };
     }
   }
   async function requestChains() {
@@ -1197,7 +1278,7 @@ function createDepositService(baseUrl, options) {
         );
       }
       const data = await response.json();
-      const deposits = Array.isArray(data?.deposits) ? data.deposits : [];
+      const deposits = Array.isArray(data?.deposits) ? data.deposits.map(normalizeHistoryTiming) : [];
       const nextCursor = data?.nextCursor ?? data?.next_cursor ?? null;
       debugLog(debug, scope, "fetchDepositHistory:success", {
         recipient: shortRef(params.recipient),
@@ -1278,36 +1359,46 @@ function createDepositService(baseUrl, options) {
         sourceToken: params.sourceToken,
         amount: params.amount
       });
-      try {
-        const response = await fetch(url, {
-          method: "POST",
-          headers: serviceHeaders(),
-          body: JSON.stringify(body),
-          cache: "no-store"
-        });
-        if (!response.ok) {
-          debugLog(debug, scope, "getQuotePreview:unavailable", {
-            status: response.status
+      return withPreflightTimeout("getQuotePreview", null, async (signal) => {
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: serviceHeaders(),
+            body: JSON.stringify(body),
+            cache: "no-store",
+            signal
           });
-          return null;
-        }
-        const quote = parseQuotePreview(await response.json());
-        if (!quote) {
-          debugLog(debug, scope, "getQuotePreview:unavailable", {
-            status: response.status,
-            reason: "malformed"
+          if (!response.ok) {
+            const refusal = await readPolicyRefusal(response);
+            if (refusal) {
+              debugLog(debug, scope, "getQuotePreview:refused", {
+                code: refusal.policyRefusal.code
+              });
+              return refusal;
+            }
+            debugLog(debug, scope, "getQuotePreview:unavailable", {
+              status: response.status
+            });
+            return null;
+          }
+          const quote = parseQuotePreview(await response.json());
+          if (!quote) {
+            debugLog(debug, scope, "getQuotePreview:unavailable", {
+              status: response.status,
+              reason: "malformed"
+            });
+            return null;
+          }
+          debugLog(debug, scope, "getQuotePreview:success", {
+            settlementLayer: quote.settlementLayer,
+            totalUsd: quote.fees.total.usd
           });
+          return quote;
+        } catch (error) {
+          debugError(debug, scope, "getQuotePreview:error", error);
           return null;
         }
-        debugLog(debug, scope, "getQuotePreview:success", {
-          settlementLayer: quote.settlementLayer,
-          totalUsd: quote.fees.total.usd
-        });
-        return quote;
-      } catch (error) {
-        debugError(debug, scope, "getQuotePreview:error", error);
-        return null;
-      }
+      });
     },
     async preparePermitDeposit(params) {
       const url = apiUrl("/deposits/permit/prepare");
@@ -1318,88 +1409,98 @@ function createDepositService(baseUrl, options) {
         token: params.token,
         amount: params.amount
       });
-      try {
-        const response = await fetch(url, {
-          method: "POST",
-          headers: serviceHeaders(),
-          body: JSON.stringify({ ...params, kind: "auto" }),
-          cache: "no-store"
-        });
-        if (!response.ok) {
-          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
-            status: response.status
-          });
-          return null;
-        }
-        const data = await response.json();
-        if (!data || typeof data.available !== "boolean") {
-          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
-            status: response.status,
-            reason: "malformed"
+      return withPreflightTimeout("preparePermitDeposit", null, async (signal) => {
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: serviceHeaders(),
+            body: JSON.stringify({ ...params, kind: "auto" }),
+            cache: "no-store",
+            signal
           });
-          return null;
-        }
-        if (data.available === false) {
-          const reason = data.reason;
-          if (reason !== "permit2-approval-required" && reason !== "unsupported-token" && reason !== "unsupported-owner") {
+          if (!response.ok) {
+            const refusal = await readPolicyRefusal(response);
+            if (refusal) {
+              debugLog(debug, scope, "preparePermitDeposit:refused", {
+                code: refusal.policyRefusal.code
+              });
+              return refusal;
+            }
+            debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+              status: response.status
+            });
             return null;
           }
-          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
-            status: response.status,
-            reason
-          });
-          const approval = data.approval;
-          const parsedApproval = approval && typeof approval.token === "string" && typeof approval.spender === "string" && typeof approval.minimumAmount === "string" ? {
-            token: approval.token,
-            spender: approval.spender,
-            minimumAmount: approval.minimumAmount
-          } : void 0;
-          return {
-            available: false,
-            reason,
-            ...parsedApproval && { approval: parsedApproval }
-          };
-        }
-        const authorization = data.authorization;
-        if (!authorization || typeof authorization.typedData !== "object" || authorization.typedData === null || typeof authorization.nonce !== "string") {
-          return null;
-        }
-        if (authorization.kind === "erc3009" && typeof authorization.validAfter === "string" && typeof authorization.validBefore === "string") {
-          debugLog(debug, scope, "preparePermitDeposit:success", {
-            kind: authorization.kind,
-            nonce: authorization.nonce
-          });
-          return {
-            available: true,
-            authorization: {
-              kind: "erc3009",
-              typedData: authorization.typedData,
-              nonce: authorization.nonce,
-              validAfter: authorization.validAfter,
-              validBefore: authorization.validBefore
+          const data = await response.json();
+          if (!data || typeof data.available !== "boolean") {
+            debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+              status: response.status,
+              reason: "malformed"
+            });
+            return null;
+          }
+          if (data.available === false) {
+            const reason = data.reason;
+            if (reason !== "permit2-approval-required" && reason !== "unsupported-token" && reason !== "unsupported-owner") {
+              return null;
             }
-          };
-        }
-        if ((authorization.kind === "erc2612" || authorization.kind === "permit2") && typeof authorization.deadline === "string") {
-          debugLog(debug, scope, "preparePermitDeposit:success", {
-            kind: authorization.kind,
-            nonce: authorization.nonce
-          });
-          return {
-            available: true,
-            authorization: {
+            debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+              status: response.status,
+              reason
+            });
+            const approval = data.approval;
+            const parsedApproval = approval && typeof approval.token === "string" && typeof approval.spender === "string" && typeof approval.minimumAmount === "string" ? {
+              token: approval.token,
+              spender: approval.spender,
+              minimumAmount: approval.minimumAmount
+            } : void 0;
+            return {
+              available: false,
+              reason,
+              ...parsedApproval && { approval: parsedApproval }
+            };
+          }
+          const authorization = data.authorization;
+          if (!authorization || typeof authorization.typedData !== "object" || authorization.typedData === null || typeof authorization.nonce !== "string") {
+            return null;
+          }
+          if (authorization.kind === "erc3009" && typeof authorization.validAfter === "string" && typeof authorization.validBefore === "string") {
+            debugLog(debug, scope, "preparePermitDeposit:success", {
               kind: authorization.kind,
-              typedData: authorization.typedData,
-              nonce: authorization.nonce,
-              deadline: authorization.deadline
-            }
-          };
+              nonce: authorization.nonce
+            });
+            return {
+              available: true,
+              authorization: {
+                kind: "erc3009",
+                typedData: authorization.typedData,
+                nonce: authorization.nonce,
+                validAfter: authorization.validAfter,
+                validBefore: authorization.validBefore
+              }
+            };
+          }
+          if ((authorization.kind === "erc2612" || authorization.kind === "permit2") && typeof authorization.deadline === "string") {
+            debugLog(debug, scope, "preparePermitDeposit:success", {
+              kind: authorization.kind,
+              nonce: authorization.nonce
+            });
+            return {
+              available: true,
+              authorization: {
+                kind: authorization.kind,
+                typedData: authorization.typedData,
+                nonce: authorization.nonce,
+                deadline: authorization.deadline
+              }
+            };
+          }
+          return null;
+        } catch (error) {
+          debugError(debug, scope, "preparePermitDeposit:error", error);
+          return null;
         }
-        return null;
-      } catch (error) {
-        debugError(debug, scope, "preparePermitDeposit:error", error);
-        return null;
-      }
+      });
     },
     async submitPermitDeposit(params) {
       const url = apiUrl("/deposits/permit");
@@ -1708,9 +1809,11 @@ function createDepositService(baseUrl, options) {
     },
     getTopTokens() {
       if (!topTokensPromise) {
-        const attempt = requestTopTokens().then((tokens) => {
-          if (!tokens && topTokensPromise === attempt) topTokensPromise = null;
-          return tokens;
+        const attempt = requestTopTokens().then((result) => {
+          if (!result.ok && topTokensPromise === attempt) {
+            topTokensPromise = null;
+          }
+          return result;
         });
         topTokensPromise = attempt;
       }
@@ -1939,6 +2042,7 @@ function useStableRpcUrls(rpcUrls) {
 // src/core/chain-catalog-context.tsx
 import {
   createContext as createContext2,
+  useCallback as useCallback2,
   useContext as useContext2,
   useEffect as useEffect2,
   useMemo as useMemo2,
@@ -1946,6 +2050,59 @@ import {
   useSyncExternalStore
 } from "react";
 
+// src/core/deposit-bounds.ts
+import { formatUnits } from "viem";
+function findListed(options, chain, token) {
+  const normalize2 = (value) => chain === "solana" ? value : value.toLowerCase();
+  return options.tokens[String(chain)]?.find(
+    (listed) => normalize2(listed.address) === normalize2(token)
+  );
+}
+function isExcludedByRestrictedList(options, chain, token) {
+  return Boolean(options?.restricted && !findListed(options, chain, token));
+}
+function findDepositBounds(options, chain, token) {
+  if (!options?.restricted) return void 0;
+  const entry = findListed(options, chain, token);
+  if (!entry || entry.minAmount === void 0 && entry.maxAmount === void 0) {
+    return void 0;
+  }
+  return {
+    symbol: entry.symbol,
+    decimals: entry.decimals,
+    ...entry.minAmount !== void 0 && { minAmount: BigInt(entry.minAmount) },
+    ...entry.maxAmount !== void 0 && { maxAmount: BigInt(entry.maxAmount) }
+  };
+}
+function boundMessage(bounds, bound) {
+  const raw = bounds?.[bound];
+  if (!bounds || raw === void 0) return null;
+  const amount = new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: Math.min(bounds.decimals, 20)
+  }).format(Number(formatUnits(raw, bounds.decimals)));
+  return `${bound === "minAmount" ? "Minimum" : "Maximum"} deposit is ${amount} ${bounds.symbol}`;
+}
+function depositBoundsViolation(bounds, units) {
+  if (!bounds || units === null || units <= 0n) return null;
+  if (bounds.minAmount !== void 0 && units < bounds.minAmount) {
+    return boundMessage(bounds, "minAmount");
+  }
+  if (bounds.maxAmount !== void 0 && units > bounds.maxAmount) {
+    return boundMessage(bounds, "maxAmount");
+  }
+  return null;
+}
+function describePolicyRefusal(refusal, bounds) {
+  switch (refusal.code) {
+    case "BALANCE-4":
+      return boundMessage(bounds, "minAmount") ?? "This amount is below the minimum deposit";
+    case "BALANCE-3":
+      return boundMessage(bounds, "maxAmount") ?? "This amount is above the maximum deposit";
+    default:
+      return "This token isn't accepted for deposits";
+  }
+}
+
 // src/core/public-client.ts
 import { createPublicClient, http } from "viem";
 var clientCache = /* @__PURE__ */ new Map();
@@ -2110,6 +2267,9 @@ var EMPTY = {
   viemChains: null,
   isLoading: true,
   shortlist: null,
+  depositOptions: { status: "loading" },
+  retryDepositOptions: () => {
+  },
   clientCapableChainIds: null
 };
 var ChainCatalogContext = createContext2(EMPTY);
@@ -2267,6 +2427,48 @@ function useTargetTokens() {
     };
   }, [catalog, shortlist]);
 }
+function createDepositOffer(state, retry) {
+  const options = state.status === "ready" ? state.options : null;
+  const restricted = options?.restricted ?? false;
+  const listed = (chain) => options?.tokens[String(chain)];
+  const isChainOffered = (chain) => {
+    if (!options) return false;
+    const entry = listed(chain);
+    return restricted ? (entry?.length ?? 0) > 0 : entry?.length !== 0;
+  };
+  return {
+    status: state.status,
+    restricted,
+    retry,
+    tokensFor: (chain) => {
+      if (!options) return [];
+      const entry = listed(chain);
+      return restricted ? entry ?? [] : entry;
+    },
+    isChainOffered
+  };
+}
+function useDepositOffer() {
+  const { depositOptions, retryDepositOptions } = useChainCatalog();
+  return useMemo2(
+    () => createDepositOffer(depositOptions, retryDepositOptions),
+    [depositOptions, retryDepositOptions]
+  );
+}
+function useDepositBounds() {
+  const { depositOptions } = useChainCatalog();
+  return useMemo2(() => {
+    const options = depositOptions.status === "ready" ? depositOptions.options : null;
+    return (chain, token) => findDepositBounds(options, chain, token);
+  }, [depositOptions]);
+}
+function useRestrictedListExclusion() {
+  const { depositOptions } = useChainCatalog();
+  return useMemo2(() => {
+    const options = depositOptions.status === "ready" ? depositOptions.options : null;
+    return (chain, token) => isExcludedByRestrictedList(options, chain, token);
+  }, [depositOptions]);
+}
 function useIsDepositChain() {
   const ids = useDepositChainIds();
   const { clientCapableChainIds } = useChainCatalog();
@@ -2359,19 +2561,36 @@ function ChainCatalogProvider({
     const chains = toViemChains(catalog, overrides, viemChains);
     if (chains.length > 0) setRuntimeChains(chains);
   }, [catalog, viemChains, overrides]);
-  const [shortlist, setShortlist] = useState(null);
+  const [depositOptions, setDepositOptions] = useState({
+    status: "loading"
+  });
+  const [depositOptionsAttempt, setDepositOptionsAttempt] = useState(0);
   useEffect2(() => {
     let active = true;
-    setShortlist(null);
-    service.getTopTokens().then((tokens) => {
-      if (!active || !tokens) return;
-      publishShortlistTokens(tokens);
-      setShortlist(tokens);
-    });
+    setDepositOptions({ status: "loading" });
+    service.getTopTokens().then(
+      (result) => {
+        if (!active) return;
+        if (!result?.ok) {
+          setDepositOptions({ status: "error" });
+          return;
+        }
+        publishShortlistTokens(result.options.tokens);
+        setDepositOptions({ status: "ready", options: result.options });
+      },
+      () => {
+        if (active) setDepositOptions({ status: "error" });
+      }
+    );
     return () => {
       active = false;
     };
-  }, [service]);
+  }, [service, depositOptionsAttempt]);
+  const retryDepositOptions = useCallback2(
+    () => setDepositOptionsAttempt((attempt) => attempt + 1),
+    []
+  );
+  const shortlist = depositOptions.status === "ready" ? depositOptions.options.tokens : null;
   const clientCapableChainIds = useMemo2(() => {
     if (!catalog) return null;
     return new Set(
@@ -2384,9 +2603,19 @@ function ChainCatalogProvider({
       viemChains,
       isLoading,
       shortlist,
+      depositOptions,
+      retryDepositOptions,
       clientCapableChainIds
     }),
-    [catalog, viemChains, isLoading, shortlist, clientCapableChainIds]
+    [
+      catalog,
+      viemChains,
+      isLoading,
+      shortlist,
+      depositOptions,
+      retryDepositOptions,
+      clientCapableChainIds
+    ]
   );
   return /* @__PURE__ */ jsx3(ChainCatalogContext.Provider, { value, children });
 }
@@ -2404,7 +2633,7 @@ function useLatestRef(value) {
 // src/core/analytics.tsx
 import {
   createContext as createContext3,
-  useCallback as useCallback2,
+  useCallback as useCallback3,
   useContext as useContext3,
   useEffect as useEffect4,
   useMemo as useMemo3,
@@ -2792,7 +3021,7 @@ function AnalyticsSession(props) {
   nowRef.current = props.now ?? (() => /* @__PURE__ */ new Date());
   const modal = props.modal;
   const reportedFailuresRef = useRef3(/* @__PURE__ */ new Set());
-  const emitFailure = useCallback2(
+  const emitFailure = useCallback3(
     ({ reason, status, droppedEvents }) => {
       if (reportedFailuresRef.current.has(reason)) return;
       reportedFailuresRef.current.add(reason);
@@ -2842,7 +3071,7 @@ function AnalyticsSession(props) {
     ingestRef.current = createIngest();
   }
   const pendingDisposalRef = useRef3(null);
-  const enqueue = useCallback2(
+  const enqueue = useCallback3(
     (event) => {
       try {
         ingestRef.current?.transport?.enqueue(
@@ -2877,7 +3106,7 @@ function AnalyticsSession(props) {
       }, 0);
     };
   }, [emitFailure]);
-  const emitDeposit = useCallback2(
+  const emitDeposit = useCallback3(
     (...[payload, fundingMethod]) => {
       if (modal !== "deposit") return;
       const event = {
@@ -2896,7 +3125,7 @@ function AnalyticsSession(props) {
     },
     [enqueue, modal, nowRef, onEventRef]
   );
-  const emitWithdraw = useCallback2(
+  const emitWithdraw = useCallback3(
     (payload) => {
       if (modal !== "withdraw") return;
       const event = {
@@ -2912,7 +3141,7 @@ function AnalyticsSession(props) {
     },
     [enqueue, modal, nowRef, onEventRef]
   );
-  const emitClaim = useCallback2(
+  const emitClaim = useCallback3(
     (payload) => {
       if (modal !== "claim") return;
       const event = {
@@ -2986,17 +3215,38 @@ function recoveryFailureCause(sourceChainName) {
 }
 
 // src/core/history-status.ts
-function normalizeStatus(raw, isSpam) {
+var UNKNOWN = ["pending", false, []];
+var STATUS_FACTS = [
+  // `delayed` is held up but still coming on the corridor's schedule.
+  ["pending", true, ["pending", "delayed"]],
+  // Nothing emits `submitted` or `bridging`; they are here so the badge and
+  // the arrival line cannot diverge should a row ever carry them.
+  ["processing", true, ["processing", "submitted", "bridging"]],
+  ["completed", false, ["completed", "complete", "bridge-complete", "processed"]],
+  // `rejected` is recoverable upstream exactly like `failed`, so it must not
+  // read as Pending — a row offering recovery would otherwise claim to still
+  // be on its way.
+  ["failed", false, ["failed", "error", "bridge-failed", "rejected"]],
+  // Where a recovered deposit lands. Terminal and not recoverable again.
+  ["refunded", false, ["refunded"]],
+  // These read Pending but are not arriving: the deposit is bound for a refund
+  // or for manual reconciliation rather than for the recipient, so an arrival
+  // expectation would be a claim about a corridor it never enters.
+  ["pending", false, ["ignored", "expecting_refund", "reconciliation_required"]]
+];
+function lookup(raw) {
   const lower = raw.toLowerCase();
-  if (lower === "completed" || lower === "complete" || lower === "bridge-complete" || lower === "processed")
-    return "completed";
-  if (lower === "failed" || lower === "error" || lower === "bridge-failed" || lower === "rejected") {
-    return isSpam ? "spam" : "failed";
-  }
-  if (lower === "refunded") return "refunded";
-  if (lower === "processing" || lower === "submitted" || lower === "bridging")
-    return "processing";
-  return "pending";
+  return STATUS_FACTS.find((facts) => facts[2].includes(lower)) ?? UNKNOWN;
+}
+function normalizeStatus(raw, isSpam) {
+  const [badge] = lookup(raw);
+  return isSpam && badge === "failed" ? "spam" : badge;
+}
+function isInFlight(status) {
+  return status === "pending" || status === "processing";
+}
+function expectsArrival(raw) {
+  return lookup(raw)[1];
 }
 var STATUS_LABEL = {
   pending: "Pending",
@@ -3016,20 +3266,37 @@ function filterVisibleDeposits(deposits) {
 }
 
 // src/core/history-badge.ts
-function deriveHistoryBadge(deposits, { recipient, canRecover }) {
+var RECOVERY_INDICATOR_WINDOW_MS = 30 * 24 * 60 * 60 * 1e3;
+function deriveHistoryBadgeState(deposits, {
+  recipient,
+  canRecover,
+  evaluatedAt = Date.now()
+}) {
   const visible = filterVisibleDeposits(deposits);
   if (canRecover) {
-    const needsYou = visible.filter(
-      (row) => toRecoverableDeposit(row, { recipient }) !== null
-    ).length;
-    if (needsYou > 0) return { state: "needs-you", count: needsYou };
-  }
-  const inProgress = visible.filter((row) => {
-    const status = normalizeStatus(row.status, row.isSpam);
-    return status === "pending" || status === "processing";
-  }).length;
-  if (inProgress > 0) return { state: "progress", count: inProgress };
-  return null;
+    let count = 0;
+    let nextExpiryAt = null;
+    for (const row of visible) {
+      if (toRecoverableDeposit(row, { recipient }) === null) continue;
+      const expiryAt = Date.parse(row.createdAt ?? "") + RECOVERY_INDICATOR_WINDOW_MS;
+      if (!(evaluatedAt < expiryAt)) continue;
+      count += 1;
+      nextExpiryAt = nextExpiryAt === null ? expiryAt : Math.min(nextExpiryAt, expiryAt);
+    }
+    if (count > 0) {
+      return {
+        badge: { state: "needs-you", count },
+        nextExpiryAt
+      };
+    }
+  }
+  const inProgress = visible.filter(
+    (row) => isInFlight(normalizeStatus(row.status, row.isSpam))
+  ).length;
+  return {
+    badge: inProgress > 0 ? { state: "progress", count: inProgress } : null,
+    nextExpiryAt: null
+  };
 }
 function historyBadgeAriaLabel(badge) {
   if (!badge) return "Deposit history";
@@ -3069,11 +3336,11 @@ function HistoryEntryButton({
 }
 
 // src/components/history/HistoryOverlay.tsx
-import { useCallback as useCallback6, useEffect as useEffect10, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect10, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
 
 // src/components/history/DepositHistoryPanel.tsx
 import {
-  useCallback as useCallback3,
+  useCallback as useCallback4,
   useEffect as useEffect5,
   useId,
   useMemo as useMemo4,
@@ -3351,8 +3618,83 @@ function TokenIcon({ symbol, className, fallback }) {
 }
 TokenIcon.displayName = "TokenIcon";
 
+// src/core/deposit-timing.ts
+var FALLBACK_SOFT_DELAY_MS = {
+  confirming: 90 * 1e3,
+  received: 90 * 1e3,
+  bridging: 4 * 60 * 1e3
+};
+var FALLBACK_ESCALATED_DELAY_MS = 10 * 60 * 1e3;
+var MIN_SOFT_DELAY_MS = 90 * 1e3;
+function formatExpectedDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) return "a few seconds";
+  if (seconds < 60) {
+    const whole = Math.round(seconds);
+    return `~${whole} second${whole === 1 ? "" : "s"}`;
+  }
+  return `~${Math.max(1, Math.round(seconds / 60))} min`;
+}
+function resolveServedThresholds(timing) {
+  const softMs = Math.max(timing.softDelaySeconds * 1e3, MIN_SOFT_DELAY_MS);
+  return {
+    softMs,
+    escalatedMs: Math.max(timing.escalatedDelaySeconds * 1e3, softMs)
+  };
+}
+function resolveServedTimingState(timing, totalElapsedMs) {
+  const { softMs, escalatedMs } = resolveServedThresholds(timing);
+  if (totalElapsedMs >= escalatedMs) return "escalated";
+  if (totalElapsedMs >= softMs) return "soft";
+  return "expected";
+}
+function resolvePendingTimingState({
+  timing,
+  totalElapsedMs,
+  phaseId,
+  phaseElapsedMs
+}) {
+  if (timing) return resolveServedTimingState(timing, totalElapsedMs);
+  if (totalElapsedMs >= FALLBACK_ESCALATED_DELAY_MS) return "escalated";
+  if (phaseId && phaseElapsedMs >= FALLBACK_SOFT_DELAY_MS[phaseId]) {
+    return "soft";
+  }
+  return "expected";
+}
+var STATE_ORDER = {
+  expected: 0,
+  soft: 1,
+  escalated: 2
+};
+function advancePendingTimingState(previous, next) {
+  return STATE_ORDER[next] > STATE_ORDER[previous] ? next : previous;
+}
+
+// src/core/history-timing.ts
+function resolveHistoryTiming({
+  status,
+  timing,
+  createdAt,
+  nowMs
+}) {
+  if (!expectsArrival(status) || !timing || !createdAt) {
+    return void 0;
+  }
+  const createdAtMs = Date.parse(createdAt);
+  if (!Number.isFinite(createdAtMs)) return void 0;
+  const elapsedMs = Math.max(0, nowMs - createdAtMs);
+  const state = resolveServedTimingState(timing, elapsedMs);
+  const { softMs, escalatedMs } = resolveServedThresholds(timing);
+  const nextTransitionAtMs = state === "expected" ? createdAtMs + softMs : state === "soft" ? createdAtMs + escalatedMs : void 0;
+  return {
+    state,
+    expectedDuration: formatExpectedDuration(timing.expectedSeconds),
+    ...nextTransitionAtMs !== void 0 ? { nextTransitionAtMs } : {}
+  };
+}
+
 // src/components/history/DepositHistoryPanel.tsx
 import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+var MAX_TIMER_DELAY_MS = 2147e6;
 function shortenHash(hash) {
   if (hash.length <= 14) return hash;
   return `${hash.slice(0, 6)}\u2026${hash.slice(-4)}`;
@@ -3458,7 +3800,7 @@ function DepositHistoryPanel({
   useEffect5(() => {
     rootRef.current?.toggleAttribute("inert", Boolean(obscured));
   }, [obscured]);
-  const handleKeyDown = useCallback3(
+  const handleKeyDown = useCallback4(
     (e) => {
       if (obscured) return;
       if (e.key === "Escape") {
@@ -3472,6 +3814,48 @@ function DepositHistoryPanel({
     () => filterVisibleDeposits(deposits),
     [deposits]
   );
+  const [nowMs, setNowMs] = useState3(() => Date.now());
+  const timingPresentations = useMemo4(
+    () => visibleDeposits.map(
+      (deposit) => resolveHistoryTiming({
+        status: deposit.status,
+        timing: deposit.timing,
+        createdAt: deposit.createdAt,
+        nowMs
+      })
+    ),
+    [nowMs, visibleDeposits]
+  );
+  useEffect5(() => {
+    setNowMs(Date.now());
+  }, [visibleDeposits]);
+  useEffect5(() => {
+    const nextBoundary = timingPresentations.reduce(
+      (earliest, presentation) => {
+        const next = presentation?.nextTransitionAtMs;
+        if (next === void 0) return earliest;
+        return earliest === void 0 || next < earliest ? next : earliest;
+      },
+      void 0
+    );
+    if (nextBoundary === void 0) return;
+    let timeout;
+    const updateAtBoundary = () => {
+      const current = Date.now();
+      if (current < nextBoundary) {
+        timeout = setTimeout(
+          updateAtBoundary,
+          Math.min(nextBoundary - current, MAX_TIMER_DELAY_MS)
+        );
+        return;
+      }
+      setNowMs(current);
+    };
+    updateAtBoundary();
+    return () => {
+      if (timeout !== void 0) clearTimeout(timeout);
+    };
+  }, [timingPresentations]);
   return /* @__PURE__ */ jsxs8(
     "div",
     {
@@ -3548,6 +3932,7 @@ function DepositHistoryPanel({
                 HistoryCard,
                 {
                   deposit,
+                  timing: timingPresentations[i],
                   position: i,
                   recipient,
                   onRecover,
@@ -3575,6 +3960,7 @@ function DepositHistoryPanel({
 }
 function HistoryCard({
   deposit,
+  timing,
   position,
   recipient,
   onRecover,
@@ -3682,6 +4068,16 @@ function HistoryCard({
               }
             )
           ] }),
+          timing && /* @__PURE__ */ jsx13(
+            "span",
+            {
+              className: "rs-history-card-timing",
+              "data-state": timing.state,
+              "aria-live": "polite",
+              "aria-atomic": "true",
+              children: timing.state === "expected" ? `Usually arrives in ${timing.expectedDuration}` : timing.state === "soft" ? "Taking longer than usual" : "Taking much longer than usual"
+            }
+          ),
           recoverable && /* @__PURE__ */ jsxs8(
             Button,
             {
@@ -3705,7 +4101,7 @@ function HistoryCard({
 DepositHistoryPanel.displayName = "DepositHistoryPanel";
 
 // src/components/history/HistoryFallbackFlow.tsx
-import { useCallback as useCallback4, useEffect as useEffect7, useRef as useRef5, useState as useState5 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef5, useState as useState5 } from "react";
 
 // src/components/ui/ListRow.tsx
 import { Fragment as Fragment3, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
@@ -3889,10 +4285,10 @@ function RecoveryLookupScreen({
 RecoveryLookupScreen.displayName = "RecoveryLookupScreen";
 
 // src/components/recovery/recovery-display.ts
-import { formatUnits as formatUnits2 } from "viem";
+import { formatUnits as formatUnits3 } from "viem";
 
 // src/core/token-amount.ts
-import { formatUnits } from "viem";
+import { formatUnits as formatUnits2 } from "viem";
 var STABLECOIN_SYMBOLS = /* @__PURE__ */ new Set([
   "USDC",
   "USDT",
@@ -3956,7 +4352,7 @@ function formatTokenAmount(amount, symbol) {
 function tokenAmountToNumber(rawAmount, decimals) {
   if (decimals === void 0) return void 0;
   try {
-    const value = Number(formatUnits(BigInt(rawAmount), decimals));
+    const value = Number(formatUnits2(BigInt(rawAmount), decimals));
     return Number.isFinite(value) ? value : void 0;
   } catch {
     return void 0;
@@ -4043,18 +4439,18 @@ function describeRecoveryDeposit(params) {
   const decimals = getTokenDecimalsByAddress(token, params.chainId);
   const symbol = getTokenSymbol(token, params.chainId);
   const raw = toBigInt(params.amountRaw);
-  const human = Number(formatUnits2(raw, decimals));
+  const human = Number(formatUnits3(raw, decimals));
   return {
     symbol,
     decimals,
-    amount: formatTokenAmount(human, symbol) ?? formatUnits2(raw, decimals),
+    amount: formatTokenAmount(human, symbol) ?? formatUnits3(raw, decimals),
     chainName: getChainName(params.chainId),
     chainIcon: getChainIcon(params.chainId)
   };
 }
 function formatRecoveryAmount(amountRaw, decimals, symbol) {
   const raw = toBigInt(amountRaw);
-  return formatTokenAmount(Number(formatUnits2(raw, decimals)), symbol) ?? formatUnits2(raw, decimals);
+  return formatTokenAmount(Number(formatUnits3(raw, decimals)), symbol) ?? formatUnits3(raw, decimals);
 }
 function toBigInt(value) {
   try {
@@ -4542,7 +4938,7 @@ function HistoryFallbackFlow({
       epochRef.current += 1;
     };
   }, [recipient]);
-  const reportSelection = useCallback4(
+  const reportSelection = useCallback5(
     (match, autoSelected) => {
       analytics.selectDeposit({
         depositId: match.depositId,
@@ -4552,7 +4948,7 @@ function HistoryFallbackFlow({
     },
     [analytics]
   );
-  const lookup = useCallback4(
+  const lookup2 = useCallback5(
     async (txHash) => {
       const epoch = epochRef.current;
       const isCurrentLookup = () => epochRef.current === epoch;
@@ -4595,7 +4991,7 @@ function HistoryFallbackFlow({
     },
     [analytics, service, recipient, onFound, reportSelection]
   );
-  const selectMatch = useCallback4(
+  const selectMatch = useCallback5(
     (match) => {
       analytics.completeStep("select");
       reportSelection(match, false);
@@ -4603,7 +4999,7 @@ function HistoryFallbackFlow({
     },
     [analytics, onFound, reportSelection]
   );
-  const handleKeyDown = useCallback4(
+  const handleKeyDown = useCallback5(
     (e) => {
       if (e.key === "Escape") {
         e.stopPropagation();
@@ -4682,7 +5078,7 @@ function HistoryFallbackFlow({
             hint: "The transaction hash from the wallet or exchange you sent from.",
             loading,
             error,
-            onSubmit: lookup,
+            onSubmit: lookup2,
             onInvalid: () => analytics.friction("lookup_transaction_hash_invalid", "lookup")
           }
         )
@@ -4698,7 +5094,7 @@ function newestFirst(rows) {
 HistoryFallbackFlow.displayName = "HistoryFallbackFlow";
 
 // src/components/history/HistoryRecoveryFlow.tsx
-import { useCallback as useCallback5, useEffect as useEffect9, useRef as useRef6, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect9, useRef as useRef6, useState as useState7 } from "react";
 
 // src/components/recovery/RecoveryOutcomeScreen.tsx
 import { jsx as jsx19, jsxs as jsxs13 } from "react/jsx-runtime";
@@ -4902,7 +5298,7 @@ function HistoryRecoveryFlow({
     token: deposit.token,
     amountRaw: deposit.amountRaw
   });
-  const submit = useCallback5(
+  const submit = useCallback6(
     async (destination) => {
       setPhase("submitting");
       onSubmittingChange(true);
@@ -4974,7 +5370,7 @@ function HistoryRecoveryFlow({
       symbol
     ]
   );
-  const retry = useCallback5(() => {
+  const retry = useCallback6(() => {
     const reason = lastFailureRef.current;
     if (reason) {
       lastFailureRef.current = null;
@@ -5071,7 +5467,7 @@ function HistoryOverlay({
   const [fallbackOpen, setFallbackOpen] = useState8(false);
   const [attempt, setAttempt] = useState8(null);
   const claimControllerRef = useRef7(null);
-  const beginAttempt = useCallback6(
+  const beginAttempt = useCallback7(
     (entrySource) => {
       const id = randomUuid();
       const started = {
@@ -5089,7 +5485,7 @@ function HistoryOverlay({
     },
     [analytics]
   );
-  const endAttempt = useCallback6(
+  const endAttempt = useCallback7(
     (source, reason) => {
       const claim = claimControllerRef.current;
       claim?.abandon(reason);
@@ -5099,12 +5495,12 @@ function HistoryOverlay({
     },
     []
   );
-  const openFallback = useCallback6(() => {
+  const openFallback = useCallback7(() => {
     const started = beginAttempt("history_fallback");
     analytics.fallbackOpened(started.id);
     setFallbackOpen(true);
   }, [analytics, beginAttempt]);
-  const closeFallback = useCallback6(
+  const closeFallback = useCallback7(
     (via) => {
       endAttempt(via === "escape" ? "escape" : "history_back", "back");
       setFallbackOpen(false);
@@ -5117,7 +5513,7 @@ function HistoryOverlay({
     setFallbackOpen(false);
     if (fallbackOpen && !recovering) endAttempt("host_controlled", "back");
   }, [canLookup, fallbackOpen, recovering, endAttempt]);
-  const startRecoveryFromRow = useCallback6(
+  const startRecoveryFromRow = useCallback7(
     (deposit) => {
       const started = beginAttempt("history_row");
       analytics.recoveryStarted(started.id, "history_row", deposit.depositId);
@@ -5125,7 +5521,7 @@ function HistoryOverlay({
     },
     [analytics, beginAttempt, controller]
   );
-  const startRecoveryFromLookup = useCallback6(
+  const startRecoveryFromLookup = useCallback7(
     (deposit) => {
       if (attempt) {
         analytics.recoveryStarted(
@@ -5139,11 +5535,11 @@ function HistoryOverlay({
     },
     [analytics, attempt, controller]
   );
-  const cancelRecovery = useCallback6(() => {
+  const cancelRecovery = useCallback7(() => {
     endAttempt("history_back", "back");
     controller.cancelRecovery();
   }, [controller, endAttempt]);
-  const closeModal = useCallback6(() => {
+  const closeModal = useCallback7(() => {
     endAttempt("header_button", "modal_close");
     onCloseModal();
   }, [endAttempt, onCloseModal]);
@@ -5234,7 +5630,8 @@ function HistoryOverlay({
 }
 
 // src/components/history/useHistoryPanel.ts
-import { useCallback as useCallback7, useEffect as useEffect11, useMemo as useMemo7, useRef as useRef8, useState as useState9 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect11, useMemo as useMemo7, useRef as useRef8, useState as useState9 } from "react";
+var MAX_TIMEOUT_MS = 2147483647;
 function sortByCreatedAtDesc(items) {
   return [...items].sort((a, b) => {
     const at = a.createdAt ? Date.parse(a.createdAt) : 0;
@@ -5262,7 +5659,7 @@ function useHistoryPanel({
   const requestRef = useRef8(0);
   const [recovering, setRecovering] = useState9(null);
   const [recoverySubmitting, setRecoverySubmitting] = useState9(false);
-  const fetchHistory = useCallback7(
+  const fetchHistory = useCallback8(
     async (mode = "initial") => {
       if (!recipient) return;
       const isInitial = mode === "initial";
@@ -5312,27 +5709,40 @@ function useHistoryPanel({
     },
     [recipient, service]
   );
-  const badge = useMemo7(
-    () => deriveHistoryBadge(deposits, { recipient, canRecover }),
-    [deposits, recipient, canRecover]
-  );
-  const openPanel = useCallback7(() => {
+  const badgeState2 = deriveHistoryBadgeState(deposits, {
+    recipient,
+    canRecover
+  });
+  const badge = badgeState2.badge;
+  useEffect11(() => {
+    if (!isOpen || badgeState2.nextExpiryAt === null) return;
+    const delay = Math.min(
+      badgeState2.nextExpiryAt - Date.now(),
+      MAX_TIMEOUT_MS
+    );
+    const timeout = setTimeout(
+      () => setDeposits((current) => current.slice()),
+      delay
+    );
+    return () => clearTimeout(timeout);
+  }, [isOpen, badgeState2.nextExpiryAt]);
+  const openPanel = useCallback8(() => {
     setIsPanelOpen(true);
     analytics?.visitOpened(badge);
     if (!loadedRef.current || staleRef.current) {
       fetchHistory("initial");
     }
   }, [analytics, badge, fetchHistory]);
-  const closePanel = useCallback7(() => {
+  const closePanel = useCallback8(() => {
     if (recovering) return;
     setIsPanelOpen(false);
     analytics?.visitEnded();
   }, [analytics, recovering]);
-  const loadMore = useCallback7(() => {
+  const loadMore = useCallback8(() => {
     analytics?.loadMore(filterVisibleDeposits(deposits).length);
     fetchHistory("more");
   }, [analytics, deposits, fetchHistory]);
-  const markStale = useCallback7(() => {
+  const markStale = useCallback8(() => {
     staleRef.current = true;
     if (isOpen) {
       fetchHistory("initial");
@@ -5368,10 +5778,10 @@ function useHistoryPanel({
     setRecovering(null);
     setRecoverySubmitting(false);
   }, [isOpen, analytics]);
-  const invalidate = useCallback7(() => {
+  const invalidate = useCallback8(() => {
     staleRef.current = true;
   }, []);
-  const cancelRecovery = useCallback7(() => setRecovering(null), []);
+  const cancelRecovery = useCallback8(() => setRecovering(null), []);
   return useMemo7(
     () => ({
       deposits,
@@ -5805,14 +6215,14 @@ function isSubmissionUncertain(error) {
 }
 
 // src/components/steps/ProcessingStep.tsx
-import { useCallback as useCallback9, useEffect as useEffect14, useRef as useRef10, useState as useState13 } from "react";
+import { useCallback as useCallback10, useEffect as useEffect14, useRef as useRef10, useState as useState13 } from "react";
 
 // src/components/ui/Tooltip.tsx
 import {
   useState as useState10,
   useRef as useRef9,
   useEffect as useEffect12,
-  useCallback as useCallback8
+  useCallback as useCallback9
 } from "react";
 import { createPortal as createPortal2 } from "react-dom";
 import { jsx as jsx23, jsxs as jsxs17 } from "react/jsx-runtime";
@@ -5821,7 +6231,7 @@ function Tooltip({ content, children, className }) {
   const [position, setPosition] = useState10(null);
   const triggerRef = useRef9(null);
   const bubbleRef = useRef9(null);
-  const updatePosition = useCallback8(() => {
+  const updatePosition = useCallback9(() => {
     const trigger = triggerRef.current;
     if (!trigger) return;
     const rect = trigger.getBoundingClientRect();
@@ -6325,12 +6735,6 @@ var MAX_POLL_INTERVAL = 3e4;
 var BACKOFF_MULTIPLIER = 1.5;
 var SWAPPED_RECEIPT_STATUS_RETRY_INTERVAL_MS = 1e3;
 var SWAPPED_FIAT_STATUS_MAX_ATTEMPTS = 12;
-var ESCALATED_DELAY_MS = 10 * 60 * 1e3;
-var SOFT_DELAY_MS = {
-  confirming: 90 * 1e3,
-  received: 90 * 1e3,
-  bridging: 4 * 60 * 1e3
-};
 var PHASE_TIMINGS_PREFIX = "rhinestone:phase-timings";
 var PAYMENT_METHOD_LABELS = {
   creditcard: "Card",
@@ -6610,7 +7014,6 @@ function ProcessingStep({
     }
     return { type: "processing" };
   });
-  const [elapsedSeconds, setElapsedSeconds] = useState13(0);
   const [phaseTimings, setPhaseTimings] = useState13(() => {
     const saved = loadPhaseTimings(txHash);
     if (saved) {
@@ -6619,8 +7022,16 @@ function ProcessingStep({
     }
     return { startedAt: startTimeRef.current };
   });
-  const [hasEscalatedDelay, setHasEscalatedDelay] = useState13(false);
-  const updatePhaseTimings = useCallback9(
+  const [elapsedSeconds, setElapsedSeconds] = useState13(
+    () => Math.max(0, Math.floor((Date.now() - startTimeRef.current) / 1e3))
+  );
+  const [latchedTiming, setLatchedTiming] = useState13(quote?.timing);
+  if (latchedTiming === void 0 && quote?.timing !== void 0) {
+    setLatchedTiming(quote.timing);
+  }
+  const timingStateRef = useRef10("expected");
+  const servedTimingLatchRef = useRef10(false);
+  const updatePhaseTimings = useCallback10(
     (updater) => {
       setPhaseTimings((previous) => {
         const next = updater(previous);
@@ -6925,21 +7336,6 @@ function ProcessingStep({
     state.type,
     txHash
   ]);
-  useEffect14(() => {
-    if (directTransfer || state.type !== "processing") return;
-    const timeoutId = setTimeout(() => {
-      if (escalatedDelayRef.current) return;
-      escalatedDelayRef.current = true;
-      setHasEscalatedDelay(true);
-      const message = "Transfer is taking longer than expected. Your funds are safe and processing will continue automatically.";
-      debugLog(debug, "processing", "state:delay-escalated", {
-        txHash,
-        timeoutMs: ESCALATED_DELAY_MS
-      });
-      onErrorRef.current?.(message, "PROCESS_TIMEOUT");
-    }, ESCALATED_DELAY_MS);
-    return () => clearTimeout(timeoutId);
-  }, [debug, directTransfer, onErrorRef, state.type, txHash]);
   const isComplete = state.type === "complete";
   const isFailed = state.type === "failed";
   const isProcessing = state.type === "processing";
@@ -7039,9 +7435,43 @@ function ProcessingStep({
   const currentPhaseId = getCurrentPhaseId(state, phaseTimings);
   const activePhaseStartedAt = currentPhaseId ? getPhaseStartTime(currentPhaseId, phaseTimings) : void 0;
   const activePhaseElapsedMs = isProcessing && activePhaseStartedAt !== void 0 ? timelineNowMs - activePhaseStartedAt : 0;
-  const delayPhaseId = isProcessing && currentPhaseId && activePhaseElapsedMs >= SOFT_DELAY_MS[currentPhaseId] ? currentPhaseId : void 0;
-  void delayPhaseId;
-  void hasEscalatedDelay;
+  if (latchedTiming !== void 0 && !servedTimingLatchRef.current) {
+    servedTimingLatchRef.current = true;
+    timingStateRef.current = "expected";
+  }
+  const timingState = isProcessing ? advancePendingTimingState(
+    timingStateRef.current,
+    resolvePendingTimingState({
+      timing: latchedTiming,
+      totalElapsedMs: elapsedSeconds * 1e3,
+      phaseId: currentPhaseId,
+      phaseElapsedMs: activePhaseElapsedMs
+    })
+  ) : timingStateRef.current;
+  timingStateRef.current = timingState;
+  const expectedDuration = latchedTiming && timingState === "expected" ? formatExpectedDuration(latchedTiming.expectedSeconds) : void 0;
+  useEffect14(() => {
+    if (directTransfer || !isProcessing || timingState !== "escalated") return;
+    if (escalatedDelayRef.current) return;
+    escalatedDelayRef.current = true;
+    debugLog(debug, "processing", "state:delay-escalated", {
+      txHash,
+      timeoutMs: latchedTiming ? resolveServedThresholds(latchedTiming).escalatedMs : FALLBACK_ESCALATED_DELAY_MS,
+      served: latchedTiming !== void 0
+    });
+    onErrorRef.current?.(
+      "Transfer is taking longer than expected. Your funds are safe and processing will continue automatically.",
+      "PROCESS_TIMEOUT"
+    );
+  }, [
+    debug,
+    directTransfer,
+    isProcessing,
+    latchedTiming,
+    onErrorRef,
+    timingState,
+    txHash
+  ]);
   const sourceChainIcon = getChainIcon(displaySourceChain);
   const targetChainIcon = getChainIcon(targetChainId);
   const sourceChainName = getChainName(displaySourceChain);
@@ -7270,6 +7700,11 @@ function ProcessingStep({
         })()
       ] }),
       isFailed && failureMessage && /* @__PURE__ */ jsx27(Callout, { variant: "error", children: failureMessage }),
+      isProcessing && expectedDuration !== void 0 && /* @__PURE__ */ jsxs20("p", { className: "rs-pending-expectation", children: [
+        "Usually arrives in ",
+        expectedDuration
+      ] }),
+      isProcessing && latchedTiming !== void 0 && timingState !== "expected" && /* @__PURE__ */ jsx27(Callout, { variant: "warning", children: timingState === "soft" ? "Taking longer than usual. Your funds are safe and this will complete automatically." : "This is taking much longer than usual. Your funds are safe and processing continues automatically." }),
       isProcessing && /* @__PURE__ */ jsx27(
         Button,
         {
@@ -7529,8 +7964,11 @@ export {
   SwappedConnectFeeChangedError,
   SUPPORTED_CONNECT_EXCHANGE_COUNT,
   resolveAppFeeBps,
+  isDepositPolicyRefusal,
   PermitDepositSubmitError,
   createDepositService,
+  depositBoundsViolation,
+  describePolicyRefusal,
   rpcUrlFor,
   RpcUrlsProvider,
   useRpcUrls,
@@ -7543,6 +7981,9 @@ export {
   useDepositChainIds,
   useDestinationChains,
   useTargetTokens,
+  useDepositOffer,
+  useDepositBounds,
+  useRestrictedListExclusion,
   useIsDepositChain,
   useChainName,
   useReadClient,
@@ -7559,6 +8000,7 @@ export {
   isUnsupportedChainSwitchError,
   formatUserError,
   Tooltip,
+  formatExpectedDuration,
   markSubmissionUncertain,
   isSubmissionUncertain,
   formatTokenAmount,