@oasisprotocol/privana-sdk 0.5.0 → 0.5.1

package/dist/index.js

@@ -1,9 +1,9 @@
 "use client";
-import { usePrivanaContext, createHostedAuthPendingStorageKey, clearHostedAuthPendingTransaction, HostedAuthRequiredError, HostedAuthError, createPkceVerifier, createPkceChallenge, createHostedAuthState, persistHostedAuthPendingTransaction, parseHostedAuthCallback, readHostedAuthPendingTransaction, HostedAuthStateMismatchError, buildHostedAuthSession, useSafePrivanaContext, usePrivateReadRequest, formatTokenAmount, useDepositVerification, getTransactionReceipt, waitForTransactionReceipt, cn, Button, stripHostedAuthCallbackParams, AccountingApiError, getChainId2, shortenAddress, formatTimeRemaining, parseTokenAmount, getExplorerAddressUrl, getExplorerLabel, Skeleton, FiatOnRampForm } from './chunk-54FC6TO3.js';
-export { AccountingApiError, Button, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, NETWORK_CONFIG, NetworkError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, ValidationError, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clearHostedAuthPendingTransaction, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createPkceChallenge, createPkceVerifier, getAccountingContract, getApiUrl, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useDepositVerification, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useSiweAuth } from './chunk-54FC6TO3.js';
+import { usePrivanaContext, createHostedAuthPendingStorageKey, clearHostedAuthPendingTransaction, HostedAuthRequiredError, HostedAuthError, createPkceVerifier, createPkceChallenge, createHostedAuthState, persistHostedAuthPendingTransaction, parseHostedAuthCallback, readHostedAuthPendingTransaction, HostedAuthStateMismatchError, buildHostedAuthSession, useSafePrivanaContext, usePrivateReadRequest, formatTokenAmount, submitPendingLock, PostDepositLockError, useDepositVerification, useEnsureCorrectChain, getTransactionReceipt, 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-SAJ7K5WT.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-SAJ7K5WT.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, useChainId, useSwitchChain, useBalance as useBalance$1, useReadContract } from 'wagmi';
+import { useAccount, useWalletClient, useConfig, useWriteContract, useSendTransaction, useBalance as useBalance$1, useReadContract } from 'wagmi';
 import { zeroAddress, erc20Abi } from 'viem';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { XIcon } from 'lucide-react';
@@ -12,202 +12,6 @@ import { toast } from 'sonner';
 import { QRCodeSVG } from 'qrcode.react';
 import { MoonPayProvider, MoonPayContext } from '@moonpay/moonpay-react';
 
