@rhinestone/deposit-modal 0.17.0 → 0.18.0

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

@@ -1,7 +1,3 @@
-import {
-  MODAL_VERSION,
-  serviceHeaders
-} from "./chunk-XCBDJPBD.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 {
@@ -736,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);
@@ -762,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 {
@@ -796,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() {
@@ -1303,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");
@@ -1343,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");
@@ -1733,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;
       }
@@ -1964,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,
@@ -1971,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();
@@ -2135,6 +2267,9 @@ var EMPTY = {
   viemChains: null,
   isLoading: true,
   shortlist: null,
+  depositOptions: { status: "loading" },
+  retryDepositOptions: () => {
+  },
   clientCapableChainIds: null
 };
 var ChainCatalogContext = createContext2(EMPTY);
@@ -2292,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();
@@ -2384,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(
@@ -2409,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 });
 }
@@ -2429,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,
@@ -2817,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);
@@ -2867,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(
@@ -2902,7 +3106,7 @@ function AnalyticsSession(props) {
       }, 0);
     };
   }, [emitFailure]);
-  const emitDeposit = useCallback2(
+  const emitDeposit = useCallback3(
     (...[payload, fundingMethod]) => {
       if (modal !== "deposit") return;
       const event = {
@@ -2921,7 +3125,7 @@ function AnalyticsSession(props) {
     },
     [enqueue, modal, nowRef, onEventRef]
   );
-  const emitWithdraw = useCallback2(
+  const emitWithdraw = useCallback3(
     (payload) => {
       if (modal !== "withdraw") return;
       const event = {
@@ -2937,7 +3141,7 @@ function AnalyticsSession(props) {
     },
     [enqueue, modal, nowRef, onEventRef]
   );
-  const emitClaim = useCallback2(
+  const emitClaim = useCallback3(
     (payload) => {
       if (modal !== "claim") return;
       const event = {
@@ -3011,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",
@@ -3041,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";
@@ -3094,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,
@@ -3428,14 +3670,13 @@ function advancePendingTimingState(previous, next) {
 }
 
 // src/core/history-timing.ts
-var TIMED_HISTORY_STATUSES = /* @__PURE__ */ new Set(["pending", "processing", "delayed"]);
 function resolveHistoryTiming({
   status,
   timing,
   createdAt,
   nowMs
 }) {
-  if (!TIMED_HISTORY_STATUSES.has(status) || !timing || !createdAt) {
+  if (!expectsArrival(status) || !timing || !createdAt) {
     return void 0;
   }
   const createdAtMs = Date.parse(createdAt);
@@ -3559,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") {
@@ -3860,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";
@@ -4044,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",
@@ -4111,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;
@@ -4198,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 {
@@ -4697,7 +4938,7 @@ function HistoryFallbackFlow({
       epochRef.current += 1;
     };
   }, [recipient]);
-  const reportSelection = useCallback4(
+  const reportSelection = useCallback5(
     (match, autoSelected) => {
       analytics.selectDeposit({
         depositId: match.depositId,
@@ -4707,7 +4948,7 @@ function HistoryFallbackFlow({
     },
     [analytics]
   );
-  const lookup = useCallback4(
+  const lookup2 = useCallback5(
     async (txHash) => {
       const epoch = epochRef.current;
       const isCurrentLookup = () => epochRef.current === epoch;
@@ -4750,7 +4991,7 @@ function HistoryFallbackFlow({
     },
     [analytics, service, recipient, onFound, reportSelection]
   );
-  const selectMatch = useCallback4(
+  const selectMatch = useCallback5(
     (match) => {
       analytics.completeStep("select");
       reportSelection(match, false);
@@ -4758,7 +4999,7 @@ function HistoryFallbackFlow({
     },
     [analytics, onFound, reportSelection]
   );
-  const handleKeyDown = useCallback4(
+  const handleKeyDown = useCallback5(
     (e) => {
       if (e.key === "Escape") {
         e.stopPropagation();
@@ -4837,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")
           }
         )
@@ -4853,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";
@@ -5057,7 +5298,7 @@ function HistoryRecoveryFlow({
     token: deposit.token,
     amountRaw: deposit.amountRaw
   });
-  const submit = useCallback5(
+  const submit = useCallback6(
     async (destination) => {
       setPhase("submitting");
       onSubmittingChange(true);
@@ -5129,7 +5370,7 @@ function HistoryRecoveryFlow({
       symbol
     ]
   );
-  const retry = useCallback5(() => {
+  const retry = useCallback6(() => {
     const reason = lastFailureRef.current;
     if (reason) {
       lastFailureRef.current = null;
@@ -5226,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 = {
@@ -5244,7 +5485,7 @@ function HistoryOverlay({
     },
     [analytics]
   );
-  const endAttempt = useCallback6(
+  const endAttempt = useCallback7(
     (source, reason) => {
       const claim = claimControllerRef.current;
       claim?.abandon(reason);
@@ -5254,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);
@@ -5272,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);
@@ -5280,7 +5521,7 @@ function HistoryOverlay({
     },
     [analytics, beginAttempt, controller]
   );
-  const startRecoveryFromLookup = useCallback6(
+  const startRecoveryFromLookup = useCallback7(
     (deposit) => {
       if (attempt) {
         analytics.recoveryStarted(
@@ -5294,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]);
@@ -5389,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;
@@ -5417,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";
@@ -5467,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");
@@ -5523,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,
@@ -5960,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";
@@ -5976,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();
@@ -6776,7 +7031,7 @@ function ProcessingStep({
   }
   const timingStateRef = useRef10("expected");
   const servedTimingLatchRef = useRef10(false);
-  const updatePhaseTimings = useCallback9(
+  const updatePhaseTimings = useCallback10(
     (updater) => {
       setPhaseTimings((previous) => {
         const next = updater(previous);
@@ -7709,8 +7964,11 @@ export {
   SwappedConnectFeeChangedError,
   SUPPORTED_CONNECT_EXCHANGE_COUNT,
   resolveAppFeeBps,
+  isDepositPolicyRefusal,
   PermitDepositSubmitError,
   createDepositService,
+  depositBoundsViolation,
+  describePolicyRefusal,
   rpcUrlFor,
   RpcUrlsProvider,
   useRpcUrls,
@@ -7723,6 +7981,9 @@ export {
   useDepositChainIds,
   useDestinationChains,
   useTargetTokens,
+  useDepositOffer,
+  useDepositBounds,
+  useRestrictedListExclusion,
   useIsDepositChain,
   useChainName,
   useReadClient,