@oasisprotocol/privana-sdk 0.5.2 → 0.5.3

package/dist/index.js

@@ -1,10 +1,10 @@
 "use client";
-import { usePrivanaContext, createHostedAuthPendingStorageKey, clearHostedAuthPendingTransaction, HostedAuthRequiredError, HostedAuthError, createPkceVerifier, createPkceChallenge, createHostedAuthState, persistHostedAuthPendingTransaction, parseHostedAuthCallback, readHostedAuthPendingTransaction, HostedAuthStateMismatchError, buildHostedAuthSession, useSafePrivanaContext, usePrivateReadRequest, formatTokenAmount, submitPendingLock, PostDepositLockError, useDepositVerification, useEnsureCorrectChain, getTransactionReceipt, getBlockNumber, waitForTransactionReceipt, canUseBrowserStorage, clampLockAmount, getWalletClient, createSignedLockRequest, signWithdrawMessage, signLockMessage, signTransferMessage, signTransferLockedMessage, signModifyLockMessage, cn, Button, stripHostedAuthCallbackParams, AccountingApiError, getBrowserStorageItem, removeBrowserStorageItem, isSignedLockUsable, setBrowserStorageItem, shortenAddress, formatTimeRemaining, parseTokenAmount, getExplorerAddressUrl, getExplorerLabel, Skeleton, formatCountdown, FiatOnRampForm } from './chunk-ZVUMV4NR.js';
-export { AccountingApiError, Button, DEFAULT_LOCK_DURATION_SECONDS, DEFAULT_ONRAMP_LOCK_BUFFER, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, LOCK_TYPES, MODIFY_LOCK_TYPES, NETWORK_CONFIG, NetworkError, PostDepositLockError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, ValidationError, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, applyLockBuffer, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clampLockAmount, clearHostedAuthPendingTransaction, clearPendingLock, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, createSignedLockRequest, getAccountingContract, getApiUrl, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, isHostedAuthRefreshActive, isHostedAuthSessionActive, isSignedLockUsable, loadPendingLock, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, savePendingLock, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, submitPendingLock, syncHostedAuthSessionToClient, useDepositVerification, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useSiweAuth } from './chunk-ZVUMV4NR.js';
+import { usePrivanaContext, createHostedAuthPendingStorageKey, clearHostedAuthPendingTransaction, HostedAuthRequiredError, HostedAuthError, createPkceVerifier, createPkceChallenge, createHostedAuthState, persistHostedAuthPendingTransaction, parseHostedAuthCallback, readHostedAuthPendingTransaction, HostedAuthStateMismatchError, buildHostedAuthSession, useSafePrivanaContext, usePrivateReadRequest, formatTokenAmount, submitPendingLock, PostDepositLockError, useDepositVerification, useEnsureCorrectChain, getTransactionReceipt, getBlockNumber, waitForTransactionReceipt, canUseBrowserStorage, clampLockAmount, requireDepositLockOwner, getWalletClient, createSignedLockRequest, requireServiceAddress, signWithdrawMessage, signLockMessage, signTransferMessage, signTransferLockedMessage, signModifyLockMessage, cn, Button, stripHostedAuthCallbackParams, AccountingApiError, getBrowserStorageItem, removeBrowserStorageItem, isSignedLockUsable, setBrowserStorageItem, shortenAddress, formatTimeRemaining, parseTokenAmount, getExplorerAddressUrl, getExplorerLabel, canUseSharedBrowserStorage, DEFAULT_LOCK_DURATION_SECONDS, Skeleton, formatCountdown, FiatOnRampForm, getSharedBrowserStorageItem, removeSharedBrowserStorageItem, setSharedBrowserStorageItem } from './chunk-DZURIIRE.js';
+export { AccountingApiError, Button, DEFAULT_LOCK_DURATION_SECONDS, DEFAULT_ONRAMP_LOCK_BUFFER, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, LOCK_TYPES, MODIFY_LOCK_TYPES, NETWORK_CONFIG, NetworkError, PostDepositLockError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, ValidationError, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, applyLockBuffer, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clampLockAmount, clearHostedAuthPendingTransaction, clearPendingLock, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, createSignedLockRequest, getAccountingContract, getApiUrl, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, isHostedAuthRefreshActive, isHostedAuthSessionActive, isSignedLockUsable, loadPendingLock, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, requireDepositLockOwner, requireServiceAddress, savePendingLock, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, submitPendingLock, syncHostedAuthSessionToClient, useDepositVerification, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useSiweAuth } from './chunk-DZURIIRE.js';
 import { useState, useRef, useMemo, useCallback, useContext, useEffect, useId } from 'react';
 import { QueryClientContext, useQuery, useQueryClient, useMutation, keepPreviousData } from '@tanstack/react-query';
 import { useAccount, useWalletClient, useConfig, useWriteContract, useSendTransaction, useBalance as useBalance$1, useReadContract } from 'wagmi';