-// src/sdk/signatures/eip712-types.ts
-function createDomain(chainId, verifyingContract) {
-  return {
-    name: "AccountingModule",
-    version: "1",
-    chainId,
-    verifyingContract
-  };
-}
-var LOCK_TYPES = {
-  Lock: [
-    { name: "serviceAddress", type: "address" },
-    { name: "tokenId", type: "bytes32" },
-    { name: "amount", type: "uint256" },
-    { name: "expiry", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
-var TRANSFER_TYPES = {
-  Transfer: [
-    { name: "toAddress", type: "address" },
-    { name: "tokenId", type: "bytes32" },
-    { name: "amount", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
-var TRANSFER_LOCKED_TYPES = {
-  TransferLocked: [
-    { name: "userAddress", type: "address" },
-    { name: "toAddress", type: "address" },
-    { name: "lockId", type: "uint256" },
-    { name: "amount", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "serviceAddress", type: "address" }
-  ]
-};
-var WITHDRAW_TYPES = {
-  Withdraw: [
-    { name: "tokenId", type: "bytes32" },
-    { name: "amount", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
-var MODIFY_LOCK_TYPES = {
-  ModifyLock: [
-    { name: "lockId", type: "uint256" },
-    { name: "amount", type: "uint256" },
-    { name: "newExpiry", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
-var WITHDRAW_FROM_LOCK_TYPES = {
-  WithdrawFromLock: [
-    { name: "userAddress", type: "address" },
-    { name: "toAddress", type: "address" },
-    { name: "lockId", type: "uint256" },
-    { name: "amount", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
-
-// src/sdk/signatures/sign-lock.ts
-async function signLockMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: LOCK_TYPES,
-    primaryType: "Lock",
-    message
-  });
-  return signature;
-}
-function createLockExpiry(minutesFromNow = 60) {
-  return BigInt(Math.floor(Date.now() / 1e3) + minutesFromNow * 60);
-}
-
-// src/sdk/signatures/sign-modify-lock.ts
-async function signModifyLockMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: MODIFY_LOCK_TYPES,
-    primaryType: "ModifyLock",
-    message
-  });
-  return signature;
-}
-
-// src/sdk/signatures/sign-transfer.ts
-async function signTransferMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: TRANSFER_TYPES,
-    primaryType: "Transfer",
-    message
-  });
-  return signature;
-}
-
-// src/sdk/signatures/sign-transfer-locked.ts
-async function signTransferLockedMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: TRANSFER_LOCKED_TYPES,
-    primaryType: "TransferLocked",
-    message
-  });
-  return signature;
-}
-
-// src/sdk/signatures/sign-withdraw.ts
-async function signWithdrawMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: WITHDRAW_TYPES,
-    primaryType: "Withdraw",
-    message
-  });
-  return signature;
-}
-
-// src/sdk/signatures/sign-withdraw-from-lock.ts
-async function signWithdrawFromLockMessage({
-  walletClient,
-  chainId,
-  verifyingContract,
-  message
-}) {
-  const account = walletClient.account;
-  if (!account) {
-    throw new Error("No account connected to wallet client");
-  }
-  const domain = createDomain(chainId, verifyingContract);
-  const signature = await walletClient.signTypedData({
-    account,
-    domain,
-    types: WITHDRAW_FROM_LOCK_TYPES,
-    primaryType: "WithdrawFromLock",
-    message
-  });
-  return signature;
-}
-
 // src/sdk/hooks/use-privana-client.ts
 function usePrivanaClient() {
   const { client } = usePrivanaContext();
@@ -468,75 +272,22 @@ function useBatchBalances(options) {
     refetch: query.refetch
   };
 }
