@oasisprotocol/privana-sdk 0.5.7 → 0.5.9

package/dist/{chunk-4VOTSHNC.js → chunk-RDYNQUMV.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, formatUnits, parseUnits, createClient, custom, decodeEventLog } from 'viem';
+import { parseAbiItem, zeroAddress, parseUnits, walletActions, hexToString, formatUnits, createClient, custom, decodeEventLog } from 'viem';
 import { useQueryClient } from '@tanstack/react-query';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
@@ -641,6 +641,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)}`,
@@ -1705,6 +1711,7 @@ var DEFAULT_NETWORK_CONFIG = NETWORK_CONFIG.testnet;
 function PrivanaProvider({
   children,
   networkConfig: networkConfigOverride,
+  onRamp,
   tokens,
   chains,
   pollingInterval = 1e4,
@@ -1738,7 +1745,9 @@ function PrivanaProvider({
     networkConfigOverride?.chainId,
     networkConfigOverride?.name,
     networkConfigOverride?.accountingContract,
-    networkConfigOverride?.apiUrl
+    networkConfigOverride?.apiUrl,
+    networkConfigOverride?.moonpayApiUrl,
+    networkConfigOverride?.moonpayApiKey
   ]);
   const resolvedChains = useMemo(() => {
     if (chains && chains.length > 0) return chains;
@@ -1921,6 +1930,7 @@ function PrivanaProvider({
     () => ({
       client,
       networkConfig,
+      onRamp,
       enabledTokens,
       defaultToken: enabledTokens[0],
       getTokenById,
@@ -1941,6 +1951,7 @@ function PrivanaProvider({
     [
       client,
       networkConfig,
+      onRamp,
       enabledTokens,
       getTokenById,
       getChainById2,
@@ -2692,18 +2703,189 @@ 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() === 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 = 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 twMerge(clsx(inputs));
 }
-function formatTokenAmount(amount, decimals = 18) {
+function formatTokenAmount(amount, decimals = 18, maxDecimals = 6) {
   const value = typeof amount === "string" ? BigInt(amount) : amount;
-  const divisor = BigInt(10 ** decimals);
+  const divisor = 10n ** BigInt(decimals);
   const integerPart = value / divisor;
   const fractionalPart = value % divisor;
   const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
-  const twoDecimals = fractionalStr.slice(0, 2).padEnd(2, "0");
+  const shown = fractionalStr.slice(0, Math.max(2, Math.min(maxDecimals, decimals)));
+  const trimmed = shown.replace(/0+$/, "").padEnd(2, "0");
   const integerWithSpaces = integerPart.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "\u2009");
-  return `${integerWithSpaces}.${twoDecimals}`;
+  return `${integerWithSpaces}.${trimmed}`;
 }
 function parseTokenAmount(amount, decimals = 18) {
   const sanitized = amount.replace(/[\s\u2009]/g, "").replace(/,/g, ".");
@@ -2809,6 +2991,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) {
@@ -3096,15 +3281,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,
@@ -3128,13 +3337,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;
@@ -3153,6 +3368,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 {
@@ -3184,6 +3418,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;
@@ -3234,17 +3510,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;
@@ -3252,6 +3542,17 @@ function isBadRequest(error) {
 var ERC20_TRANSFER_EVENT = parseAbiItem(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
+function decodeErc20TransferLog(log) {
+  try {
+    return decodeEventLog({
+      abi: [ERC20_TRANSFER_EVENT],
+      data: log.data,
+      topics: log.topics
+    });
+  } catch {
+    return void 0;
+  }
+}
 function assertErc20OnRampToken(tokenAddress) {
   if (tokenAddress.toLowerCase() === zeroAddress) {
     throw new Error("On-ramp verification supports ERC-20 tokens only");
@@ -3261,23 +3562,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 = 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
@@ -3359,6 +3668,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,
@@ -3400,6 +3715,7 @@ function useOnRamp(options) {
   const flowSession = useMemo(() => Symbol(flowIdentity), [flowIdentity]);
   const flowSessionRef = useRef(flowSession);
   flowSessionRef.current = flowSession;
+  useEffect(() => bindOnRampFlowSession(flowSessionRef, flowSession), [flowSession]);
   const [status, setStatus] = useState("idle");
   const [pending, setPending] = useState([]);
   const [error, setError] = useState(null);
@@ -3422,6 +3738,7 @@ function useOnRamp(options) {
   const activeVerificationSurfacesFailureRef = useRef(false);
   const lockOwnerRef = useRef(null);
   const triggeredVerificationKeysRef = useRef(/* @__PURE__ */ new Set());
+  const creditedVerificationKeysRef = useRef(/* @__PURE__ */ new Set());
   const activeVerificationDoneRef = useRef(null);
   const closeReconcilePromiseRef = useRef(null);
   const deliveryWaitPromiseRef = useRef(null);
@@ -3529,7 +3846,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 = useMemo(
     () => createPendingOnRampReadCoordinator({
@@ -3572,7 +3895,8 @@ function useOnRamp(options) {
     activeVerificationDoneRef.current = null;
   }, []);
   const submitPendingLockAfterCredit = useCallback(
-    async (transactionId, userAddress, creditedAmount) => {
+    async (record, userAddress, creditedAmount) => {
+      const transactionId = record.transaction_id;
       try {
         const settlement = await settlePendingOnRampLock({
           client,
@@ -3587,7 +3911,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"] });
@@ -3597,7 +3922,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",
@@ -3610,7 +3935,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]
@@ -3640,6 +3966,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 };
@@ -3648,39 +3981,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)) {
@@ -3692,7 +4034,7 @@ function useOnRamp(options) {
           }
         }
       })();
-      onCreditedRef.current?.(depositTxHash);
+      if (record) onCreditedRef.current?.(depositTxHash, record);
     },
     onCheckTimeout: (depositTxHash) => {
       const record = activeVerificationRecordRef.current;
@@ -3730,6 +4072,7 @@ function useOnRamp(options) {
     resetDepositVerification();
     clearActiveVerification();
     triggeredVerificationKeysRef.current.clear();
+    creditedVerificationKeysRef.current.clear();
     setPending([]);
     setFinalityProgress({});
     statusRef.current = "idle";
@@ -3785,28 +4128,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
@@ -4047,7 +4381,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,
@@ -4060,12 +4394,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");
@@ -4073,12 +4409,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;
@@ -4336,7 +4674,7 @@ function summariseOnRampRecord(record) {
     credited_at: record.credited_at ?? null
   };
 }
-async function resolveDeliveredAmount({
+async function resolveDeliveredTransfer({
   onChainTxHash,
   chainId,
   walletAddress,
@@ -4345,7 +4683,6 @@ async function resolveDeliveredAmount({
   emitDebug
 }) {
   assertErc20OnRampToken(token.contract);
-  let receiptError;
   try {
     const receipt = await waitForTransactionReceipt(wagmiConfig, {
       hash: onChainTxHash,
@@ -4353,27 +4690,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) {
@@ -4653,7 +4984,12 @@ function FiatOnRampForm({
   onLockSubmitted,
   onLockFailed,
   onError,
-  onDebugEvent
+  onLeaveFlow,
+  onDebugEvent,
+  onlyRouteActiveIntentCallbacks = false,
+  frozenToken,
+  onUnsafeToCloseChange,
+  onActiveFlowChange
 }) {
   const { address } = useAccount();
   const [visible, setVisible] = useState(false);
@@ -4661,6 +4997,14 @@ function FiatOnRampForm({
   const [rowError, setRowError] = useState(null);
   const [lockError, setLockError] = useState(null);
   const [lockSettled, setLockSettled] = useState(false);
+  const [ownedTerminal, setOwnedTerminal] = useState(false);
+  const ownedIntentIdRef = useRef(null);
+  const ownsRecord = useCallback(
+    (record) => Boolean(
+      ownedIntentIdRef.current && matchesOnRampTransaction(record, ownedIntentIdRef.current)
+    ),
+    []
+  );
   const {
     status,
     activeIntentId,
@@ -4681,18 +5025,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
@@ -4721,6 +5084,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;
@@ -4732,10 +5097,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 = useCallback(async () => {
@@ -4754,6 +5132,8 @@ function FiatOnRampForm({
       return;
     }
     setIsPreparing(true);
+    setOwnedTerminal(false);
+    ownedIntentIdRef.current = null;
     setLockError(null);
     setLockSettled(false);
     emitFormDebug("form:open-click", {
@@ -4772,6 +5152,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)
@@ -4799,7 +5181,8 @@ function FiatOnRampForm({
     depositAddress,
     emitFormDebug,
     prepareOnRampIntent,
-    status
+    status,
+    onActiveFlowChange
   ]);
   const handleClose = useCallback(async () => {
     emitFormDebug("moonpay:onClose");
@@ -4814,6 +5197,11 @@ function FiatOnRampForm({
   const handleReady = useCallback(async () => {
     emitFormDebug("moonpay:onReady");
   }, [emitFormDebug]);
+  const handleLeaveFlow = useCallback(() => {
+    setVisible(false);
+    onActiveFlowChange?.(false);
+    onLeaveFlow?.();
+  }, [onActiveFlowChange, onLeaveFlow]);
   const widgetElement = useMoonPayOnRampAdapter({
     variant,
     visible,
@@ -4841,6 +5229,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);
+  useEffect(() => {
+    onActiveFlowChange?.(ownedFlowActive);
+  }, [onActiveFlowChange, ownedFlowActive]);
+  const unsafeToClose = isPreparing || lockPending;
+  useEffect(() => {
+    onUnsafeToCloseChange?.(unsafeToClose);
+    return () => onUnsafeToCloseChange?.(false);
+  }, [onUnsafeToCloseChange, unsafeToClose]);
   useEffect(() => {
     if (visible && !activeIntentId && status === "idle") setVisible(false);
   }, [activeIntentId, status, visible]);
@@ -4856,10 +5259,8 @@ function FiatOnRampForm({
       /* @__PURE__ */ 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__ */ jsxs(
           "div",
           {
@@ -4868,7 +5269,7 @@ function FiatOnRampForm({
               /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-2", children: [
                 /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground flex items-center gap-1 text-xs", children: [
                   /* @__PURE__ */ jsx(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__ */ jsxs("p", { className: "text-muted-foreground text-xs", children: [
                   record.quote_currency_amount ?? "?",
@@ -4894,7 +5295,17 @@ function FiatOnRampForm({
                       });
                     }
                   },
-                  children: "Retry"
+                  children: "Retry verification"
+                }
+              ),
+              !record.on_chain_tx_hash && /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => void refreshPending(),
+                  children: "Refresh delivery"
                 }
               )
             ]
@@ -4921,6 +5332,10 @@ function FiatOnRampForm({
       "Buy"
     ] }),
     widgetElement,
+    onLeaveFlow && ownedFlowActive && !unsafeToClose && /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: handleLeaveFlow, children: "Leave checkout" }),
+      /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-xs", children: "Privana will keep this signed purchase available for exact recovery." })
+    ] }),
     error && /* @__PURE__ */ jsx("p", { className: "text-destructive text-sm", role: "alert", children: error.message }),
     lockError && /* @__PURE__ */ jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
       "Purchase credited to your account, but locking the funds to a service failed: ",
@@ -4931,6 +5346,8 @@ function FiatOnRampForm({
       minFiatGate.toFixed(2),
       "."
     ] }),
+    tokenMismatch && /* @__PURE__ */ 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__ */ 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__ */ jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-sm", children: [
       /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
       "Verifying your purchase\u2026"
@@ -4943,6 +5360,702 @@ function parseFinalityProgress(message) {
   return match ? `${match[1]} confirmations` : null;
 }
 
-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-4VOTSHNC.js.map
-//# sourceMappingURL=chunk-4VOTSHNC.js.map
+// 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 = useRef(null);
+  const loadedGenerationRef = useRef(null);
+  const renderable = isTransakWidgetFrameRenderable(session, loadedGenerationRef.current);
+  const readyRef = useRef(false);
+  const expiryTimerRef = useRef(null);
+  const callbacksRef = useRef({
+    getCurrentGeneration,
+    refreshPending,
+    onReady,
+    onAction,
+    onExpired
+  });
+  callbacksRef.current = {
+    getCurrentGeneration,
+    refreshPending,
+    onReady,
+    onAction,
+    onExpired
+  };
+  const expireUnloadedSession = useCallback(() => {
+    if (loadedGenerationRef.current === session.generation) return;
+    callbacksRef.current.onExpired(session.generation);
+  }, [session.generation]);
+  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]);
+  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]);
+  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 = 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__ */ 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] = useState(null);
+  const [isLaunching, setIsLaunching] = useState(false);
+  const [sessionRecreationState, setSessionRecreationState] = useState("none");
+  const sessionRecreationStateRef = useRef("none");
+  const sessionRef = useRef(null);
+  const mountedSessionScopeRef = useRef(null);
+  const generationRef = useRef(0);
+  const sessionRequestRef = useRef(null);
+  const activeIntentIdRef = useRef(core.activeIntentId);
+  activeIntentIdRef.current = core.activeIntentId;
+  const activeVerificationIdRef = useRef(core.activeVerificationId);
+  activeVerificationIdRef.current = core.activeVerificationId;
+  const activeVerificationRecord = useMemo(
+    () => core.activeVerificationId ? core.pending.find((record) => record.transaction_id === core.activeVerificationId) ?? null : null,
+    [core.activeVerificationId, core.pending]
+  );
+  const activeVerificationRecordRef = useRef(activeVerificationRecord);
+  activeVerificationRecordRef.current = activeVerificationRecord;
+  const pendingRef = useRef(core.pending);
+  pendingRef.current = core.pending;
+  const coreStatusRef = 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 = useMemo(() => Symbol(scopeIdentity), [scopeIdentity]);
+  const scopeSessionRef = useRef(scopeSession);
+  scopeSessionRef.current = scopeSession;
+  const setSession = useCallback((next, nextScope) => {
+    sessionRef.current = next;
+    mountedSessionScopeRef.current = nextScope;
+    setSessionState(next);
+  }, []);
+  const updateSessionRecreation = 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 = useCallback(
+    (intentId, generation) => executePrivateRead(
+      (readClient) => requestTransakWidgetSession({
+        client: readClient,
+        intentId,
+        generation
+      })
+    ),
+    [executePrivateRead]
+  );
+  const launch = 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 = 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 = useCallback(async () => {
+    generationRef.current++;
+    const shouldReconcile = Boolean(sessionRef.current || activeIntentIdRef.current);
+    setSession(null, null);
+    setIsLaunching(false);
+    if (shouldReconcile) await handleProviderClosed();
+  }, [handleProviderClosed, setSession]);
+  const getCurrentGeneration = useCallback(() => generationRef.current, []);
+  const handleFrameReady = useCallback(
+    (generation) => {
+      const current = sessionRef.current;
+      if (!current || current.generation !== generation || generationRef.current !== generation)
+        return;
+      updateSessionRecreation("provider-ui-activated");
+      handleProviderLaunchReady();
+    },
+    [handleProviderLaunchReady, updateSessionRecreation]
+  );
+  const handleFrameExpired = 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 = 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
+    ]
+  );
+  useEffect(() => {
+    const current = sessionRef.current;
+    if (!current || core.activeIntentId === current.intentId) return;
+    generationRef.current++;
+    setSession(null, null);
+  }, [core.activeIntentId, setSession]);
+  useEffect(() => {
+    if (!core.activeIntentId) {
+      updateSessionRecreation("reset");
+      return;
+    }
+    if (hasProviderEvidence) {
+      updateSessionRecreation("provider-evidence");
+    }
+  }, [core.activeIntentId, hasProviderEvidence, updateSessionRecreation]);
+  useEffect(() => {
+    generationRef.current++;
+    setSession(null, null);
+    setIsLaunching(false);
+    updateSessionRecreation("reset");
+  }, [scopeSession, setSession, updateSessionRecreation]);
+  useEffect(
+    () => () => {
+      generationRef.current++;
+      sessionRef.current = null;
+      mountedSessionScopeRef.current = null;
+    },
+    []
+  );
+  const scopedSession = mountedSessionScopeRef.current === scopeSession ? session : null;
+  const widget = useMemo(
+    () => scopedSession ? /* @__PURE__ */ 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
+  };
+}
+
+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, canRetryOnRampVerification, canUseBrowserStorage, canUseSharedBrowserStorage, clampLockAmount, clearHostedAuthPendingTransaction, clearPendingLock, cn, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, createProductOnRampFlowSnapshot, createProductOnRampOutcomeCallbacks, createSignedLockRequest, formatCountdown, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getBlockNumber, getBrowserStorageItem, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, getSharedBrowserStorageItem, getTransactionReceipt, getTransakMinimumTargetBaseUnits, getWalletClient3 as getWalletClient, isHostedAuthRefreshActive, isHostedAuthSessionActive, isMoonPayProductOnRamp, isSignedLockUsable, loadPendingLock, matchesFrozenOnRampToken, matchesOnRampTransaction, matchesProductOnRampScope, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, removeBrowserStorageItem, removeSharedBrowserStorageItem, requireDepositLockOwner, requireServiceAddress, resolveProductOnRamp, savePendingLock, setBrowserStorageItem, setSharedBrowserStorageItem, shortenAddress, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, submitPendingLock, syncHostedAuthSessionToClient, useDepositVerification, useEnsureCorrectChain, useFiatOnRamp, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, useTransakOnRamp, waitForTransactionReceipt };
+//# sourceMappingURL=chunk-RDYNQUMV.js.map
+//# sourceMappingURL=chunk-RDYNQUMV.js.map