-import { zeroAddress, erc20Abi } from 'viem';
+import { zeroAddress, erc20Abi, formatUnits } from 'viem';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { XIcon } from 'lucide-react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
@@ -234,7 +234,7 @@ function useBalance(options = {}) {
       if (!privateReadAddress) throw new Error("No authenticated account available");
       if (!tokenId) throw new Error("No token ID provided");
       if (!client) throw new Error("No accounting client");
-      return executePrivateRead(() => client.getBalance(tokenId));
+      return executePrivateRead((readClient) => readClient.getBalance(tokenId));
     },
     enabled: hasProviders && (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!tokenId && !!client,
     refetchInterval: pollingInterval
@@ -259,7 +259,9 @@ function useBatchBalances(options) {
     queryKey: ["accounting-batch-balances", ...privateReadQueryScope, options.tokenIds],
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
-      return executePrivateRead(() => client.getBatchBalances({ token_ids: options.tokenIds }));
+      return executePrivateRead(
+        (readClient) => readClient.getBatchBalances({ token_ids: options.tokenIds })
+      );
     },
     enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && options.tokenIds.length > 0 && !!client,
     refetchInterval: pollingInterval
@@ -313,7 +315,9 @@ function useDeposit(options = {}) {
   const { data: walletClient } = useWalletClient();
   const queryClient = useQueryClient();
   const config = useConfig();
-  const { executePrivateRead } = usePrivateReadRequest();
+  const { executePrivateRead, privateReadAddress } = usePrivateReadRequest();
+  const privateReadAddressRef = useRef(privateReadAddress);
+  privateReadAddressRef.current = privateReadAddress;
   const confirmations = options.confirmations ?? 15;
   const [depositAddress, setDepositAddress] = useState(null);
   const [txHash, setTxHash] = useState();
@@ -349,12 +353,12 @@ function useDeposit(options = {}) {
   ]);
   const pendingLockRef = useRef(null);
   const submitPendingLockAfterCredit = useCallback(
-    async (signedLock, response) => {
+    async (signedLock, creditedAmount) => {
       try {
         const result = await submitPendingLock({
           client,
           payload: signedLock,
-          creditedAmount: response.amount != null ? BigInt(response.amount) : void 0
+          creditedAmount
         });
         queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
         queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
@@ -366,7 +370,7 @@ function useDeposit(options = {}) {
           err instanceof Error ? err.message : "Lock submission failed",
           "submission-failed",
           BigInt(signedLock.amount),
-          void 0,
+          creditedAmount,
           { cause: err }
         );
         (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
@@ -384,12 +388,12 @@ function useDeposit(options = {}) {
   } = useDepositVerification({
     pollInterval: options.pollInterval,
     pollTimeout: options.pollTimeout,
-    onCredited: (hash, response) => {
+    onCredited: (hash, response, creditedAmount) => {
       verificationContextRef.current = null;
       const signedLock = pendingLockRef.current;
       pendingLockRef.current = null;
       if (signedLock) {
-        void submitPendingLockAfterCredit(signedLock, response).finally(() => {
+        void submitPendingLockAfterCredit(signedLock, creditedAmount).finally(() => {
           if (address) clearPendingDeposit(address, hash);
         });
       } else if (address) {
@@ -407,7 +411,7 @@ function useDeposit(options = {}) {
   const addressMutation = useMutation({
     mutationFn: async () => {
       if (!address) throw new Error("No wallet connected");
-      return executePrivateRead(() => client.getDepositAddress());
+      return executePrivateRead((readClient) => readClient.getDepositAddress());
     },
     onSuccess: (data) => {
       setDepositAddress(data);
@@ -545,6 +549,7 @@ function useDeposit(options = {}) {
         const lockAmount = clampLockAmount(params.amount, params.postDepositLock?.maxAmount);
         let signedLock;
         if (params.postDepositLock) {
+          const lockOwner = requireDepositLockOwner(address, privateReadAddress);
           setIsSwitchingChain(true);
           try {
             await ensureCorrectChain(networkConfig.chainId);
@@ -558,7 +563,7 @@ function useDeposit(options = {}) {
           signedLock = await createSignedLockRequest({
             client,
             walletClient: signingWalletClient,
-            userAddress: address,
+            userAddress: lockOwner,
             networkConfig,
             serviceAddress: requireServiceAddress(
               params.postDepositLock.serviceAddress ?? serviceAddress
@@ -567,6 +572,9 @@ function useDeposit(options = {}) {
             amount: lockAmount,
             lockDuration: params.postDepositLock.lockDuration
           });
+          if (privateReadAddressRef.current?.toLowerCase() !== lockOwner.toLowerCase()) {
+            throw new Error("Authenticated deposit account changed while signing");
+          }
         }
         if (isStale()) return;
         setIsSwitchingChain(true);
@@ -649,6 +657,7 @@ function useDeposit(options = {}) {
       enabledTokens,
       ensureCorrectChain,
       networkConfig,
+      privateReadAddress,
       queryClient,
       serviceAddress,
       writeContractAsync,
@@ -685,12 +694,6 @@ function useDeposit(options = {}) {
     reset
   };
 }
-function requireServiceAddress(serviceAddress) {
-  if (!serviceAddress) {
-    throw new Error("Service address not configured");
-  }
-  return serviceAddress;
-}
 function useDepositAddress(options = {}) {
   const queryClient = useContext(QueryClientContext);
   const accountingContext = useSafePrivanaContext();
@@ -703,11 +706,12 @@ function useDepositAddress(options = {}) {
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
       if (!client) throw new Error("No accounting client");
-      return executePrivateRead(() => client.getDepositAddress());
+      return executePrivateRead((readClient) => readClient.getDepositAddress());
     },
     enabled: isReady && (options.enabled ?? true)
   });
   return {
+    response: query.data,
     depositAddress: query.data?.deposit_address ?? null,
     isReady,
     isLoading: query.isLoading,
@@ -1158,7 +1162,7 @@ function useLockedFunds(options = {}) {
     queryKey: ["accounting-locked-funds", ...privateReadQueryScope, serviceAddress ?? null],
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
-      return executePrivateRead(() => client.getLockedFunds(serviceAddress));
+      return executePrivateRead((readClient) => readClient.getLockedFunds(serviceAddress));
     },
     enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
     refetchInterval: pollingInterval,
@@ -1183,7 +1187,7 @@ function useTotalLockedBalance(options = {}) {
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
       if (!tokenId) throw new Error("No token ID provided");
-      return executePrivateRead(() => client.getTotalLockedBalance(tokenId));
+      return executePrivateRead((readClient) => readClient.getTotalLockedBalance(tokenId));
     },
     enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!tokenId && !!client,
     refetchInterval: pollingInterval
@@ -1203,7 +1207,7 @@ function useExpiredLocks(options = {}) {
     queryKey: ["accounting-expired-locks", ...privateReadQueryScope],
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
-      return executePrivateRead(() => client.getExpiredLocks());
+      return executePrivateRead((readClient) => readClient.getExpiredLocks());
     },
     enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
     refetchInterval: pollingInterval
@@ -1236,7 +1240,7 @@ function usePendingDeposits(options = {}) {
       if (!client) throw new Error("No accounting client");
       try {
         return await executePrivateRead(
-          () => client.getPendingDeposits({
+          (readClient) => readClient.getPendingDeposits({
             chain_id: chainId,
             token_address: tokenAddress,
             lookback_blocks: lookbackBlocks
@@ -1317,7 +1321,7 @@ function useHistory(options = {}) {
     queryKey: ["accounting-history", ...privateReadQueryScope, offset, limit],
     queryFn: async () => {
       if (!privateReadAddress) throw new Error("No authenticated account available");
-      return executePrivateRead(() => client.getHistory({ offset, limit }));
+      return executePrivateRead((readClient) => readClient.getHistory({ offset, limit }));
     },
     enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
     refetchInterval: pollingInterval,
@@ -1904,7 +1908,16 @@ function WarningIcon() {
     }
   ) });
 }
-function TransactionWarningView({ title, message, onDone }) {
+function TransactionWarningView({
+  title,
+  message,
+  onDone,
+  actionLabel = "Done",
+  pendingLabel = actionLabel,
+  isPending = false,
+  onDismiss,
+  dismissLabel = "Dismiss"
+}) {
   return /* @__PURE__ */ jsxs("div", { className: "flex w-full flex-col gap-4", children: [
     /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
       /* @__PURE__ */ jsx("div", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-amber-500/10 text-amber-400", children: /* @__PURE__ */ jsx(WarningIcon, {}) }),
@@ -1913,14 +1926,26 @@ function TransactionWarningView({ title, message, onDone }) {
         /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: message })
       ] })
     ] }),
-    /* @__PURE__ */ jsx(
-      "button",
-      {
-        onClick: onDone,
-        className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors",
-        children: "Done"
-      }
-    )
+    /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+      onDismiss && /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onDismiss,
+          disabled: isPending,
+          className: "border-border text-foreground hover:bg-secondary flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
+          children: dismissLabel
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onDone,
+          disabled: isPending,
+          className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
+          children: isPending ? pendingLabel : actionLabel
+        }
+      )
+    ] })
   ] });
 }
 function TransactionErrorView({
@@ -1931,7 +1956,8 @@ function TransactionErrorView({
   onRetry,
   onDismiss,
   isRetrying,
-  retryLabel = "Retry Verification"
+  retryLabel = "Retry Verification",
+  dismissLabel = "Close"
 }) {
   return /* @__PURE__ */ jsxs("div", { className: "flex w-full flex-col gap-4", children: [
     /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
@@ -1955,13 +1981,13 @@ function TransactionErrorView({
       }
     ),
     /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
-      /* @__PURE__ */ jsx(
+      onDismiss && /* @__PURE__ */ jsx(
         "button",
         {
           onClick: onDismiss,
           disabled: isRetrying,
           className: "border-border text-foreground hover:bg-secondary flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
-          children: "Close"
+          children: dismissLabel
         }
       ),
       /* @__PURE__ */ jsx(
@@ -1970,7 +1996,7 @@ function TransactionErrorView({
           onClick: onRetry,
           disabled: isRetrying,
           className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
-          children: isRetrying ? "Retrying..." : retryLabel
+          children: isRetrying ? "Retrying\u2026" : retryLabel
         }
       )
     ] })
@@ -2110,7 +2136,7 @@ function DepositForm({
   };
   const getButtonText = () => {
     if (!isConnected) return "Connect Wallet";
-    if (isSwitchingChain) return "Switching...";
+    if (isSwitchingChain) return "Switching\u2026";
     return "Deposit";
   };
   if (showSuccess) {
@@ -2134,7 +2160,7 @@ function DepositForm({
     );
   }
   if (verificationFailed) {
-    const baseMessage = "Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address \u2014 retry verification instead of starting a new deposit.";
+    const baseMessage = "Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address. Retry verification instead of starting a new deposit.";
     const detail = error?.message;
     const message = detail ? `${baseMessage} (${detail})` : baseMessage;
     return /* @__PURE__ */ jsx(
@@ -2154,7 +2180,7 @@ function DepositForm({
     return /* @__PURE__ */ jsx(
       TransactionProgressView,
       {
-        title: "Depositing...",
+        title: "Depositing\u2026",
         steps: depositSteps,
         onCancel: canCancel ? handleCancel : void 0
       }
@@ -3094,6 +3120,745 @@ function PrivanaButton({
     )
   ] });
 }
+
+// src/sdk/hooks/external-deposit-lock.ts
+var ACTIVE_SESSION_PREFIX = "privana:external-deposit-lock:active:";
+var SESSION_PREFIX = "privana:external-deposit-lock:session:";
+var ExternalDepositLockSessionChangedError = class _ExternalDepositLockSessionChangedError extends Error {
+  constructor() {
+    super("External deposit lock session changed");
+    this.name = "ExternalDepositLockSessionChangedError";
+    Object.setPrototypeOf(this, _ExternalDepositLockSessionChangedError.prototype);
+  }
+};
+function externalDepositSessionId(chainId, tokenId) {
+  return `${chainId}:${tokenId.toLowerCase()}`;
+}
+function isExternalDepositBlockInSession(session, blockNumber) {
+  return Number.isSafeInteger(blockNumber) && blockNumber > session.startBlock;
+}
+function isCurrentExternalDepositVerification(session, txHash) {
+  return session.creditedAmount === void 0 && session.verification?.hash.toLowerCase() === txHash.toLowerCase();
+}
+function getExternalDepositMinimum(response, chainId) {
+  const value = response?.min_deposit?.[String(chainId)]?.erc20;
+  if (value === void 0) return void 0;
+  try {
+    const amount = BigInt(value);
+    return amount >= 0n ? amount : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function activeSessionKey(owner) {
+  return `${ACTIVE_SESSION_PREFIX}${owner.toLowerCase()}`;
+}
+function sessionKey(owner, sessionId) {
+  return `${SESSION_PREFIX}${owner.toLowerCase()}:${sessionId}`;
+}
+function activeSessionId(owner) {
+  const value = getSharedBrowserStorageItem(activeSessionKey(owner));
+  return value || void 0;
+}
+function isPositiveIntegerString(value) {
+  if (typeof value !== "string") return false;
+  try {
+    return BigInt(value) > 0n;
+  } catch {
+    return false;
+  }
+}
+function isSessionRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (record.version !== 1 || typeof record.owner !== "string" || typeof record.serviceAddress !== "string" || !Number.isInteger(record.chainId) || (record.chainId ?? 0) <= 0 || typeof record.tokenId !== "string" || !Number.isSafeInteger(record.startBlock) || (record.startBlock ?? -1) < 0 || !isPositiveIntegerString(record.depositAmount) || !isPositiveIntegerString(record.maxLockAmount) || !Number.isInteger(record.lockDuration) || (record.lockDuration ?? 0) <= 0 || typeof record.generation !== "string" || !record.generation || record.submissionAmbiguous !== void 0 && typeof record.submissionAmbiguous !== "boolean" || record.creditedAmount !== void 0 && !isPositiveIntegerString(record.creditedAmount)) {
+    return false;
+  }
+  if (record.verification && (typeof record.verification.hash !== "string" || record.verification.chainId !== record.chainId || !isPositiveIntegerString(record.verification.amount) || record.verification.logIndex !== void 0 && (!Number.isInteger(record.verification.logIndex) || record.verification.logIndex < 0))) {
+    return false;
+  }
+  if (record.verification && record.creditedAmount !== void 0) return false;
+  if (record.submissionAmbiguous && record.creditedAmount === void 0) return false;
+  if (!record.payload) {
+    return record.creditedAmount !== void 0 && !record.submissionAmbiguous;
+  }
+  if (typeof record.payload.signature !== "string" || typeof record.payload.token_id !== "string" || typeof record.payload.service_address !== "string" || record.payload.signature !== record.generation || record.payload.token_id.toLowerCase() !== record.tokenId.toLowerCase() || record.payload.service_address.toLowerCase() !== record.serviceAddress.toLowerCase() || !isPositiveIntegerString(record.payload.amount)) {
+    return false;
+  }
+  return BigInt(record.payload.amount) <= BigInt(record.maxLockAmount);
+}
+function writeSessionRecord(session) {
+  const id = externalDepositSessionId(session.chainId, session.tokenId);
+  return setSharedBrowserStorageItem(sessionKey(session.owner, id), JSON.stringify(session));
+}
+function saveExternalDepositLockSession(session, expectedSession = null) {
+  if (!isSessionRecord(session)) throw new Error("Invalid external deposit lock session");
+  const current = loadExternalDepositLockSession(session.owner);
+  if (expectedSession === null && current || expectedSession !== null && (!current || !isSameSessionSnapshot(current, expectedSession))) {
+    throw new ExternalDepositLockSessionChangedError();
+  }
+  const nextId = externalDepositSessionId(session.chainId, session.tokenId);
+  const previousId = activeSessionId(session.owner);
+  if (!writeSessionRecord(session)) {
+    throw new Error("Unable to persist external deposit lock session");
+  }
+  if (previousId !== nextId) {
+    if (!setSharedBrowserStorageItem(activeSessionKey(session.owner), nextId)) {
+      removeSharedBrowserStorageItem(sessionKey(session.owner, nextId));
+      throw new Error("Unable to persist external deposit lock session");
+    }
+    if (previousId) {
+      removeSharedBrowserStorageItem(sessionKey(session.owner, previousId));
+    }
+  }
+}
+function loadExternalDepositLockSession(owner) {
+  const id = activeSessionId(owner);
+  if (!id) return void 0;
+  const key = sessionKey(owner, id);
+  try {
+    const raw = getSharedBrowserStorageItem(key);
+    const parsed = raw ? JSON.parse(raw) : void 0;
+    if (!isSessionRecord(parsed) || parsed.owner.toLowerCase() !== owner.toLowerCase() || externalDepositSessionId(parsed.chainId, parsed.tokenId) !== id) {
+      removeSharedBrowserStorageItem(key);
+      removeSharedBrowserStorageItem(activeSessionKey(owner));
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    removeSharedBrowserStorageItem(key);
+    removeSharedBrowserStorageItem(activeSessionKey(owner));
+    return void 0;
+  }
+}
+function subscribeExternalDepositLockSession(owner, onChange) {
+  if (typeof window === "undefined") return () => void 0;
+  let localStorage;
+  try {
+    localStorage = window.localStorage;
+  } catch {
+    return () => void 0;
+  }
+  const activeKey = activeSessionKey(owner);
+  const ownerSessionPrefix = `${SESSION_PREFIX}${owner.toLowerCase()}:`;
+  const handleStorage = (event) => {
+    if (event.storageArea !== localStorage) return;
+    if (event.key !== null && event.key !== activeKey && !event.key.startsWith(ownerSessionPrefix)) {
+      return;
+    }
+    onChange(loadExternalDepositLockSession(owner));
+  };
+  window.addEventListener("storage", handleStorage);
+  return () => window.removeEventListener("storage", handleStorage);
+}
+function clearExternalDepositLockSession(owner, expectedSessionId, expectedGeneration) {
+  const id = activeSessionId(owner);
+  if (!id || expectedSessionId && id !== expectedSessionId) return;
+  if (expectedGeneration) {
+    const current = loadExternalDepositLockSession(owner);
+    if (!current || current.generation !== expectedGeneration) return;
+  }
+  removeSharedBrowserStorageItem(sessionKey(owner, id));
+  removeSharedBrowserStorageItem(activeSessionKey(owner));
+}
+function isSameVerification(left, right) {
+  if (!left || !right) return left === right;
+  return left.hash.toLowerCase() === right.hash.toLowerCase() && left.chainId === right.chainId && left.amount === right.amount && (left.logIndex ?? 0) === (right.logIndex ?? 0);
+}
+function isSamePayload(left, right) {
+  if (!left || !right) return left === right;
+  return left.service_address.toLowerCase() === right.service_address.toLowerCase() && left.token_id.toLowerCase() === right.token_id.toLowerCase() && left.amount === right.amount && left.expiry === right.expiry && left.nonce === right.nonce && left.signature === right.signature;
+}
+function isSameSessionSnapshot(left, right) {
+  return left.version === right.version && left.owner.toLowerCase() === right.owner.toLowerCase() && left.serviceAddress.toLowerCase() === right.serviceAddress.toLowerCase() && left.chainId === right.chainId && left.tokenId.toLowerCase() === right.tokenId.toLowerCase() && left.startBlock === right.startBlock && left.depositAmount === right.depositAmount && left.maxLockAmount === right.maxLockAmount && left.lockDuration === right.lockDuration && left.generation === right.generation && left.creditedAmount === right.creditedAmount && left.submissionAmbiguous === right.submissionAmbiguous && isSameVerification(left.verification, right.verification) && isSamePayload(left.payload, right.payload);
+}
+function isSameExternalDepositLockSession(left, right) {
+  return isSameSessionSnapshot(left, right);
+}
+function clearExternalDepositVerification(session) {
+  if (!session.verification || session.creditedAmount) return void 0;
+  const current = loadExternalDepositLockSession(session.owner);
+  if (!current || current.generation !== session.generation || current.creditedAmount || !isSameVerification(current.verification, session.verification)) {
+    return void 0;
+  }
+  const next = { ...current, verification: void 0 };
+  if (!writeSessionRecord(next)) {
+    throw new Error("Unable to clear failed deposit verification");
+  }
+  return next;
+}
+function discardExternalDepositLockSession(session) {
+  const current = loadExternalDepositLockSession(session.owner);
+  if (!current) return true;
+  if (!isSameSessionSnapshot(current, session)) return false;
+  clearExternalDepositLockSession(
+    current.owner,
+    externalDepositSessionId(current.chainId, current.tokenId),
+    current.generation
+  );
+  return loadExternalDepositLockSession(current.owner) === void 0;
+}
+function clearSubmittedPayload(session, signature, clearAmbiguous = false) {
+  const current = loadExternalDepositLockSession(session.owner);
+  if (!current?.payload || current.payload.signature !== signature || current.submissionAmbiguous && !clearAmbiguous) {
+    return false;
+  }
+  return writeSessionRecord({ ...current, submissionAmbiguous: void 0, payload: void 0 });
+}
+function markSubmissionAmbiguous(session, signature) {
+  const current = loadExternalDepositLockSession(session.owner);
+  if (!current?.payload || current.payload.signature !== signature) return false;
+  if (current.submissionAmbiguous) return true;
+  return writeSessionRecord({ ...current, submissionAmbiguous: true });
+}
+function ambiguousSubmissionError(error) {
+  return new PostDepositLockError(
+    "Lock submission could not be confirmed. Retry only the saved signature, or check locked funds before stopping recovery.",
+    error.reason,
+    error.signedAmount,
+    error.creditedAmount,
+    {
+      cause: error.cause,
+      submissionMayHaveSucceeded: true
+    }
+  );
+}
+function isDefinitiveSubmissionFailure(error) {
+  const cause = error.cause;
+  return cause instanceof AccountingApiError && cause.statusCode !== 408 && cause.statusCode < 500;
+}
+function submissionLockName(session) {
+  return `privana:external-deposit-lock:submit:${session.owner.toLowerCase()}:${externalDepositSessionId(session.chainId, session.tokenId)}`;
+}
+async function withSubmissionLock(session, task) {
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  if (!locks) return task(false);
+  return locks.request(submissionLockName(session), () => task(true));
+}
+function externalDepositRetryAmount(session) {
+  if (!session.creditedAmount) throw new Error("No credited external deposit to recover");
+  const creditedAmount = BigInt(session.creditedAmount);
+  const maxLockAmount = BigInt(session.maxLockAmount);
+  return creditedAmount < maxLockAmount ? creditedAmount : maxLockAmount;
+}
+async function submitExternalDepositLock(client, session) {
+  return withSubmissionLock(session, async (crossTabExclusive) => {
+    const current = loadExternalDepositLockSession(session.owner);
+    if (!current || current.generation !== session.generation) {
+      throw new PostDepositLockError(
+        "External deposit lock session changed before submission",
+        "not-found",
+        BigInt(session.maxLockAmount),
+        session.creditedAmount ? BigInt(session.creditedAmount) : void 0
+      );
+    }
+    const result = await submitExternalDepositLockAttempt(client, current, crossTabExclusive);
+    clearExternalDepositLockSession(
+      current.owner,
+      externalDepositSessionId(current.chainId, current.tokenId),
+      current.generation
+    );
+    return result;
+  });
+}
+async function submitExternalDepositLockAttempt(client, session, crossTabExclusive) {
+  const creditedAmount = session.creditedAmount ? BigInt(session.creditedAmount) : void 0;
+  if (!creditedAmount) {
+    throw new PostDepositLockError(
+      "External deposit has not been credited",
+      "submission-failed",
+      BigInt(session.maxLockAmount)
+    );
+  }
+  const payload = session.payload;
+  if (!payload) {
+    throw new PostDepositLockError(
+      "No persisted signed policy found for this deposit session",
+      "not-found",
+      BigInt(session.maxLockAmount),
+      creditedAmount
+    );
+  }
+  try {
+    return await submitPendingLock({
+      client,
+      payload,
+      creditedAmount,
+      beforeSubmit: () => {
+        if (!markSubmissionAmbiguous(session, payload.signature)) {
+          throw new Error("Unable to persist lock submission recovery state");
+        }
+      }
+    });
+  } catch (err) {
+    if (err instanceof PostDepositLockError && err.reason === "submission-failed" && crossTabExclusive && !session.submissionAmbiguous && isDefinitiveSubmissionFailure(err)) {
+      if (!clearSubmittedPayload(session, payload.signature, true)) {
+        const latest = loadExternalDepositLockSession(session.owner);
+        if (latest?.submissionAmbiguous) throw ambiguousSubmissionError(err);
+      }
+    } else if (err instanceof PostDepositLockError && err.reason === "submission-failed") {
+      const ambiguous = markSubmissionAmbiguous(session, payload.signature) || loadExternalDepositLockSession(session.owner)?.submissionAmbiguous === true;
+      if (ambiguous) throw ambiguousSubmissionError(err);
+    } else {
+      const current = loadExternalDepositLockSession(session.owner);
+      if (session.submissionAmbiguous || current?.submissionAmbiguous) {
+        if (err instanceof PostDepositLockError) throw ambiguousSubmissionError(err);
+        throw err;
+      }
+      if (!clearSubmittedPayload(session, payload.signature)) {
+        const latest = loadExternalDepositLockSession(session.owner);
+        if (latest?.submissionAmbiguous && err instanceof PostDepositLockError) {
+          throw ambiguousSubmissionError(err);
+        }
+      }
+    }
+    throw err;
+  }
+}
+function useExternalDepositLock({
+  allowance,
+  onLockSubmitted,
+  onLockFailed
+}) {
+  const { client, networkConfig, serviceAddress, getTokenById, tokensStatus } = usePrivanaContext();
+  const config = useConfig();
+  const queryClient = useQueryClient();
+  const { address } = useAccount();
+  const { privateReadAddress } = usePrivateReadRequest();
+  const { ensureCorrectChain } = useEnsureCorrectChain();
+  const [isSigning, setIsSigning] = useState(false);
+  const [isSubmittingLock, setIsSubmittingLock] = useState(false);
+  const [session, setSession] = useState(null);
+  const sessionRef = useRef(null);
+  const signingRef = useRef(false);
+  const settlingRef = useRef(false);
+  const pendingCreditedTransitionRef = useRef(null);
+  const hydratedScopeRef = useRef(null);
+  const beneficiaryRef = useRef(privateReadAddress);
+  beneficiaryRef.current = privateReadAddress;
+  const onLockSubmittedRef = useRef(onLockSubmitted);
+  const onLockFailedRef = useRef(onLockFailed);
+  useEffect(() => {
+    onLockSubmittedRef.current = onLockSubmitted;
+    onLockFailedRef.current = onLockFailed;
+  }, [onLockSubmitted, onLockFailed]);
+  const installSession = useCallback((next) => {
+    sessionRef.current = next;
+    setSession(next);
+  }, []);
+  const preserveCreditedFallback = useCallback(
+    (durable) => {
+      const pending = pendingCreditedTransitionRef.current;
+      if (pending && durable && isSameExternalDepositLockSession(durable, pending.predecessor)) {
+        return pending.credited;
+      }
+      pendingCreditedTransitionRef.current = null;
+      return durable;
+    },
+    []
+  );
+  const notifyFailure = useCallback((error) => {
+    onLockFailedRef.current?.(error);
+  }, []);
+  const submitSession = useCallback(
+    async (active) => {
+      if (settlingRef.current) return;
+      settlingRef.current = true;
+      setIsSubmittingLock(true);
+      let result;
+      try {
+        let submission = active;
+        const storedBeforeSubmit = loadExternalDepositLockSession(active.owner);
+        if (storedBeforeSubmit?.generation === active.generation) {
+          if (active.creditedAmount && !storedBeforeSubmit.creditedAmount) {
+            const pending = pendingCreditedTransitionRef.current;
+            if (!pending || !isSameExternalDepositLockSession(active, pending.credited) || !isSameExternalDepositLockSession(storedBeforeSubmit, pending.predecessor)) {
+              throw new ExternalDepositLockSessionChangedError();
+            }
+            saveExternalDepositLockSession(pending.credited, pending.predecessor);
+            pendingCreditedTransitionRef.current = null;
+            submission = pending.credited;
+          } else {
+            submission = storedBeforeSubmit;
+          }
+        }
+        result = await submitExternalDepositLock(client, submission);
+      } catch (err) {
+        const stored = loadExternalDepositLockSession(active.owner);
+        const error = err instanceof PostDepositLockError ? err : new PostDepositLockError(
+          err instanceof Error ? err.message : "Lock submission failed",
+          "submission-failed",
+          BigInt(active.maxLockAmount),
+          active.creditedAmount ? BigInt(active.creditedAmount) : void 0,
+          { cause: err }
+        );
+        if (err instanceof ExternalDepositLockSessionChangedError) {
+          pendingCreditedTransitionRef.current = null;
+          installSession(stored ?? null);
+          return;
+        }
+        if (!stored || stored.generation !== active.generation) {
+          pendingCreditedTransitionRef.current = null;
+          installSession(stored ?? null);
+          return;
+        }
+        if (active.creditedAmount && !stored.creditedAmount) {
+          const pending = pendingCreditedTransitionRef.current;
+          if (pending && isSameExternalDepositLockSession(active, pending.credited) && isSameExternalDepositLockSession(stored, pending.predecessor)) {
+            installSession(pending.credited);
+            notifyFailure(error);
+            return;
+          }
+          pendingCreditedTransitionRef.current = null;
+          installSession(stored);
+          return;
+        }
+        installSession(active.creditedAmount && !stored.creditedAmount ? active : stored);
+        notifyFailure(error);
+        return;
+      } finally {
+        settlingRef.current = false;
+        setIsSubmittingLock(false);
+      }
+      installSession(loadExternalDepositLockSession(active.owner) ?? null);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+      onLockSubmittedRef.current?.(result);
+    },
+    [client, installSession, notifyFailure, queryClient]
+  );
+  const validateRestoredSession = useCallback(
+    (restored) => {
+      if (!restored || !serviceAddress) return null;
+      const token = getTokenById(restored.tokenId);
+      const invalid = restored.serviceAddress.toLowerCase() !== serviceAddress.toLowerCase() || !token || token.chainId !== restored.chainId || token.contract === zeroAddress || !restored.creditedAmount && !restored.payload;
+      if (!invalid) return restored;
+      clearExternalDepositLockSession(
+        restored.owner,
+        externalDepositSessionId(restored.chainId, restored.tokenId),
+        restored.generation
+      );
+      return null;
+    },
+    [getTokenById, serviceAddress]
+  );
+  useEffect(() => {
+    if (!privateReadAddress || !serviceAddress || tokensStatus !== "ready") {
+      setSession(null);
+      return;
+    }
+    const hydrationKey = `${privateReadAddress.toLowerCase()}:${serviceAddress.toLowerCase()}`;
+    const shouldResume = hydratedScopeRef.current !== hydrationKey;
+    hydratedScopeRef.current = hydrationKey;
+    const restored = preserveCreditedFallback(
+      validateRestoredSession(loadExternalDepositLockSession(privateReadAddress))
+    );
+    installSession(restored);
+    if (!restored) {
+      return;
+    }
+    if (!shouldResume) return;
+    if (restored.creditedAmount && restored.payload) {
+      void submitSession(restored);
+    } else if (restored.creditedAmount) {
+      notifyFailure(
+        new PostDepositLockError(
+          "Deposit credited; sign a fresh policy to lock the funds",
+          "not-found",
+          BigInt(restored.maxLockAmount),
+          BigInt(restored.creditedAmount)
+        )
+      );
+    }
+  }, [
+    installSession,
+    notifyFailure,
+    privateReadAddress,
+    preserveCreditedFallback,
+    serviceAddress,
+    submitSession,
+    tokensStatus,
+    validateRestoredSession
+  ]);
+  useEffect(() => {
+    if (!privateReadAddress || !serviceAddress || tokensStatus !== "ready") return;
+    const reconcile = (restored) => {
+      installSession(preserveCreditedFallback(validateRestoredSession(restored)));
+    };
+    const unsubscribe = subscribeExternalDepositLockSession(privateReadAddress, reconcile);
+    reconcile(loadExternalDepositLockSession(privateReadAddress));
+    return unsubscribe;
+  }, [
+    installSession,
+    preserveCreditedFallback,
+    privateReadAddress,
+    serviceAddress,
+    tokensStatus,
+    validateRestoredSession
+  ]);
+  const signAndPersist = useCallback(
+    async ({ tokenId, amount }) => {
+      if (!allowance) throw new Error("No allowance configured for this deposit");
+      if (signingRef.current || settlingRef.current) {
+        throw new Error("A policy operation is already in progress");
+      }
+      if (!canUseSharedBrowserStorage()) {
+        throw new Error("Browser storage is required for locked deposit recovery");
+      }
+      const owner = requireDepositLockOwner(address, privateReadAddress);
+      if (sessionRef.current || loadExternalDepositLockSession(owner)) {
+        throw new Error("Finish or cancel the active external deposit before starting another");
+      }
+      const token = getTokenById(tokenId);
+      if (!token) throw new Error(`Unknown token ID: ${tokenId}`);
+      if (token.contract === zeroAddress) {
+        throw new Error("External deposits support ERC20 tokens only");
+      }
+      const targetService = requireServiceAddress(serviceAddress);
+      const lockDuration = allowance.lockDuration ?? DEFAULT_LOCK_DURATION_SECONDS;
+      signingRef.current = true;
+      setIsSigning(true);
+      try {
+        await ensureCorrectChain(networkConfig.chainId);
+        const signingWalletClient = await getWalletClient(config, {
+          chainId: networkConfig.chainId
+        });
+        const payload = await createSignedLockRequest({
+          client,
+          walletClient: signingWalletClient,
+          userAddress: owner,
+          networkConfig,
+          serviceAddress: targetService,
+          tokenId: token.id,
+          amount: clampLockAmount(amount, BigInt(allowance.value)),
+          lockDuration
+        });
+        const startBlock = await getBlockNumber(config, { chainId: token.chainId });
+        if (startBlock > BigInt(Number.MAX_SAFE_INTEGER)) {
+          throw new Error("Source-chain block number exceeds the supported range");
+        }
+        if (beneficiaryRef.current?.toLowerCase() !== owner.toLowerCase()) {
+          throw new Error("Authenticated deposit account changed while signing");
+        }
+        const next = {
+          version: 1,
+          owner,
+          serviceAddress: targetService,
+          chainId: token.chainId,
+          tokenId: token.id,
+          startBlock: Number(startBlock),
+          depositAmount: amount.toString(),
+          maxLockAmount: String(payload.amount),
+          lockDuration,
+          generation: payload.signature,
+          payload
+        };
+        saveExternalDepositLockSession(next, null);
+        installSession(next);
+      } finally {
+        signingRef.current = false;
+        setIsSigning(false);
+      }
+    },
+    [
+      address,
+      allowance,
+      client,
+      config,
+      ensureCorrectChain,
+      getTokenById,
+      installSession,
+      networkConfig,
+      privateReadAddress,
+      serviceAddress
+    ]
+  );
+  const settleAfterCredit = useCallback(
+    async (txHash, creditedAmount) => {
+      const active = sessionRef.current;
+      if (!active || settlingRef.current) return;
+      if (!isCurrentExternalDepositVerification(active, txHash)) {
+        return;
+      }
+      if (creditedAmount <= 0n) throw new Error("Credited amount must be positive");
+      const credited = {
+        ...active,
+        verification: void 0,
+        creditedAmount: creditedAmount.toString()
+      };
+      try {
+        saveExternalDepositLockSession(credited, active);
+        pendingCreditedTransitionRef.current = null;
+      } catch (err) {
+        const stored = loadExternalDepositLockSession(active.owner);
+        if (err instanceof ExternalDepositLockSessionChangedError || !stored || !isSameExternalDepositLockSession(stored, active)) {
+          pendingCreditedTransitionRef.current = null;
+          installSession(stored ?? null);
+          return;
+        }
+        pendingCreditedTransitionRef.current = { predecessor: active, credited };
+        installSession(credited);
+        notifyFailure(
+          new PostDepositLockError(
+            err instanceof Error ? err.message : "Unable to persist credited deposit state",
+            "submission-failed",
+            BigInt(active.maxLockAmount),
+            creditedAmount,
+            { cause: err }
+          )
+        );
+        return;
+      }
+      installSession(credited);
+      await submitSession(credited);
+    },
+    [installSession, notifyFailure, submitSession]
+  );
+  const recordVerification = useCallback(
+    (context) => {
+      const active = sessionRef.current;
+      if (!active || active.creditedAmount) {
+        throw new Error("No external deposit session is awaiting verification");
+      }
+      if (active.verification) {
+        const sameTransfer = active.verification.hash.toLowerCase() === context.hash.toLowerCase() && active.verification.chainId === context.chainId && active.verification.amount === context.amount.toString() && (active.verification.logIndex ?? 0) === (context.logIndex ?? 0);
+        if (sameTransfer) return;
+        throw new Error("Another transfer is already being verified for this deposit session");
+      }
+      if (context.chainId !== active.chainId || context.amount <= 0n) {
+        throw new Error("Discovered transfer does not match the signed deposit session");
+      }
+      const current = loadExternalDepositLockSession(active.owner);
+      if (!current || current.generation !== active.generation) {
+        throw new Error("The signed deposit session changed before verification");
+      }
+      const next = {
+        ...active,
+        verification: {
+          hash: context.hash,
+          chainId: context.chainId,
+          amount: context.amount.toString(),
+          logIndex: context.logIndex
+        }
+      };
+      saveExternalDepositLockSession(next, active);
+      installSession(next);
+    },
+    [installSession]
+  );
+  const retryAfterCredit = useCallback(async () => {
+    const active = sessionRef.current;
+    if (!active?.creditedAmount) throw new Error("No credited external deposit to recover");
+    if (signingRef.current || settlingRef.current) {
+      throw new Error("A policy operation is already in progress");
+    }
+    if (privateReadAddress?.toLowerCase() !== active.owner.toLowerCase()) {
+      throw new Error("Authenticated deposit account does not match the credited deposit");
+    }
+    const token = getTokenById(active.tokenId);
+    if (!token || token.chainId !== active.chainId || token.contract === zeroAddress) {
+      throw new Error("The credited token is no longer available");
+    }
+    const targetService = requireServiceAddress(serviceAddress);
+    if (targetService.toLowerCase() !== active.serviceAddress.toLowerCase()) {
+      throw new Error("The service for this credited deposit has changed");
+    }
+    if (active.payload) {
+      await submitSession(active);
+      return;
+    }
+    if (active.submissionAmbiguous) {
+      throw new Error(
+        "The previous lock submission may have succeeded; a fresh signature is unsafe"
+      );
+    }
+    const owner = requireDepositLockOwner(address, privateReadAddress);
+    const amount = externalDepositRetryAmount(active);
+    let retrySession;
+    signingRef.current = true;
+    setIsSigning(true);
+    try {
+      await ensureCorrectChain(networkConfig.chainId);
+      const signingWalletClient = await getWalletClient(config, {
+        chainId: networkConfig.chainId
+      });
+      const payload = await createSignedLockRequest({
+        client,
+        walletClient: signingWalletClient,
+        userAddress: owner,
+        networkConfig,
+        serviceAddress: targetService,
+        tokenId: active.tokenId,
+        amount,
+        lockDuration: active.lockDuration
+      });
+      if (beneficiaryRef.current?.toLowerCase() !== owner.toLowerCase()) {
+        throw new Error("Authenticated deposit account changed while signing");
+      }
+      retrySession = {
+        ...active,
+        depositAmount: amount.toString(),
+        generation: payload.signature,
+        verification: void 0,
+        submissionAmbiguous: void 0,
+        payload
+      };
+      saveExternalDepositLockSession(retrySession, active);
+      installSession(retrySession);
+    } finally {
+      signingRef.current = false;
+      setIsSigning(false);
+    }
+    await submitSession(retrySession);
+  }, [
+    address,
+    client,
+    config,
+    ensureCorrectChain,
+    getTokenById,
+    installSession,
+    networkConfig,
+    privateReadAddress,
+    serviceAddress,
+    submitSession
+  ]);
+  const clearVerification = useCallback(() => {
+    const active = sessionRef.current;
+    if (!active?.verification || active.creditedAmount) return false;
+    const next = clearExternalDepositVerification(active);
+    if (!next) {
+      installSession(loadExternalDepositLockSession(active.owner) ?? null);
+      return false;
+    }
+    installSession(next);
+    return true;
+  }, [installSession]);
+  const discardSession = useCallback(() => {
+    const active = sessionRef.current;
+    if (!active) return true;
+    if (signingRef.current || settlingRef.current) return false;
+    const pending = pendingCreditedTransitionRef.current;
+    const discardTarget = pending && isSameExternalDepositLockSession(active, pending.credited) ? pending.predecessor : active;
+    const discarded = discardExternalDepositLockSession(discardTarget);
+    const restored = loadExternalDepositLockSession(active.owner) ?? null;
+    if (discarded) pendingCreditedTransitionRef.current = null;
+    installSession(restored);
+    return discarded && !restored;
+  }, [installSession]);
+  return {
+    isSigning,
+    isSubmittingLock,
+    session,
+    signAndPersist,
+    recordVerification,
+    settleAfterCredit,
+    retryAfterCredit,
+    clearVerification,
+    discardSession
+  };
+}
 var DEFAULT_MOONPAY_API_URL = "https://api.moonpay.com/v3";
 function useMoonpayLimits({
   currencyCode,
@@ -3328,6 +4093,14 @@ function MoonPayGate({ enabled, children }) {
   if (!enabled || !apiKey) return /* @__PURE__ */ jsx(Fragment, { children });
   return /* @__PURE__ */ jsx(MoonPayProvider, { apiKey, children });
 }
+function formatPostDepositLockFailure(error, token) {
+  if (error?.reason === "credited-below-signed" && error.creditedAmount !== void 0 && error.signedAmount !== void 0 && token) {
+    const creditedAmount = `${formatUnits(error.creditedAmount, token.decimals)} ${token.symbol}`;
+    const signedAmount = `${formatUnits(error.signedAmount, token.decimals)} ${token.symbol}`;
+    return `Credited amount (${creditedAmount}) is below the signed lock amount (${signedAmount})`;
+  }
+  return error?.message ?? "Lock submission failed";
+}
 function MethodTabs({
   activeTab,
   onTabChange
@@ -3394,19 +4167,21 @@ function DepositView({
   selectedToken,
   amount,
   allowance,
+  externalMinimum,
   onAmountChange,
   onSelectToken,
   onConnectWallet,
   onSubmit,
   isSubmitting = false
 }) {
-  const { getChainById: getChainById2, chains, serviceName, serviceIcon, networkConfig } = usePrivanaContext();
+  const { getChainById: getChainById2, chains, serviceName, serviceIcon, networkConfig, hostedAuthConfig } = usePrivanaContext();
   const { address, isConnected } = useAccount();
   const appName = serviceName ?? "Privana";
   const chain = selectedToken ? getChainById2(selectedToken.chainId) : void 0;
   const targetChain = chain ?? chains[0];
   const sourceLabel = source === "connected" ? "Connected Wallet" : "External Wallet";
   const isConnectedSource = source === "connected";
+  const isExternal = source === "external";
   const isCreditCard = source === "credit-card";
   const isNative = selectedToken?.contract === zeroAddress;
   const { data: nativeBalanceData } = useBalance$1({
@@ -3440,8 +4215,14 @@ function DepositView({
   const belowMoonpayMin = isCreditCard && hasValidAmount && moonpayMinBuy != null && parseFloat(amount) < moonpayMinBuy;
   const moonpayLimitsUnready = isCreditCard && !!selectedToken?.moonpayCurrencyCode && moonpayMinBuy == null;
   const creditCardUnavailable = isCreditCard && !!selectedToken && !selectedToken.moonpayCurrencyCode;
-  const needsConnect = isConnectedSource && !isConnected;
-  const canDeposit = hasValidAmount && !!selectedToken && !tooManyDecimals && !exceedsBalance && !belowMoonpayMin && !moonpayLimitsUnready && !creditCardUnavailable && !needsConnect;
+  const externalTokenUnavailable = isExternal && !!selectedToken && isNative;
+  const externalMinimumRequired = isExternal && !!allowance && !!selectedToken;
+  const externalMinimumLoading = externalMinimumRequired && externalMinimum === void 0;
+  const externalMinimumUnavailable = externalMinimumRequired && externalMinimum === null;
+  const belowExternalMinimum = externalMinimumRequired && hasValidAmount && !tooManyDecimals && !!selectedToken && typeof externalMinimum === "bigint" && parseTokenAmount(amount, selectedToken.decimals) < externalMinimum;
+  const externalNeedsWallet = isExternal && (!!allowance || !hostedAuthConfig);
+  const needsConnect = (isConnectedSource || externalNeedsWallet) && !isConnected;
+  const canDeposit = hasValidAmount && !!selectedToken && !tooManyDecimals && !exceedsBalance && !belowMoonpayMin && !moonpayLimitsUnready && !creditCardUnavailable && !externalTokenUnavailable && !externalMinimumLoading && !externalMinimumUnavailable && !belowExternalMinimum && !needsConnect;
   const handleMax = () => {
     const max = formattedWalletBalance.replace(/\s/g, "");
     if (parseFloat(max) > 0) onAmountChange(max);
@@ -3450,9 +4231,12 @@ function DepositView({
     isCreditCard ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
       /* @__PURE__ */ jsx("h2", { className: "text-foreground text-[28px] leading-8 font-medium", children: "Buy with credit card and deposit" }),
       /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Enter your deposit amount and proceed to sign a policy." })
-    ] }) : /* @__PURE__ */ jsxs("h2", { className: "text-foreground text-[28px] leading-8 font-medium", children: [
-      "Deposit from ",
-      sourceLabel
+    ] }) : /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+      /* @__PURE__ */ jsxs("h2", { className: "text-foreground text-[28px] leading-8 font-medium", children: [
+        "Deposit from ",
+        sourceLabel
+      ] }),
+      allowance && /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Enter your deposit amount and proceed to sign a policy." })
     ] }),
     /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3", children: [
       /* @__PURE__ */ jsx("label", { className: "text-muted-foreground text-sm", children: "Token" }),
@@ -3461,7 +4245,8 @@ function DepositView({
         {
           type: "button",
           onClick: onSelectToken,
-          className: "border-border bg-input flex w-full cursor-pointer items-center gap-3 rounded-lg border p-3 text-left",
+          disabled: isSubmitting,
+          className: "border-border bg-input flex w-full cursor-pointer items-center gap-3 rounded-lg border p-3 text-left disabled:cursor-not-allowed disabled:opacity-50",
           children: [
             selectedToken ? /* @__PURE__ */ jsxs(Fragment, { children: [
               /* @__PURE__ */ jsx("div", { className: "h-8 w-8 shrink-0 overflow-hidden rounded-full", children: getTokenIcon(selectedToken.symbol, 32) }),
@@ -3502,6 +4287,7 @@ function DepositView({
                 type: "text",
                 inputMode: "decimal",
                 placeholder: "Enter Amount",
+                disabled: isSubmitting,
                 value: amount,
                 onChange: (e) => {
                   const value = e.target.value.replace(/[^0-9.,]/g, "").replace(/,/g, ".");
@@ -3533,11 +4319,24 @@ function DepositView({
         moonpayMinBuy,
         " USD."
       ] }),
+      belowExternalMinimum && selectedToken && typeof externalMinimum === "bigint" && /* @__PURE__ */ jsxs("p", { className: "text-destructive text-sm", children: [
+        "Minimum deposit is ",
+        formatUnits(externalMinimum, selectedToken.decimals),
+        " ",
+        selectedToken.symbol,
+        "."
+      ] }),
+      externalMinimumLoading && /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Checking minimum deposit\u2026" }),
+      externalMinimumUnavailable && /* @__PURE__ */ jsx("p", { className: "text-destructive text-sm", children: "Couldn\u2019t load the minimum deposit. Please try again." }),
       isCreditCard && moonpayLimitsError && /* @__PURE__ */ jsx("p", { className: "text-destructive text-sm", children: "Couldn\u2019t load purchase limits. Please try again." }),
       isCreditCard && moonpayLimitsLoading && /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Checking purchase limits\u2026" }),
       creditCardUnavailable && /* @__PURE__ */ jsxs("p", { className: "text-destructive text-sm", children: [
         selectedToken?.symbol ?? "This token",
         " isn\u2019t available for card purchases yet."
+      ] }),
+      externalTokenUnavailable && /* @__PURE__ */ jsxs("p", { className: "text-destructive text-sm", children: [
+        selectedToken?.symbol ?? "This token",
+        " can\u2019t be used for external deposits. Choose an ERC20 token."
       ] })
     ] }),
     allowance && /* @__PURE__ */ jsx(
@@ -3612,19 +4411,33 @@ function AwaitingDepositStatus({
 function ExternalDepositView({
   token,
   amount,
-  onCredited
+  depositAddressState,
+  onCredited,
+  onDiscardLock,
+  lock
 }) {
-  const { getChainById: getChainById2 } = usePrivanaContext();
-  const { depositAddress, isReady, isLoading } = useDepositAddress();
+  const { getChainById: getChainById2, getTokenById, serviceName } = usePrivanaContext();
+  const appName = serviceName ?? "Privana";
+  const { depositAddress, isReady, isLoading } = depositAddressState;
   const chain = token ? getChainById2(token.chainId) : void 0;
+  const lockSession = lock?.session;
+  const recordVerification = lock?.recordVerification;
+  const settleAfterCredit = lock?.settleAfterCredit;
+  const retryAfterCredit = lock?.retryAfterCredit;
+  const discoveryToken = lockSession ? getTokenById(lockSession.tokenId) : token;
   const [copied, setCopied] = useState(false);
   const [deadline] = useState(() => Date.now() + LISTENING_WINDOW_MS);
   const secondsLeft = useCountdown(deadline);
   const listening = secondsLeft > 0;
   const [nothingFound, setNothingFound] = useState(false);
   const [credited, setCredited] = useState(null);
+  const [showCancelWarning, setShowCancelWarning] = useState(false);
   const verification = useDepositVerification({
-    onCredited: (txHash) => {
+    onCredited: (txHash, _response, creditedAmount) => {
+      if (settleAfterCredit) {
+        void settleAfterCredit(txHash, creditedAmount);
+        return;
+      }
       if (onCredited) {
         onCredited();
         return;
@@ -3632,8 +4445,9 @@ function ExternalDepositView({
       setCredited({ txHash });
     }
   });
-  const { isVerifying, verificationFailed, didTimeout, verify } = verification;
-  const scanPaused = isVerifying || verificationFailed || didTimeout || !!credited;
+  const { isVerifying, verificationFailed, canCheckAnotherTransfer, didTimeout, verify } = verification;
+  const scanPaused = isVerifying || verificationFailed || didTimeout || !!credited || !!lock?.isSigning || !!lock?.isSubmittingLock || !!lockSession?.verification || !!lockSession?.creditedAmount;
+  const showDepositInstructions = !credited && !lockSession?.creditedAmount;
   const {
     pending,
     isFetching: isScanning,
@@ -3642,23 +4456,58 @@ function ExternalDepositView({
     isUnavailable,
     refetch: refetchPendingDeposits
   } = usePendingDeposits({
-    chainId: token?.chainId,
-    enabled: isReady && !!depositAddress && !!token,
+    chainId: discoveryToken?.chainId,
+    tokenAddress: discoveryToken?.contract === zeroAddress ? void 0 : discoveryToken?.contract,
+    enabled: isReady && !!depositAddress && !!discoveryToken && discoveryToken.contract !== zeroAddress,
     refetchInterval: listening && !scanPaused ? 3e4 : false
   });
   const processedRef = useRef(/* @__PURE__ */ new Set());
+  const verificationRunRef = useRef(null);
+  useEffect(
+    () => () => {
+      verificationRunRef.current = null;
+    },
+    []
+  );
+  useEffect(() => {
+    const stored = lockSession?.verification;
+    if (!stored || lockSession.creditedAmount || isVerifying || verificationFailed || didTimeout) {
+      return;
+    }
+    const key = `${lockSession.generation}:${stored.chainId}:${stored.hash}:${stored.logIndex ?? 0}`;
+    if (verificationRunRef.current === key) return;
+    verificationRunRef.current = key;
+    processedRef.current.add(`${stored.hash}:${stored.logIndex ?? 0}`);
+    void verify({
+      hash: stored.hash,
+      chainId: stored.chainId,
+      amount: BigInt(stored.amount),
+      logIndex: stored.logIndex
+    });
+  }, [didTimeout, isVerifying, lockSession, verificationFailed, verify]);
   useEffect(() => {
     if (scanPaused) return;
-    const next = [...pending].sort((a, b) => a.block_number - b.block_number).find((d) => !processedRef.current.has(`${d.tx_hash}:${d.log_index}`));
+    const next = [...pending].sort((a, b) => a.block_number - b.block_number).find(
+      (deposit) => (!lockSession || isExternalDepositBlockInSession(lockSession, deposit.block_number)) && !processedRef.current.has(`${deposit.tx_hash}:${deposit.log_index}`)
+    );
     if (!next) return;
-    processedRef.current.add(`${next.tx_hash}:${next.log_index}`);
-    void verify({
+    const context = {
       hash: next.tx_hash,
       chainId: next.chain_id,
       amount: BigInt(next.amount),
       logIndex: next.log_index
-    });
-  }, [pending, scanPaused, verify]);
+    };
+    if (recordVerification) {
+      try {
+        recordVerification(context);
+      } catch (err) {
+        toast.error(err instanceof Error ? err.message : "Unable to save deposit recovery state");
+        return;
+      }
+    }
+    processedRef.current.add(`${next.tx_hash}:${next.log_index}`);
+    if (!recordVerification) void verify(context);
+  }, [lockSession, pending, recordVerification, scanPaused, verify]);
   const nothingFoundTimerRef = useRef(void 0);
   useEffect(() => () => clearTimeout(nothingFoundTimerRef.current), []);
   const handleRefresh = () => {
@@ -3671,11 +4520,27 @@ function ExternalDepositView({
       }
     });
   };
-  const handleCopy = () => {
+  const handleCopy = async () => {
     if (!depositAddress) return;
-    void navigator.clipboard.writeText(depositAddress);
-    setCopied(true);
-    setTimeout(() => setCopied(false), 2e3);
+    try {
+      await navigator.clipboard.writeText(depositAddress);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    } catch {
+      toast.error("Unable to copy the deposit address");
+    }
+  };
+  const handleCheckAnotherTransfer = () => {
+    try {
+      if (!lock?.clearVerification()) {
+        toast.error("Deposit recovery changed in another tab. Please review the current state.");
+        return;
+      }
+      verificationRunRef.current = null;
+      verification.reset();
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : "Unable to continue deposit discovery");
+    }
   };
   return /* @__PURE__ */ jsxs("div", { className: "bg-muted flex flex-col gap-6 rounded-[10px] p-5", children: [
     /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
@@ -3689,27 +4554,64 @@ function ExternalDepositView({
       /* @__PURE__ */ jsx("div", { className: "bg-border h-px w-full" }),
       /* @__PURE__ */ jsx(SummaryRow, { value: amount || "\u2014", label: "Value" })
     ] }),
-    /* @__PURE__ */ jsx("div", { className: "bg-secondary flex h-50 items-center justify-center rounded-[10px]", children: !isReady ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground px-6 text-center text-sm", children: "Connect your wallet to generate a deposit address." }) : depositAddress ? /* @__PURE__ */ jsx("div", { className: "rounded-[10px] bg-white p-3", children: /* @__PURE__ */ jsx(QRCodeSVG, { value: depositAddress, size: 160 }) }) : isLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-full w-full rounded-[10px]" }) : /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: "Deposit address unavailable" }) }),
-    /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3", children: [
-      /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Deposit Address" }),
-      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
-        /* @__PURE__ */ jsx("div", { className: "border-border flex h-10 min-w-0 flex-1 items-center rounded-[10px] border px-3", children: depositAddress ? /* @__PURE__ */ jsx("p", { className: "text-foreground min-w-0 flex-1 truncate text-sm", children: depositAddress }) : isReady && isLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-3/4" }) : /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "\u2014" }) }),
-        /* @__PURE__ */ jsxs(
-          "button",
-          {
-            type: "button",
-            onClick: handleCopy,
-            disabled: !depositAddress,
-            className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 shrink-0 cursor-pointer items-center gap-2 rounded-[10px] px-3 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
-            children: [
-              /* @__PURE__ */ jsx(CopyIcon, {}),
-              copied ? "Copied" : "Copy"
-            ]
-          }
-        )
+    showDepositInstructions && /* @__PURE__ */ jsxs(Fragment, { children: [
+      !scanPaused && /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Send the displayed amount in one transfer. Transfers below the minimum are not combined or automatically returned." }),
+      /* @__PURE__ */ jsx("div", { className: "bg-secondary flex h-50 items-center justify-center rounded-[10px]", children: !isReady ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground px-6 text-center text-sm", children: "Connect your wallet to generate a deposit address." }) : depositAddress ? /* @__PURE__ */ jsx("div", { className: "rounded-[10px] bg-white p-3", children: /* @__PURE__ */ jsx(QRCodeSVG, { value: depositAddress, size: 160 }) }) : isLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-full w-full rounded-[10px]" }) : /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: "Deposit address unavailable" }) }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "Deposit Address" }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsx("div", { className: "border-border flex h-10 min-w-0 flex-1 items-center rounded-[10px] border px-3", children: depositAddress ? /* @__PURE__ */ jsx("p", { className: "text-foreground min-w-0 flex-1 truncate text-sm", children: depositAddress }) : isReady && isLoading ? /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-3/4" }) : /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "\u2014" }) }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: handleCopy,
+              disabled: !depositAddress,
+              className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 shrink-0 cursor-pointer items-center gap-2 rounded-[10px] px-3 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
+              children: [
+                /* @__PURE__ */ jsx(CopyIcon, {}),
+                copied ? "Copied" : "Copy"
+              ]
+            }
+          )
+        ] })
       ] })
     ] }),
-    credited ? /* @__PURE__ */ jsx(
+    showCancelWarning && lockSession && !lockSession.verification && !lockSession.creditedAmount ? /* @__PURE__ */ jsx(
+      TransactionWarningView,
+      {
+        title: "Cancel this deposit?",
+        message: "Only cancel if you have not sent funds. Canceling after a transfer was sent stops recovery and can leave the transfer uncredited or unlocked.",
+        onDone: () => onDiscardLock?.(),
+        actionLabel: "I haven\u2019t sent funds",
+        onDismiss: () => setShowCancelWarning(false),
+        dismissLabel: "Keep waiting"
+      }
+    ) : lock?.isSigning ? /* @__PURE__ */ jsx(
+      AwaitingDepositStatus,
+      {
+        title: "Confirm policy in your wallet",
+        subtitle: "Sign a fresh policy for the funds already credited."
+      }
+    ) : lock?.isSubmittingLock ? /* @__PURE__ */ jsx(
+      AwaitingDepositStatus,
+      {
+        title: `Locking funds for ${appName}`,
+        subtitle: "Deposit credited. Applying your signed policy\u2026"
+      }
+    ) : lock?.session?.creditedAmount ? /* @__PURE__ */ jsx(
+      TransactionWarningView,
+      {
+        title: lock.session.submissionAmbiguous ? "Lock status unknown" : "Deposit credited",
+        message: lock.session.submissionAmbiguous ? "The lock may already have succeeded. Retry only the saved signature, or check locked funds before stopping recovery." : "The deposit is credited, but its signed lock still needs to be submitted.",
+        onDone: () => {
+          void retryAfterCredit?.().catch((err) => {
+            toast.error(err instanceof Error ? err.message : "Policy recovery failed");
+          });
+        },
+        actionLabel: lock.session.payload ? "Retry lock submission" : "Sign policy and lock funds"
+      }
+    ) : credited ? /* @__PURE__ */ jsx(
       TransactionSuccessView,
       {
         title: "Deposit Credited",
@@ -3726,14 +4628,15 @@ function ExternalDepositView({
         title: "Could not verify deposit",
         message: didTimeout ? "Verification timed out \u2014 your deposit may still be credited in the background." : verification.error?.message ?? "Your transfer was found but could not be verified.",
         onRetry: () => void verification.retryVerification(),
-        onDismiss: () => verification.reset(),
+        onDismiss: lock ? canCheckAnotherTransfer ? handleCheckAnotherTransfer : void 0 : () => verification.reset(),
+        dismissLabel: lock && canCheckAnotherTransfer ? "Check another transfer" : void 0,
         isRetrying: isVerifying
       }
     ) : isVerifying ? /* @__PURE__ */ jsx(
       AwaitingDepositStatus,
       {
         title: "Deposit detected",
-        subtitle: "Crediting the incoming transaction to your Privana balance..."
+        subtitle: "Crediting the incoming transaction to your Privana balance\u2026"
       }
     ) : /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx(
@@ -3755,7 +4658,16 @@ function ExternalDepositView({
             children: "Refresh deposit status"
           }
         ),
-        isRateLimited ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Checked too recently \u2014 try again in a moment." }) : isUnavailable ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Deposit discovery is unavailable for this chain." }) : isScanError ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Chain temporarily unreachable \u2014 retrying automatically." }) : nothingFound ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "No incoming transaction found yet." }) : null
+        lockSession && !lockSession.verification && !lockSession.creditedAmount && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setShowCancelWarning(true),
+            className: "border-border text-foreground hover:bg-secondary flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors",
+            children: "Cancel deposit"
+          }
+        ),
+        isRateLimited ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Checked too recently. Try again in a moment." }) : isUnavailable ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Deposit discovery is unavailable for this chain." }) : isScanError ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "Chain temporarily unreachable. Retrying automatically." }) : nothingFound ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-center text-sm", children: "No incoming transaction found yet." }) : null
       ] })
     ] })
   ] });
@@ -3774,7 +4686,7 @@ function DepositModalContent({
   onCloseBlockedChange,
   onExit
 }) {
-  const { serviceName, enabledTokens, defaultToken, hostedAuthConfig, getChainById: getChainById2 } = usePrivanaContext();
+  const { serviceName, enabledTokens, defaultToken, hostedAuthConfig, getChainById: getChainById2, getTokenById } = usePrivanaContext();
   const { address } = useAccount();
   const appName = serviceName ?? "Privana";
   const [activeTab, setActiveTab] = useState(defaultTab);
@@ -3783,6 +4695,10 @@ function DepositModalContent({
   const [selectedTokenId, setSelectedTokenId] = useState(defaultToken?.id ?? "");
   const [amount, setAmount] = useState("");
   const selectedToken = enabledTokens.find((t) => t.id === selectedTokenId) ?? defaultToken;
+  const externalDepositAddress = useDepositAddress({
+    enabled: source === "external" && (view === "deposit" || view === "external-deposit")
+  });
+  const externalMinimum = source !== "external" || !selectedToken ? void 0 : externalDepositAddress.isError ? null : externalDepositAddress.response ? getExternalDepositMinimum(externalDepositAddress.response, selectedToken.chainId) ?? null : void 0;
   const prevAddressRef = useRef(address);
   useEffect(() => {
     const prev = prevAddressRef.current;
@@ -3802,9 +4718,10 @@ function DepositModalContent({
   const [showTimeout, setShowTimeout] = useState(false);
   const [cancelled, setCancelled] = useState(false);
   const [isSubmittingLock, setIsSubmittingLock] = useState(false);
-  const [lockFailedMessage, setLockFailedMessage] = useState(null);
+  const [lockFailure, setLockFailure] = useState(null);
   const finishDeposit = () => {
     setAmount("");
+    if (view === "external-deposit") setView("deposit");
     if (onDepositSuccess) {
       resetDeposit();
       onDepositSuccess();
@@ -3839,6 +4756,7 @@ function DepositModalContent({
     },
     onLockSubmitted: () => {
       setIsSubmittingLock(false);
+      setLockFailure(null);
       finishDeposit();
     },
     // The deposit credited; only the policy lock failed. Success must not
@@ -3846,7 +4764,7 @@ function DepositModalContent({
     // error view and let the host re-prompt for a fresh lock.
     onLockFailed: (err) => {
       setIsSubmittingLock(false);
-      setLockFailedMessage(err.message);
+      setLockFailure(err);
       onLockFailed?.(err);
     },
     onCheckTimeout: () => {
@@ -3854,7 +4772,37 @@ function DepositModalContent({
       setShowTimeout(true);
     }
   });
-  const isUnsafeToClose = (isGettingAddress || isSendingTransaction) && !cancelled;
+  const externalLock = useExternalDepositLock({
+    allowance,
+    onLockSubmitted: () => {
+      setLockFailure(null);
+      finishDeposit();
+    },
+    // Same contract as the connected flow: the deposit credited, only the
+    // lock failed — never report success, show the lock-error view instead.
+    onLockFailed: (err) => {
+      setLockFailure(err);
+      onLockFailed?.(err);
+    }
+  });
+  useEffect(() => {
+    const restored = externalLock.session;
+    if (!restored) return;
+    const canRestore = view === "method" || source === "external" && (view === "deposit" || view === "external-deposit");
+    if (!canRestore) return;
+    const token = getTokenById(restored.tokenId);
+    if (!token) return;
+    setSource("external");
+    setSelectedTokenId(token.id);
+    setAmount(formatUnits(BigInt(restored.depositAmount), token.decimals));
+    setView("external-deposit");
+  }, [externalLock.session, getTokenById, source, view]);
+  useEffect(() => {
+    if (view === "external-deposit" && allowance && !externalLock.session) {
+      setView("deposit");
+    }
+  }, [allowance, externalLock.session, view]);
+  const isUnsafeToClose = (isGettingAddress || isSendingTransaction) && !cancelled || externalLock.isSigning || externalLock.isSubmittingLock;
   useEffect(() => {
     onCloseBlockedChange?.(isUnsafeToClose);
   }, [isUnsafeToClose, onCloseBlockedChange]);
@@ -3867,7 +4815,33 @@ function DepositModalContent({
   }, [depositError, verificationFailed]);
   const handleSubmit = (args) => {
     if (args.source === "external") {
-      setView("external-deposit");
+      const token2 = enabledTokens.find((candidate) => candidate.id === args.tokenId);
+      if (!token2) return;
+      if (token2.contract === zeroAddress) {
+        toast.error("External deposits support ERC20 tokens only");
+        return;
+      }
+      const depositAmount = parseTokenAmount(args.amount, token2.decimals);
+      if (!allowance) {
+        setView("external-deposit");
+        return;
+      }
+      if (typeof externalMinimum !== "bigint") {
+        toast.error("Minimum deposit is unavailable. Please try again.");
+        return;
+      }
+      if (depositAmount < externalMinimum) {
+        toast.error(
+          `Minimum deposit is ${formatUnits(externalMinimum, token2.decimals)} ${token2.symbol}`
+        );
+        return;
+      }
+      externalLock.signAndPersist({
+        tokenId: token2.id,
+        amount: depositAmount
+      }).then(() => setView("external-deposit")).catch((err) => {
+        toast.error(err instanceof Error ? err.message : "Policy signing failed");
+      });
       return;
     }
     if (args.source === "credit-card") {
@@ -3919,7 +4893,14 @@ function DepositModalContent({
       }
     ] : []
   ];
-  const flowView = showSuccess ? "deposit-success" : lockFailedMessage ? "lock-error" : showTimeout ? "deposit-timeout" : verificationFailed ? "deposit-error" : isPending && !cancelled || isSubmittingLock ? "depositing" : null;
+  const hasExternalLockRecovery = view === "external-deposit" && !!externalLock.session?.creditedAmount;
+  const externalSubmissionAmbiguous = hasExternalLockRecovery && !!lockFailure?.submissionMayHaveSucceeded;
+  const savedExternalPayloadUsable = !!externalLock.session?.payload && isSignedLockUsable(externalLock.session.payload);
+  const ambiguousRecoveryMustBeAbandoned = externalSubmissionAmbiguous && !savedExternalPayloadUsable;
+  const externalRecoveryExitLabel = externalSubmissionAmbiguous ? "Stop recovery" : "Keep funds unlocked";
+  const lockFailureToken = hasExternalLockRecovery && externalLock.session ? getTokenById(externalLock.session.tokenId) ?? selectedToken : selectedToken;
+  const lockFailureMessage = formatPostDepositLockFailure(lockFailure, lockFailureToken);
+  const flowView = showSuccess ? "deposit-success" : lockFailure ? "lock-error" : showTimeout ? "deposit-timeout" : verificationFailed ? "deposit-error" : isPending && !cancelled || isSubmittingLock ? "depositing" : null;
   const activeView = flowView ?? view;
   const handleDepositDone = () => {
     setShowSuccess(false);
@@ -3932,10 +4913,28 @@ function DepositModalContent({
     resetDeposit();
   };
   const handleLockFailedDone = () => {
-    setLockFailedMessage(null);
+    if (hasExternalLockRecovery && !externalLock.discardSession()) {
+      toast.error("Deposit recovery changed in another tab. Please review the current state.");
+      return;
+    }
+    setLockFailure(null);
     setAmount("");
     setCancelled(false);
     resetDeposit();
+    if (view === "external-deposit") setView("deposit");
+  };
+  const handleExternalLockRetry = () => {
+    externalLock.retryAfterCredit().catch((err) => {
+      toast.error(err instanceof Error ? err.message : "Policy signing failed");
+    });
+  };
+  const handleExternalVerificationDiscard = () => {
+    if (!externalLock.discardSession()) {
+      toast.error("Deposit recovery changed in another tab. Please review the current state.");
+      return;
+    }
+    setAmount("");
+    setView("deposit");
   };
   const handleDismissVerificationError = () => {
     setAmount("");
@@ -3948,6 +4947,10 @@ function DepositModalContent({
   };
   const back = view === "external-deposit" ? { to: "deposit", label: "Deposit from External Wallet" } : view === "credit-card-widget" ? { to: "deposit", label: "Buy with credit card and deposit" } : view === "select-token" ? { to: "deposit", label: "Deposit" } : { to: "method", label: "Deposit Method" };
   const goBack = () => {
+    if (view === "external-deposit" && externalLock.session) {
+      toast.error("Cancel the active deposit from the address screen before going back");
+      return;
+    }
     if (back.to === "method") {
       setAmount("");
       setSelectedTokenId("");
@@ -3993,9 +4996,14 @@ function DepositModalContent({
       activeView === "lock-error" && /* @__PURE__ */ jsx(
         TransactionWarningView,
         {
-          title: "Deposit credited, lock failed",
-          message: `Your deposit was credited but locking the funds for ${appName} failed: ${lockFailedMessage}`,
-          onDone: handleLockFailedDone
+          title: externalSubmissionAmbiguous ? "Deposit credited, lock status unknown" : "Deposit credited, lock failed",
+          message: externalSubmissionAmbiguous ? `Your deposit was credited, but the lock for ${appName} may already have succeeded. Retry only the saved signature; if it has expired, check locked funds before stopping recovery.` : `Your deposit was credited but locking the funds for ${appName} failed: ${lockFailureMessage}`,
+          onDone: hasExternalLockRecovery && !ambiguousRecoveryMustBeAbandoned ? handleExternalLockRetry : handleLockFailedDone,
+          actionLabel: hasExternalLockRecovery ? ambiguousRecoveryMustBeAbandoned ? externalRecoveryExitLabel : externalLock.session?.payload ? "Retry lock submission" : "Sign policy and lock funds" : void 0,
+          pendingLabel: externalLock.isSigning ? "Confirm policy in wallet\u2026" : "Locking funds\u2026",
+          isPending: externalLock.isSigning || externalLock.isSubmittingLock,
+          onDismiss: hasExternalLockRecovery && !ambiguousRecoveryMustBeAbandoned ? handleLockFailedDone : void 0,
+          dismissLabel: externalRecoveryExitLabel
         }
       ),
       activeView === "deposit-timeout" && /* @__PURE__ */ jsx(
@@ -4010,7 +5018,7 @@ function DepositModalContent({
         TransactionErrorView,
         {
           title: "Verification failed",
-          message: depositError?.message ? `Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address \u2014 retry verification instead of starting a new deposit. (${depositError.message})` : "Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address \u2014 retry verification instead of starting a new deposit.",
+          message: depositError?.message ? `Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address. Retry verification instead of starting a new deposit. (${depositError.message})` : "Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address. Retry verification instead of starting a new deposit.",
           explorerUrl: explorerTxUrl,
           explorerLabel: "View transaction",
           onRetry: handleRetryVerification,
@@ -4020,7 +5028,7 @@ function DepositModalContent({
       activeView === "depositing" && /* @__PURE__ */ jsx(
         TransactionProgressView,
         {
-          title: "Depositing...",
+          title: "Depositing\u2026",
           steps: depositSteps,
           onCancel: isGettingAddress || isSendingTransaction ? handleDepositCancel : void 0
         }
@@ -4074,11 +5082,12 @@ function DepositModalContent({
         selectedToken,
         amount,
         allowance,
+        externalMinimum,
         onAmountChange: setAmount,
         onSelectToken: () => setView("select-token"),
         onConnectWallet,
         onSubmit: handleSubmit,
-        isSubmitting: isPending
+        isSubmitting: isPending || externalLock.isSigning || externalLock.isSubmittingLock
       }
     ) }),
     activeView === "select-token" && /* @__PURE__ */ jsx(
@@ -4091,12 +5100,15 @@ function DepositModalContent({
         }
       }
     ),
-    activeView === "external-deposit" && /* @__PURE__ */ jsx(
+    activeView === "external-deposit" && (!allowance || externalLock.session) && /* @__PURE__ */ jsx(
       ExternalDepositView,
       {
         token: selectedToken,
         amount,
-        onCredited: allowance ? void 0 : onDepositSuccess
+        depositAddressState: externalDepositAddress,
+        onCredited: allowance ? void 0 : onDepositSuccess,
+        onDiscardLock: handleExternalVerificationDiscard,
+        lock: externalLock.session ? externalLock : void 0
       }
     ),
     activeView === "credit-card-widget" && /* @__PURE__ */ jsx(MoonPayGate, { enabled: true, children: /* @__PURE__ */ jsx(
@@ -4108,7 +5120,7 @@ function DepositModalContent({
         onCredited: allowance ? void 0 : finishCardPurchase,
         onLockSubmitted: finishCardPurchase,
         onLockFailed: (err) => {
-          setLockFailedMessage(err.message);
+          setLockFailure(err);
           onLockFailed?.(err);
         }
       }
@@ -4868,7 +5880,7 @@ function WalletModalContent({
         onAmountChange: setAmount,
         onFundSession: onFundSession ? fundSession : void 0,
         onAddFunds: () => setView("deposit"),
-        onWithdraw: handleWithdraw
+        onWithdraw: session && !onEndSession ? void 0 : handleWithdraw
       }
     ),
     view === "funding-session" && /* @__PURE__ */ jsx("div", { className: "bg-muted flex flex-col gap-6 rounded-[10px] p-5", children: /* @__PURE__ */ jsx(