-function useEnsureCorrectChain() {
-  const config = useConfig();
-  const chainId = useChainId();
-  const { switchChainAsync } = useSwitchChain();
-  const waitUntilOnChain = useCallback(
-    async (expectedChainId, timeoutMs, pollIntervalMs = 250) => {
-      const startedAt = Date.now();
-      while (Date.now() - startedAt < timeoutMs) {
-        const currentChainId = getChainId2(config);
-        if (currentChainId === expectedChainId) return true;
-        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      }
-      return false;
-    },
-    [config]
-  );
-  const ensureCorrectChain = useCallback(
-    async (targetChainId) => {
-      const currentChainId = getChainId2(config);
-      if (currentChainId === targetChainId) return false;
-      let switchErrorMessage;
-      try {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("Chain switch timeout")), 3e3);
-        });
-        await Promise.race([switchChainAsync({ chainId: targetChainId }), timeoutPromise]);
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Unsupported Chain")) {
-          console.warn("Got 'Unsupported Chain' error, chain may have switched anyway.");
-        } else {
-          switchErrorMessage = error instanceof Error ? error.message : "Unknown chain switch error";
-        }
-      }
-      const settled = await waitUntilOnChain(targetChainId, 2e4);
-      if (settled) return true;
-      if (switchErrorMessage) {
-        throw new Error(
-          `Failed to switch to chain (Chain ID: ${targetChainId}): ${switchErrorMessage}`
-        );
-      }
-      throw new Error(`Chain switch did not settle in time (expected ${targetChainId}).`);
-    },
-    [config, switchChainAsync, waitUntilOnChain]
-  );
-  const isOnChain = useCallback((targetChainId) => chainId === targetChainId, [chainId]);
-  return {
-    chainId,
-    ensureCorrectChain,
-    isOnChain
-  };
-}
-
-// src/sdk/hooks/use-deposit.ts
 var STALE_MS = 30 * 60 * 1e3;
 function storageKey(address) {
   return `privana:pending-deposit:${address.toLowerCase()}`;
 }
 function savePendingDeposit(address, data) {
-  try {
-    sessionStorage.setItem(storageKey(address), JSON.stringify(data));
-  } catch {
+  const stored = setBrowserStorageItem(storageKey(address), JSON.stringify(data));
+  if (!stored && data.signedLock) {
+    throw new Error("Unable to persist pending locked deposit for recovery");
   }
 }
 function loadPendingDeposit(address) {
   try {
-    const raw = sessionStorage.getItem(storageKey(address));
+    const raw = getBrowserStorageItem(storageKey(address));
     if (!raw) return null;
     const data = JSON.parse(raw);
-    if (Date.now() - data.savedAt > STALE_MS) {
+    if (Date.now() - data.savedAt > STALE_MS && !(data.signedLock && isSignedLockUsable(data.signedLock))) {
       clearPendingDeposit(address);
       return null;
     }
@@ -545,15 +296,20 @@ function loadPendingDeposit(address) {
     return null;
   }
 }
-function clearPendingDeposit(address) {
-  try {
-    sessionStorage.removeItem(storageKey(address));
-  } catch {
+function clearPendingDeposit(address, onlyForTxHash) {
+  if (onlyForTxHash) {
+    try {
+      const raw = getBrowserStorageItem(storageKey(address));
+      const recordTxHash = raw ? JSON.parse(raw).txHash : void 0;
+      if (recordTxHash && recordTxHash !== onlyForTxHash) return;
+    } catch {
+    }
   }
+  removeBrowserStorageItem(storageKey(address));
 }
 function useDeposit(options = {}) {
   const { address } = useAccount();
-  const { client, enabledTokens, getChainById: getChainById2 } = usePrivanaContext();
+  const { client, enabledTokens, getChainById: getChainById2, networkConfig, serviceAddress } = usePrivanaContext();
   const { data: walletClient } = useWalletClient();
   const queryClient = useQueryClient();
   const config = useConfig();
@@ -570,21 +326,54 @@ function useDeposit(options = {}) {
   const onDepositAddressReceivedRef = useRef(options.onDepositAddressReceived);
   const onDepositSuccessRef = useRef(options.onDepositSuccess);
   const onCreditedRef = useRef(options.onCredited);
+  const onLockSubmittedRef = useRef(options.onLockSubmitted);
+  const onLockFailedRef = useRef(options.onLockFailed);
   const onCheckTimeoutRef = useRef(options.onCheckTimeout);
   const onErrorRef = useRef(options.onError);
   useEffect(() => {
     onDepositAddressReceivedRef.current = options.onDepositAddressReceived;
     onDepositSuccessRef.current = options.onDepositSuccess;
     onCreditedRef.current = options.onCredited;
+    onLockSubmittedRef.current = options.onLockSubmitted;
+    onLockFailedRef.current = options.onLockFailed;
     onCheckTimeoutRef.current = options.onCheckTimeout;
     onErrorRef.current = options.onError;
   }, [
     options.onDepositAddressReceived,
     options.onDepositSuccess,
     options.onCredited,
+    options.onLockSubmitted,
+    options.onLockFailed,
     options.onCheckTimeout,
     options.onError
   ]);
+  const pendingLockRef = useRef(null);
+  const submitPendingLockAfterCredit = useCallback(
+    async (signedLock, response) => {
+      try {
+        const result = await submitPendingLock({
+          client,
+          payload: signedLock,
+          creditedAmount: response.amount != null ? BigInt(response.amount) : void 0
+        });
+        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);
+      } catch (err) {
+        const error2 = err instanceof PostDepositLockError ? err : new PostDepositLockError(
+          err instanceof Error ? err.message : "Lock submission failed",
+          "submission-failed",
+          BigInt(signedLock.amount),
+          void 0,
+          { cause: err }
+        );
+        (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
+      }
+    },
+    [client, queryClient]
+  );
   const {
     isVerifying,
     didTimeout,
@@ -597,8 +386,16 @@ function useDeposit(options = {}) {
     pollTimeout: options.pollTimeout,
     onCredited: (hash, response) => {
       verificationContextRef.current = null;
-      if (address) clearPendingDeposit(address);
-      onCreditedRef.current?.(hash, response);
+      const signedLock = pendingLockRef.current;
+      pendingLockRef.current = null;
+      if (signedLock) {
+        void submitPendingLockAfterCredit(signedLock, response).finally(() => {
+          if (address) clearPendingDeposit(address, hash);
+        });
+      } else if (address) {
+        clearPendingDeposit(address);
+      }
+      onCreditedRef.current?.(hash, response, signedLock !== null);
     },
     onCheckTimeout: (hash) => {
       onCheckTimeoutRef.current?.(hash);
@@ -649,6 +446,7 @@ function useDeposit(options = {}) {
     resetVerification();
     if (address) clearPendingDeposit(address);
     verificationContextRef.current = null;
+    pendingLockRef.current = null;
     setDepositAddress(null);
     setTxHash(void 0);
     setIsSwitchingChain(false);
@@ -668,6 +466,7 @@ function useDeposit(options = {}) {
     setTxHash(hash);
     setDepositAddress(persisted.depositAddress);
     setIsWaitingForConfirmation(true);
+    pendingLockRef.current = persisted.signedLock ?? null;
     const ctx = {
       hash,
       chainId: persisted.chainId,
@@ -724,13 +523,6 @@ function useDeposit(options = {}) {
         if (!sourceChain) throw new Error(`Chain ${token.chainId} not configured`);
         const addrResponse = await addressMutation.mutateAsync();
         if (isStale()) return;
-        setIsSwitchingChain(true);
-        try {
-          await ensureCorrectChain(sourceChain.id);
-        } finally {
-          if (!isStale()) setIsSwitchingChain(false);
-        }
-        if (isStale()) return;
         const depositAddr = addrResponse.deposit_address;
         if (!depositAddr || depositAddr === zeroAddress) {
           throw new Error("Invalid deposit address received from API");
@@ -743,6 +535,43 @@ function useDeposit(options = {}) {
             `Amount is below the minimum deposit (${minAmountStr}) for ${isNative ? "native" : "ERC-20"} on chain ${sourceChain.id}`
           );
         }
+        if (params.postDepositLock && !canUseBrowserStorage()) {
+          throw new Error("Browser storage is required for locked deposit recovery");
+        }
+        const lockAmount = clampLockAmount(params.amount, params.postDepositLock?.maxAmount);
+        let signedLock;
+        if (params.postDepositLock) {
+          setIsSwitchingChain(true);
+          try {
+            await ensureCorrectChain(networkConfig.chainId);
+          } finally {
+            if (!isStale()) setIsSwitchingChain(false);
+          }
+          if (isStale()) return;
+          const signingWalletClient = await getWalletClient(config, {
+            chainId: networkConfig.chainId
+          });
+          signedLock = await createSignedLockRequest({
+            client,
+            walletClient: signingWalletClient,
+            userAddress: address,
+            networkConfig,
+            serviceAddress: requireServiceAddress(
+              params.postDepositLock.serviceAddress ?? serviceAddress
+            ),
+            tokenId: params.tokenId,
+            amount: lockAmount,
+            lockDuration: params.postDepositLock.lockDuration
+          });
+        }
+        if (isStale()) return;
+        setIsSwitchingChain(true);
+        try {
+          await ensureCorrectChain(sourceChain.id);
+        } finally {
+          if (!isStale()) setIsSwitchingChain(false);
+        }
+        if (isStale()) return;
         const hash = token.contract === zeroAddress ? await sendTransactionAsync({
           to: depositAddr,
           value: params.amount,
@@ -762,13 +591,19 @@ function useDeposit(options = {}) {
           amount: params.amount
         };
         verificationContextRef.current = ctx;
-        savePendingDeposit(address, {
-          txHash: hash,
-          chainId: sourceChain.id,
-          amount: params.amount.toString(),
-          depositAddress: addrResponse,
-          savedAt: Date.now()
-        });
+        pendingLockRef.current = signedLock ?? null;
+        try {
+          savePendingDeposit(address, {
+            txHash: hash,
+            chainId: sourceChain.id,
+            amount: params.amount.toString(),
+            depositAddress: addrResponse,
+            signedLock,
+            savedAt: Date.now()
+          });
+        } catch (err) {
+          console.warn("Failed to persist pending deposit after transfer broadcast:", err);
+        }
         try {
           setIsWaitingForConfirmation(true);
           try {
@@ -803,12 +638,15 @@ function useDeposit(options = {}) {
       address,
       walletClient,
       addressMutation,
+      client,
       getChainById2,
       config,
       confirmations,
       enabledTokens,
       ensureCorrectChain,
+      networkConfig,
       queryClient,
+      serviceAddress,
       writeContractAsync,
       sendTransactionAsync,
       reset,
@@ -843,6 +681,12 @@ 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();
@@ -1370,6 +1214,59 @@ function useExpiredLocks(options = {}) {
     refetch: query.refetch
   };
 }
+function statusCodeOf(error) {
+  return error instanceof AccountingApiError ? error.statusCode : void 0;
+}
+function usePendingDeposits(options = {}) {
+  const queryClient = useContext(QueryClientContext);
+  const accountingContext = useSafePrivanaContext();
+  const hasProviders = !!queryClient && !!accountingContext;
+  const client = accountingContext?.client;
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { chainId, tokenAddress, lookbackBlocks } = options;
+  const query = useQuery({
+    queryKey: ["accounting-pending-deposits", ...privateReadQueryScope, chainId, tokenAddress],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      if (!chainId) throw new Error("No chain ID provided");
+      if (!client) throw new Error("No accounting client");
+      try {
+        return await executePrivateRead(
+          () => client.getPendingDeposits({
+            chain_id: chainId,
+            token_address: tokenAddress,
+            lookback_blocks: lookbackBlocks
+          })
+        );
+      } catch (error) {
+        if (statusCodeOf(error) === 404) {
+          return { pending: [], scanned_from_block: 0, scanned_to_block: 0 };
+        }
+        throw error;
+      }
+    },
+    enabled: hasProviders && (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!chainId && !!client,
+    // A 503 means discovery is not configured for this chain server-side —
+    // polling can't fix that, so stop until a manual refetch succeeds.
+    refetchInterval: (query2) => statusCodeOf(query2.state.error) === 503 ? false : options.refetchInterval ?? 3e4,
+    staleTime: 25e3,
+    retry: (failureCount, error) => {
+      const status = statusCodeOf(error);
+      if (status === 429 || status === 404 || status === 503) return false;
+      return failureCount < 2;
+    }
+  });
+  return {
+    pending: query.data?.pending ?? [],
+    scannedToBlock: query.data?.scanned_to_block,
+    isFetching: query.isFetching,
+    isError: query.isError,
+    error: query.error,
+    isRateLimited: statusCodeOf(query.error) === 429,
+    isUnavailable: statusCodeOf(query.error) === 503,
+    refetch: async () => (await query.refetch()).data
+  };
+}
 function usePendingWithdrawals(options = {}) {
   const { address, isConnected } = useAccount();
   const { client, pollingInterval } = usePrivanaContext();
@@ -3285,7 +3182,10 @@ function TokenSelectorView2({ selectedTokenId, onSelect }) {
 function CreditCardWidgetView({
   token,
   amount,
-  allowance
+  allowance,
+  onCredited,
+  onLockSubmitted,
+  onLockFailed
 }) {
   const moonpayCurrencyCode = token?.moonpayCurrencyCode;
   const containerRef = useRef(null);
@@ -3300,10 +3200,18 @@ function CreditCardWidgetView({
       {
         tokenId: token.id,
         currencyCode: moonpayCurrencyCode,
-        defaultBaseCurrencyAmount: amount || void 0,
+        quoteCurrencyAmount: amount || void 0,
+        lockAmount: true,
         variant: "embedded",
         autoStart: true,
-        theme: widgetTheme
+        theme: widgetTheme,
+        postDepositLock: allowance ? {
+          maxAmount: BigInt(allowance.value),
+          lockDuration: allowance.lockDuration
+        } : void 0,
+        onCredited,
+        onLockSubmitted,
+        onLockFailed
       }
     ) : /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm", children: [
       token?.symbol ?? "This token",
@@ -3605,7 +3513,7 @@ function DepositView({
                 className: "bg-secondary text-foreground hover:bg-secondary/80 cursor-pointer rounded px-3 py-2.5 text-xs font-semibold transition-colors",
                 children: "MAX"
               }
-            ) : isCreditCard ? /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: "USD" }) : selectedToken && /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: selectedToken.symbol })
+            ) : isCreditCard ? /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: selectedToken?.symbol ?? "USD" }) : selectedToken && /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: selectedToken.symbol })
           ]
         }
       ),
@@ -3659,14 +3567,105 @@ function SummaryRow({ value, label }) {
     /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: label })
   ] });
 }
+var LISTENING_WINDOW_MS = 36e5;
+function remainingSeconds(deadline) {
+  return Math.max(0, Math.round((deadline - Date.now()) / 1e3));
+}
+function useCountdown(deadline) {
+  const [secondsLeft, setSecondsLeft] = useState(() => remainingSeconds(deadline));
+  useEffect(() => {
+    if (remainingSeconds(deadline) <= 0) return;
+    const id = setInterval(() => {
+      const left = remainingSeconds(deadline);
+      setSecondsLeft(left);
+      if (left <= 0) clearInterval(id);
+    }, 1e3);
+    return () => clearInterval(id);
+  }, [deadline]);
+  return secondsLeft;
+}
+function AwaitingDepositStatus({
+  title,
+  subtitle,
+  remaining
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-3 text-center", children: [
+    /* @__PURE__ */ jsx("div", { className: "text-foreground", children: /* @__PURE__ */ jsx(Spinner, { size: 32 }) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-foreground text-xl leading-6 font-medium", children: title }),
+      /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm leading-[18px]", children: [
+        subtitle,
+        remaining && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("br", {}),
+          "Remaining time: ",
+          remaining
+        ] })
+      ] })
+    ] })
+  ] });
+}
 function ExternalDepositView({
   token,
-  amount
+  amount,
+  onCredited
 }) {
   const { getChainById: getChainById2 } = usePrivanaContext();
   const { depositAddress, isReady, isLoading } = useDepositAddress();
   const chain = token ? getChainById2(token.chainId) : void 0;
   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 verification = useDepositVerification({
+    onCredited: (txHash) => {
+      if (onCredited) {
+        onCredited();
+        return;
+      }
+      setCredited({ txHash });
+    }
+  });
+  const { isVerifying, verificationFailed, didTimeout, verify } = verification;
+  const scanPaused = isVerifying || verificationFailed || didTimeout || !!credited;
+  const {
+    pending,
+    isFetching: isScanning,
+    isError: isScanError,
+    isRateLimited,
+    isUnavailable,
+    refetch: refetchPendingDeposits
+  } = usePendingDeposits({
+    chainId: token?.chainId,
+    enabled: isReady && !!depositAddress && !!token,
+    refetchInterval: listening && !scanPaused ? 3e4 : false
+  });
+  const processedRef = useRef(/* @__PURE__ */ new Set());
+  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}`));
+    if (!next) return;
+    processedRef.current.add(`${next.tx_hash}:${next.log_index}`);
+    void verify({
+      hash: next.tx_hash,
+      chainId: next.chain_id,
+      amount: BigInt(next.amount),
+      logIndex: next.log_index
+    });
+  }, [pending, scanPaused, verify]);
+  const nothingFoundTimerRef = useRef(void 0);
+  useEffect(() => () => clearTimeout(nothingFoundTimerRef.current), []);
+  const handleRefresh = () => {
+    processedRef.current.clear();
+    void refetchPendingDeposits().then((result) => {
+      if (!result || result.pending.length === 0) {
+        setNothingFound(true);
+        clearTimeout(nothingFoundTimerRef.current);
+        nothingFoundTimerRef.current = setTimeout(() => setNothingFound(false), 4e3);
+      }
+    });
+  };
   const handleCopy = () => {
     if (!depositAddress) return;
     void navigator.clipboard.writeText(depositAddress);
@@ -3704,6 +3703,55 @@ function ExternalDepositView({
           }
         )
       ] })
+    ] }),
+    credited ? /* @__PURE__ */ jsx(
+      TransactionSuccessView,
+      {
+        title: "Deposit Credited",
+        message: `Transfer ${shortenAddress(credited.txHash)} has been credited to your Privana balance.`,
+        onDone: () => {
+          setCredited(null);
+          verification.reset();
+          void refetchPendingDeposits();
+        }
+      }
+    ) : verificationFailed || didTimeout ? /* @__PURE__ */ jsx(
+      TransactionErrorView,
+      {
+        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(),
+        isRetrying: isVerifying
+      }
+    ) : isVerifying ? /* @__PURE__ */ jsx(
+      AwaitingDepositStatus,
+      {
+        title: "Deposit detected",
+        subtitle: "Crediting the incoming transaction to your Privana balance..."
+      }
+    ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        AwaitingDepositStatus,
+        {
+          title: "Awaiting Deposit",
+          subtitle: listening ? "We are listening for your incoming transaction for the next hour." : "We've stopped listening automatically. Use the button below to check for your deposit.",
+          remaining: listening ? formatCountdown(secondsLeft) : void 0
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: handleRefresh,
+            disabled: !depositAddress || isScanning,
+            className: "bg-secondary text-foreground hover:bg-secondary/80 flex h-10 w-full 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: "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
+      ] })
     ] })
   ] });
 }
@@ -3716,6 +3764,7 @@ function DepositModalContent({
   onConnectWallet,
   onDeposit,
   onDepositSuccess,
+  onLockFailed,
   onClose,
   onCloseBlockedChange,
   onExit
@@ -3747,6 +3796,21 @@ function DepositModalContent({
   const [showSuccess, setShowSuccess] = useState(false);
   const [showTimeout, setShowTimeout] = useState(false);
   const [cancelled, setCancelled] = useState(false);
+  const [isSubmittingLock, setIsSubmittingLock] = useState(false);
+  const [lockFailedMessage, setLockFailedMessage] = useState(null);
+  const finishDeposit = () => {
+    setAmount("");
+    if (onDepositSuccess) {
+      resetDeposit();
+      onDepositSuccess();
+    } else {
+      setShowSuccess(true);
+    }
+  };
+  const finishCardPurchase = () => {
+    setAmount("");
+    onDepositSuccess?.();
+  };
   const {
     txHash,
     isGettingAddress,
@@ -3761,14 +3825,24 @@ function DepositModalContent({
     retryVerification,
     reset: resetDeposit
   } = useDeposit({
-    onCredited: () => {
-      setAmount("");
-      if (onDepositSuccess) {
-        resetDeposit();
-        onDepositSuccess();
-      } else {
-        setShowSuccess(true);
+    onCredited: (_txHash, _response, lockPending) => {
+      if (lockPending) {
+        setIsSubmittingLock(true);
+        return;
       }
+      finishDeposit();
+    },
+    onLockSubmitted: () => {
+      setIsSubmittingLock(false);
+      finishDeposit();
+    },
+    // The deposit credited; only the policy lock failed. Success must not
+    // fire (the host would act on unlocked funds) — show the dedicated
+    // error view and let the host re-prompt for a fresh lock.
+    onLockFailed: (err) => {
+      setIsSubmittingLock(false);
+      setLockFailedMessage(err.message);
+      onLockFailed?.(err);
     },
     onCheckTimeout: () => {
       setAmount("");
@@ -3801,7 +3875,11 @@ function DepositModalContent({
     setCancelled(false);
     deposit({
       tokenId: token.id,
-      amount: parseTokenAmount(args.amount, token.decimals)
+      amount: parseTokenAmount(args.amount, token.decimals),
+      postDepositLock: allowance ? {
+        maxAmount: BigInt(allowance.value),
+        lockDuration: allowance.lockDuration
+      } : void 0
     }).catch((err) => {
       toast.error(err instanceof Error ? err.message : "Deposit failed");
     });
@@ -3811,26 +3889,32 @@ function DepositModalContent({
   const depositSteps = [
     {
       label: "Getting deposit address",
-      status: isGettingAddress ? "active" : isSwitchingChain || isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+      status: isGettingAddress ? "active" : isSwitchingChain || isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing || isSubmittingLock ? "completed" : "pending"
     },
     {
       label: `Switching to ${targetChain?.name ?? "deposit chain"}`,
-      status: isSwitchingChain ? "active" : isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+      status: isSwitchingChain ? "active" : isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing || isSubmittingLock ? "completed" : "pending"
     },
     {
       label: "Confirm in wallet",
-      status: isSendingTransaction ? "active" : isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+      status: isSendingTransaction ? "active" : isWaitingForConfirmation || isWaitingForProcessing || isSubmittingLock ? "completed" : "pending"
     },
     {
       label: "Confirming transaction",
-      status: isWaitingForConfirmation ? "active" : isWaitingForProcessing ? "completed" : "pending"
+      status: isWaitingForConfirmation ? "active" : isWaitingForProcessing || isSubmittingLock ? "completed" : "pending"
     },
     {
       label: "Verifying deposit \u2014 may take up to a few minutes",
-      status: isWaitingForProcessing ? "active" : "pending"
-    }
+      status: isWaitingForProcessing ? "active" : isSubmittingLock ? "completed" : "pending"
+    },
+    ...allowance ? [
+      {
+        label: `Locking funds for ${appName}`,
+        status: isSubmittingLock ? "active" : "pending"
+      }
+    ] : []
   ];
-  const flowView = showSuccess ? "deposit-success" : showTimeout ? "deposit-timeout" : verificationFailed ? "deposit-error" : isPending && !cancelled ? "depositing" : null;
+  const flowView = showSuccess ? "deposit-success" : lockFailedMessage ? "lock-error" : showTimeout ? "deposit-timeout" : verificationFailed ? "deposit-error" : isPending && !cancelled || isSubmittingLock ? "depositing" : null;
   const activeView = flowView ?? view;
   const handleDepositDone = () => {
     setShowSuccess(false);
@@ -3842,6 +3926,12 @@ function DepositModalContent({
     setCancelled(true);
     resetDeposit();
   };
+  const handleLockFailedDone = () => {
+    setLockFailedMessage(null);
+    setAmount("");
+    setCancelled(false);
+    resetDeposit();
+  };
   const handleDismissVerificationError = () => {
     setAmount("");
     setCancelled(false);
@@ -3895,6 +3985,14 @@ function DepositModalContent({
           onDone: handleDepositDone
         }
       ),
+      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
+        }
+      ),
       activeView === "deposit-timeout" && /* @__PURE__ */ jsx(
         TransactionWarningView,
         {
@@ -3988,8 +4086,28 @@ function DepositModalContent({
         }
       }
     ),
-    activeView === "external-deposit" && /* @__PURE__ */ jsx(ExternalDepositView, { token: selectedToken, amount }),
-    activeView === "credit-card-widget" && /* @__PURE__ */ jsx(MoonPayGate, { enabled: true, children: /* @__PURE__ */ jsx(CreditCardWidgetView, { token: selectedToken, amount, allowance }) })
+    activeView === "external-deposit" && /* @__PURE__ */ jsx(
+      ExternalDepositView,
+      {
+        token: selectedToken,
+        amount,
+        onCredited: allowance ? void 0 : onDepositSuccess
+      }
+    ),
+    activeView === "credit-card-widget" && /* @__PURE__ */ jsx(MoonPayGate, { enabled: true, children: /* @__PURE__ */ jsx(
+      CreditCardWidgetView,
+      {
+        token: selectedToken,
+        amount,
+        allowance,
+        onCredited: allowance ? void 0 : finishCardPurchase,
+        onLockSubmitted: finishCardPurchase,
+        onLockFailed: (err) => {
+          setLockFailedMessage(err.message);
+          onLockFailed?.(err);
+        }
+      }
+    ) })
   ] });
 }
 function DepositModal({ open, onClose, ...handlers }) {
@@ -4780,6 +4898,6 @@ function WalletInlineModal({ className, ...handlers }) {
   );
 }
 
-export { DepositInlineModal, DepositModal, LOCK_TYPES, MODIFY_LOCK_TYPES, PrivanaButton, PrivanaIcon, PrivanaInlineModal, PrivanaModal, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, WalletInlineModal, WalletModal, WithdrawInlineModal, WithdrawModal, createDomain, createLockExpiry, getChainIcon, getTokenIcon, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, useBalance, useBatchBalances, useDeposit, useDepositAddress, useExpiredLocks, useHistory, useHostedRedirectAuth, useLockFunds, useLockedFunds, useModifyLock, usePendingWithdrawals, usePrivanaClient, useTokenInfo, useTokenList, useTotalLockedBalance, useTransfer, useUnlockFunds, useWithdraw };
+export { DepositInlineModal, DepositModal, PrivanaButton, PrivanaIcon, PrivanaInlineModal, PrivanaModal, WalletInlineModal, WalletModal, WithdrawInlineModal, WithdrawModal, getChainIcon, getTokenIcon, useBalance, useBatchBalances, useDeposit, useDepositAddress, useExpiredLocks, useHistory, useHostedRedirectAuth, useLockFunds, useLockedFunds, useModifyLock, usePendingDeposits, usePendingWithdrawals, usePrivanaClient, useTokenInfo, useTokenList, useTotalLockedBalance, useTransfer, useUnlockFunds, useWithdraw };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map