@oasisprotocol/privana-sdk 0.5.4 → 0.5.6

package/dist/{chunk-FGWMLLEC.cjs → chunk-TNR7AA52.cjs}

@@ -43,8 +43,8 @@ var config_default = {
     mainnet: {
       chainId: 23294,
       name: "Sapphire Mainnet",
-      accountingContract: "0x0000000000000000000000000000000000000000",
-      apiUrl: ""
+      accountingContract: "0x5f16C90a0F410AE4Cdb76d9964f5FFDDeE305876",
+      apiUrl: "https://api.privana.finance"
     }
   }
 };
@@ -622,9 +622,7 @@ var PrivanaClient = class _PrivanaClient {
       wallet_address: request.wallet_address ? normalizeAddress(request.wallet_address) : void 0,
       token_id: normalizeHex(request.token_id),
       chain_id: request.chain_id,
-      moonpay_currency_code: request.moonpay_currency_code,
-      base_currency_code: request.base_currency_code,
-      base_currency_amount: request.base_currency_amount
+      moonpay_currency_code: request.moonpay_currency_code
     });
   }
   async updateOnRamp(transactionId, request) {
@@ -643,8 +641,15 @@ var PrivanaClient = class _PrivanaClient {
       }
     );
   }
-  async getPendingOnRamps() {
-    return this.http.get("/v1/accounting/onramp/pending");
+  async getPendingOnRamps(externalTransactionIds = []) {
+    const params = new URLSearchParams();
+    for (const transactionId of externalTransactionIds.slice(0, 10)) {
+      params.append("externalTransactionId", transactionId);
+    }
+    const query = params.toString();
+    return this.http.get(
+      `/v1/accounting/onramp/pending${query ? `?${query}` : ""}`
+    );
   }
   /**
    * @deprecated This mutates the shared client's headers and displaces its Authorization
@@ -2224,6 +2229,49 @@ function loadPendingLock(userAddress, correlationId) {
 function clearPendingLock(userAddress, correlationId) {
   removeBrowserStorageItem(pendingLockKey(userAddress, correlationId));
 }
+
+// src/sdk/hooks/deposit-finality.ts
+async function checkDepositWithFinalityRetry({
+  checkDeposit,
+  isStale,
+  onRetry,
+  timeoutMs,
+  retryIntervalMs,
+  startedAt = Date.now(),
+  now = Date.now,
+  sleep = defaultSleep
+}) {
+  while (true) {
+    if (isStale()) return { kind: "stale" };
+    try {
+      const response = await checkDeposit();
+      if (!isInsufficientFinalityMessage(response.detail) || response.status !== "error") {
+        return { kind: "response", response };
+      }
+      if (response.detail) onRetry(response.detail);
+    } catch (error) {
+      if (isStale()) return { kind: "stale" };
+      if (!isInsufficientFinalityError(error)) throw error;
+      onRetry(
+        error instanceof AccountingApiError && error.detail ? error.detail : error instanceof Error ? error.message : String(error)
+      );
+    }
+    if (now() - startedAt > timeoutMs) return { kind: "timeout" };
+    await sleep(retryIntervalMs);
+  }
+}
+function isInsufficientFinalityError(error) {
+  if (error instanceof AccountingApiError) {
+    return isInsufficientFinalityMessage(error.detail) || isInsufficientFinalityMessage(error.message);
+  }
+  return error instanceof Error && isInsufficientFinalityMessage(error.message);
+}
+function isInsufficientFinalityMessage(message) {
+  return message?.includes("Insufficient finality") ?? false;
+}
+function defaultSleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
 var INITIAL_AUTH_BACKOFF_MS = 5e3;
 var MAX_AUTH_BACKOFF_MS = 6e4;
 var privateReadFailureCache = /* @__PURE__ */ new Map();
@@ -2463,44 +2511,27 @@ function useDepositVerification(options = {}) {
         queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
       };
       try {
-        let triggerResult;
-        while (!triggerResult) {
-          if (isStale()) return;
-          try {
-            const result = await executePrivateRead(
-              (readClient) => readClient.checkDeposit({
-                chain_id: chainId,
-                tx_hash: hash,
-                amount: amount.toString(),
-                log_index: logIndex
-              })
-            );
-            if (result.status === "error" && isInsufficientFinalityMessage(result.detail)) {
-              if (result.detail) onCheckRetryRef.current?.(result.detail);
-              if (Date.now() - pollStartTime > pollTimeout) {
-                markVerificationTimedOut();
-                return;
-              }
-              await sleep(finalityRetryInterval);
-              if (isStale()) return;
-              continue;
-            }
-            triggerResult = result;
-          } catch (err) {
-            if (isStale()) return;
-            if (!isInsufficientFinalityError(err)) {
-              throw err;
-            }
-            const message = err instanceof AccountingApiError && err.detail ? err.detail : err instanceof Error ? err.message : String(err);
-            onCheckRetryRef.current?.(message);
-            if (Date.now() - pollStartTime > pollTimeout) {
-              markVerificationTimedOut();
-              return;
-            }
-            await sleep(finalityRetryInterval);
-            if (isStale()) return;
-          }
+        const finality = await checkDepositWithFinalityRetry({
+          checkDeposit: () => executePrivateRead(
+            (readClient) => readClient.checkDeposit({
+              chain_id: chainId,
+              tx_hash: hash,
+              amount: amount.toString(),
+              log_index: logIndex
+            })
+          ),
+          isStale,
+          onRetry: (message) => onCheckRetryRef.current?.(message),
+          timeoutMs: pollTimeout,
+          retryIntervalMs: finalityRetryInterval,
+          startedAt: pollStartTime
+        });
+        if (finality.kind === "stale") return;
+        if (finality.kind === "timeout") {
+          markVerificationTimedOut();
+          return;
         }
+        const triggerResult = finality.response;
         if (isStale()) return;
         if (triggerResult.status === "credited") {
           const creditedAmount = creditedAmountFromResponse(triggerResult, amount);
@@ -2645,18 +2676,6 @@ function creditedAmountFromResponse(response, requestedAmount) {
 function isDefinitiveCandidateFailure(error) {
   return error instanceof AccountingApiError && error.statusCode === 400;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isInsufficientFinalityError(error) {
-  if (error instanceof AccountingApiError) {
-    return isInsufficientFinalityMessage(error.detail) || isInsufficientFinalityMessage(error.message);
-  }
-  return error instanceof Error && isInsufficientFinalityMessage(error.message);
-}
-function isInsufficientFinalityMessage(message) {
-  return message?.includes("Insufficient finality") ?? false;
-}
 function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
 }
@@ -2760,6 +2779,31 @@ function Skeleton({ className, ...props }) {
   );
 }
 
+// src/sdk/on-ramp/moonpay-adapter.ts
+var moonPayOnRampAdapter = {
+  provider: "moonpay",
+  pollPendingWhileOpen: true,
+  buildIntentRequest: ({ walletAddress, tokenId, chainId, providerAssetCode }) => ({
+    wallet_address: walletAddress,
+    token_id: tokenId,
+    chain_id: chainId,
+    moonpay_currency_code: providerAssetCode
+  }),
+  registerTransaction: async ({ client, intentId, providerTransactionId, tokenId, chainId }) => client.updateOnRamp(intentId, {
+    token_id: tokenId,
+    chain_id: chainId,
+    moonpay_transaction_id: intentId === providerTransactionId ? void 0 : providerTransactionId
+  })
+};
+function normalizeMoonPayProviderEvent(kind, event) {
+  return {
+    provider: "moonpay",
+    kind,
+    providerTransactionId: event.id,
+    intentId: event.externalTransactionId || void 0
+  };
+}
+
 // ../../node_modules/@wagmi/core/dist/esm/utils/getAction.js
 function getAction(client, actionFn, name) {
   const action_implicit = client[actionFn.name];
@@ -3010,6 +3054,239 @@ async function waitForTransactionReceipt(config, parameters) {
     chainId: client.chain.id
   };
 }
+
+// src/sdk/on-ramp/provider.ts
+function resolveOnRampProviderEventTarget(configuredProvider, activeIntentId, event) {
+  if (event.provider !== configuredProvider) {
+    throw new Error(
+      `On-ramp event provider ${event.provider} does not match configured adapter ${configuredProvider}`
+    );
+  }
+  if (!event.providerTransactionId) {
+    throw new Error("On-ramp provider event is missing a transaction id");
+  }
+  const intentId = event.intentId || activeIntentId || event.providerTransactionId;
+  const isActive = activeIntentId !== null && intentId === activeIntentId;
+  return {
+    intentId,
+    isActive,
+    isStale: activeIntentId !== null && event.intentId !== void 0 && !isActive
+  };
+}
+function assertOnRampRecordProvider(record, configuredProvider) {
+  if (record.provider !== configuredProvider) {
+    throw new Error(
+      `On-ramp record provider ${String(record.provider)} does not match configured adapter ${configuredProvider}`
+    );
+  }
+}
+function matchesOnRampTransaction(record, transactionId) {
+  return record.transaction_id === transactionId || record.external_transaction_id === transactionId || record.provider_transaction_id === transactionId || record.moonpay_transaction_id === transactionId;
+}
+function getOnRampVerificationKey(record) {
+  return record.on_chain_tx_hash ?? record.transaction_id;
+}
+function getOnRampIntentId(record) {
+  return record.external_transaction_id ?? record.transaction_id;
+}
+async function verifyPendingOnRampsSequentially({
+  records,
+  shouldStop,
+  wasTriggered,
+  trigger,
+  waitForTerminal
+}) {
+  for (const record of records) {
+    if (shouldStop()) return;
+    if (!record.on_chain_tx_hash) continue;
+    const key = getOnRampVerificationKey(record);
+    if (wasTriggered(key)) continue;
+    try {
+      await trigger(record);
+    } catch {
+      continue;
+    }
+    await waitForTerminal(key);
+  }
+}
+
+// src/sdk/on-ramp/recovery.ts
+var MAX_UNRESOLVED_ONRAMP_INTENTS = 10;
+var MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS = 1e4;
+var ONRAMP_INTENT_RETENTION_MS = 365 * 24 * 60 * 60 * 1e3;
+var ONRAMP_RECOVERY_VERSION = 1;
+function recoveryKey(scope) {
+  const api = encodeURIComponent(scope.apiUrl.replace(/\/$/, ""));
+  return `privana:onramp-intents:${api}:${scope.chainId}:${scope.userAddress.toLowerCase()}`;
+}
+function isIntent(value) {
+  if (!value || typeof value !== "object") return false;
+  const intent = value;
+  return typeof intent.transactionId === "string" && intent.transactionId.length > 0 && intent.transactionId.length <= 512 && Number.isFinite(intent.savedAt) && (intent.savedAt ?? 0) > 0;
+}
+function writeIntents(scope, intents) {
+  if (intents.length === 0) {
+    removeBrowserStorageItem(recoveryKey(scope));
+    return true;
+  }
+  return setBrowserStorageItem(
+    recoveryKey(scope),
+    JSON.stringify({
+      version: ONRAMP_RECOVERY_VERSION,
+      intents
+    })
+  );
+}
+function loadUnresolvedOnRampIntents(scope, now = Date.now()) {
+  const key = recoveryKey(scope);
+  try {
+    const raw = getBrowserStorageItem(key);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== ONRAMP_RECOVERY_VERSION || !Array.isArray(parsed.intents)) {
+      removeBrowserStorageItem(key);
+      return [];
+    }
+    const retained = parsed.intents.filter(isIntent).filter((intent) => now - intent.savedAt <= ONRAMP_INTENT_RETENTION_MS).sort((left, right) => left.savedAt - right.savedAt).slice(-MAX_UNRESOLVED_ONRAMP_INTENTS);
+    if (retained.length !== parsed.intents.length) writeIntents(scope, retained);
+    return retained;
+  } catch {
+    removeBrowserStorageItem(key);
+    return [];
+  }
+}
+function rememberUnresolvedOnRampIntent(scope, transactionId, now = Date.now()) {
+  const intents = loadUnresolvedOnRampIntents(scope, now).filter(
+    (intent) => intent.transactionId !== transactionId
+  );
+  intents.push({ transactionId, savedAt: now });
+  return writeIntents(scope, intents.slice(-MAX_UNRESOLVED_ONRAMP_INTENTS));
+}
+function forgetUnresolvedOnRampIntent(scope, transactionId, now = Date.now()) {
+  const intents = loadUnresolvedOnRampIntents(scope, now).filter(
+    (intent) => intent.transactionId !== transactionId
+  );
+  writeIntents(scope, intents);
+}
+function discardInvalidOnRampIntent(scope, invalidIntentId, activeIntentId) {
+  forgetUnresolvedOnRampIntent(scope, invalidIntentId);
+  const invalidatedActiveIntent = activeIntentId === invalidIntentId;
+  return {
+    activeIntentId: invalidatedActiveIntent ? null : activeIntentId,
+    invalidatedActiveIntent
+  };
+}
+function getOnRampCloseRecoveryAction(activeIntentId, purchaseEventObserved) {
+  if (!activeIntentId) return "refresh";
+  return purchaseEventObserved ? "poll-for-delivery" : "refresh-and-retain";
+}
+function createPendingOnRampReadCoordinator({
+  read,
+  intervalMs = MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS,
+  now = Date.now,
+  sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))
+}) {
+  const safeInterval = Math.max(
+    MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS,
+    Number.isFinite(intervalMs) ? intervalMs : MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS
+  );
+  let inFlight = null;
+  let nextReadAt = 0;
+  return () => {
+    if (inFlight) return inFlight;
+    const request = (async () => {
+      const delay = Math.max(0, nextReadAt - now());
+      if (delay > 0) await sleep(delay);
+      nextReadAt = now() + safeInterval;
+      return read();
+    })();
+    const tracked = request.finally(() => {
+      if (inFlight === tracked) inFlight = null;
+    });
+    inFlight = tracked;
+    return tracked;
+  };
+}
+async function getPendingOnRampsWithRecovery({
+  client,
+  intentIds,
+  onInvalidIntent
+}) {
+  const bounded = [...new Set(intentIds)].slice(-MAX_UNRESOLVED_ONRAMP_INTENTS);
+  try {
+    return await client.getPendingOnRamps(bounded);
+  } catch (error) {
+    if (!isBadRequest(error) || bounded.length === 0) throw error;
+  }
+  const valid = [];
+  for (const intentId of bounded) {
+    try {
+      await client.getPendingOnRamps([intentId]);
+      valid.push(intentId);
+    } catch (error) {
+      if (!isBadRequest(error)) throw error;
+      onInvalidIntent(intentId);
+    }
+  }
+  return client.getPendingOnRamps(valid);
+}
+function isBadRequest(error) {
+  return error instanceof AccountingApiError && error.statusCode === 400;
+}
+var ERC20_TRANSFER_EVENT = viem.parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+);
+function assertErc20OnRampToken(tokenAddress) {
+  if (tokenAddress.toLowerCase() === viem.zeroAddress) {
+    throw new Error("On-ramp verification supports ERC-20 tokens only");
+  }
+}
+function erc20MinDepositBaseUnits(minDepositByChain, chainId) {
+  const minimum = minDepositByChain?.[String(chainId)]?.erc20;
+  return minimum !== void 0 && /^\d+$/.test(minimum) ? BigInt(minimum) : void 0;
+}
+function deliveredErc20Amount(logs, tokenAddress, depositAddress) {
+  let delivered = 0n;
+  for (const log of logs) {
+    if (log.address.toLowerCase() !== tokenAddress.toLowerCase()) continue;
+    try {
+      const decoded = viem.decodeEventLog({
+        abi: [ERC20_TRANSFER_EVENT],
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "Transfer" && decoded.args.to.toLowerCase() === depositAddress.toLowerCase()) {
+        delivered += decoded.args.value;
+      }
+    } catch {
+    }
+  }
+  return delivered;
+}
+
+// src/sdk/on-ramp/settlement.ts
+async function settlePendingOnRampLock({
+  client,
+  userAddress,
+  transactionId,
+  creditedAmount
+}) {
+  const payload = loadPendingLock(userAddress, transactionId);
+  if (!payload) {
+    clearPendingLock(userAddress, transactionId);
+    return { kind: "not-found" };
+  }
+  try {
+    const response = await submitPendingLock({
+      client,
+      payload,
+      creditedAmount
+    });
+    return { kind: "submitted", payload, response };
+  } finally {
+    clearPendingLock(userAddress, transactionId);
+  }
+}
 function useEnsureCorrectChain() {
   const config = wagmi.useConfig();
   const chainId = wagmi.useChainId();
@@ -3062,15 +3339,13 @@ function useEnsureCorrectChain() {
   };
 }
 
-// src/sdk/hooks/use-fiat-on-ramp.ts
+// src/sdk/hooks/use-on-ramp.ts
 var DEFAULT_DELIVERY_TIMEOUT_MS = 12e4;
 var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_FINALITY_RETRY_INTERVAL_MS = 15e3;
-var ERC20_TRANSFER_EVENT = viem.parseAbiItem(
-  "event Transfer(address indexed from, address indexed to, uint256 value)"
-);
-function useFiatOnRamp(options) {
+function useOnRamp(options) {
   const {
+    adapter,
     tokenId,
     postDepositLock,
     onCredited,
@@ -3080,24 +3355,40 @@ function useFiatOnRamp(options) {
     onDebugEvent
   } = options;
   const deliveryTimeout = options.deliveryTimeout ?? DEFAULT_DELIVERY_TIMEOUT_MS;
-  const deliveryPollInterval = options.deliveryPollInterval ?? 3e3;
+  const requestedDeliveryPollInterval = options.deliveryPollInterval ?? MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS;
+  const deliveryPollInterval = Number.isFinite(requestedDeliveryPollInterval) ? Math.max(requestedDeliveryPollInterval, MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS) : MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS;
   const verificationTimeout = options.verificationTimeout ?? DEFAULT_VERIFICATION_TIMEOUT_MS;
   const finalityRetryInterval = options.finalityRetryInterval ?? DEFAULT_FINALITY_RETRY_INTERVAL_MS;
   const { address } = wagmi.useAccount();
   const { data: walletClient } = wagmi.useWalletClient();
   const { client, enabledTokens, networkConfig, serviceAddress } = usePrivanaContext();
   const { executePrivateRead, privateReadAddress, privateReadReady } = usePrivateReadRequest();
+  const executeOnRampPrivateRead = executePrivateRead;
   const privateReadAddressRef = react.useRef(privateReadAddress);
   privateReadAddressRef.current = privateReadAddress;
   const { ensureCorrectChain } = useEnsureCorrectChain();
   const wagmiConfig = wagmi.useConfig();
   const queryClient = reactQuery.useQueryClient();
   const selectedToken = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+  const recoveryScope = react.useMemo(
+    () => privateReadAddress ? {
+      apiUrl: networkConfig.apiUrl,
+      chainId: networkConfig.chainId,
+      userAddress: privateReadAddress
+    } : null,
+    [networkConfig.apiUrl, networkConfig.chainId, privateReadAddress]
+  );
+  const recoveryScopeRef = react.useRef(recoveryScope);
+  recoveryScopeRef.current = recoveryScope;
+  const flowIdentity = `${networkConfig.apiUrl}\0${networkConfig.chainId}\0${privateReadAddress ?? ""}\0${privateReadReady}\0${tokenId}\0${adapter.provider}`;
+  const flowSession = react.useMemo(() => Symbol(flowIdentity), [flowIdentity]);
+  const flowSessionRef = react.useRef(flowSession);
+  flowSessionRef.current = flowSession;
   const [status, setStatus] = react.useState("idle");
   const [pending, setPending] = react.useState([]);
   const [error, setError] = react.useState(null);
   const [depositAddress, setDepositAddress] = react.useState();
-  const [minDepositBaseUnits, setMinDepositBaseUnits] = react.useState();
+  const [minDepositByChain, setMinDepositByChain] = react.useState();
   const [activeIntentId, setActiveIntentId] = react.useState(null);
   const [activeVerificationId, setActiveVerificationId] = react.useState(null);
   const [finalityProgress, setFinalityProgress] = react.useState({});
@@ -3107,14 +3398,21 @@ function useFiatOnRamp(options) {
   const onErrorRef = react.useRef(onError);
   const onDebugEventRef = react.useRef(onDebugEvent);
   const statusRef = react.useRef(status);
+  const depositAddressSessionRef = react.useRef(null);
   const activeIntentIdRef = react.useRef(null);
+  const activeIntentSessionRef = react.useRef(null);
   const activeVerificationRecordRef = react.useRef(null);
   const activeVerificationKeyRef = react.useRef(null);
+  const activeVerificationSurfacesFailureRef = react.useRef(false);
   const lockOwnerRef = react.useRef(null);
   const triggeredVerificationKeysRef = react.useRef(/* @__PURE__ */ new Set());
   const activeVerificationDoneRef = react.useRef(null);
   const closeReconcilePromiseRef = react.useRef(null);
+  const deliveryWaitPromiseRef = react.useRef(null);
   const purchaseInitiatedRef = react.useRef(false);
+  const scopedDepositAddress = depositAddressSessionRef.current === flowSession ? depositAddress : void 0;
+  const scopedMinDepositByChain = depositAddressSessionRef.current === flowSession ? minDepositByChain : void 0;
+  const scopedMinDepositBaseUnits = selectedToken ? erc20MinDepositBaseUnits(scopedMinDepositByChain, selectedToken.chainId) : void 0;
   react.useEffect(() => {
     onCreditedRef.current = onCredited;
     onLockSubmittedRef.current = onLockSubmitted;
@@ -3128,10 +3426,6 @@ function useFiatOnRamp(options) {
   react.useEffect(() => {
     activeIntentIdRef.current = activeIntentId;
   }, [activeIntentId]);
-  react.useEffect(() => {
-    activeIntentIdRef.current = null;
-    setActiveIntentId(null);
-  }, [tokenId]);
   const emitDebug = react.useCallback(
     (event, payload) => {
       onDebugEventRef.current?.({
@@ -3148,24 +3442,28 @@ function useFiatOnRamp(options) {
     emitDebug("private-read-state", { privateReadReady });
   }, [emitDebug, privateReadReady]);
   react.useEffect(() => {
+    depositAddressSessionRef.current = null;
     if (!privateReadReady) {
       emitDebug("deposit-address:skip", { reason: "private-read-not-ready" });
       setDepositAddress(void 0);
-      setMinDepositBaseUnits(void 0);
+      setMinDepositByChain(void 0);
       return;
     }
+    setDepositAddress(void 0);
+    setMinDepositByChain(void 0);
     let cancelled = false;
     void (async () => {
       try {
         emitDebug("deposit-address:request");
-        const resp = await executePrivateRead((readClient) => readClient.getDepositAddress());
-        if (cancelled) return;
+        const resp = await executeOnRampPrivateRead((readClient) => readClient.getDepositAddress());
+        if (cancelled || flowSessionRef.current !== flowSession) return;
+        depositAddressSessionRef.current = flowSession;
         setDepositAddress(resp.deposit_address);
+        setMinDepositByChain(resp.min_deposit);
         const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
         const mins = token ? resp.min_deposit?.[String(token.chainId)] : void 0;
-        if (mins?.erc20) setMinDepositBaseUnits(BigInt(mins.erc20));
         emitDebug("deposit-address:success", {
-          depositAddress: resp.deposit_address,
+          depositAddressReady: true,
           selectedToken: token ? summariseToken(token) : null,
           minDepositBaseUnits: mins?.erc20 ?? null
         });
@@ -3179,8 +3477,53 @@ function useFiatOnRamp(options) {
     return () => {
       cancelled = true;
     };
-  }, [client, emitDebug, enabledTokens, executePrivateRead, privateReadReady, tokenId]);
+  }, [emitDebug, enabledTokens, executeOnRampPrivateRead, flowSession, privateReadReady, tokenId]);
+  const fetchPendingRows = react.useCallback(async () => {
+    const intents = recoveryScope ? loadUnresolvedOnRampIntents(recoveryScope) : [];
+    const intentIds = intents.map((intent) => intent.transactionId);
+    if (activeIntentIdRef.current && activeIntentSessionRef.current === flowSession) {
+      intentIds.push(activeIntentIdRef.current);
+    }
+    const { pending: rows } = await executeOnRampPrivateRead(
+      (readClient) => getPendingOnRampsWithRecovery({
+        client: readClient,
+        intentIds,
+        onInvalidIntent: (intentId) => {
+          if (!recoveryScope || flowSessionRef.current !== flowSession) return;
+          const disposition = discardInvalidOnRampIntent(
+            recoveryScope,
+            intentId,
+            activeIntentIdRef.current
+          );
+          if (disposition.invalidatedActiveIntent) {
+            activeIntentIdRef.current = null;
+            activeIntentSessionRef.current = null;
+            setActiveIntentId(null);
+            purchaseInitiatedRef.current = false;
+            lockOwnerRef.current = null;
+            if (statusRef.current !== "verifying" && statusRef.current !== "credited") {
+              statusRef.current = "idle";
+              setStatus("idle");
+              setError(null);
+            }
+          }
+          emitDebug("pending:discard-invalid-intent", {
+            invalidatedActiveIntent: disposition.invalidatedActiveIntent
+          });
+        }
+      })
+    );
+    return rows;
+  }, [emitDebug, executeOnRampPrivateRead, flowSession, recoveryScope]);
+  const readPendingRows = react.useMemo(
+    () => createPendingOnRampReadCoordinator({
+      read: fetchPendingRows,
+      intervalMs: deliveryPollInterval
+    }),
+    [deliveryPollInterval, fetchPendingRows]
+  );
   const refreshPending = react.useCallback(async () => {
+    if (flowSessionRef.current !== flowSession) return;
     if (!privateReadReady) {
       emitDebug("pending:skip", { reason: "private-read-not-ready" });
       setPending([]);
@@ -3188,79 +3531,75 @@ function useFiatOnRamp(options) {
     }
     try {
       emitDebug("pending:request");
-      const { pending: rows } = await executePrivateRead(
-        (readClient) => readClient.getPendingOnRamps()
-      );
+      const rows = await readPendingRows();
+      if (flowSessionRef.current !== flowSession) return;
       setPending(rows);
       emitDebug("pending:success", {
         count: rows.length,
         rows: rows.map(summariseOnRampRecord)
       });
     } catch (err) {
+      if (flowSessionRef.current !== flowSession) return;
       emitDebug("pending:error", errorPayload(err));
       console.warn("Failed to load pending on-ramps:", err);
     }
-  }, [emitDebug, executePrivateRead, privateReadReady]);
-  react.useEffect(() => {
-    refreshPending();
-  }, [refreshPending]);
+  }, [emitDebug, flowSession, privateReadReady, readPendingRows]);
   const clearActiveVerification = react.useCallback((expectedKey) => {
     const key = activeVerificationKeyRef.current;
     if (expectedKey != null && key !== null && key !== expectedKey) return;
     if (key) triggeredVerificationKeysRef.current.delete(key);
     activeVerificationKeyRef.current = null;
     activeVerificationRecordRef.current = null;
+    activeVerificationSurfacesFailureRef.current = false;
     setActiveVerificationId(null);
     activeVerificationDoneRef.current?.();
     activeVerificationDoneRef.current = null;
   }, []);
   const submitPendingLockAfterCredit = react.useCallback(
     async (transactionId, userAddress, creditedAmount) => {
-      const signedLock = loadPendingLock(userAddress, transactionId);
-      if (!signedLock) {
-        clearPendingLock(userAddress, transactionId);
-        if (!postDepositLock || transactionId !== activeIntentIdRef.current) return;
-        const error2 = new PostDepositLockError(
-          "No persisted signed lock found for this on-ramp",
-          "not-found"
-        );
-        emitDebug("lock:not-found", { transactionId });
-        (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
-        return;
-      }
       try {
-        const result = await submitPendingLock({ client, payload: signedLock, creditedAmount });
+        const settlement = await settlePendingOnRampLock({
+          client,
+          userAddress,
+          transactionId,
+          creditedAmount
+        });
+        if (settlement.kind === "not-found") {
+          if (!postDepositLock || transactionId !== activeIntentIdRef.current) return;
+          const lockError = new PostDepositLockError(
+            "No persisted signed lock found for this on-ramp",
+            "not-found"
+          );
+          emitDebug("lock:not-found");
+          (onLockFailedRef.current ?? onErrorRef.current)?.(lockError);
+          return;
+        }
         queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
         queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
         queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
         queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
         emitDebug("lock:submitted", {
-          transactionId,
-          amount: signedLock.amount,
-          submissionId: result.submission_id
+          submissionIdPresent: Boolean(settlement.response.submission_id)
         });
-        onLockSubmittedRef.current?.(result);
+        onLockSubmittedRef.current?.(settlement.response);
       } 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,
           creditedAmount,
           { cause: err }
         );
         emitDebug("lock:failed", {
-          transactionId,
           reason: error2.reason,
           message: error2.message
         });
         (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
-      } finally {
-        clearPendingLock(userAddress, transactionId);
       }
     },
     [client, emitDebug, postDepositLock, queryClient]
   );
-  const { verify } = useDepositVerification({
+  const { verify, reset: resetDepositVerification } = useDepositVerification({
     pollTimeout: verificationTimeout,
     pollInterval: options.verificationPollInterval,
     finalityRetryInterval,
@@ -3275,12 +3614,13 @@ function useFiatOnRamp(options) {
     },
     onCredited: (depositTxHash, _response, creditedAmount) => {
       const record = activeVerificationRecordRef.current;
+      const recoveryScopeAtCredit = recoveryScopeRef.current;
       const verificationKey = record ? getOnRampVerificationKey(record) : null;
       emitDebug("verification:credited", {
         depositTxHash,
         record: record ? summariseOnRampRecord(record) : null
       });
-      if (record && activeIntentIdRef.current === record.transaction_id) {
+      if (record && activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)) {
         setStatus("credited");
       }
       if (record) {
@@ -3294,7 +3634,7 @@ function useFiatOnRamp(options) {
         if (lockOwner) {
           void submitPendingLockAfterCredit(record.transaction_id, lockOwner, creditedAmount);
         } else if (postDepositLock) {
-          emitDebug("lock:owner-unavailable", { transactionId: record.transaction_id });
+          emitDebug("lock:owner-unavailable");
           (onLockFailedRef.current ?? onErrorRef.current)?.(
             new PostDepositLockError(
               "No wallet address available to look up the signed lock for this on-ramp",
@@ -3307,10 +3647,9 @@ function useFiatOnRamp(options) {
         try {
           if (record && depositTxHash.startsWith("0x")) {
             emitDebug("onramp:mark-deposit-triggered-request", {
-              transactionId: record.transaction_id,
               depositTxHash
             });
-            const updated = await executePrivateRead(
+            const updated = await executeOnRampPrivateRead(
               (readClient) => readClient.updateOnRamp(record.transaction_id, {
                 deposit_tx_hash: depositTxHash
               })
@@ -3323,11 +3662,17 @@ function useFiatOnRamp(options) {
           emitDebug("onramp:mark-deposit-triggered-error", errorPayload(err));
           console.warn("Failed to mark on-ramp row complete:", err);
         } finally {
+          if (record && recoveryScopeAtCredit) {
+            forgetUnresolvedOnRampIntent(recoveryScopeAtCredit, getOnRampIntentId(record));
+          }
           await refreshPending();
           clearActiveVerification(verificationKey);
-          if (record && activeIntentIdRef.current === record.transaction_id) {
+          if (record && activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)) {
             activeIntentIdRef.current = null;
+            activeIntentSessionRef.current = null;
             setActiveIntentId(null);
+            purchaseInitiatedRef.current = false;
+            lockOwnerRef.current = null;
           }
         }
       })();
@@ -3335,12 +3680,13 @@ function useFiatOnRamp(options) {
     },
     onCheckTimeout: (depositTxHash) => {
       const record = activeVerificationRecordRef.current;
+      const shouldSurfaceFailure = activeVerificationSurfacesFailureRef.current || !record;
       const err = new Error(
         "Privana verification is still pending. Retry from the pending on-ramp list if it does not complete."
       );
       emitDebug("verification:timeout", { depositTxHash, message: err.message });
       clearActiveVerification();
-      if (!record || activeIntentIdRef.current === record.transaction_id) {
+      if (shouldSurfaceFailure) {
         setStatus("failed");
         setError(err);
       }
@@ -3349,18 +3695,37 @@ function useFiatOnRamp(options) {
     },
     onError: (err) => {
       const record = activeVerificationRecordRef.current;
+      const shouldSurfaceFailure = activeVerificationSurfacesFailureRef.current || !record;
       emitDebug("verification:error", errorPayload(err));
       clearActiveVerification();
-      if (!record || activeIntentIdRef.current === record.transaction_id) {
+      if (shouldSurfaceFailure) {
         setStatus("failed");
         setError(err);
       }
       onErrorRef.current?.(err);
     }
   });
+  react.useEffect(() => {
+    activeIntentIdRef.current = null;
+    activeIntentSessionRef.current = null;
+    setActiveIntentId(null);
+    purchaseInitiatedRef.current = false;
+    lockOwnerRef.current = null;
+    resetDepositVerification();
+    clearActiveVerification();
+    triggeredVerificationKeysRef.current.clear();
+    setPending([]);
+    setFinalityProgress({});
+    statusRef.current = "idle";
+    setStatus("idle");
+    setError(null);
+  }, [clearActiveVerification, flowSession, resetDepositVerification]);
+  react.useEffect(() => {
+    void refreshPending();
+  }, [refreshPending]);
   const prepareOnRampIntent = react.useCallback(
     async ({
-      currencyCode,
+      providerAssetCode,
       baseCurrencyCode,
       baseCurrencyAmount,
       quoteCurrencyAmount
@@ -3370,7 +3735,7 @@ function useFiatOnRamp(options) {
         purchaseInitiatedRef.current = false;
         const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
         if (!token) throw new Error(`Unknown token: ${tokenId}`);
-        if (!depositAddress) throw new Error("Privana deposit address is not ready");
+        if (!scopedDepositAddress) throw new Error("Privana deposit address is not ready");
         let lockAmount;
         let lockOwner;
         if (postDepositLock) {
@@ -3397,22 +3762,35 @@ function useFiatOnRamp(options) {
         emitDebug("intent:create-request", {
           tokenId,
           chainId: token.chainId,
-          currencyCode,
+          provider: adapter.provider,
+          providerAssetCode,
           baseCurrencyCode: baseCurrencyCode ?? null,
-          baseCurrencyAmount: baseCurrencyAmount ?? null,
-          quoteCurrencyAmount: quoteCurrencyAmount ?? null,
-          depositAddress
+          baseCurrencyAmountPresent: baseCurrencyAmount !== void 0,
+          quoteCurrencyAmountPresent: quoteCurrencyAmount !== void 0,
+          depositAddressReady: true
         });
-        const record = await executePrivateRead(
-          (readClient) => readClient.createOnRampIntent({
-            wallet_address: depositAddress,
-            token_id: tokenId,
-            chain_id: token.chainId,
-            moonpay_currency_code: currencyCode,
-            base_currency_code: baseCurrencyCode,
-            base_currency_amount: baseCurrencyAmount
-          })
+        const record = await executeOnRampPrivateRead(
+          (readClient) => readClient.createOnRampIntent(
+            adapter.buildIntentRequest({
+              walletAddress: scopedDepositAddress,
+              tokenId,
+              chainId: token.chainId,
+              providerAssetCode
+            })
+          )
         );
+        if (flowSessionRef.current !== flowSession) {
+          throw new Error("On-ramp account or network changed while creating the intent");
+        }
+        assertOnRampRecordProvider(record, adapter.provider);
+        if (!record.provider_asset_code) {
+          throw new Error("On-ramp intent response is missing provider_asset_code");
+        }
+        if (record.provider_asset_code.toLowerCase() !== providerAssetCode.toLowerCase()) {
+          throw new Error(
+            `On-ramp intent asset ${record.provider_asset_code} does not match requested asset ${providerAssetCode}`
+          );
+        }
         if (postDepositLock && lockOwner && lockAmount !== void 0) {
           const signingWalletClient = await getWalletClient3(wagmiConfig, {
             chainId: networkConfig.chainId
@@ -3430,15 +3808,23 @@ function useFiatOnRamp(options) {
           if (privateReadAddressRef.current?.toLowerCase() !== lockOwner.toLowerCase()) {
             throw new Error("Authenticated deposit account changed while signing");
           }
+          if (flowSessionRef.current !== flowSession) {
+            throw new Error("On-ramp account or network changed while signing");
+          }
           savePendingLock(lockOwner, record.transaction_id, signedLock);
           lockOwnerRef.current = lockOwner;
           emitDebug("intent:lock-signed", {
-            transactionId: record.transaction_id,
-            amount: signedLock.amount,
-            expiry: signedLock.expiry
+            lockConfigured: true
           });
         }
+        if (recoveryScope && !rememberUnresolvedOnRampIntent(recoveryScope, record.transaction_id)) {
+          emitDebug("intent:recovery-storage-unavailable");
+        }
+        if (flowSessionRef.current !== flowSession) {
+          throw new Error("On-ramp account or network changed while preparing the purchase");
+        }
         activeIntentIdRef.current = record.transaction_id;
+        activeIntentSessionRef.current = flowSession;
         setActiveIntentId(record.transaction_id);
         emitDebug("intent:create-success", {
           record: summariseOnRampRecord(record)
@@ -3446,150 +3832,163 @@ function useFiatOnRamp(options) {
         return record;
       } catch (err) {
         const e = err instanceof Error ? err : new Error("Failed to create on-ramp intent");
-        setStatus("failed");
-        setError(e);
-        emitDebug("intent:create-error", errorPayload(e));
-        onErrorRef.current?.(e);
+        if (flowSessionRef.current === flowSession) {
+          setStatus("failed");
+          setError(e);
+          emitDebug("intent:create-error", errorPayload(e));
+          onErrorRef.current?.(e);
+        }
         throw e;
       }
     },
     [
+      adapter,
       address,
       client,
-      depositAddress,
       emitDebug,
       enabledTokens,
       ensureCorrectChain,
-      executePrivateRead,
+      executeOnRampPrivateRead,
+      flowSession,
       networkConfig,
       postDepositLock,
       privateReadAddress,
+      recoveryScope,
+      scopedDepositAddress,
       serviceAddress,
       tokenId,
       wagmiConfig,
       walletClient
     ]
   );
-  const registerOnRampTokenMapping = react.useCallback(
-    async (moonpayTransactionId) => {
+  const registerProviderTransaction = react.useCallback(
+    async (event, intentId) => {
+      if (flowSessionRef.current !== flowSession) return;
+      const register = adapter.registerTransaction;
+      if (!register) return;
       const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
       if (!token) {
-        emitDebug("register-token-mapping:skip", {
-          moonpayTransactionId,
+        emitDebug("provider-transaction:register-skip", {
+          provider: adapter.provider,
           reason: "selected-token-not-found"
         });
         return;
       }
-      const transactionId = activeIntentIdRef.current ?? moonpayTransactionId;
       try {
-        emitDebug("register-token-mapping:request", {
-          transactionId,
-          moonpayTransactionId,
+        emitDebug("provider-transaction:register-request", {
+          provider: adapter.provider,
+          intentIdPresent: Boolean(intentId),
+          providerTransactionIdPresent: Boolean(event.providerTransactionId),
           tokenId,
           chainId: token.chainId
         });
-        const record = await executePrivateRead(
-          (readClient) => readClient.updateOnRamp(transactionId, {
-            token_id: tokenId,
-            chain_id: token.chainId,
-            moonpay_transaction_id: transactionId === moonpayTransactionId ? void 0 : moonpayTransactionId
+        const record = await executeOnRampPrivateRead(
+          (readClient) => register({
+            client: readClient,
+            intentId,
+            providerTransactionId: event.providerTransactionId,
+            tokenId,
+            chainId: token.chainId
           })
         );
-        emitDebug("register-token-mapping:success", {
-          transactionId,
-          moonpayTransactionId,
-          record: summariseOnRampRecord(record)
+        if (flowSessionRef.current !== flowSession) return;
+        if (record) assertOnRampRecordProvider(record, adapter.provider);
+        emitDebug("provider-transaction:register-success", {
+          provider: adapter.provider,
+          record: record ? summariseOnRampRecord(record) : null
         });
       } catch (err) {
-        emitDebug("register-token-mapping:error", {
-          transactionId,
-          moonpayTransactionId,
+        if (flowSessionRef.current !== flowSession) return;
+        emitDebug("provider-transaction:register-error", {
+          provider: adapter.provider,
           ...errorPayload(err)
         });
         console.warn("Failed to register on-ramp token mapping:", err);
       }
     },
-    [emitDebug, enabledTokens, executePrivateRead, tokenId]
-  );
-  const handleTransactionCreated = react.useCallback(
-    async (props) => {
-      emitDebug("moonpay:onTransactionCreated", summariseMoonPayEventProps(props));
-      purchaseInitiatedRef.current = true;
-      await registerOnRampTokenMapping(props.id);
-    },
-    [emitDebug, registerOnRampTokenMapping]
+    [adapter, emitDebug, enabledTokens, executeOnRampPrivateRead, flowSession, tokenId]
   );
-  const signUrl = react.useCallback(
-    async (url) => {
-      setError(null);
-      try {
-        emitDebug("moonpay:onUrlSignatureRequested", summariseMoonPayUrl(url));
-        const { signature } = await executePrivateRead(
-          (readClient) => readClient.signOnRampUrl({ url })
-        );
-        setStatus("awaiting-purchase");
-        emitDebug("sign-url:success", {
-          signatureLength: signature.length
-        });
-        return signature;
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error("Failed to sign on-ramp URL");
-        setStatus("failed");
-        setError(e);
-        emitDebug("sign-url:error", errorPayload(e));
-        onErrorRef.current?.(e);
-        throw err;
-      }
+  const handleProviderLaunchReady = react.useCallback(() => {
+    if (flowSessionRef.current !== flowSession) return;
+    setError(null);
+    statusRef.current = "awaiting-purchase";
+    setStatus("awaiting-purchase");
+    emitDebug("provider:launch-ready", { provider: adapter.provider });
+  }, [adapter.provider, emitDebug, flowSession]);
+  const handleProviderLaunchFailed = react.useCallback(
+    (launchError) => {
+      if (flowSessionRef.current !== flowSession) return;
+      statusRef.current = "failed";
+      setStatus("failed");
+      setError(launchError);
+      emitDebug("provider:launch-error", {
+        provider: adapter.provider,
+        ...errorPayload(launchError)
+      });
+      onErrorRef.current?.(launchError);
     },
-    [emitDebug, executePrivateRead]
+    [adapter.provider, emitDebug, flowSession]
   );
   const waitForOnChainHash = react.useCallback(
     async (transactionId) => {
-      const startTime = Date.now();
-      emitDebug("delivery-poll:start", {
-        transactionId,
-        deliveryTimeout,
-        deliveryPollInterval
-      });
-      while (Date.now() - startTime < deliveryTimeout) {
-        try {
-          const { pending: rows } = await executePrivateRead(
-            (readClient) => readClient.getPendingOnRamps()
-          );
-          setPending(rows);
-          const record = rows.find((r) => matchesOnRampTransaction(r, transactionId));
-          emitDebug("delivery-poll:tick", {
-            transactionId,
-            count: rows.length,
-            matchingRecord: record ? summariseOnRampRecord(record) : null
-          });
-          if (record?.on_chain_tx_hash && record.quote_currency_amount) {
-            emitDebug("delivery-poll:success", {
-              transactionId,
-              record: summariseOnRampRecord(record)
+      if (flowSessionRef.current !== flowSession) return null;
+      const existing = deliveryWaitPromiseRef.current;
+      if (existing?.flowSession === flowSession && existing.transactionId === transactionId) {
+        return existing.promise;
+      }
+      const promise = (async () => {
+        const startTime = Date.now();
+        emitDebug("delivery-poll:start", {
+          deliveryTimeout,
+          deliveryPollInterval
+        });
+        while (Date.now() - startTime < deliveryTimeout) {
+          if (flowSessionRef.current !== flowSession) return null;
+          try {
+            const rows = await readPendingRows();
+            if (flowSessionRef.current !== flowSession) return null;
+            setPending(rows);
+            const record = rows.find((r) => matchesOnRampTransaction(r, transactionId));
+            emitDebug("delivery-poll:tick", {
+              count: rows.length,
+              matchingRecord: record ? summariseOnRampRecord(record) : null
+            });
+            if (record?.on_chain_tx_hash) {
+              emitDebug("delivery-poll:success", {
+                record: summariseOnRampRecord(record)
+              });
+              return record;
+            }
+          } catch (err) {
+            emitDebug("delivery-poll:error", {
+              ...errorPayload(err)
             });
-            return record;
+            console.warn("Polling pending on-ramps failed:", err);
           }
-        } catch (err) {
-          emitDebug("delivery-poll:error", {
-            transactionId,
-            ...errorPayload(err)
-          });
-          console.warn("Polling pending on-ramps failed:", err);
+          await new Promise((resolve) => setTimeout(resolve, deliveryPollInterval));
+        }
+        if (flowSessionRef.current !== flowSession) return null;
+        emitDebug("delivery-poll:timeout");
+        return null;
+      })();
+      const entry = { flowSession, transactionId, promise };
+      deliveryWaitPromiseRef.current = entry;
+      try {
+        return await promise;
+      } finally {
+        if (deliveryWaitPromiseRef.current === entry) {
+          deliveryWaitPromiseRef.current = null;
         }
-        await new Promise((r) => setTimeout(r, deliveryPollInterval));
       }
-      emitDebug("delivery-poll:timeout", { transactionId });
-      return null;
     },
-    [deliveryPollInterval, deliveryTimeout, emitDebug, executePrivateRead]
+    [deliveryPollInterval, deliveryTimeout, emitDebug, flowSession, readPendingRows]
   );
   const triggerVerification = react.useCallback(
-    async (record) => {
+    async (record, surfaceFailure = false) => {
+      if (flowSessionRef.current !== flowSession) return;
       const verificationKey = getOnRampVerificationKey(record);
       if (triggeredVerificationKeysRef.current.has(verificationKey)) {
         emitDebug("verification:skip-duplicate", {
-          verificationKey,
           record: summariseOnRampRecord(record)
         });
         return;
@@ -3603,6 +4002,9 @@ function useFiatOnRamp(options) {
       triggeredVerificationKeysRef.current.add(verificationKey);
       activeVerificationKeyRef.current = verificationKey;
       activeVerificationRecordRef.current = record;
+      activeVerificationSurfacesFailureRef.current = surfaceFailure || Boolean(
+        activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)
+      );
       setActiveVerificationId(record.transaction_id);
       setFinalityProgress((prev) => {
         if (!(record.transaction_id in prev)) return prev;
@@ -3611,14 +4013,11 @@ function useFiatOnRamp(options) {
         return next;
       });
       emitDebug("verification:start", {
-        verificationKey,
         record: summariseOnRampRecord(record)
       });
       try {
-        if (!record.on_chain_tx_hash || !record.quote_currency_amount) {
-          throw new Error("On-ramp record missing on-chain tx hash or delivered amount");
-        }
-        if (record.chain_id === void 0 || !record.wallet_address) {
+        if (!record.on_chain_tx_hash) throw new Error("On-ramp record missing on-chain tx hash");
+        if (record.chain_id == null || !record.wallet_address) {
           throw new Error("On-ramp record missing chain id or wallet address");
         }
         const recordTokenId = record.token_id;
@@ -3637,20 +4036,22 @@ function useFiatOnRamp(options) {
           chainId: record.chain_id,
           walletAddress: record.wallet_address,
           token,
-          fallbackAmount: record.quote_currency_amount,
           wagmiConfig,
           emitDebug
         });
-        if (minDepositBaseUnits !== void 0 && amount < minDepositBaseUnits) {
+        if (flowSessionRef.current !== flowSession) return;
+        const recordMinDepositBaseUnits = erc20MinDepositBaseUnits(
+          scopedMinDepositByChain,
+          record.chain_id
+        );
+        if (recordMinDepositBaseUnits !== void 0 && amount < recordMinDepositBaseUnits) {
           emitDebug("verification:below-minimum", {
-            quoteCurrencyAmount: record.quote_currency_amount,
-            minDepositBaseUnits: String(minDepositBaseUnits)
+            deliveredAmount: amount.toString(),
+            minDepositBaseUnits: String(recordMinDepositBaseUnits)
           });
-          throw new Error(
-            `Delivered amount (${record.quote_currency_amount}) is below the minimum deposit.`
-          );
+          throw new Error(`Delivered amount (${amount} base units) is below the minimum deposit.`);
         }
-        if (activeIntentIdRef.current === record.transaction_id) {
+        if (activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)) {
           setStatus("verifying");
         }
         emitDebug("verification:check-deposit-request", {
@@ -3664,107 +4065,180 @@ function useFiatOnRamp(options) {
           amount
         });
       } catch (err) {
+        if (flowSessionRef.current !== flowSession) return;
         triggeredVerificationKeysRef.current.delete(verificationKey);
         if (activeVerificationKeyRef.current === verificationKey) {
           activeVerificationKeyRef.current = null;
           activeVerificationRecordRef.current = null;
+          activeVerificationSurfacesFailureRef.current = false;
           setActiveVerificationId(null);
         }
         throw err;
       }
     },
-    [emitDebug, enabledTokens, minDepositBaseUnits, verify, wagmiConfig]
+    [emitDebug, enabledTokens, flowSession, scopedMinDepositByChain, verify, wagmiConfig]
   );
-  const handleTransactionCompleted = react.useCallback(
-    async (props) => {
-      emitDebug("moonpay:onTransactionCompleted", summariseMoonPayEventProps(props));
+  const handleProviderEvent = react.useCallback(
+    async (event) => {
+      if (flowSessionRef.current !== flowSession) return;
+      let target;
       try {
-        setStatus("awaiting-delivery");
-        await registerOnRampTokenMapping(props.id);
-        const transactionId = activeIntentIdRef.current ?? props.id;
-        const record = await waitForOnChainHash(transactionId);
+        target = resolveOnRampProviderEventTarget(
+          adapter.provider,
+          activeIntentIdRef.current,
+          event
+        );
+        emitDebug(`provider:${event.kind}`, {
+          provider: event.provider,
+          intentIdPresent: Boolean(target.intentId),
+          providerTransactionIdPresent: Boolean(event.providerTransactionId),
+          stale: target.isStale
+        });
+        if (target.isActive) purchaseInitiatedRef.current = true;
+        if (event.kind === "transaction-created") {
+          await registerProviderTransaction(event, target.intentId);
+          if (flowSessionRef.current !== flowSession) return;
+          if (target.isStale) await refreshPending();
+          return;
+        }
+        if (target.isActive || activeIntentIdRef.current === null) {
+          statusRef.current = "awaiting-delivery";
+          setStatus("awaiting-delivery");
+        }
+        await registerProviderTransaction(event, target.intentId);
+        if (flowSessionRef.current !== flowSession) return;
+        if (target.isStale) {
+          await refreshPending();
+          return;
+        }
+        const record = await waitForOnChainHash(target.intentId);
+        if (flowSessionRef.current !== flowSession) return;
         if (!record) {
-          const err = new Error(
+          const deliveryError = new Error(
             "Backend has not yet confirmed delivery. You can finish from the pending list."
           );
-          emitDebug("moonpay:completed-without-backend-row", {
-            transactionId,
-            moonpayTransactionId: props.id,
-            message: err.message
+          emitDebug("provider:completed-without-backend-row", {
+            provider: event.provider,
+            message: deliveryError.message
           });
-          setStatus("failed");
-          setError(err);
-          onErrorRef.current?.(err);
+          if (target.isActive || activeIntentIdRef.current === null) {
+            statusRef.current = "failed";
+            setStatus("failed");
+            setError(deliveryError);
+            onErrorRef.current?.(deliveryError);
+          }
           return;
         }
-        await triggerVerification(record);
+        await triggerVerification(record, true);
       } catch (err) {
-        const e = err instanceof Error ? err : new Error("Verification failed");
-        emitDebug("moonpay:onTransactionCompleted-error", errorPayload(e));
-        setStatus("failed");
-        setError(e);
-        onErrorRef.current?.(e);
+        if (flowSessionRef.current !== flowSession) return;
+        const providerError = err instanceof Error ? err : new Error("Verification failed");
+        emitDebug("provider:event-error", {
+          provider: event.provider,
+          kind: event.kind,
+          ...errorPayload(providerError)
+        });
+        if (!target?.isStale) {
+          statusRef.current = "failed";
+          setStatus("failed");
+          setError(providerError);
+          onErrorRef.current?.(providerError);
+        }
       }
     },
-    [emitDebug, registerOnRampTokenMapping, triggerVerification, waitForOnChainHash]
+    [
+      adapter.provider,
+      emitDebug,
+      flowSession,
+      refreshPending,
+      registerProviderTransaction,
+      triggerVerification,
+      waitForOnChainHash
+    ]
   );
-  const handleWidgetClosed = react.useCallback(async () => {
-    if (closeReconcilePromiseRef.current) return closeReconcilePromiseRef.current;
-    closeReconcilePromiseRef.current = (async () => {
+  const handleProviderClosed = react.useCallback(async () => {
+    if (flowSessionRef.current !== flowSession) return;
+    const existing = closeReconcilePromiseRef.current;
+    if (existing?.flowSession === flowSession) return existing.promise;
+    const promise = (async () => {
       const previousStatus = statusRef.current;
       const transactionId = activeIntentIdRef.current;
-      emitDebug("moonpay:widget-closed-reconcile", {
+      const action = getOnRampCloseRecoveryAction(transactionId, purchaseInitiatedRef.current);
+      emitDebug("provider:closed-reconcile", {
+        provider: adapter.provider,
         previousStatus,
-        transactionId
+        intentPresent: Boolean(transactionId),
+        action
       });
-      if (!transactionId) {
+      if (action === "refresh") {
         await refreshPending();
         return;
       }
-      if (!purchaseInitiatedRef.current) {
-        emitDebug("moonpay:widget-closed-without-purchase", {
+      if (action === "refresh-and-retain") {
+        emitDebug("provider:closed-without-event", {
+          provider: adapter.provider,
           previousStatus,
-          transactionId
+          recoveryRetained: true
         });
-        if (address) clearPendingLock(address, transactionId);
         await refreshPending();
+        if (flowSessionRef.current !== flowSession) return;
         if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          statusRef.current = "idle";
           setStatus("idle");
         }
         return;
       }
       try {
+        statusRef.current = "awaiting-delivery";
         setStatus("awaiting-delivery");
         const record = await waitForOnChainHash(transactionId);
+        if (flowSessionRef.current !== flowSession) return;
         if (record) {
-          await triggerVerification(record);
+          await triggerVerification(record, true);
           return;
         }
         await refreshPending();
+        if (flowSessionRef.current !== flowSession) return;
         if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          statusRef.current = "idle";
           setStatus("idle");
         }
       } catch (err) {
+        if (flowSessionRef.current !== flowSession) return;
         const e = err instanceof Error ? err : new Error("On-ramp reconciliation failed");
-        emitDebug("moonpay:widget-closed-reconcile-error", errorPayload(e));
+        emitDebug("provider:closed-reconcile-error", {
+          provider: adapter.provider,
+          ...errorPayload(e)
+        });
         setStatus("failed");
         setError(e);
         onErrorRef.current?.(e);
       }
     })();
+    const entry = { flowSession, promise };
+    closeReconcilePromiseRef.current = entry;
     try {
-      await closeReconcilePromiseRef.current;
+      await promise;
     } finally {
-      closeReconcilePromiseRef.current = null;
+      if (closeReconcilePromiseRef.current === entry) {
+        closeReconcilePromiseRef.current = null;
+      }
     }
-  }, [address, emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
+  }, [
+    adapter.provider,
+    emitDebug,
+    flowSession,
+    refreshPending,
+    triggerVerification,
+    waitForOnChainHash
+  ]);
   const finishPendingVerification = react.useCallback(
     async (record) => {
       try {
         emitDebug("pending:finish-verification", {
           record: summariseOnRampRecord(record)
         });
-        await triggerVerification(record);
+        await triggerVerification(record, true);
       } catch (err) {
         const e = err instanceof Error ? err : new Error("Verification failed");
         emitDebug("pending:finish-verification-error", errorPayload(e));
@@ -3783,22 +4257,17 @@ function useFiatOnRamp(options) {
   react.useEffect(() => {
     let cancelled = false;
     void (async () => {
-      for (const record of pending) {
-        if (cancelled) break;
-        if (!record.on_chain_tx_hash || !record.quote_currency_amount) continue;
-        const key = getOnRampVerificationKey(record);
-        if (triggeredVerificationKeysRef.current.has(key)) continue;
-        try {
-          await triggerVerificationRef.current(record);
-        } catch {
-          continue;
-        }
-        if (activeVerificationKeyRef.current === key) {
-          await new Promise((resolve) => {
-            activeVerificationDoneRef.current = resolve;
-          });
-        }
-      }
+      await verifyPendingOnRampsSequentially({
+        records: pending,
+        shouldStop: () => cancelled,
+        wasTriggered: (key) => triggeredVerificationKeysRef.current.has(key),
+        trigger: (record) => triggerVerificationRef.current(record),
+        // verify() resolves after scheduling status polling. Waiting for its
+        // terminal callback prevents the next record from cancelling it.
+        waitForTerminal: (key) => activeVerificationKeyRef.current === key ? new Promise((resolve) => {
+          activeVerificationDoneRef.current = resolve;
+        }) : Promise.resolve()
+      });
     })();
     return () => {
       cancelled = true;
@@ -3811,15 +4280,15 @@ function useFiatOnRamp(options) {
     activeVerificationId,
     error,
     finalityProgress,
-    depositAddress,
-    minDepositBaseUnits,
+    depositAddress: scopedDepositAddress,
+    minDepositBaseUnits: scopedMinDepositBaseUnits,
     selectedToken,
     prepareOnRampIntent,
-    signUrl,
-    handleTransactionCreated,
-    handleTransactionCompleted,
+    handleProviderLaunchReady,
+    handleProviderLaunchFailed,
+    handleProviderEvent,
     finishPendingVerification,
-    handleWidgetClosed,
+    handleProviderClosed,
     refreshPending
   };
 }
@@ -3833,17 +4302,20 @@ function summariseToken(token) {
 }
 function summariseOnRampRecord(record) {
   return {
-    transaction_id: record.transaction_id,
-    external_transaction_id: record.external_transaction_id ?? null,
-    moonpay_transaction_id: record.moonpay_transaction_id ?? null,
+    provider: record.provider,
+    provider_asset_code: record.provider_asset_code,
     status: record.status,
-    wallet_address: record.wallet_address,
     token_id: record.token_id,
     chain_id: record.chain_id,
     moonpay_currency_code: record.moonpay_currency_code ?? null,
-    quote_currency_amount: record.quote_currency_amount ?? null,
-    on_chain_tx_hash: record.on_chain_tx_hash ?? null,
-    deposit_tx_hash: record.deposit_tx_hash ?? null,
+    external_transaction_id_present: Boolean(record.external_transaction_id),
+    provider_transaction_id_present: Boolean(record.provider_transaction_id),
+    moonpay_transaction_id_present: Boolean(record.moonpay_transaction_id),
+    wallet_address_present: Boolean(record.wallet_address),
+    quote_currency_amount_present: record.quote_currency_amount != null,
+    on_chain_tx_hash_present: Boolean(record.on_chain_tx_hash),
+    deposit_id_present: Boolean(record.deposit_id),
+    deposit_tx_hash_present: Boolean(record.deposit_tx_hash),
     deposit_triggered_at: record.deposit_triggered_at ?? null,
     credited_at: record.credited_at ?? null
   };
@@ -3853,13 +4325,10 @@ async function resolveDeliveredAmount({
   chainId,
   walletAddress,
   token,
-  fallbackAmount,
   wagmiConfig,
   emitDebug
 }) {
-  if (token.contract === viem.zeroAddress) {
-    return viem.parseUnits(fallbackAmount, token.decimals);
-  }
+  assertErc20OnRampToken(token.contract);
   let receiptError;
   try {
     const receipt = await waitForTransactionReceipt(wagmiConfig, {
@@ -3868,63 +4337,142 @@ async function resolveDeliveredAmount({
       timeout: 6e4,
       pollingInterval: 4e3
     });
-    let delivered = 0n;
-    for (const log of receipt.logs) {
-      if (log.address.toLowerCase() !== token.contract.toLowerCase()) continue;
-      try {
-        const decoded = viem.decodeEventLog({
-          abi: [ERC20_TRANSFER_EVENT],
-          data: log.data,
-          topics: log.topics
-        });
-        if (decoded.eventName !== "Transfer") continue;
-        const to = decoded.args.to.toLowerCase();
-        if (to !== walletAddress.toLowerCase()) continue;
-        delivered += decoded.args.value;
-      } catch {
-      }
-    }
+    const delivered = deliveredErc20Amount(receipt.logs, token.contract, walletAddress);
     if (delivered > 0n) {
       emitDebug("verification:amount-from-receipt", {
         amount: delivered.toString(),
         tokenAddress: token.contract,
-        walletAddress,
-        moonpayQuoteCurrencyAmount: fallbackAmount
+        depositAddressMatched: true
       });
       return delivered;
     }
     emitDebug("verification:amount-from-receipt-missing", {
       tokenAddress: token.contract,
-      walletAddress,
-      moonpayQuoteCurrencyAmount: fallbackAmount
+      depositAddressMatched: false
     });
   } catch (err) {
     emitDebug("verification:amount-from-receipt-error", errorPayload(err));
     receiptError = err;
   }
-  const errorDetail = receiptError instanceof Error ? receiptError.message : receiptError === void 0 ? `no ${token.symbol} Transfer to ${walletAddress} found` : String(receiptError);
+  const errorDetail = receiptError instanceof Error ? receiptError.message : receiptError === void 0 ? `no ${token.symbol} Transfer to the derived deposit address found` : String(receiptError);
   throw new Error(
-    `Unable to derive delivered ${token.symbol} amount from ${onChainTxHash}: ${errorDetail}`
+    `Unable to derive delivered ${token.symbol} amount from its receipt: ${errorDetail}`
   );
 }
-function matchesOnRampTransaction(record, transactionId) {
-  return record.transaction_id === transactionId || record.external_transaction_id === transactionId || record.moonpay_transaction_id === transactionId;
+function errorPayload(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack?.split("\n").slice(0, 4).join("\n")
+    };
+  }
+  return { message: String(err) };
 }
-function getOnRampVerificationKey(record) {
-  return record.on_chain_tx_hash ?? record.transaction_id;
+
+// src/sdk/hooks/use-fiat-on-ramp.ts
+function useFiatOnRamp(options) {
+  const { executePrivateRead } = usePrivateReadRequest();
+  const core = useOnRamp({ ...options, adapter: moonPayOnRampAdapter });
+  const {
+    prepareOnRampIntent: prepareProviderIntent,
+    handleProviderLaunchReady,
+    handleProviderLaunchFailed,
+    handleProviderEvent,
+    handleProviderClosed
+  } = core;
+  const debugRef = react.useRef(options.onDebugEvent);
+  const statusRef = react.useRef(core.status);
+  react.useEffect(() => {
+    debugRef.current = options.onDebugEvent;
+    statusRef.current = core.status;
+  }, [core.status, options.onDebugEvent]);
+  const emitDebug = react.useCallback(
+    (event, payload) => {
+      debugRef.current?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status: statusRef.current,
+        tokenId: options.tokenId,
+        payload
+      });
+    },
+    [options.tokenId]
+  );
+  const prepareOnRampIntent = react.useCallback(
+    ({
+      currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount,
+      quoteCurrencyAmount
+    }) => prepareProviderIntent({
+      providerAssetCode: currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount,
+      quoteCurrencyAmount
+    }),
+    [prepareProviderIntent]
+  );
+  const signUrl = react.useCallback(
+    async (url) => {
+      emitDebug("moonpay:onUrlSignatureRequested", summariseMoonPayUrl(url));
+      try {
+        const { signature } = await executePrivateRead(
+          (readClient) => readClient.signOnRampUrl({ url })
+        );
+        handleProviderLaunchReady();
+        emitDebug("sign-url:success", { signatureLength: signature.length });
+        return signature;
+      } catch (error) {
+        const launchError = error instanceof Error ? error : new Error("Failed to sign on-ramp URL");
+        handleProviderLaunchFailed(launchError);
+        emitDebug("sign-url:error", errorPayload2(launchError));
+        throw launchError;
+      }
+    },
+    [emitDebug, executePrivateRead, handleProviderLaunchFailed, handleProviderLaunchReady]
+  );
+  const handleTransactionCreated = react.useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCreated", summariseMoonPayEventProps(props));
+      await handleProviderEvent(normalizeMoonPayProviderEvent("transaction-created", props));
+    },
+    [emitDebug, handleProviderEvent]
+  );
+  const handleTransactionCompleted = react.useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCompleted", summariseMoonPayEventProps(props));
+      await handleProviderEvent(normalizeMoonPayProviderEvent("transaction-completed", props));
+    },
+    [emitDebug, handleProviderEvent]
+  );
+  return {
+    status: core.status,
+    activeIntentId: core.activeIntentId,
+    pending: core.pending,
+    activeVerificationId: core.activeVerificationId,
+    error: core.error,
+    finalityProgress: core.finalityProgress,
+    depositAddress: core.depositAddress,
+    minDepositBaseUnits: core.minDepositBaseUnits,
+    selectedToken: core.selectedToken,
+    finishPendingVerification: core.finishPendingVerification,
+    refreshPending: core.refreshPending,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    handleWidgetClosed: handleProviderClosed
+  };
 }
 function summariseMoonPayEventProps(props) {
   return {
-    id: props.id,
-    externalTransactionId: props.externalTransactionId,
+    transactionIdPresent: Boolean(props.id),
+    externalTransactionIdPresent: Boolean(props.externalTransactionId),
     status: props.status,
-    walletAddress: props.walletAddress,
-    walletAddressTag: props.walletAddressTag,
-    baseCurrencyAmount: props.baseCurrencyAmount,
-    quoteCurrencyAmount: props.quoteCurrencyAmount,
     baseCurrency: props.baseCurrency,
     quoteCurrency: props.quoteCurrency,
-    createdAt: props.createdAt
+    walletAddressPresent: Boolean(props.walletAddress)
   };
 }
 function summariseMoonPayUrl(url) {
@@ -3934,36 +4482,34 @@ function summariseMoonPayUrl(url) {
     return {
       origin: parsed.origin,
       pathname: parsed.pathname,
-      apiKeyPrefix: params.get("apiKey")?.slice(0, 8) ?? null,
+      apiKeyPresent: params.has("apiKey"),
       currencyCode: params.get("currencyCode"),
       baseCurrencyCode: params.get("baseCurrencyCode"),
-      baseCurrencyAmount: params.get("baseCurrencyAmount"),
-      walletAddress: params.get("walletAddress"),
-      externalCustomerId: params.get("externalCustomerId"),
-      externalTransactionId: params.get("externalTransactionId"),
-      redirectURL: params.get("redirectURL"),
+      baseCurrencyAmountPresent: params.has("baseCurrencyAmount"),
+      walletAddressPresent: params.has("walletAddress"),
+      externalCustomerIdPresent: params.has("externalCustomerId"),
+      externalTransactionIdPresent: params.has("externalTransactionId"),
+      redirectURLPresent: params.has("redirectURL"),
       signaturePresent: params.has("signature")
     };
   } catch {
     return { parseError: true, length: url.length };
   }
 }
-function errorPayload(err) {
-  if (err instanceof Error) {
-    return {
-      name: err.name,
-      message: err.message,
-      stack: err.stack?.split("\n").slice(0, 4).join("\n")
-    };
-  }
-  return { message: String(err) };
+function errorPayload2(error) {
+  return {
+    name: error.name,
+    message: error.message,
+    stack: error.stack?.split("\n").slice(0, 4).join("\n")
+  };
 }
-function useMoonPayBuyWidget({
+function useMoonPayOnRampAdapter({
   variant,
   visible,
   autoStart,
   canBuy,
   openWidget,
+  shouldPollPending,
   refreshPending,
   theme,
   themeId,
@@ -3991,10 +4537,12 @@ function useMoonPayBuyWidget({
     void openWidget();
   }, [autoStart, canBuy, openWidget]);
   react.useEffect(() => {
-    if (variant !== "embedded" || !visible) return;
-    const id = setInterval(() => void refreshPending(), 5e3);
+    if (!moonPayOnRampAdapter.pollPendingWhileOpen || variant !== "embedded" || !visible || !shouldPollPending) {
+      return;
+    }
+    const id = setInterval(() => void refreshPending(), MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS);
     return () => clearInterval(id);
-  }, [variant, visible, refreshPending]);
+  }, [variant, visible, shouldPollPending, refreshPending]);
   const callbacksRef = react.useRef({
     onClose,
     onCloseOverlay,
@@ -4182,9 +4730,9 @@ function FiatOnRampForm({
         tokenSymbol: displaySymbol,
         tokenDecimals: decimals ?? null,
         baseCurrencyCode,
-        defaultBaseCurrencyAmount,
-        depositAddress: depositAddress ?? null,
-        walletAddress: address ?? null,
+        baseCurrencyAmountPresent: Boolean(defaultBaseCurrencyAmount),
+        depositAddressReady: Boolean(depositAddress),
+        walletConnected: Boolean(address),
         status
       });
       return;
@@ -4197,8 +4745,8 @@ function FiatOnRampForm({
       tokenSymbol: displaySymbol,
       tokenDecimals: decimals ?? null,
       baseCurrencyCode,
-      defaultBaseCurrencyAmount,
-      depositAddress: depositAddress ?? null,
+      baseCurrencyAmountPresent: Boolean(defaultBaseCurrencyAmount),
+      depositAddressReady: Boolean(depositAddress),
       walletConnected: Boolean(address)
     });
     try {
@@ -4209,8 +4757,8 @@ function FiatOnRampForm({
         quoteCurrencyAmount
       });
       emitFormDebug("form:intent-ready", {
-        transactionId: intent.transaction_id,
-        externalTransactionId: intent.external_transaction_id ?? null
+        transactionIdPresent: Boolean(intent.transaction_id),
+        externalTransactionIdPresent: Boolean(intent.external_transaction_id)
       });
       setVisible(true);
     } catch (err) {
@@ -4250,12 +4798,13 @@ function FiatOnRampForm({
   const handleReady = react.useCallback(async () => {
     emitFormDebug("moonpay:onReady");
   }, [emitFormDebug]);
-  const widgetElement = useMoonPayBuyWidget({
+  const widgetElement = useMoonPayOnRampAdapter({
     variant,
     visible,
     autoStart,
     canBuy,
     openWidget: handleOpen,
+    shouldPollPending: status === "awaiting-purchase",
     refreshPending,
     theme,
     themeId,
@@ -4276,6 +4825,9 @@ function FiatOnRampForm({
     onTransactionCreated: handleTransactionCreated,
     onTransactionCompleted: handleTransactionCompleted
   });
+  react.useEffect(() => {
+    if (visible && !activeIntentId && status === "idle") setVisible(false);
+  }, [activeIntentId, status, visible]);
   react.useEffect(() => {
     if (variant !== "embedded" || !visible) return;
     if (isVerifying || status === "credited") {
@@ -4470,5 +5022,5 @@ exports.useSafeAccount = useSafeAccount;
 exports.useSafePrivanaContext = useSafePrivanaContext;
 exports.useSiweAuth = useSiweAuth;
 exports.waitForTransactionReceipt = waitForTransactionReceipt;
-//# sourceMappingURL=chunk-FGWMLLEC.cjs.map
-//# sourceMappingURL=chunk-FGWMLLEC.cjs.map
+//# sourceMappingURL=chunk-TNR7AA52.cjs.map
+//# sourceMappingURL=chunk-TNR7AA52.cjs.map