@oasisprotocol/privana-sdk 0.5.3 → 0.5.5

package/dist/{chunk-DZURIIRE.js → chunk-PMBU2F2R.js}

@@ -4,7 +4,7 @@ import { createContext, useContext, useRef, useCallback, useSyncExternalStore, u
 import { WagmiContext, useConfig, useChainId, useSwitchChain, useAccount, useWalletClient } from 'wagmi';
 import { watchAccount, getAccount, getWalletClient } from 'wagmi/actions';
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { parseAbiItem, zeroAddress, walletActions, hexToString, parseUnits, decodeEventLog, formatUnits, createClient, custom } from 'viem';
+import { parseAbiItem, zeroAddress, walletActions, hexToString, formatUnits, parseUnits, createClient, custom, decodeEventLog } from 'viem';
 import { useQueryClient } from '@tanstack/react-query';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
@@ -35,7 +35,7 @@ var config_default = {
     testnet: {
       chainId: 23295,
       name: "Sapphire Testnet",
-      accountingContract: "0xad3C76e4E621C0cfF7540479Ee9B0A945723A642",
+      accountingContract: "0x910CFfe4e8B27bc367F6E34D6D8e3C31DED68B6f",
       apiUrl: "https://api.testnet.privana.finance"
     },
     mainnet: {
@@ -620,9 +620,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) {
@@ -641,8 +639,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
@@ -2222,6 +2227,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();
@@ -2461,44 +2509,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);
@@ -2643,18 +2674,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 twMerge(clsx(inputs));
 }
@@ -2758,6 +2777,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];
@@ -3008,6 +3052,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 = parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+);
+function assertErc20OnRampToken(tokenAddress) {
+  if (tokenAddress.toLowerCase() === 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 = 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 = useConfig();
   const chainId = useChainId();
@@ -3060,15 +3337,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 = parseAbiItem(
-  "event Transfer(address indexed from, address indexed to, uint256 value)"
-);
-function useFiatOnRamp(options) {
+function useOnRamp(options) {
   const {
+    adapter,
     tokenId,
     postDepositLock,
     onCredited,
@@ -3078,24 +3353,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 } = useAccount();
   const { data: walletClient } = useWalletClient();
   const { client, enabledTokens, networkConfig, serviceAddress } = usePrivanaContext();
   const { executePrivateRead, privateReadAddress, privateReadReady } = usePrivateReadRequest();
+  const executeOnRampPrivateRead = executePrivateRead;
   const privateReadAddressRef = useRef(privateReadAddress);
   privateReadAddressRef.current = privateReadAddress;
   const { ensureCorrectChain } = useEnsureCorrectChain();
   const wagmiConfig = useConfig();
   const queryClient = useQueryClient();
   const selectedToken = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+  const recoveryScope = useMemo(
+    () => privateReadAddress ? {
+      apiUrl: networkConfig.apiUrl,
+      chainId: networkConfig.chainId,
+      userAddress: privateReadAddress
+    } : null,
+    [networkConfig.apiUrl, networkConfig.chainId, privateReadAddress]
+  );
+  const recoveryScopeRef = useRef(recoveryScope);
+  recoveryScopeRef.current = recoveryScope;
+  const flowIdentity = `${networkConfig.apiUrl}\0${networkConfig.chainId}\0${privateReadAddress ?? ""}\0${privateReadReady}\0${tokenId}\0${adapter.provider}`;
+  const flowSession = useMemo(() => Symbol(flowIdentity), [flowIdentity]);
+  const flowSessionRef = useRef(flowSession);
+  flowSessionRef.current = flowSession;
   const [status, setStatus] = useState("idle");
   const [pending, setPending] = useState([]);
   const [error, setError] = useState(null);
   const [depositAddress, setDepositAddress] = useState();
-  const [minDepositBaseUnits, setMinDepositBaseUnits] = useState();
+  const [minDepositByChain, setMinDepositByChain] = useState();
   const [activeIntentId, setActiveIntentId] = useState(null);
   const [activeVerificationId, setActiveVerificationId] = useState(null);
   const [finalityProgress, setFinalityProgress] = useState({});
@@ -3105,14 +3396,21 @@ function useFiatOnRamp(options) {
   const onErrorRef = useRef(onError);
   const onDebugEventRef = useRef(onDebugEvent);
   const statusRef = useRef(status);
+  const depositAddressSessionRef = useRef(null);
   const activeIntentIdRef = useRef(null);
+  const activeIntentSessionRef = useRef(null);
   const activeVerificationRecordRef = useRef(null);
   const activeVerificationKeyRef = useRef(null);
+  const activeVerificationSurfacesFailureRef = useRef(false);
   const lockOwnerRef = useRef(null);
   const triggeredVerificationKeysRef = useRef(/* @__PURE__ */ new Set());
   const activeVerificationDoneRef = useRef(null);
   const closeReconcilePromiseRef = useRef(null);
+  const deliveryWaitPromiseRef = useRef(null);
   const purchaseInitiatedRef = 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;
   useEffect(() => {
     onCreditedRef.current = onCredited;
     onLockSubmittedRef.current = onLockSubmitted;
@@ -3126,10 +3424,6 @@ function useFiatOnRamp(options) {
   useEffect(() => {
     activeIntentIdRef.current = activeIntentId;
   }, [activeIntentId]);
-  useEffect(() => {
-    activeIntentIdRef.current = null;
-    setActiveIntentId(null);
-  }, [tokenId]);
   const emitDebug = useCallback(
     (event, payload) => {
       onDebugEventRef.current?.({
@@ -3146,24 +3440,28 @@ function useFiatOnRamp(options) {
     emitDebug("private-read-state", { privateReadReady });
   }, [emitDebug, privateReadReady]);
   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
         });
@@ -3177,8 +3475,53 @@ function useFiatOnRamp(options) {
     return () => {
       cancelled = true;
     };
-  }, [client, emitDebug, enabledTokens, executePrivateRead, privateReadReady, tokenId]);
+  }, [emitDebug, enabledTokens, executeOnRampPrivateRead, flowSession, privateReadReady, tokenId]);
+  const fetchPendingRows = 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 = useMemo(
+    () => createPendingOnRampReadCoordinator({
+      read: fetchPendingRows,
+      intervalMs: deliveryPollInterval
+    }),
+    [deliveryPollInterval, fetchPendingRows]
+  );
   const refreshPending = useCallback(async () => {
+    if (flowSessionRef.current !== flowSession) return;
     if (!privateReadReady) {
       emitDebug("pending:skip", { reason: "private-read-not-ready" });
       setPending([]);
@@ -3186,79 +3529,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]);
-  useEffect(() => {
-    refreshPending();
-  }, [refreshPending]);
+  }, [emitDebug, flowSession, privateReadReady, readPendingRows]);
   const clearActiveVerification = 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 = 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,
@@ -3273,12 +3612,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) {
@@ -3292,7 +3632,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",
@@ -3305,10 +3645,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
               })
@@ -3321,11 +3660,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;
           }
         }
       })();
