@oasisprotocol/privana-sdk 0.5.7 → 0.5.8

package/dist/{chunk-FFYLKZ7J.cjs → chunk-EXFISDHQ.cjs}

@@ -643,6 +643,12 @@ var PrivanaClient = class _PrivanaClient {
       moonpay_currency_code: request.moonpay_currency_code
     });
   }
+  async createOnRampSession(request) {
+    return this.http.post("/v1/accounting/onramp/session", {
+      transaction_id: request.transaction_id,
+      ip_attestation: request.ip_attestation
+    });
+  }
   async updateOnRamp(transactionId, request) {
     return this.http.post(
       `/v1/accounting/onramp/${encodeURIComponent(transactionId)}`,
@@ -1707,6 +1713,7 @@ var DEFAULT_NETWORK_CONFIG = NETWORK_CONFIG.testnet;
 function PrivanaProvider({
   children,
   networkConfig: networkConfigOverride,
+  onRamp,
   tokens,
   chains,
   pollingInterval = 1e4,
@@ -1740,7 +1747,9 @@ function PrivanaProvider({
     networkConfigOverride?.chainId,
     networkConfigOverride?.name,
     networkConfigOverride?.accountingContract,
-    networkConfigOverride?.apiUrl
+    networkConfigOverride?.apiUrl,
+    networkConfigOverride?.moonpayApiUrl,
+    networkConfigOverride?.moonpayApiKey
   ]);
   const resolvedChains = react.useMemo(() => {
     if (chains && chains.length > 0) return chains;
@@ -1923,6 +1932,7 @@ function PrivanaProvider({
     () => ({
       client,
       networkConfig,
+      onRamp,
       enabledTokens,
       defaultToken: enabledTokens[0],
       getTokenById,
@@ -1943,6 +1953,7 @@ function PrivanaProvider({
     [
       client,
       networkConfig,
+      onRamp,
       enabledTokens,
       getTokenById,
       getChainById2,
@@ -2694,6 +2705,176 @@ function creditedAmountFromResponse(response, requestedAmount) {
 function isDefinitiveCandidateFailure(error) {
   return error instanceof AccountingApiError && error.statusCode === 400;
 }
+var BYTES32_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+var PROVIDER_ASSET_CODE_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+var TRANSAK_MINIMUM_TARGET_PERCENT = 105n;
+function resolveProductOnRamp({
+  config,
+  enabledTokens,
+  legacyToken,
+  moonpayApiKey
+}) {
+  if (config === void 0) {
+    if (!moonpayApiKey) {
+      return unavailable("moonpay", legacyToken, false, "MoonPay is not configured.");
+    }
+    if (!legacyToken) {
+      return available("moonpay", void 0, void 0, false);
+    }
+    if (!legacyToken.moonpayCurrencyCode) {
+      return unavailable(
+        "moonpay",
+        legacyToken,
+        false,
+        `${legacyToken.symbol} isn\u2019t available for card purchases yet.`
+      );
+    }
+    return available("moonpay", legacyToken, legacyToken.moonpayCurrencyCode, false);
+  }
+  if (!isValidConfig(config)) {
+    return unavailable(null, void 0, true, "Card on-ramp configuration is invalid.");
+  }
+  const providerAssetCode = config.providerAssetCode.trim().toLowerCase();
+  const token = enabledTokens.find(
+    (candidate) => candidate.id.toLowerCase() === config.tokenId.toLowerCase()
+  );
+  if (!token) {
+    return unavailable(
+      config.provider,
+      void 0,
+      true,
+      "The configured card-purchase token is not enabled."
+    );
+  }
+  if (token.contract.toLowerCase() === viem.zeroAddress) {
+    return unavailable(config.provider, token, true, "Card purchases require an ERC20 token.");
+  }
+  if (config.provider === "moonpay") {
+    if (!moonpayApiKey) {
+      return unavailable("moonpay", token, true, "MoonPay is not configured.");
+    }
+    if (!token.moonpayCurrencyCode || token.moonpayCurrencyCode.toLowerCase() !== providerAssetCode) {
+      return unavailable(
+        "moonpay",
+        token,
+        true,
+        "The configured MoonPay asset does not match the selected token."
+      );
+    }
+  }
+  return available(config.provider, token, providerAssetCode, true);
+}
+function createProductOnRampFlowSnapshot({
+  id,
+  selection,
+  amount,
+  allowance,
+  lockServiceAddress,
+  moonpayApiKey,
+  scope
+}) {
+  if (selection.unavailableReason || !selection.provider || !selection.token || !selection.providerAssetCode) {
+    throw new Error(selection.unavailableReason ?? "Card on-ramp configuration is unavailable.");
+  }
+  const amountBaseUnits = viem.parseUnits(amount, selection.token.decimals);
+  if (amountBaseUnits <= 0n) throw new Error("Card purchase amount must be positive.");
+  if (!scope.beneficiaryAddress) {
+    throw new Error("Sign in or connect a wallet before starting a card purchase.");
+  }
+  if (allowance && !lockServiceAddress) {
+    throw new Error("The lock service address is not configured.");
+  }
+  return {
+    id,
+    selection: {
+      ...selection,
+      provider: selection.provider,
+      token: { ...selection.token },
+      providerAssetCode: selection.providerAssetCode,
+      unavailableReason: null
+    },
+    amount,
+    amountBaseUnits,
+    allowance: cloneAllowance(allowance),
+    requiresLock: allowance !== void 0,
+    lockServiceAddress: allowance ? lockServiceAddress : void 0,
+    moonpayApiKey: selection.provider === "moonpay" ? moonpayApiKey : void 0,
+    scope: { ...scope }
+  };
+}
+function matchesProductOnRampScope(expected, current) {
+  return expected.apiUrl === current.apiUrl && expected.accountingChainId === current.accountingChainId && expected.accountingContract.toLowerCase() === current.accountingContract.toLowerCase() && expected.beneficiaryAddress?.toLowerCase() === current.beneficiaryAddress?.toLowerCase();
+}
+function isMoonPayProductOnRamp(selection) {
+  return selection.provider === "moonpay" && !selection.unavailableReason;
+}
+function getTransakMinimumTargetBaseUnits(minimum) {
+  return (minimum * TRANSAK_MINIMUM_TARGET_PERCENT + 99n) / 100n;
+}
+function getOnRampTokenFingerprint(token) {
+  if (!token) return "";
+  return [token.id.toLowerCase(), token.contract.toLowerCase(), token.chainId, token.decimals].join(
+    "\0"
+  );
+}
+function matchesFrozenOnRampToken(frozen, live) {
+  return live !== void 0 && getOnRampTokenFingerprint(live) === getOnRampTokenFingerprint(frozen);
+}
+function createProductOnRampOutcomeCallbacks({
+  requiresLock,
+  onComplete,
+  onLockFailed
+}) {
+  return {
+    onCredited: requiresLock ? void 0 : onComplete,
+    onLockSubmitted: onComplete,
+    onLockFailed
+  };
+}
+function isValidConfig(config) {
+  const candidate = config;
+  if (!isPlainRecord(candidate)) return false;
+  if (candidate.provider !== "moonpay" && candidate.provider !== "transak") return false;
+  if (typeof candidate.tokenId !== "string" || !BYTES32_PATTERN.test(candidate.tokenId)) {
+    return false;
+  }
+  return typeof candidate.providerAssetCode === "string" && PROVIDER_ASSET_CODE_PATTERN.test(candidate.providerAssetCode.trim());
+}
+function available(provider, token, providerAssetCode, tokenSelectionLocked) {
+  return {
+    provider,
+    token,
+    providerAssetCode,
+    tokenSelectionLocked,
+    unavailableReason: null
+  };
+}
+function unavailable(provider, token, tokenSelectionLocked, unavailableReason) {
+  return {
+    provider,
+    token,
+    providerAssetCode: void 0,
+    tokenSelectionLocked,
+    unavailableReason
+  };
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function cloneAllowance(allowance) {
+  if (!allowance) return void 0;
+  return {
+    value: allowance.value,
+    minAmount: allowance.minAmount,
+    lockDuration: allowance.lockDuration,
+    terms: allowance.terms ? {
+      permissions: allowance.terms.permissions?.map((term) => ({ ...term })),
+      restrictions: allowance.terms.restrictions?.map((term) => ({ ...term }))
+    } : void 0
+  };
+}
 function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
 }
@@ -2811,6 +2992,9 @@ var moonPayOnRampAdapter = {
     token_id: tokenId,
     chain_id: chainId,
     moonpay_transaction_id: intentId === providerTransactionId ? void 0 : providerTransactionId
+  }),
+  recordDeposit: async ({ client, record, depositTxHash }) => client.updateOnRamp(record.transaction_id, {
+    deposit_tx_hash: depositTxHash
   })
 };
 function normalizeMoonPayProviderEvent(kind, event) {
@@ -3098,15 +3282,39 @@ function assertOnRampRecordProvider(record, configuredProvider) {
     );
   }
 }
+function assertCreatedOnRampIntent(record, configuredProvider, expected) {
+  assertOnRampRecordProvider(record, configuredProvider);
+  if (typeof record.provider_asset_code !== "string" || record.provider_asset_code.toLowerCase() !== expected.providerAssetCode.toLowerCase()) {
+    throw new Error(
+      `On-ramp intent asset ${record.provider_asset_code} does not match requested asset ${expected.providerAssetCode}`
+    );
+  }
+  if (typeof record.token_id !== "string" || record.token_id.toLowerCase() !== expected.tokenId.toLowerCase()) {
+    throw new Error("On-ramp intent token does not match the requested token");
+  }
+  if (record.chain_id !== expected.chainId) {
+    throw new Error("On-ramp intent chain does not match the requested chain");
+  }
+  if (typeof record.wallet_address !== "string" || record.wallet_address.toLowerCase() !== expected.walletAddress.toLowerCase()) {
+    throw new Error("On-ramp intent wallet does not match the Privana deposit address");
+  }
+}
 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;
 }
+function getOnRampVerificationKey(record) {
+  return getOnRampIntentId(record);
+}
+function canRetryOnRampVerification(record, activeVerificationId) {
+  return Boolean(record.on_chain_tx_hash) && activeVerificationId === null;
+}
+async function recordOnRampProviderDeposit(adapter, context) {
+  if (context.record.provider !== adapter.provider) return void 0;
+  return adapter.recordDeposit?.(context);
+}
 async function verifyPendingOnRampsSequentially({
   records,
   shouldStop,
@@ -3130,13 +3338,19 @@ async function verifyPendingOnRampsSequentially({
 
 // src/sdk/on-ramp/recovery.ts
 var MAX_UNRESOLVED_ONRAMP_INTENTS = 10;
+var MAX_CREDITED_ONRAMP_VERIFICATIONS = 1e3;
 var MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS = 1e4;
 var ONRAMP_INTENT_RETENTION_MS = 365 * 24 * 60 * 60 * 1e3;
 var ONRAMP_RECOVERY_VERSION = 1;
+var ONRAMP_CREDIT_RECOVERY_VERSION = 2;
 function recoveryKey(scope) {
   const api = encodeURIComponent(scope.apiUrl.replace(/\/$/, ""));
   return `privana:onramp-intents:${api}:${scope.chainId}:${scope.userAddress.toLowerCase()}`;
 }
+function creditedRecoveryKey(scope) {
+  const api = encodeURIComponent(scope.apiUrl.replace(/\/$/, ""));
+  return `privana:onramp-credited:${api}:${scope.chainId}:${scope.userAddress.toLowerCase()}`;
+}
 function isIntent(value) {
   if (!value || typeof value !== "object") return false;
   const intent = value;
@@ -3155,6 +3369,25 @@ function writeIntents(scope, intents) {
     })
   );
 }
+function isCreditedVerification(value) {
+  if (!value || typeof value !== "object") return false;
+  const verification = value;
+  return typeof verification.verificationKey === "string" && verification.verificationKey.length > 0 && verification.verificationKey.length <= 512 && Number.isFinite(verification.savedAt) && (verification.savedAt ?? 0) > 0;
+}
+function writeCreditedVerifications(scope, verifications) {
+  const key = creditedRecoveryKey(scope);
+  if (verifications.length === 0) {
+    removeBrowserStorageItem(key);
+    return true;
+  }
+  return setBrowserStorageItem(
+    key,
+    JSON.stringify({
+      version: ONRAMP_CREDIT_RECOVERY_VERSION,
+      verifications
+    })
+  );
+}
 function loadUnresolvedOnRampIntents(scope, now = Date.now()) {
   const key = recoveryKey(scope);
   try {
@@ -3186,6 +3419,48 @@ function forgetUnresolvedOnRampIntent(scope, transactionId, now = Date.now()) {
   );
   writeIntents(scope, intents);
 }
+function loadCreditedOnRampVerifications(scope, now = Date.now()) {
+  const key = creditedRecoveryKey(scope);
+  try {
+    const raw = getBrowserStorageItem(key);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== ONRAMP_CREDIT_RECOVERY_VERSION || !Array.isArray(parsed.verifications)) {
+      removeBrowserStorageItem(key);
+      return [];
+    }
+    const retained = parsed.verifications.filter(isCreditedVerification).filter((verification) => now - verification.savedAt <= ONRAMP_INTENT_RETENTION_MS).sort((left, right) => left.savedAt - right.savedAt).slice(-MAX_CREDITED_ONRAMP_VERIFICATIONS);
+    if (retained.length !== parsed.verifications.length) {
+      writeCreditedVerifications(scope, retained);
+    }
+    return retained;
+  } catch {
+    removeBrowserStorageItem(key);
+    return [];
+  }
+}
+function rememberCreditedOnRampVerification(scope, verificationKey, now = Date.now()) {
+  if (!verificationKey || verificationKey.length > 512) return false;
+  const verifications = loadCreditedOnRampVerifications(scope, now).filter(
+    (verification) => verification.verificationKey !== verificationKey
+  );
+  verifications.push({ verificationKey, savedAt: now });
+  return writeCreditedVerifications(scope, verifications.slice(-MAX_CREDITED_ONRAMP_VERIFICATIONS));
+}
+function finalizeCreditedOnRampIntent(scope, record, now = Date.now()) {
+  const remembered = rememberCreditedOnRampVerification(
+    scope,
+    getOnRampVerificationKey(record),
+    now
+  );
+  if (remembered) forgetUnresolvedOnRampIntent(scope, getOnRampIntentId(record), now);
+  return remembered;
+}
+function filterCreditedOnRampRecords(records, creditedVerificationKeys) {
+  const credited = new Set(creditedVerificationKeys);
+  if (credited.size === 0) return [...records];
+  return records.filter((record) => !credited.has(getOnRampVerificationKey(record)));
+}
 function discardInvalidOnRampIntent(scope, invalidIntentId, activeIntentId) {
   forgetUnresolvedOnRampIntent(scope, invalidIntentId);
   const invalidatedActiveIntent = activeIntentId === invalidIntentId;
@@ -3236,17 +3511,31 @@ async function getPendingOnRampsWithRecovery({
   } catch (error) {
     if (!isBadRequest(error) || bounded.length === 0) throw error;
   }
-  const valid = [];
+  const validResponses = [];
   for (const intentId of bounded) {
     try {
-      await client.getPendingOnRamps([intentId]);
-      valid.push(intentId);
+      validResponses.push(await client.getPendingOnRamps([intentId]));
     } catch (error) {
       if (!isBadRequest(error)) throw error;
       onInvalidIntent(intentId);
     }
   }
-  return client.getPendingOnRamps(valid);
+  if (validResponses.length === 0) return client.getPendingOnRamps([]);
+  return { pending: mergePendingOnRampRows(validResponses.flatMap((response) => response.pending)) };
+}
+function mergePendingOnRampRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((record) => {
+    const identifier = record.provider_transaction_id || record.transaction_id;
+    const key = `${record.provider}\0${identifier}`;
+    if (!identifier || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).sort(
+    (left, right) => right.updated_at - left.updated_at || right.created_at - left.created_at || String(right.provider_transaction_id ?? "").localeCompare(
+      String(left.provider_transaction_id ?? "")
+    )
+  );
 }
 function isBadRequest(error) {
   return error instanceof AccountingApiError && error.statusCode === 400;
@@ -3254,6 +3543,17 @@ function isBadRequest(error) {
 var ERC20_TRANSFER_EVENT = viem.parseAbiItem(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
+function decodeErc20TransferLog(log) {
+  try {
+    return viem.decodeEventLog({
+      abi: [ERC20_TRANSFER_EVENT],
+      data: log.data,
+      topics: log.topics
+    });
+  } catch {
+    return void 0;
+  }
+}
 function assertErc20OnRampToken(tokenAddress) {
   if (tokenAddress.toLowerCase() === viem.zeroAddress) {
     throw new Error("On-ramp verification supports ERC-20 tokens only");
@@ -3263,23 +3563,31 @@ 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;
+function resolveErc20OnRampTransfer(logs, tokenAddress, depositAddress) {
+  let match;
   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 {
+    const decoded = decodeErc20TransferLog(log);
+    if (!decoded) continue;
+    if (decoded.eventName !== "Transfer" || decoded.args.to.toLowerCase() !== depositAddress.toLowerCase()) {
+      continue;
     }
+    if (match) {
+      throw new Error("On-ramp receipt contains multiple matching ERC-20 Transfer logs");
+    }
+    const logIndex = log.logIndex;
+    if (typeof logIndex !== "number" || !Number.isSafeInteger(logIndex) || logIndex < 0) {
+      throw new Error("Matching on-ramp ERC-20 Transfer does not have a valid log index");
+    }
+    match = { amount: decoded.args.value, logIndex };
+  }
+  if (!match) {
+    throw new Error("On-ramp receipt does not contain a matching ERC-20 Transfer");
   }
-  return delivered;
+  if (match.amount <= 0n) {
+    throw new Error("Matching on-ramp ERC-20 Transfer must have a positive amount");
+  }
+  return match;
 }
 
 // src/sdk/on-ramp/settlement.ts
@@ -3361,6 +3669,12 @@ function useEnsureCorrectChain() {
 var DEFAULT_DELIVERY_TIMEOUT_MS = 12e4;
 var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_FINALITY_RETRY_INTERVAL_MS = 15e3;
+function bindOnRampFlowSession(ref, flowSession) {
+  ref.current = flowSession;
+  return () => {
+    if (ref.current === flowSession) ref.current = null;
+  };
+}
 function useOnRamp(options) {
   const {
     adapter,
@@ -3402,6 +3716,7 @@ function useOnRamp(options) {
   const flowSession = react.useMemo(() => Symbol(flowIdentity), [flowIdentity]);
   const flowSessionRef = react.useRef(flowSession);
   flowSessionRef.current = flowSession;
+  react.useEffect(() => bindOnRampFlowSession(flowSessionRef, flowSession), [flowSession]);
   const [status, setStatus] = react.useState("idle");
   const [pending, setPending] = react.useState([]);
   const [error, setError] = react.useState(null);
@@ -3424,6 +3739,7 @@ function useOnRamp(options) {
   const activeVerificationSurfacesFailureRef = react.useRef(false);
   const lockOwnerRef = react.useRef(null);
   const triggeredVerificationKeysRef = react.useRef(/* @__PURE__ */ new Set());
+  const creditedVerificationKeysRef = react.useRef(/* @__PURE__ */ new Set());
   const activeVerificationDoneRef = react.useRef(null);
   const closeReconcilePromiseRef = react.useRef(null);
   const deliveryWaitPromiseRef = react.useRef(null);
@@ -3531,7 +3847,13 @@ function useOnRamp(options) {
         }
       })
     );
-    return rows;
+    const creditedKeys = recoveryScope ? loadCreditedOnRampVerifications(recoveryScope).map(
+      (verification) => verification.verificationKey
+    ) : [];
+    return filterCreditedOnRampRecords(rows, [
+      ...creditedKeys,
+      ...creditedVerificationKeysRef.current
+    ]);
   }, [emitDebug, executeOnRampPrivateRead, flowSession, recoveryScope]);
   const readPendingRows = react.useMemo(
     () => createPendingOnRampReadCoordinator({
@@ -3574,7 +3896,8 @@ function useOnRamp(options) {
     activeVerificationDoneRef.current = null;
   }, []);
   const submitPendingLockAfterCredit = react.useCallback(
-    async (transactionId, userAddress, creditedAmount) => {
+    async (record, userAddress, creditedAmount) => {
+      const transactionId = record.transaction_id;
       try {
         const settlement = await settlePendingOnRampLock({
           client,
@@ -3589,7 +3912,8 @@ function useOnRamp(options) {
             "not-found"
           );
           emitDebug("lock:not-found");
-          (onLockFailedRef.current ?? onErrorRef.current)?.(lockError);
+          if (onLockFailedRef.current) onLockFailedRef.current(lockError, record);
+          else onErrorRef.current?.(lockError);
           return;
         }
         queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
@@ -3599,7 +3923,7 @@ function useOnRamp(options) {
         emitDebug("lock:submitted", {
           submissionIdPresent: Boolean(settlement.response.submission_id)
         });
-        onLockSubmittedRef.current?.(settlement.response);
+        onLockSubmittedRef.current?.(settlement.response, record);
       } catch (err) {
         const error2 = err instanceof PostDepositLockError ? err : new PostDepositLockError(
           err instanceof Error ? err.message : "Lock submission failed",
@@ -3612,7 +3936,8 @@ function useOnRamp(options) {
           reason: error2.reason,
           message: error2.message
         });
-        (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
+        if (onLockFailedRef.current) onLockFailedRef.current(error2, record);
+        else onErrorRef.current?.(error2);
       }
     },
     [client, emitDebug, postDepositLock, queryClient]
@@ -3642,6 +3967,13 @@ function useOnRamp(options) {
         setStatus("credited");
       }
       if (record) {
+        creditedVerificationKeysRef.current.add(getOnRampVerificationKey(record));
+        setPending((rows) => filterCreditedOnRampRecords(rows, creditedVerificationKeysRef.current));
+        const finalizeRecovery = () => {
+          if (recoveryScopeAtCredit && !finalizeCreditedOnRampIntent(recoveryScopeAtCredit, record)) {
+            emitDebug("verification:credit-recovery-storage-unavailable");
+          }
+        };
         setFinalityProgress((prev) => {
           if (!(record.transaction_id in prev)) return prev;
           const next = { ...prev };
@@ -3650,39 +3982,48 @@ function useOnRamp(options) {
         });
         const lockOwner = lockOwnerRef.current ?? privateReadAddress;
         if (lockOwner) {
-          void submitPendingLockAfterCredit(record.transaction_id, lockOwner, creditedAmount);
+          void submitPendingLockAfterCredit(record, lockOwner, creditedAmount).finally(
+            finalizeRecovery
+          );
         } else if (postDepositLock) {
           emitDebug("lock:owner-unavailable");
-          (onLockFailedRef.current ?? onErrorRef.current)?.(
-            new PostDepositLockError(
-              "No wallet address available to look up the signed lock for this on-ramp",
-              "not-found"
-            )
+          const lockError = new PostDepositLockError(
+            "No wallet address available to look up the signed lock for this on-ramp",
+            "not-found"
           );
+          if (onLockFailedRef.current) onLockFailedRef.current(lockError, record);
+          else onErrorRef.current?.(lockError);
+          finalizeRecovery();
+        } else {
+          finalizeRecovery();
         }
       }
       void (async () => {
         try {
-          if (record && depositTxHash.startsWith("0x")) {
-            emitDebug("onramp:mark-deposit-triggered-request", {
+          if (record && adapter.recordDeposit && record.provider === adapter.provider && depositTxHash.startsWith("0x")) {
+            emitDebug("provider-deposit:record-request", {
+              provider: adapter.provider,
               depositTxHash
             });
             const updated = await executeOnRampPrivateRead(
-              (readClient) => readClient.updateOnRamp(record.transaction_id, {
-                deposit_tx_hash: depositTxHash
+              (readClient) => recordOnRampProviderDeposit(adapter, {
+                client: readClient,
+                record,
+                depositTxHash
               })
             );
-            emitDebug("onramp:mark-deposit-triggered-success", {
-              record: summariseOnRampRecord(updated)
+            emitDebug("provider-deposit:record-success", {
+              provider: adapter.provider,
+              record: updated ? summariseOnRampRecord(updated) : null
             });
           }
         } catch (err) {
-          emitDebug("onramp:mark-deposit-triggered-error", errorPayload(err));
-          console.warn("Failed to mark on-ramp row complete:", err);
+          emitDebug("provider-deposit:record-error", {
+            provider: adapter.provider,
+            ...errorPayload(err)
+          });
+          console.warn("Failed to record provider deposit:", err);
         } finally {
-          if (record && recoveryScopeAtCredit) {
-            forgetUnresolvedOnRampIntent(recoveryScopeAtCredit, getOnRampIntentId(record));
-          }
           await refreshPending();
           clearActiveVerification(verificationKey);
           if (record && activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)) {
@@ -3694,7 +4035,7 @@ function useOnRamp(options) {
           }
         }
       })();
-      onCreditedRef.current?.(depositTxHash);
+      if (record) onCreditedRef.current?.(depositTxHash, record);
     },
     onCheckTimeout: (depositTxHash) => {
       const record = activeVerificationRecordRef.current;
@@ -3732,6 +4073,7 @@ function useOnRamp(options) {
     resetDepositVerification();
     clearActiveVerification();
     triggeredVerificationKeysRef.current.clear();
+    creditedVerificationKeysRef.current.clear();
     setPending([]);
     setFinalityProgress({});
     statusRef.current = "idle";
@@ -3787,28 +4129,19 @@ function useOnRamp(options) {
           quoteCurrencyAmountPresent: quoteCurrencyAmount !== void 0,
           depositAddressReady: true
         });
+        const intentInput = {
+          walletAddress: scopedDepositAddress,
+          tokenId,
+          chainId: token.chainId,
+          providerAssetCode
+        };
         const record = await executeOnRampPrivateRead(
-          (readClient) => readClient.createOnRampIntent(
-            adapter.buildIntentRequest({
-              walletAddress: scopedDepositAddress,
-              tokenId,
-              chainId: token.chainId,
-              providerAssetCode
-            })
-          )
+          (readClient) => readClient.createOnRampIntent(adapter.buildIntentRequest(intentInput))
         );
         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}`
-          );
-        }
+        assertCreatedOnRampIntent(record, adapter.provider, intentInput);
         if (postDepositLock && lockOwner && lockAmount !== void 0) {
           const signingWalletClient = await getWalletClient3(wagmiConfig, {
             chainId: networkConfig.chainId
@@ -4049,7 +4382,7 @@ function useOnRamp(options) {
             `Token ${recordTokenId} is on chain ${token.chainId} but record is on chain ${record.chain_id}`
           );
         }
-        const amount = await resolveDeliveredAmount({
+        const delivered = await resolveDeliveredTransfer({
           onChainTxHash: record.on_chain_tx_hash,
           chainId: record.chain_id,
           walletAddress: record.wallet_address,
@@ -4062,12 +4395,14 @@ function useOnRamp(options) {
           scopedMinDepositByChain,
           record.chain_id
         );
-        if (recordMinDepositBaseUnits !== void 0 && amount < recordMinDepositBaseUnits) {
+        if (recordMinDepositBaseUnits !== void 0 && delivered.amount < recordMinDepositBaseUnits) {
           emitDebug("verification:below-minimum", {
-            deliveredAmount: amount.toString(),
+            deliveredAmount: delivered.amount.toString(),
             minDepositBaseUnits: String(recordMinDepositBaseUnits)
           });
-          throw new Error(`Delivered amount (${amount} base units) is below the minimum deposit.`);
+          throw new Error(
+            `Delivered amount (${delivered.amount} base units) is below the minimum deposit.`
+          );
         }
         if (activeIntentIdRef.current && matchesOnRampTransaction(record, activeIntentIdRef.current)) {
           setStatus("verifying");
@@ -4075,12 +4410,14 @@ function useOnRamp(options) {
         emitDebug("verification:check-deposit-request", {
           hash: record.on_chain_tx_hash,
           chainId: record.chain_id,
-          amount: amount.toString()
+          amount: delivered.amount.toString(),
+          logIndex: delivered.logIndex
         });
         await verify({
           hash: record.on_chain_tx_hash,
           chainId: record.chain_id,
-          amount
+          amount: delivered.amount,
+          logIndex: delivered.logIndex
         });
       } catch (err) {
         if (flowSessionRef.current !== flowSession) return;
@@ -4338,7 +4675,7 @@ function summariseOnRampRecord(record) {
     credited_at: record.credited_at ?? null
   };
 }
-async function resolveDeliveredAmount({
+async function resolveDeliveredTransfer({
   onChainTxHash,
   chainId,
   walletAddress,
@@ -4347,7 +4684,6 @@ async function resolveDeliveredAmount({
   emitDebug
 }) {
   assertErc20OnRampToken(token.contract);
-  let receiptError;
   try {
     const receipt = await waitForTransactionReceipt(wagmiConfig, {
       hash: onChainTxHash,
@@ -4355,27 +4691,21 @@ async function resolveDeliveredAmount({
       timeout: 6e4,
       pollingInterval: 4e3
     });
-    const delivered = deliveredErc20Amount(receipt.logs, token.contract, walletAddress);
-    if (delivered > 0n) {
-      emitDebug("verification:amount-from-receipt", {
-        amount: delivered.toString(),
-        tokenAddress: token.contract,
-        depositAddressMatched: true
-      });
-      return delivered;
-    }
-    emitDebug("verification:amount-from-receipt-missing", {
+    const delivered = resolveErc20OnRampTransfer(receipt.logs, token.contract, walletAddress);
+    emitDebug("verification:amount-from-receipt", {
+      amount: delivered.amount.toString(),
+      logIndex: delivered.logIndex,
       tokenAddress: token.contract,
-      depositAddressMatched: false
+      depositAddressMatched: true
     });
+    return delivered;
   } catch (err) {
     emitDebug("verification:amount-from-receipt-error", errorPayload(err));
-    receiptError = err;
+    const errorDetail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Unable to derive delivered ${token.symbol} transfer from its receipt: ${errorDetail}`
+    );
   }
-  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 its receipt: ${errorDetail}`
-  );
 }
 function errorPayload(err) {
   if (err instanceof Error) {
@@ -4655,7 +4985,12 @@ function FiatOnRampForm({
   onLockSubmitted,
   onLockFailed,
   onError,
-  onDebugEvent
+  onLeaveFlow,
+  onDebugEvent,
+  onlyRouteActiveIntentCallbacks = false,
+  frozenToken,
+  onUnsafeToCloseChange,
+  onActiveFlowChange
 }) {
   const { address } = wagmi.useAccount();
   const [visible, setVisible] = react.useState(false);
@@ -4663,6 +4998,14 @@ function FiatOnRampForm({
   const [rowError, setRowError] = react.useState(null);
   const [lockError, setLockError] = react.useState(null);
   const [lockSettled, setLockSettled] = react.useState(false);
+  const [ownedTerminal, setOwnedTerminal] = react.useState(false);
+  const ownedIntentIdRef = react.useRef(null);
+  const ownsRecord = react.useCallback(
+    (record) => Boolean(
+      ownedIntentIdRef.current && matchesOnRampTransaction(record, ownedIntentIdRef.current)
+    ),
+    []
+  );
   const {
     status,
     activeIntentId,
@@ -4683,18 +5026,37 @@ function FiatOnRampForm({
   } = useFiatOnRamp({
     tokenId,
     postDepositLock,
-    onCredited,
-    // Lock callbacks aren't intent-keyed, so a resumed background row's lock
-    // can settle these flags while a newer purchase is still locking — a
-    // transient overpromise that the newer lock's own outcome then corrects.
-    onLockSubmitted: (response) => {
+    onCredited: (depositTxHash, record) => {
+      if (!onlyRouteActiveIntentCallbacks || ownsRecord(record)) {
+        onCredited?.(depositTxHash);
+      }
+      if (ownsRecord(record) && !postDepositLock) {
+        setOwnedTerminal(true);
+        onActiveFlowChange?.(false);
+      }
+    },
+    // Product modals route only the snapshotted intent. Standalone consumers
+    // retain the legacy behavior of receiving recovered-row callbacks.
+    onLockSubmitted: (response, record) => {
+      const routesToCurrentFlow = !onlyRouteActiveIntentCallbacks || ownsRecord(record);
+      if (!routesToCurrentFlow) return;
       setLockError(null);
       setLockSettled(true);
       onLockSubmitted?.(response);
+      if (ownsRecord(record)) {
+        setOwnedTerminal(true);
+        onActiveFlowChange?.(false);
+      }
     },
-    onLockFailed: (err) => {
+    onLockFailed: (err, record) => {
+      const routesToCurrentFlow = !onlyRouteActiveIntentCallbacks || ownsRecord(record);
+      if (!routesToCurrentFlow) return;
       setLockError(err.message);
       onLockFailed?.(err);
+      if (ownsRecord(record)) {
+        setOwnedTerminal(true);
+        onActiveFlowChange?.(false);
+      }
     },
     onError,
     onDebugEvent
@@ -4723,6 +5085,8 @@ function FiatOnRampForm({
     }
   })();
   const isBelowMin = quoteBaseUnits !== void 0 && minDepositBaseUnits !== void 0 ? quoteBaseUnits < minDepositBaseUnits : minFiatGate !== void 0 && Number(defaultBaseCurrencyAmount) < minFiatGate;
+  const minimumUnknown = minDepositBaseUnits === void 0;
+  const tokenMismatch = frozenToken !== void 0 && !matchesFrozenOnRampToken(frozenToken, selectedToken);
   const isBusy = isPreparing || status === "awaiting-purchase";
   const lockPending = !!postDepositLock && status === "credited" && !lockSettled && !lockError;
   const isInitializing = !!address && !depositAddress;
@@ -4734,10 +5098,23 @@ function FiatOnRampForm({
       !depositAddress ? "deposit-address-not-loaded" : null,
       isBusy ? `busy:${isPreparing ? "preparing" : status}` : null,
       visible ? "widget-open" : null,
+      minimumUnknown ? "minimum-unknown" : null,
       isBelowMin ? "below-minimum" : null,
+      tokenMismatch ? "token-drift" : null,
       quoteParseFailed ? "invalid-quote-amount" : null
     ].filter((reason) => Boolean(reason)),
-    [address, depositAddress, isBelowMin, isBusy, isPreparing, quoteParseFailed, status, visible]
+    [
+      address,
+      depositAddress,
+      isBelowMin,
+      isBusy,
+      isPreparing,
+      minimumUnknown,
+      quoteParseFailed,
+      status,
+      tokenMismatch,
+      visible
+    ]
   );
   const canBuy = blockReasons.length === 0;
   const handleOpen = react.useCallback(async () => {
@@ -4756,6 +5133,8 @@ function FiatOnRampForm({
       return;
     }
     setIsPreparing(true);
+    setOwnedTerminal(false);
+    ownedIntentIdRef.current = null;
     setLockError(null);
     setLockSettled(false);
     emitFormDebug("form:open-click", {
@@ -4774,6 +5153,8 @@ function FiatOnRampForm({
         baseCurrencyAmount: defaultBaseCurrencyAmount,
         quoteCurrencyAmount
       });
+      ownedIntentIdRef.current = intent.transaction_id;
+      onActiveFlowChange?.(true);
       emitFormDebug("form:intent-ready", {
         transactionIdPresent: Boolean(intent.transaction_id),
         externalTransactionIdPresent: Boolean(intent.external_transaction_id)
@@ -4801,7 +5182,8 @@ function FiatOnRampForm({
     depositAddress,
     emitFormDebug,
     prepareOnRampIntent,
-    status
+    status,
+    onActiveFlowChange
   ]);
   const handleClose = react.useCallback(async () => {
     emitFormDebug("moonpay:onClose");
@@ -4816,6 +5198,11 @@ function FiatOnRampForm({
   const handleReady = react.useCallback(async () => {
     emitFormDebug("moonpay:onReady");
   }, [emitFormDebug]);
+  const handleLeaveFlow = react.useCallback(() => {
+    setVisible(false);
+    onActiveFlowChange?.(false);
+    onLeaveFlow?.();
+  }, [onActiveFlowChange, onLeaveFlow]);
   const widgetElement = useMoonPayOnRampAdapter({
     variant,
     visible,
@@ -4843,6 +5230,21 @@ function FiatOnRampForm({
     onTransactionCreated: handleTransactionCreated,
     onTransactionCompleted: handleTransactionCompleted
   });
+  const ownsActiveIntent = Boolean(
+    activeIntentId && ownedIntentIdRef.current && activeIntentId === ownedIntentIdRef.current
+  );
+  const ownsPending = Boolean(
+    ownedIntentIdRef.current && pending.some((record) => matchesOnRampTransaction(record, ownedIntentIdRef.current))
+  );
+  const ownedFlowActive = !ownedTerminal && (ownsActiveIntent || ownsPending || lockPending);
+  react.useEffect(() => {
+    onActiveFlowChange?.(ownedFlowActive);
+  }, [onActiveFlowChange, ownedFlowActive]);
+  const unsafeToClose = isPreparing || lockPending;
+  react.useEffect(() => {
+    onUnsafeToCloseChange?.(unsafeToClose);
+    return () => onUnsafeToCloseChange?.(false);
+  }, [onUnsafeToCloseChange, unsafeToClose]);
   react.useEffect(() => {
     if (visible && !activeIntentId && status === "idle") setVisible(false);
   }, [activeIntentId, status, visible]);
@@ -4858,10 +5260,8 @@ function FiatOnRampForm({
       /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground text-sm font-medium", children: "Validating purchases" }),
       pending.map((record) => {
         const progress = parseFinalityProgress(finalityProgress[record.transaction_id]);
-        const hasProgress = !!finalityProgress[record.transaction_id];
-        const isStalled = !hasProgress && Date.now() / 1e3 - (record.updated_at ?? 0) > 60;
         const isActivelyVerifying = record.transaction_id === activeVerificationId;
-        const showRetry = rowError?.id === record.transaction_id || isStalled && !isActivelyVerifying;
+        const showRetry = canRetryOnRampVerification(record, activeVerificationId);
         return /* @__PURE__ */ jsxRuntime.jsxs(
           "div",
           {
@@ -4870,7 +5270,7 @@ function FiatOnRampForm({
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between gap-2", children: [
                 /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground flex items-center gap-1 text-xs", children: [
                   /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3 animate-spin", "aria-hidden": true }),
-                  progress ?? "Verifying\u2026"
+                  record.on_chain_tx_hash ? progress ?? (isActivelyVerifying ? "Verifying\u2026" : "Ready to verify") : "Waiting for provider delivery\u2026"
                 ] }),
                 /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground text-xs", children: [
                   record.quote_currency_amount ?? "?",
@@ -4896,7 +5296,17 @@ function FiatOnRampForm({
                       });
                     }
                   },
-                  children: "Retry"
+                  children: "Retry verification"
+                }
+              ),
+              !record.on_chain_tx_hash && /* @__PURE__ */ jsxRuntime.jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => void refreshPending(),
+                  children: "Refresh delivery"
                 }
               )
             ]
@@ -4923,6 +5333,10 @@ function FiatOnRampForm({
       "Buy"
     ] }),
     widgetElement,
+    onLeaveFlow && ownedFlowActive && !unsafeToClose && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Button, { type: "button", variant: "outline", onClick: handleLeaveFlow, children: "Leave checkout" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground text-xs", children: "Privana will keep this signed purchase available for exact recovery." })
+    ] }),
     error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", role: "alert", children: error.message }),
     lockError && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
       "Purchase credited to your account, but locking the funds to a service failed: ",
@@ -4933,6 +5347,8 @@ function FiatOnRampForm({
       minFiatGate.toFixed(2),
       "."
     ] }),
+    tokenMismatch && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", role: "alert", children: "The token configuration changed. Close this purchase and start again." }),
+    !tokenMismatch && depositAddress && minimumUnknown && !error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", role: "alert", children: "The minimum purchase amount is unavailable. Close this purchase and try again." }),
     isVerifying && pending.length === 0 && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-sm", children: [
       /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
       "Verifying your purchase\u2026"
@@ -4945,6 +5361,702 @@ function parseFinalityProgress(message) {
   return match ? `${match[1]} confirmations` : null;
 }
 
+// src/sdk/on-ramp/transak-adapter.ts
+var MAX_INTENT_ID_LENGTH = 512;
+var MAX_WIDGET_URL_LENGTH = 8192;
+var TRANSAK_IP_ATTESTATION_PATH = "/__onramp-ip-attest";
+var TRANSAK_IP_ATTESTATION_TIMEOUT_MS = 1e4;
+var TRANSAK_WIDGET_ORIGINS = /* @__PURE__ */ new Set([
+  "https://global-stg.transak.com",
+  "https://global.transak.com"
+]);
+var transakOnRampAdapter = {
+  provider: "transak",
+  pollPendingWhileOpen: true,
+  buildIntentRequest: ({ walletAddress, tokenId, chainId }) => ({
+    wallet_address: walletAddress,
+    token_id: tokenId,
+    chain_id: chainId
+  })
+};
+async function requestTransakWidgetSession({
+  client,
+  intentId,
+  generation,
+  now = Date.now,
+  fetcher = globalThis.fetch
+}) {
+  if (!intentId || intentId.length > MAX_INTENT_ID_LENGTH) {
+    throw new Error("Transak session requires a valid on-ramp intent");
+  }
+  const ipAttestation = await fetchTransakIpAttestation({
+    intentId,
+    fetcher
+  });
+  const response = await client.createOnRampSession({
+    transaction_id: intentId,
+    ip_attestation: ipAttestation
+  });
+  return validateTransakWidgetSession(response, intentId, generation, now());
+}
+async function fetchTransakIpAttestation({
+  intentId,
+  fetcher
+}) {
+  const subtleCrypto = globalThis.crypto?.subtle;
+  const origin = globalThis.location?.origin;
+  if (typeof fetcher !== "function" || !subtleCrypto || !origin || origin === "null") {
+    throw new Error("Secure client-IP attestation is unavailable");
+  }
+  const digest = await subtleCrypto.digest("SHA-256", new TextEncoder().encode(intentId));
+  const intentHash = Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), TRANSAK_IP_ATTESTATION_TIMEOUT_MS);
+  try {
+    let response;
+    try {
+      response = await fetcher(`${origin}${TRANSAK_IP_ATTESTATION_PATH}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ intentHash }),
+        cache: "no-store",
+        credentials: "omit",
+        redirect: "error",
+        signal: controller.signal
+      });
+    } catch (error) {
+      throw new Error("Client-IP attestation request failed", { cause: error });
+    }
+    if (!response.ok) {
+      throw new Error(`Client-IP attestation request failed with HTTP ${response.status}`);
+    }
+    try {
+      return await response.json();
+    } catch (error) {
+      throw new Error("Client-IP attestation response is malformed", { cause: error });
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function validateTransakWidgetSession(response, intentId, generation, now = Date.now()) {
+  if (!isPlainRecord2(response) || response.provider !== "transak") {
+    throw new Error("On-ramp session provider does not match Transak");
+  }
+  if (!Number.isSafeInteger(response.expires_at) || response.expires_at * 1e3 <= now) {
+    throw new Error("Transak session is expired or malformed");
+  }
+  const origin = validateTransakWidgetUrl(response.url);
+  return {
+    provider: "transak",
+    url: response.url,
+    origin,
+    expiresAt: response.expires_at,
+    intentId,
+    generation
+  };
+}
+function isTransakWidgetSessionLoadable(session, now = Date.now()) {
+  return session.expiresAt * 1e3 > now;
+}
+function resolveTransakWidgetMessage({
+  message,
+  iframeWindow,
+  session,
+  currentGeneration
+}) {
+  if (session.generation !== currentGeneration) return null;
+  if (!iframeWindow || message.source !== iframeWindow) return null;
+  if (message.origin !== session.origin) return null;
+  return normalizeTransakWidgetMessage(message.data, session.intentId);
+}
+function normalizeTransakWidgetMessage(data, intentId) {
+  if (!isPlainRecord2(data) || typeof data.event_id !== "string") return null;
+  switch (data.event_id) {
+    case "TRANSAK_WIDGET_INITIALISED":
+    case "TRANSAK_WIDGET_OPEN":
+      return { type: "ready" };
+    case "TRANSAK_ORDER_CREATED":
+      return {
+        type: "provider-event",
+        event: {
+          provider: "transak",
+          kind: "transaction-created",
+          providerTransactionId: intentId,
+          intentId
+        }
+      };
+    case "TRANSAK_ORDER_SUCCESSFUL":
+      return {
+        type: "provider-event",
+        event: {
+          provider: "transak",
+          kind: "transaction-completed",
+          providerTransactionId: intentId,
+          intentId
+        }
+      };
+    case "TRANSAK_ORDER_CANCELLED":
+    case "TRANSAK_ORDER_FAILED":
+      return { type: "refresh" };
+    case "TRANSAK_WIDGET_CLOSE":
+      return { type: "close" };
+    default:
+      return null;
+  }
+}
+function validateTransakWidgetUrl(url) {
+  if (typeof url !== "string" || url.length === 0 || url.length > MAX_WIDGET_URL_LENGTH || !/^[\x21-\x7e]+$/.test(url) || url.includes("\\")) {
+    throw new Error("Transak widget URL is malformed");
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error("Transak widget URL is malformed");
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password) {
+    throw new Error("Transak widget URL is malformed");
+  }
+  if (!TRANSAK_WIDGET_ORIGINS.has(parsed.origin)) {
+    throw new Error("Transak widget URL origin is not allowed");
+  }
+  return parsed.origin;
+}
+function isPlainRecord2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isTransakWidgetFrameRenderable(session, loadedGeneration, now = Date.now()) {
+  return loadedGeneration === session.generation || isTransakWidgetSessionLoadable(session, now);
+}
+function TransakWidgetFrame({
+  session,
+  getCurrentGeneration,
+  shouldPollPending,
+  refreshPending,
+  onReady,
+  onAction,
+  onExpired,
+  title = "Transak secure checkout",
+  className
+}) {
+  const iframeRef = react.useRef(null);
+  const loadedGenerationRef = react.useRef(null);
+  const renderable = isTransakWidgetFrameRenderable(session, loadedGenerationRef.current);
+  const readyRef = react.useRef(false);
+  const expiryTimerRef = react.useRef(null);
+  const callbacksRef = react.useRef({
+    getCurrentGeneration,
+    refreshPending,
+    onReady,
+    onAction,
+    onExpired
+  });
+  callbacksRef.current = {
+    getCurrentGeneration,
+    refreshPending,
+    onReady,
+    onAction,
+    onExpired
+  };
+  const expireUnloadedSession = react.useCallback(() => {
+    if (loadedGenerationRef.current === session.generation) return;
+    callbacksRef.current.onExpired(session.generation);
+  }, [session.generation]);
+  react.useEffect(() => {
+    loadedGenerationRef.current = null;
+    readyRef.current = false;
+    const remaining = session.expiresAt * 1e3 - Date.now();
+    if (remaining <= 0) {
+      expireUnloadedSession();
+      return;
+    }
+    expiryTimerRef.current = setTimeout(expireUnloadedSession, remaining);
+    return () => {
+      if (expiryTimerRef.current) clearTimeout(expiryTimerRef.current);
+      expiryTimerRef.current = null;
+    };
+  }, [expireUnloadedSession, session.expiresAt]);
+  react.useEffect(() => {
+    const handleMessage = (message) => {
+      const action = resolveTransakWidgetMessage({
+        message,
+        iframeWindow: iframeRef.current?.contentWindow ?? null,
+        session,
+        currentGeneration: callbacksRef.current.getCurrentGeneration()
+      });
+      if (!action) return;
+      loadedGenerationRef.current = session.generation;
+      if (expiryTimerRef.current) clearTimeout(expiryTimerRef.current);
+      expiryTimerRef.current = null;
+      void callbacksRef.current.onAction(session.generation, action);
+    };
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, [session]);
+  react.useEffect(() => {
+    if (!renderable || !transakOnRampAdapter.pollPendingWhileOpen || !shouldPollPending) return;
+    const id = setInterval(
+      () => void callbacksRef.current.refreshPending(),
+      MIN_ONRAMP_PENDING_REQUEST_INTERVAL_MS
+    );
+    return () => clearInterval(id);
+  }, [renderable, shouldPollPending]);
+  const handleLoad = react.useCallback(() => {
+    if (!isTransakWidgetSessionLoadable(session)) {
+      expireUnloadedSession();
+      return;
+    }
+    loadedGenerationRef.current = session.generation;
+    if (expiryTimerRef.current) clearTimeout(expiryTimerRef.current);
+    expiryTimerRef.current = null;
+    if (readyRef.current) return;
+    readyRef.current = true;
+    callbacksRef.current.onReady(session.generation);
+  }, [expireUnloadedSession, session]);
+  if (!renderable) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "iframe",
+    {
+      ref: iframeRef,
+      src: session.url,
+      title,
+      className,
+      allow: "camera; microphone; payment",
+      referrerPolicy: "strict-origin-when-cross-origin",
+      onLoad: handleLoad,
+      "data-privana-transak-widget": true
+    }
+  );
+}
+function transitionTransakSessionRecreation(state, event) {
+  if (event === "reset") return "none";
+  if (event === "intent-created") return "preload-only";
+  if (state === "none") return "none";
+  return "blocked";
+}
+function getMountedTransakSessionError(action, hasMountedSession) {
+  if (!hasMountedSession) return null;
+  return action === "launch" ? new Error("Close the current Transak checkout before launching another") : new Error("Close or expire the current Transak checkout before reopening");
+}
+function getTransakRecreateSessionError({
+  hasMountedSession,
+  activeIntentId,
+  canRecreateSession
+}) {
+  const mountedError = getMountedTransakSessionError("reopen", hasMountedSession);
+  if (mountedError) return mountedError;
+  if (!activeIntentId) {
+    return new Error("No unresolved Transak intent is available to reopen");
+  }
+  if (!canRecreateSession) {
+    return new Error(
+      "This Transak purchase may already be in progress; continue recovery instead of reopening checkout"
+    );
+  }
+  return null;
+}
+function getTransakSessionContextError({
+  currentGeneration,
+  expectedGeneration,
+  scopeChanged
+}) {
+  if (currentGeneration !== expectedGeneration) {
+    return new Error("Transak checkout request was cancelled");
+  }
+  if (scopeChanged) {
+    return new Error("On-ramp account or network changed while creating the session");
+  }
+  return null;
+}
+function getTransakSessionRequestError({
+  currentGeneration,
+  expectedGeneration,
+  scopeChanged,
+  activeIntentId,
+  expectedIntentId
+}) {
+  const contextError = getTransakSessionContextError({
+    currentGeneration,
+    expectedGeneration,
+    scopeChanged
+  });
+  if (contextError) return contextError;
+  if (activeIntentId !== expectedIntentId) {
+    return new Error("The Transak purchase intent is no longer active");
+  }
+  return null;
+}
+function shouldSurfaceTransakSessionFailure({
+  status,
+  activeIntentId,
+  activeVerificationId,
+  activeVerificationRecord,
+  expectedIntentId
+}) {
+  if (!expectedIntentId || activeIntentId !== expectedIntentId) return false;
+  if (status === "awaiting-delivery") return false;
+  const ownsActiveVerification = activeVerificationRecord ? matchesOnRampTransaction(activeVerificationRecord, expectedIntentId) : activeVerificationId === expectedIntentId;
+  return !(ownsActiveVerification && (status === "verifying" || status === "credited"));
+}
+function hasTransakProviderEvidence({
+  status,
+  activeIntentId,
+  pending,
+  activeVerificationRecord
+}) {
+  if (!activeIntentId) return false;
+  const ownsRecord = (record) => matchesOnRampTransaction(record, activeIntentId);
+  return pending.some(ownsRecord) || activeVerificationRecord !== null && ownsRecord(activeVerificationRecord) || status === "awaiting-delivery" || status === "credited";
+}
+function useTransakOnRamp(options) {
+  const { iframeTitle, iframeClassName, ...coreOptions } = options;
+  const { executePrivateRead, privateReadQueryScope } = usePrivateReadRequest();
+  const core = useOnRamp({ ...coreOptions, adapter: transakOnRampAdapter });
+  const {
+    prepareOnRampIntent,
+    handleProviderLaunchReady,
+    handleProviderLaunchFailed,
+    handleProviderEvent,
+    handleProviderClosed,
+    refreshPending
+  } = core;
+  const [session, setSessionState] = react.useState(null);
+  const [isLaunching, setIsLaunching] = react.useState(false);
+  const [sessionRecreationState, setSessionRecreationState] = react.useState("none");
+  const sessionRecreationStateRef = react.useRef("none");
+  const sessionRef = react.useRef(null);
+  const mountedSessionScopeRef = react.useRef(null);
+  const generationRef = react.useRef(0);
+  const sessionRequestRef = react.useRef(null);
+  const activeIntentIdRef = react.useRef(core.activeIntentId);
+  activeIntentIdRef.current = core.activeIntentId;
+  const activeVerificationIdRef = react.useRef(core.activeVerificationId);
+  activeVerificationIdRef.current = core.activeVerificationId;
+  const activeVerificationRecord = react.useMemo(
+    () => core.activeVerificationId ? core.pending.find((record) => record.transaction_id === core.activeVerificationId) ?? null : null,
+    [core.activeVerificationId, core.pending]
+  );
+  const activeVerificationRecordRef = react.useRef(activeVerificationRecord);
+  activeVerificationRecordRef.current = activeVerificationRecord;
+  const pendingRef = react.useRef(core.pending);
+  pendingRef.current = core.pending;
+  const coreStatusRef = react.useRef(core.status);
+  coreStatusRef.current = core.status;
+  const [apiUrl, chainId, privateReadAddress] = privateReadQueryScope;
+  const scopeIdentity = [
+    apiUrl,
+    chainId,
+    privateReadAddress?.toLowerCase() ?? "",
+    coreOptions.tokenId.toLowerCase(),
+    getOnRampTokenFingerprint(core.selectedToken)
+  ].join("\0");
+  const scopeSession = react.useMemo(() => Symbol(scopeIdentity), [scopeIdentity]);
+  const scopeSessionRef = react.useRef(scopeSession);
+  scopeSessionRef.current = scopeSession;
+  const setSession = react.useCallback((next, nextScope) => {
+    sessionRef.current = next;
+    mountedSessionScopeRef.current = nextScope;
+    setSessionState(next);
+  }, []);
+  const updateSessionRecreation = react.useCallback((event) => {
+    const next = transitionTransakSessionRecreation(sessionRecreationStateRef.current, event);
+    sessionRecreationStateRef.current = next;
+    setSessionRecreationState(next);
+  }, []);
+  const hasProviderEvidence = hasTransakProviderEvidence({
+    status: core.status,
+    activeIntentId: core.activeIntentId,
+    pending: core.pending,
+    activeVerificationRecord
+  });
+  const canRecreateSession = sessionRecreationState === "preload-only" && !hasProviderEvidence;
+  const requestSession = react.useCallback(
+    (intentId, generation) => executePrivateRead(
+      (readClient) => requestTransakWidgetSession({
+        client: readClient,
+        intentId,
+        generation
+      })
+    ),
+    [executePrivateRead]
+  );
+  const launch = react.useCallback(
+    (request) => {
+      const currentRequest = sessionRequestRef.current;
+      if (currentRequest?.generation === generationRef.current) return currentRequest.promise;
+      const mountedSessionError = getMountedTransakSessionError(
+        "launch",
+        sessionRef.current !== null
+      );
+      if (mountedSessionError) return Promise.reject(mountedSessionError);
+      const generation = ++generationRef.current;
+      setIsLaunching(true);
+      updateSessionRecreation("reset");
+      let launchedIntentId = null;
+      const pendingRequest = (async () => {
+        try {
+          const intent = await prepareOnRampIntent({
+            providerAssetCode: request.providerAssetCode,
+            quoteCurrencyAmount: request.quoteCurrencyAmount
+          });
+          launchedIntentId = intent.transaction_id;
+          updateSessionRecreation("intent-created");
+          const beforeSessionError = getTransakSessionContextError({
+            currentGeneration: generationRef.current,
+            expectedGeneration: generation,
+            scopeChanged: scopeSessionRef.current !== scopeSession
+          });
+          if (beforeSessionError) throw beforeSessionError;
+          const next = await requestSession(intent.transaction_id, generation);
+          const afterSessionError = getTransakSessionRequestError({
+            currentGeneration: generationRef.current,
+            expectedGeneration: generation,
+            scopeChanged: scopeSessionRef.current !== scopeSession,
+            activeIntentId: activeIntentIdRef.current,
+            expectedIntentId: intent.transaction_id
+          });
+          if (afterSessionError) throw afterSessionError;
+          setSession(next, scopeSession);
+        } catch (error) {
+          const launchError = error instanceof Error ? error : new Error("Failed to launch Transak checkout");
+          if (generationRef.current === generation && shouldSurfaceTransakSessionFailure({
+            status: coreStatusRef.current,
+            activeIntentId: activeIntentIdRef.current,
+            activeVerificationId: activeVerificationIdRef.current,
+            activeVerificationRecord: activeVerificationRecordRef.current,
+            expectedIntentId: launchedIntentId
+          })) {
+            handleProviderLaunchFailed(launchError);
+          }
+          throw launchError;
+        } finally {
+          if (generationRef.current === generation) setIsLaunching(false);
+          if (sessionRequestRef.current?.generation === generation) {
+            sessionRequestRef.current = null;
+          }
+        }
+      })();
+      sessionRequestRef.current = { generation, promise: pendingRequest };
+      return pendingRequest;
+    },
+    [
+      handleProviderLaunchFailed,
+      prepareOnRampIntent,
+      requestSession,
+      scopeSession,
+      setSession,
+      updateSessionRecreation
+    ]
+  );
+  const recreateSession = react.useCallback(() => {
+    const currentRequest = sessionRequestRef.current;
+    if (currentRequest?.generation === generationRef.current) return currentRequest.promise;
+    const intentId = activeIntentIdRef.current;
+    const hasProviderEvidence2 = hasTransakProviderEvidence({
+      status: coreStatusRef.current,
+      activeIntentId: intentId,
+      pending: pendingRef.current,
+      activeVerificationRecord: activeVerificationRecordRef.current
+    });
+    const recreateError = getTransakRecreateSessionError({
+      hasMountedSession: sessionRef.current !== null,
+      activeIntentId: intentId,
+      canRecreateSession: sessionRecreationStateRef.current === "preload-only" && !hasProviderEvidence2
+    });
+    if (recreateError) return Promise.reject(recreateError);
+    if (!intentId) return Promise.reject(new Error("No unresolved Transak intent is available"));
+    const generation = ++generationRef.current;
+    setIsLaunching(true);
+    const pendingRequest = (async () => {
+      try {
+        const next = await requestSession(intentId, generation);
+        const requestError = getTransakSessionRequestError({
+          currentGeneration: generationRef.current,
+          expectedGeneration: generation,
+          scopeChanged: scopeSessionRef.current !== scopeSession,
+          activeIntentId: activeIntentIdRef.current,
+          expectedIntentId: intentId
+        });
+        if (requestError) throw requestError;
+        setSession(next, scopeSession);
+      } catch (error) {
+        const launchError = error instanceof Error ? error : new Error("Failed to recreate Transak checkout");
+        if (generationRef.current === generation && shouldSurfaceTransakSessionFailure({
+          status: coreStatusRef.current,
+          activeIntentId: activeIntentIdRef.current,
+          activeVerificationId: activeVerificationIdRef.current,
+          activeVerificationRecord: activeVerificationRecordRef.current,
+          expectedIntentId: intentId
+        })) {
+          handleProviderLaunchFailed(launchError);
+        }
+        throw launchError;
+      } finally {
+        if (generationRef.current === generation) setIsLaunching(false);
+        if (sessionRequestRef.current?.generation === generation) {
+          sessionRequestRef.current = null;
+        }
+      }
+    })();
+    sessionRequestRef.current = { generation, promise: pendingRequest };
+    return pendingRequest;
+  }, [handleProviderLaunchFailed, requestSession, scopeSession, setSession]);
+  const closeWidget = react.useCallback(async () => {
+    generationRef.current++;
+    const shouldReconcile = Boolean(sessionRef.current || activeIntentIdRef.current);
+    setSession(null, null);
+    setIsLaunching(false);
+    if (shouldReconcile) await handleProviderClosed();
+  }, [handleProviderClosed, setSession]);
+  const getCurrentGeneration = react.useCallback(() => generationRef.current, []);
+  const handleFrameReady = react.useCallback(
+    (generation) => {
+      const current = sessionRef.current;
+      if (!current || current.generation !== generation || generationRef.current !== generation)
+        return;
+      updateSessionRecreation("provider-ui-activated");
+      handleProviderLaunchReady();
+    },
+    [handleProviderLaunchReady, updateSessionRecreation]
+  );
+  const handleFrameExpired = react.useCallback(
+    (generation) => {
+      const current = sessionRef.current;
+      if (!current || current.generation !== generation || generationRef.current !== generation)
+        return;
+      const shouldSurfaceFailure = shouldSurfaceTransakSessionFailure({
+        status: coreStatusRef.current,
+        activeIntentId: activeIntentIdRef.current,
+        activeVerificationId: activeVerificationIdRef.current,
+        activeVerificationRecord: activeVerificationRecordRef.current,
+        expectedIntentId: current.intentId
+      });
+      generationRef.current++;
+      setSession(null, null);
+      if (shouldSurfaceFailure) {
+        handleProviderLaunchFailed(
+          new Error(
+            "Transak checkout session expired before it could be loaded; reopen to continue"
+          )
+        );
+      }
+    },
+    [handleProviderLaunchFailed, setSession]
+  );
+  const handleFrameAction = react.useCallback(
+    async (generation, action) => {
+      const current = sessionRef.current;
+      if (!current || current.generation !== generation || generationRef.current !== generation)
+        return;
+      updateSessionRecreation("provider-ui-activated");
+      switch (action.type) {
+        case "ready":
+          handleProviderLaunchReady();
+          return;
+        case "refresh":
+          await refreshPending();
+          return;
+        case "provider-event":
+          await handleProviderEvent(action.event);
+          return;
+        case "close":
+          await closeWidget();
+      }
+    },
+    [
+      closeWidget,
+      handleProviderEvent,
+      handleProviderLaunchReady,
+      refreshPending,
+      updateSessionRecreation
+    ]
+  );
+  react.useEffect(() => {
+    const current = sessionRef.current;
+    if (!current || core.activeIntentId === current.intentId) return;
+    generationRef.current++;
+    setSession(null, null);
+  }, [core.activeIntentId, setSession]);
+  react.useEffect(() => {
+    if (!core.activeIntentId) {
+      updateSessionRecreation("reset");
+      return;
+    }
+    if (hasProviderEvidence) {
+      updateSessionRecreation("provider-evidence");
+    }
+  }, [core.activeIntentId, hasProviderEvidence, updateSessionRecreation]);
+  react.useEffect(() => {
+    generationRef.current++;
+    setSession(null, null);
+    setIsLaunching(false);
+    updateSessionRecreation("reset");
+  }, [scopeSession, setSession, updateSessionRecreation]);
+  react.useEffect(
+    () => () => {
+      generationRef.current++;
+      sessionRef.current = null;
+      mountedSessionScopeRef.current = null;
+    },
+    []
+  );
+  const scopedSession = mountedSessionScopeRef.current === scopeSession ? session : null;
+  const widget = react.useMemo(
+    () => scopedSession ? /* @__PURE__ */ jsxRuntime.jsx(
+      TransakWidgetFrame,
+      {
+        session: scopedSession,
+        getCurrentGeneration,
+        shouldPollPending: core.status === "awaiting-purchase",
+        refreshPending,
+        onReady: handleFrameReady,
+        onAction: handleFrameAction,
+        onExpired: handleFrameExpired,
+        title: iframeTitle,
+        className: iframeClassName
+      },
+      scopedSession.generation
+    ) : null,
+    [
+      core.status,
+      getCurrentGeneration,
+      handleFrameAction,
+      handleFrameExpired,
+      handleFrameReady,
+      iframeClassName,
+      iframeTitle,
+      refreshPending,
+      scopedSession
+    ]
+  );
+  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,
+    isLaunching,
+    isWidgetOpen: scopedSession !== null,
+    canRecreateSession,
+    widget,
+    launch,
+    recreateSession,
+    closeWidget
+  };
+}
+
 exports.AccountingApiError = AccountingApiError;
 exports.Button = Button;
 exports.DEFAULT_LOCK_DURATION_SECONDS = DEFAULT_LOCK_DURATION_SECONDS;
@@ -4975,6 +6087,7 @@ exports.applyRefreshResponse = applyRefreshResponse;
 exports.buildHostedAuthSession = buildHostedAuthSession;
 exports.buildSiweStatement = buildSiweStatement;
 exports.buttonVariants = buttonVariants;
+exports.canRetryOnRampVerification = canRetryOnRampVerification;
 exports.canUseBrowserStorage = canUseBrowserStorage;
 exports.canUseSharedBrowserStorage = canUseSharedBrowserStorage;
 exports.clampLockAmount = clampLockAmount;
@@ -4988,6 +6101,8 @@ exports.createHostedAuthStorageKey = createHostedAuthStorageKey;
 exports.createLockExpiry = createLockExpiry;
 exports.createPkceChallenge = createPkceChallenge;
 exports.createPkceVerifier = createPkceVerifier;
+exports.createProductOnRampFlowSnapshot = createProductOnRampFlowSnapshot;
+exports.createProductOnRampOutcomeCallbacks = createProductOnRampOutcomeCallbacks;
 exports.createSignedLockRequest = createSignedLockRequest;
 exports.formatCountdown = formatCountdown;
 exports.formatTimeRemaining = formatTimeRemaining;
@@ -5002,11 +6117,16 @@ exports.getExplorerAddressUrl = getExplorerAddressUrl;
 exports.getExplorerLabel = getExplorerLabel;
 exports.getSharedBrowserStorageItem = getSharedBrowserStorageItem;
 exports.getTransactionReceipt = getTransactionReceipt;
+exports.getTransakMinimumTargetBaseUnits = getTransakMinimumTargetBaseUnits;
 exports.getWalletClient = getWalletClient3;
 exports.isHostedAuthRefreshActive = isHostedAuthRefreshActive;
 exports.isHostedAuthSessionActive = isHostedAuthSessionActive;
+exports.isMoonPayProductOnRamp = isMoonPayProductOnRamp;
 exports.isSignedLockUsable = isSignedLockUsable;
 exports.loadPendingLock = loadPendingLock;
+exports.matchesFrozenOnRampToken = matchesFrozenOnRampToken;
+exports.matchesOnRampTransaction = matchesOnRampTransaction;
+exports.matchesProductOnRampScope = matchesProductOnRampScope;
 exports.normalizeAddress = normalizeAddress;
 exports.normalizeHex = normalizeHex;
 exports.parseHostedAuthCallback = parseHostedAuthCallback;
@@ -5018,6 +6138,7 @@ exports.removeBrowserStorageItem = removeBrowserStorageItem;
 exports.removeSharedBrowserStorageItem = removeSharedBrowserStorageItem;
 exports.requireDepositLockOwner = requireDepositLockOwner;
 exports.requireServiceAddress = requireServiceAddress;
+exports.resolveProductOnRamp = resolveProductOnRamp;
 exports.savePendingLock = savePendingLock;
 exports.setBrowserStorageItem = setBrowserStorageItem;
 exports.setSharedBrowserStorageItem = setSharedBrowserStorageItem;
@@ -5039,6 +6160,7 @@ exports.usePrivateReadRequest = usePrivateReadRequest;
 exports.useSafeAccount = useSafeAccount;
 exports.useSafePrivanaContext = useSafePrivanaContext;
 exports.useSiweAuth = useSiweAuth;
+exports.useTransakOnRamp = useTransakOnRamp;
 exports.waitForTransactionReceipt = waitForTransactionReceipt;
-//# sourceMappingURL=chunk-FFYLKZ7J.cjs.map
-//# sourceMappingURL=chunk-FFYLKZ7J.cjs.map
+//# sourceMappingURL=chunk-EXFISDHQ.cjs.map
+//# sourceMappingURL=chunk-EXFISDHQ.cjs.map