@@ -3333,12 +3678,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);
       }
@@ -3347,18 +3693,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);
     }
   });
+  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]);
+  useEffect(() => {
+    void refreshPending();
+  }, [refreshPending]);
   const prepareOnRampIntent = useCallback(
     async ({
-      currencyCode,
+      providerAssetCode,
       baseCurrencyCode,
       baseCurrencyAmount,
       quoteCurrencyAmount
@@ -3368,7 +3733,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) {
@@ -3395,22 +3760,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
@@ -3428,15 +3806,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)
@@ -3444,150 +3830,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 = useCallback(
-    async (moonpayTransactionId) => {
+  const registerProviderTransaction = 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 = 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 = 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 = 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 = 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 = 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 = 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;
@@ -3601,6 +4000,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;
@@ -3609,14 +4011,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;
@@ -3635,20 +4034,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", {
@@ -3662,107 +4063,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 = useCallback(
-    async (props) => {
-      emitDebug("moonpay:onTransactionCompleted", summariseMoonPayEventProps(props));
+  const handleProviderEvent = 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 = useCallback(async () => {
-    if (closeReconcilePromiseRef.current) return closeReconcilePromiseRef.current;
-    closeReconcilePromiseRef.current = (async () => {
+  const handleProviderClosed = 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 = 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));
@@ -3781,22 +4255,17 @@ function useFiatOnRamp(options) {
   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;
@@ -3809,15 +4278,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
   };
 }
@@ -3831,17 +4300,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
   };
@@ -3851,13 +4323,10 @@ async function resolveDeliveredAmount({
   chainId,
   walletAddress,
   token,
-  fallbackAmount,
   wagmiConfig,
   emitDebug
 }) {
-  if (token.contract === zeroAddress) {
-    return parseUnits(fallbackAmount, token.decimals);
-  }
+  assertErc20OnRampToken(token.contract);
   let receiptError;
   try {
     const receipt = await waitForTransactionReceipt(wagmiConfig, {
@@ -3866,63 +4335,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 = 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 = useRef(options.onDebugEvent);
+  const statusRef = useRef(core.status);
+  useEffect(() => {
+    debugRef.current = options.onDebugEvent;
+    statusRef.current = core.status;
+  }, [core.status, options.onDebugEvent]);
+  const emitDebug = useCallback(
+    (event, payload) => {
+      debugRef.current?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status: statusRef.current,
+        tokenId: options.tokenId,
+        payload
+      });
+    },
+    [options.tokenId]
+  );
+  const prepareOnRampIntent = useCallback(
+    ({
+      currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount,
+      quoteCurrencyAmount
+    }) => prepareProviderIntent({
+      providerAssetCode: currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount,
+      quoteCurrencyAmount
+    }),
+    [prepareProviderIntent]
+  );
+  const signUrl = 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 = useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCreated", summariseMoonPayEventProps(props));
+      await handleProviderEvent(normalizeMoonPayProviderEvent("transaction-created", props));
+    },
+    [emitDebug, handleProviderEvent]
+  );
+  const handleTransactionCompleted = 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) {
@@ -3932,36 +4480,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,
@@ -3989,10 +4535,12 @@ function useMoonPayBuyWidget({
     void openWidget();
   }, [autoStart, canBuy, openWidget]);
   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 = useRef({
     onClose,
     onCloseOverlay,
@@ -4180,9 +4728,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;
@@ -4195,8 +4743,8 @@ function FiatOnRampForm({
       tokenSymbol: displaySymbol,
       tokenDecimals: decimals ?? null,
       baseCurrencyCode,
-      defaultBaseCurrencyAmount,
-      depositAddress: depositAddress ?? null,
+      baseCurrencyAmountPresent: Boolean(defaultBaseCurrencyAmount),
+      depositAddressReady: Boolean(depositAddress),
       walletConnected: Boolean(address)
     });
     try {
@@ -4207,8 +4755,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) {
@@ -4248,12 +4796,13 @@ function FiatOnRampForm({
   const handleReady = 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,
@@ -4274,6 +4823,9 @@ function FiatOnRampForm({
     onTransactionCreated: handleTransactionCreated,
     onTransactionCompleted: handleTransactionCompleted
   });
+  useEffect(() => {
+    if (visible && !activeIntentId && status === "idle") setVisible(false);
+  }, [activeIntentId, status, visible]);
   useEffect(() => {
     if (variant !== "embedded" || !visible) return;
     if (isVerifying || status === "credited") {
@@ -4374,5 +4926,5 @@ function parseFinalityProgress(message) {
 }
 
 export { AccountingApiError, Button, DEFAULT_LOCK_DURATION_SECONDS, DEFAULT_ONRAMP_LOCK_BUFFER, FiatOnRampForm, 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, canUseBrowserStorage, canUseSharedBrowserStorage, clampLockAmount, clearHostedAuthPendingTransaction, clearPendingLock, cn, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, createSignedLockRequest, formatCountdown, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getBlockNumber, getBrowserStorageItem, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, getSharedBrowserStorageItem, getTransactionReceipt, getWalletClient3 as getWalletClient, isHostedAuthRefreshActive, isHostedAuthSessionActive, isSignedLockUsable, loadPendingLock, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, removeBrowserStorageItem, removeSharedBrowserStorageItem, requireDepositLockOwner, requireServiceAddress, savePendingLock, setBrowserStorageItem, setSharedBrowserStorageItem, shortenAddress, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, submitPendingLock, syncHostedAuthSessionToClient, useDepositVerification, useEnsureCorrectChain, useFiatOnRamp, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, waitForTransactionReceipt };
-//# sourceMappingURL=chunk-DZURIIRE.js.map
-//# sourceMappingURL=chunk-DZURIIRE.js.map
+//# sourceMappingURL=chunk-PMBU2F2R.js.map
+//# sourceMappingURL=chunk-PMBU2F2R.js.map