@oasisprotocol/privana-sdk 0.4.4 → 0.5.0

package/dist/{chunk-WV6CGHEF.js → chunk-54FC6TO3.js}

@@ -1,16 +1,18 @@
 "use client";
 import { createContext, useContext, useRef, useCallback, useSyncExternalStore, useState, useEffect, useMemo } from 'react';
-import { WagmiContext } from 'wagmi';
+import { WagmiContext, useConfig, useAccount } from 'wagmi';
 import { watchAccount, getAccount, getWalletClient } from 'wagmi/actions';
 import { createSiweMessage } from 'viem/siwe';
-import { jsx } from 'react/jsx-runtime';
-import { zeroAddress, hexToString } from 'viem';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { parseAbiItem, zeroAddress, hexToString, parseUnits, decodeEventLog, formatUnits } from 'viem';
 import { useQueryClient } from '@tanstack/react-query';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 import { getTransactionReceipt as getTransactionReceipt$1, waitForTransactionReceipt as waitForTransactionReceipt$1, getTransaction, call } from 'viem/actions';
+import { Loader2, CircleCheckIcon } from 'lucide-react';
+import { MoonPayBuyWidget } from '@moonpay/moonpay-react';
 
 // ../../shared/config.json
 var config_default = {
@@ -18,12 +20,14 @@ var config_default = {
     {
       id: 84532,
       name: "Base Sepolia",
-      explorerUrl: "https://sepolia.basescan.org"
+      explorerUrl: "https://sepolia.basescan.org",
+      explorerName: "BaseScan"
     },
     {
       id: 11155111,
       name: "Ethereum Sepolia",
-      explorerUrl: "https://sepolia.etherscan.io"
+      explorerUrl: "https://sepolia.etherscan.io",
+      explorerName: "Etherscan"
     }
   ],
   networks: {
@@ -74,11 +78,16 @@ function normalizeAddress(value) {
 var SUPPORTED_CHAINS = config_default.chains.map((chain) => ({
   id: chain.id,
   name: chain.name,
-  explorerUrl: chain.explorerUrl
+  explorerUrl: chain.explorerUrl,
+  explorerName: chain.explorerName
 }));
 function getChainById(chainId) {
   return SUPPORTED_CHAINS.find((c) => c.id === chainId);
 }
+function getExplorerLabel(chainId) {
+  const chain = getChainById(chainId);
+  return `View on ${chain?.explorerName ?? "Explorer"}`;
+}
 function getExplorerAddressUrl(chainId, address) {
   const chain = getChainById(chainId);
   if (!chain) return void 0;
@@ -841,6 +850,15 @@ function useSiweAuth() {
   if (!ctx) throw new Error("useSiweAuth must be used within SiweAuthProvider");
   return ctx;
 }
+
+// src/sdk/moonpay-currency-codes.ts
+var MOONPAY_CURRENCY_CODE_BY_TOKEN_ID = {
+  // Sandbox MPT test token (Ethereum Sepolia).
+  "0xbd3a41ffd21be1cfcdca7a4e7755842a5b78c9443fb7ea008e6a7314f0caea87": "usdc"
+};
+function resolveMoonpayCurrencyCode(tokenId) {
+  return MOONPAY_CURRENCY_CODE_BY_TOKEN_ID[tokenId.toLowerCase()];
+}
 var PrivanaContext = createContext(null);
 function readStoredHostedAuthSession(storage, hostedAuthStorageKey, now = Date.now()) {
   const raw = storage.getItem(hostedAuthStorageKey);
@@ -881,6 +899,8 @@ function PrivanaProvider({
   chains,
   pollingInterval = 1e4,
   serviceAddress,
+  serviceName,
+  serviceIcon,
   hostedAuth,
   siweAuth
 }) {
@@ -932,7 +952,8 @@ function PrivanaProvider({
           decimals: t.decimals,
           contract: t.token_address ?? zeroAddress,
           name: t.name,
-          chainId: t.chain_id
+          chainId: t.chain_id,
+          moonpayCurrencyCode: resolveMoonpayCurrencyCode(t.token_id)
         }))
       );
       setTokensStatus("ready");
@@ -1099,6 +1120,8 @@ function PrivanaProvider({
       tokensError,
       pollingInterval,
       serviceAddress,
+      serviceName,
+      serviceIcon,
       hostedAuthConfig,
       hostedAuthSession,
       setHostedAuthSession,
@@ -1116,6 +1139,8 @@ function PrivanaProvider({
       tokensError,
       pollingInterval,
       serviceAddress,
+      serviceName,
+      serviceIcon,
       hostedAuthConfig,
       hostedAuthSession,
       setHostedAuthSession,
@@ -1658,7 +1683,7 @@ function Skeleton({ className, ...props }) {
     "div",
     {
       "data-slot": "skeleton",
-      className: cn("bg-accent animate-pulse rounded-md", className),
+      className: cn("bg-secondary animate-pulse rounded-md", className),
       ...props
     }
   );
@@ -1675,7 +1700,10 @@ function getAction(client, actionFn, name) {
   return (params) => actionFn(client, params);
 }
 
-// ../../node_modules/@wagmi/core/dist/esm/actions/getTransactionReceipt.js
+// ../../node_modules/@wagmi/core/dist/esm/actions/getChainId.js
+function getChainId2(config) {
+  return config.state.chainId;
+}
 async function getTransactionReceipt(config, parameters) {
   const { chainId, ...rest } = parameters;
   const client = config.getClient({ chainId });
@@ -1709,12 +1737,1102 @@ async function waitForTransactionReceipt(config, parameters) {
     chainId: client.chain.id
   };
 }
-
-// ../../node_modules/@wagmi/core/dist/esm/actions/getChainId.js
-function getChainId2(config) {
-  return config.state.chainId;
+var DEFAULT_DELIVERY_TIMEOUT_MS = 12e4;
+var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
+var DEFAULT_FINALITY_RETRY_INTERVAL_MS = 15e3;
+var ERC20_TRANSFER_EVENT = parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+);
+function useFiatOnRamp(options) {
+  const { tokenId, onCredited, onError, onDebugEvent } = options;
+  const deliveryTimeout = options.deliveryTimeout ?? DEFAULT_DELIVERY_TIMEOUT_MS;
+  const deliveryPollInterval = options.deliveryPollInterval ?? 3e3;
+  const verificationTimeout = options.verificationTimeout ?? DEFAULT_VERIFICATION_TIMEOUT_MS;
+  const finalityRetryInterval = options.finalityRetryInterval ?? DEFAULT_FINALITY_RETRY_INTERVAL_MS;
+  const { client, enabledTokens } = usePrivanaContext();
+  const { executePrivateRead, privateReadReady } = usePrivateReadRequest();
+  const wagmiConfig = useConfig();
+  const selectedToken = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+  const [status, setStatus] = useState("idle");
+  const [pending, setPending] = useState([]);
+  const [error, setError] = useState(null);
+  const [depositAddress, setDepositAddress] = useState();
+  const [minDepositBaseUnits, setMinDepositBaseUnits] = useState();
+  const [activeIntentId, setActiveIntentId] = useState(null);
+  const [activeVerificationId, setActiveVerificationId] = useState(null);
+  const [finalityProgress, setFinalityProgress] = useState({});
+  const onCreditedRef = useRef(onCredited);
+  const onErrorRef = useRef(onError);
+  const onDebugEventRef = useRef(onDebugEvent);
+  const statusRef = useRef(status);
+  const activeIntentIdRef = useRef(null);
+  const activeVerificationRecordRef = useRef(null);
+  const activeVerificationKeyRef = useRef(null);
+  const triggeredVerificationKeysRef = useRef(/* @__PURE__ */ new Set());
+  const closeReconcilePromiseRef = useRef(null);
+  const purchaseInitiatedRef = useRef(false);
+  useEffect(() => {
+    onCreditedRef.current = onCredited;
+    onErrorRef.current = onError;
+    onDebugEventRef.current = onDebugEvent;
+  }, [onCredited, onError, onDebugEvent]);
+  useEffect(() => {
+    statusRef.current = status;
+  }, [status]);
+  useEffect(() => {
+    activeIntentIdRef.current = activeIntentId;
+  }, [activeIntentId]);
+  useEffect(() => {
+    activeIntentIdRef.current = null;
+    setActiveIntentId(null);
+  }, [tokenId]);
+  const emitDebug = useCallback(
+    (event, payload) => {
+      onDebugEventRef.current?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status: statusRef.current,
+        tokenId,
+        payload
+      });
+    },
+    [tokenId]
+  );
+  useEffect(() => {
+    emitDebug("private-read-state", { privateReadReady });
+  }, [emitDebug, privateReadReady]);
+  useEffect(() => {
+    if (!privateReadReady) {
+      emitDebug("deposit-address:skip", { reason: "private-read-not-ready" });
+      setDepositAddress(void 0);
+      setMinDepositBaseUnits(void 0);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        emitDebug("deposit-address:request");
+        const resp = await executePrivateRead(() => client.getDepositAddress());
+        if (cancelled) return;
+        setDepositAddress(resp.deposit_address);
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+        const mins = token ? resp.min_deposit?.[String(token.chainId)] : void 0;
+        if (mins?.erc20) setMinDepositBaseUnits(BigInt(mins.erc20));
+        emitDebug("deposit-address:success", {
+          depositAddress: resp.deposit_address,
+          selectedToken: token ? summariseToken(token) : null,
+          minDepositBaseUnits: mins?.erc20 ?? null
+        });
+      } catch (err) {
+        if (!cancelled) {
+          emitDebug("deposit-address:error", errorPayload(err));
+          console.warn("Failed to fetch Privana deposit address:", err);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, emitDebug, enabledTokens, executePrivateRead, privateReadReady, tokenId]);
+  const refreshPending = useCallback(async () => {
+    if (!privateReadReady) {
+      emitDebug("pending:skip", { reason: "private-read-not-ready" });
+      setPending([]);
+      return;
+    }
+    try {
+      emitDebug("pending:request");
+      const { pending: rows } = await executePrivateRead(() => client.getPendingOnRamps());
+      setPending(rows);
+      emitDebug("pending:success", {
+        count: rows.length,
+        rows: rows.map(summariseOnRampRecord)
+      });
+    } catch (err) {
+      emitDebug("pending:error", errorPayload(err));
+      console.warn("Failed to load pending on-ramps:", err);
+    }
+  }, [client, emitDebug, executePrivateRead, privateReadReady]);
+  useEffect(() => {
+    refreshPending();
+  }, [refreshPending]);
+  const clearActiveVerification = useCallback(() => {
+    const key = activeVerificationKeyRef.current;
+    if (key) triggeredVerificationKeysRef.current.delete(key);
+    activeVerificationKeyRef.current = null;
+    activeVerificationRecordRef.current = null;
+    setActiveVerificationId(null);
+  }, []);
+  const { verify } = useDepositVerification({
+    pollTimeout: verificationTimeout,
+    pollInterval: options.verificationPollInterval,
+    finalityRetryInterval,
+    onCheckRetry: (message) => {
+      const record = activeVerificationRecordRef.current;
+      if (!record) return;
+      emitDebug("verification:check-retry", {
+        message,
+        record: summariseOnRampRecord(record)
+      });
+      setFinalityProgress((prev) => ({ ...prev, [record.transaction_id]: message }));
+    },
+    onCredited: (depositTxHash) => {
+      const record = activeVerificationRecordRef.current;
+      emitDebug("verification:credited", {
+        depositTxHash,
+        record: record ? summariseOnRampRecord(record) : null
+      });
+      if (record && activeIntentIdRef.current === record.transaction_id) {
+        setStatus("credited");
+      }
+      if (record) {
+        setFinalityProgress((prev) => {
+          if (!(record.transaction_id in prev)) return prev;
+          const next = { ...prev };
+          delete next[record.transaction_id];
+          return next;
+        });
+      }
+      void (async () => {
+        try {
+          if (record && depositTxHash.startsWith("0x")) {
+            emitDebug("onramp:mark-deposit-triggered-request", {
+              transactionId: record.transaction_id,
+              depositTxHash
+            });
+            const updated = await executePrivateRead(
+              () => client.updateOnRamp(record.transaction_id, {
+                deposit_tx_hash: depositTxHash
+              })
+            );
+            emitDebug("onramp:mark-deposit-triggered-success", {
+              record: summariseOnRampRecord(updated)
+            });
+          }
+        } catch (err) {
+          emitDebug("onramp:mark-deposit-triggered-error", errorPayload(err));
+          console.warn("Failed to mark on-ramp row complete:", err);
+        } finally {
+          await refreshPending();
+          clearActiveVerification();
+          if (record && activeIntentIdRef.current === record.transaction_id) {
+            activeIntentIdRef.current = null;
+            setActiveIntentId(null);
+          }
+        }
+      })();
+      onCreditedRef.current?.(depositTxHash);
+    },
+    onCheckTimeout: (depositTxHash) => {
+      const record = activeVerificationRecordRef.current;
+      const err = new Error(
+        "Privana verification is still pending. Retry from the pending on-ramp list if it does not complete."
+      );
+      emitDebug("verification:timeout", { depositTxHash, message: err.message });
+      clearActiveVerification();
+      if (!record || activeIntentIdRef.current === record.transaction_id) {
+        setStatus("failed");
+        setError(err);
+      }
+      void refreshPending();
+      onErrorRef.current?.(err);
+    },
+    onError: (err) => {
+      const record = activeVerificationRecordRef.current;
+      emitDebug("verification:error", errorPayload(err));
+      clearActiveVerification();
+      if (!record || activeIntentIdRef.current === record.transaction_id) {
+        setStatus("failed");
+        setError(err);
+      }
+      onErrorRef.current?.(err);
+    }
+  });
+  const prepareOnRampIntent = useCallback(
+    async ({
+      currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount
+    }) => {
+      try {
+        setError(null);
+        purchaseInitiatedRef.current = false;
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+        if (!token) throw new Error(`Unknown token: ${tokenId}`);
+        if (!depositAddress) throw new Error("Privana deposit address is not ready");
+        emitDebug("intent:create-request", {
+          tokenId,
+          chainId: token.chainId,
+          currencyCode,
+          baseCurrencyCode: baseCurrencyCode ?? null,
+          baseCurrencyAmount: baseCurrencyAmount ?? null,
+          depositAddress
+        });
+        const record = await executePrivateRead(
+          () => client.createOnRampIntent({
+            wallet_address: depositAddress,
+            token_id: tokenId,
+            chain_id: token.chainId,
+            moonpay_currency_code: currencyCode,
+            base_currency_code: baseCurrencyCode,
+            base_currency_amount: baseCurrencyAmount
+          })
+        );
+        activeIntentIdRef.current = record.transaction_id;
+        setActiveIntentId(record.transaction_id);
+        emitDebug("intent:create-success", {
+          record: summariseOnRampRecord(record)
+        });
+        return record;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Failed to create on-ramp intent");
+        setStatus("failed");
+        setError(e);
+        emitDebug("intent:create-error", errorPayload(e));
+        onErrorRef.current?.(e);
+        throw e;
+      }
+    },
+    [client, depositAddress, emitDebug, enabledTokens, executePrivateRead, tokenId]
+  );
+  const registerOnRampTokenMapping = useCallback(
+    async (moonpayTransactionId) => {
+      const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+      if (!token) {
+        emitDebug("register-token-mapping:skip", {
+          moonpayTransactionId,
+          reason: "selected-token-not-found"
+        });
+        return;
+      }
+      const transactionId = activeIntentIdRef.current ?? moonpayTransactionId;
+      try {
+        emitDebug("register-token-mapping:request", {
+          transactionId,
+          moonpayTransactionId,
+          tokenId,
+          chainId: token.chainId
+        });
+        const record = await executePrivateRead(
+          () => client.updateOnRamp(transactionId, {
+            token_id: tokenId,
+            chain_id: token.chainId,
+            moonpay_transaction_id: transactionId === moonpayTransactionId ? void 0 : moonpayTransactionId
+          })
+        );
+        emitDebug("register-token-mapping:success", {
+          transactionId,
+          moonpayTransactionId,
+          record: summariseOnRampRecord(record)
+        });
+      } catch (err) {
+        emitDebug("register-token-mapping:error", {
+          transactionId,
+          moonpayTransactionId,
+          ...errorPayload(err)
+        });
+        console.warn("Failed to register on-ramp token mapping:", err);
+      }
+    },
+    [client, emitDebug, enabledTokens, executePrivateRead, tokenId]
+  );
+  const handleTransactionCreated = useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCreated", summariseMoonPayEventProps(props));
+      purchaseInitiatedRef.current = true;
+      await registerOnRampTokenMapping(props.id);
+    },
+    [emitDebug, registerOnRampTokenMapping]
+  );
+  const signUrl = useCallback(
+    async (url) => {
+      setError(null);
+      try {
+        emitDebug("moonpay:onUrlSignatureRequested", summariseMoonPayUrl(url));
+        const { signature } = await executePrivateRead(() => client.signOnRampUrl({ url }));
+        setStatus("awaiting-purchase");
+        emitDebug("sign-url:success", {
+          signatureLength: signature.length
+        });
+        return signature;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Failed to sign on-ramp URL");
+        setStatus("failed");
+        setError(e);
+        emitDebug("sign-url:error", errorPayload(e));
+        onErrorRef.current?.(e);
+        throw err;
+      }
+    },
+    [client, emitDebug, executePrivateRead]
+  );
+  const waitForOnChainHash = useCallback(
+    async (transactionId) => {
+      const startTime = Date.now();
+      emitDebug("delivery-poll:start", {
+        transactionId,
+        deliveryTimeout,
+        deliveryPollInterval
+      });
+      while (Date.now() - startTime < deliveryTimeout) {
+        try {
+          const { pending: rows } = await executePrivateRead(() => client.getPendingOnRamps());
+          setPending(rows);
+          const record = rows.find((r) => matchesOnRampTransaction(r, transactionId));
+          emitDebug("delivery-poll:tick", {
+            transactionId,
+            count: rows.length,
+            matchingRecord: record ? summariseOnRampRecord(record) : null
+          });
+          if (record?.on_chain_tx_hash && record.quote_currency_amount) {
+            emitDebug("delivery-poll:success", {
+              transactionId,
+              record: summariseOnRampRecord(record)
+            });
+            return record;
+          }
+        } catch (err) {
+          emitDebug("delivery-poll:error", {
+            transactionId,
+            ...errorPayload(err)
+          });
+          console.warn("Polling pending on-ramps failed:", err);
+        }
+        await new Promise((r) => setTimeout(r, deliveryPollInterval));
+      }
+      emitDebug("delivery-poll:timeout", { transactionId });
+      return null;
+    },
+    [client, deliveryPollInterval, deliveryTimeout, emitDebug, executePrivateRead]
+  );
+  const triggerVerification = useCallback(
+    async (record) => {
+      const verificationKey = getOnRampVerificationKey(record);
+      if (triggeredVerificationKeysRef.current.has(verificationKey)) {
+        emitDebug("verification:skip-duplicate", {
+          verificationKey,
+          record: summariseOnRampRecord(record)
+        });
+        return;
+      }
+      triggeredVerificationKeysRef.current.add(verificationKey);
+      activeVerificationKeyRef.current = verificationKey;
+      activeVerificationRecordRef.current = record;
+      setActiveVerificationId(record.transaction_id);
+      setFinalityProgress((prev) => {
+        if (!(record.transaction_id in prev)) return prev;
+        const next = { ...prev };
+        delete next[record.transaction_id];
+        return next;
+      });
+      emitDebug("verification:start", {
+        verificationKey,
+        record: summariseOnRampRecord(record)
+      });
+      try {
+        if (!record.on_chain_tx_hash || !record.quote_currency_amount) {
+          throw new Error("On-ramp record missing on-chain tx hash or delivered amount");
+        }
+        if (record.chain_id === void 0 || !record.wallet_address) {
+          throw new Error("On-ramp record missing chain id or wallet address");
+        }
+        const recordTokenId = record.token_id;
+        if (!recordTokenId) {
+          throw new Error("On-ramp record missing token id");
+        }
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === recordTokenId.toLowerCase());
+        if (!token) throw new Error(`Unknown token: ${recordTokenId}`);
+        if (token.chainId !== record.chain_id) {
+          throw new Error(
+            `Token ${recordTokenId} is on chain ${token.chainId} but record is on chain ${record.chain_id}`
+          );
+        }
+        const amount = await resolveDeliveredAmount({
+          onChainTxHash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          walletAddress: record.wallet_address,
+          token,
+          fallbackAmount: record.quote_currency_amount,
+          wagmiConfig,
+          emitDebug
+        });
+        if (minDepositBaseUnits !== void 0 && amount < minDepositBaseUnits) {
+          emitDebug("verification:below-minimum", {
+            quoteCurrencyAmount: record.quote_currency_amount,
+            minDepositBaseUnits: String(minDepositBaseUnits)
+          });
+          throw new Error(
+            `Delivered amount (${record.quote_currency_amount}) is below the minimum deposit.`
+          );
+        }
+        if (activeIntentIdRef.current === record.transaction_id) {
+          setStatus("verifying");
+        }
+        emitDebug("verification:check-deposit-request", {
+          hash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          amount: amount.toString()
+        });
+        await verify({
+          hash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          amount
+        });
+      } catch (err) {
+        triggeredVerificationKeysRef.current.delete(verificationKey);
+        if (activeVerificationKeyRef.current === verificationKey) {
+          activeVerificationKeyRef.current = null;
+          activeVerificationRecordRef.current = null;
+          setActiveVerificationId(null);
+        }
+        throw err;
+      }
+    },
+    [emitDebug, enabledTokens, minDepositBaseUnits, verify, wagmiConfig]
+  );
+  const handleTransactionCompleted = useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCompleted", summariseMoonPayEventProps(props));
+      try {
+        setStatus("awaiting-delivery");
+        await registerOnRampTokenMapping(props.id);
+        const transactionId = activeIntentIdRef.current ?? props.id;
+        const record = await waitForOnChainHash(transactionId);
+        if (!record) {
+          const err = new Error(
+            "Backend has not yet confirmed delivery. You can finish from the pending list."
+          );
+          emitDebug("moonpay:completed-without-backend-row", {
+            transactionId,
+            moonpayTransactionId: props.id,
+            message: err.message
+          });
+          setStatus("failed");
+          setError(err);
+          onErrorRef.current?.(err);
+          return;
+        }
+        await triggerVerification(record);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Verification failed");
+        emitDebug("moonpay:onTransactionCompleted-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+      }
+    },
+    [emitDebug, registerOnRampTokenMapping, triggerVerification, waitForOnChainHash]
+  );
+  const handleWidgetClosed = useCallback(async () => {
+    if (closeReconcilePromiseRef.current) return closeReconcilePromiseRef.current;
+    closeReconcilePromiseRef.current = (async () => {
+      const previousStatus = statusRef.current;
+      const transactionId = activeIntentIdRef.current;
+      emitDebug("moonpay:widget-closed-reconcile", {
+        previousStatus,
+        transactionId
+      });
+      if (!transactionId) {
+        await refreshPending();
+        return;
+      }
+      if (!purchaseInitiatedRef.current) {
+        emitDebug("moonpay:widget-closed-without-purchase", {
+          previousStatus,
+          transactionId
+        });
+        await refreshPending();
+        if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          setStatus("idle");
+        }
+        return;
+      }
+      try {
+        setStatus("awaiting-delivery");
+        const record = await waitForOnChainHash(transactionId);
+        if (record) {
+          await triggerVerification(record);
+          return;
+        }
+        await refreshPending();
+        if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          setStatus("idle");
+        }
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("On-ramp reconciliation failed");
+        emitDebug("moonpay:widget-closed-reconcile-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+      }
+    })();
+    try {
+      await closeReconcilePromiseRef.current;
+    } finally {
+      closeReconcilePromiseRef.current = null;
+    }
+  }, [emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
+  const finishPendingVerification = useCallback(
+    async (record) => {
+      try {
+        emitDebug("pending:finish-verification", {
+          record: summariseOnRampRecord(record)
+        });
+        await triggerVerification(record);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Verification failed");
+        emitDebug("pending:finish-verification-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+        throw e;
+      }
+    },
+    [emitDebug, triggerVerification]
+  );
+  const triggerVerificationRef = useRef(triggerVerification);
+  useEffect(() => {
+    triggerVerificationRef.current = triggerVerification;
+  }, [triggerVerification]);
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      for (const record of pending) {
+        if (cancelled) break;
+        if (!record.on_chain_tx_hash || !record.quote_currency_amount) continue;
+        const key = getOnRampVerificationKey(record);
+        if (triggeredVerificationKeysRef.current.has(key)) continue;
+        try {
+          await triggerVerificationRef.current(record);
+        } catch {
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [pending]);
+  return {
+    status,
+    activeIntentId,
+    pending,
+    activeVerificationId,
+    error,
+    finalityProgress,
+    depositAddress,
+    minDepositBaseUnits,
+    selectedToken,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    finishPendingVerification,
+    handleWidgetClosed,
+    refreshPending
+  };
+}
+function summariseToken(token) {
+  return {
+    tokenId: token.id,
+    chainId: token.chainId,
+    symbol: token.symbol ?? null,
+    decimals: token.decimals ?? null
+  };
+}
+function summariseOnRampRecord(record) {
+  return {
+    transaction_id: record.transaction_id,
+    external_transaction_id: record.external_transaction_id ?? null,
+    moonpay_transaction_id: record.moonpay_transaction_id ?? null,
+    status: record.status,
+    wallet_address: record.wallet_address,
+    token_id: record.token_id,
+    chain_id: record.chain_id,
+    moonpay_currency_code: record.moonpay_currency_code ?? null,
+    quote_currency_amount: record.quote_currency_amount ?? null,
+    on_chain_tx_hash: record.on_chain_tx_hash ?? null,
+    deposit_tx_hash: record.deposit_tx_hash ?? null,
+    deposit_triggered_at: record.deposit_triggered_at ?? null,
+    credited_at: record.credited_at ?? null
+  };
+}
+async function resolveDeliveredAmount({
+  onChainTxHash,
+  chainId,
+  walletAddress,
+  token,
+  fallbackAmount,
+  wagmiConfig,
+  emitDebug
+}) {
+  if (token.contract === zeroAddress) {
+    return parseUnits(fallbackAmount, token.decimals);
+  }
+  let receiptError;
+  try {
+    const receipt = await waitForTransactionReceipt(wagmiConfig, {
+      hash: onChainTxHash,
+      chainId,
+      timeout: 6e4,
+      pollingInterval: 4e3
+    });
+    let delivered = 0n;
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== token.contract.toLowerCase()) continue;
+      try {
+        const decoded = decodeEventLog({
+          abi: [ERC20_TRANSFER_EVENT],
+          data: log.data,
+          topics: log.topics
+        });
+        if (decoded.eventName !== "Transfer") continue;
+        const to = decoded.args.to.toLowerCase();
+        if (to !== walletAddress.toLowerCase()) continue;
+        delivered += decoded.args.value;
+      } catch {
+      }
+    }
+    if (delivered > 0n) {
+      emitDebug("verification:amount-from-receipt", {
+        amount: delivered.toString(),
+        tokenAddress: token.contract,
+        walletAddress,
+        moonpayQuoteCurrencyAmount: fallbackAmount
+      });
+      return delivered;
+    }
+    emitDebug("verification:amount-from-receipt-missing", {
+      tokenAddress: token.contract,
+      walletAddress,
+      moonpayQuoteCurrencyAmount: fallbackAmount
+    });
+  } catch (err) {
+    emitDebug("verification:amount-from-receipt-error", errorPayload(err));
+    receiptError = err;
+  }
+  const errorDetail = receiptError instanceof Error ? receiptError.message : receiptError === void 0 ? `no ${token.symbol} Transfer to ${walletAddress} found` : String(receiptError);
+  throw new Error(
+    `Unable to derive delivered ${token.symbol} amount from ${onChainTxHash}: ${errorDetail}`
+  );
+}
+function matchesOnRampTransaction(record, transactionId) {
+  return record.transaction_id === transactionId || record.external_transaction_id === transactionId || record.moonpay_transaction_id === transactionId;
+}
+function getOnRampVerificationKey(record) {
+  return record.on_chain_tx_hash ?? record.transaction_id;
+}
+function summariseMoonPayEventProps(props) {
+  return {
+    id: props.id,
+    externalTransactionId: props.externalTransactionId,
+    status: props.status,
+    walletAddress: props.walletAddress,
+    walletAddressTag: props.walletAddressTag,
+    baseCurrencyAmount: props.baseCurrencyAmount,
+    quoteCurrencyAmount: props.quoteCurrencyAmount,
+    baseCurrency: props.baseCurrency,
+    quoteCurrency: props.quoteCurrency,
+    createdAt: props.createdAt
+  };
+}
+function summariseMoonPayUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const params = parsed.searchParams;
+    return {
+      origin: parsed.origin,
+      pathname: parsed.pathname,
+      apiKeyPrefix: params.get("apiKey")?.slice(0, 8) ?? null,
+      currencyCode: params.get("currencyCode"),
+      baseCurrencyCode: params.get("baseCurrencyCode"),
+      baseCurrencyAmount: params.get("baseCurrencyAmount"),
+      walletAddress: params.get("walletAddress"),
+      externalCustomerId: params.get("externalCustomerId"),
+      externalTransactionId: params.get("externalTransactionId"),
+      redirectURL: params.get("redirectURL"),
+      signaturePresent: params.has("signature")
+    };
+  } catch {
+    return { parseError: true, length: url.length };
+  }
+}
+function errorPayload(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack?.split("\n").slice(0, 4).join("\n")
+    };
+  }
+  return { message: String(err) };
+}
+function useMoonPayBuyWidget({
+  variant,
+  visible,
+  autoStart,
+  canBuy,
+  openWidget,
+  refreshPending,
+  theme,
+  themeId,
+  colorCode,
+  baseCurrencyCode,
+  baseCurrencyAmount,
+  lockAmount,
+  paymentMethod,
+  currencyCode,
+  depositAddress,
+  externalCustomerId,
+  externalTransactionId,
+  onClose,
+  onCloseOverlay,
+  onReady,
+  onUrlSignatureRequested,
+  onTransactionCreated,
+  onTransactionCompleted
+}) {
+  const autoStartedRef = useRef(false);
+  useEffect(() => {
+    if (!autoStart || autoStartedRef.current || !canBuy) return;
+    autoStartedRef.current = true;
+    void openWidget();
+  }, [autoStart, canBuy, openWidget]);
+  useEffect(() => {
+    if (variant !== "embedded" || !visible) return;
+    const id = setInterval(() => void refreshPending(), 5e3);
+    return () => clearInterval(id);
+  }, [variant, visible, refreshPending]);
+  const callbacksRef = useRef({
+    onClose,
+    onCloseOverlay,
+    onReady,
+    onUrlSignatureRequested,
+    onTransactionCreated,
+    onTransactionCompleted
+  });
+  useEffect(() => {
+    callbacksRef.current = {
+      onClose,
+      onCloseOverlay,
+      onReady,
+      onUrlSignatureRequested,
+      onTransactionCreated,
+      onTransactionCompleted
+    };
+  });
+  const overlayNode = useMemo(
+    () => variant === "overlay" ? buildOverlayNode() : void 0,
+    [variant]
+  );
+  return useMemo(() => {
+    if (!visible || !depositAddress || !externalTransactionId) return null;
+    return /* @__PURE__ */ jsx(
+      MoonPayBuyWidget,
+      {
+        variant,
+        visible: true,
+        theme,
+        themeId,
+        colorCode,
+        overlayNode,
+        baseCurrencyCode,
+        baseCurrencyAmount,
+        lockAmount: lockAmount ? "true" : void 0,
+        paymentMethod,
+        currencyCode,
+        walletAddress: depositAddress,
+        externalCustomerId,
+        externalTransactionId,
+        onClose: () => callbacksRef.current.onClose(),
+        onCloseOverlay: () => callbacksRef.current.onCloseOverlay(),
+        onReady: () => callbacksRef.current.onReady(),
+        onUrlSignatureRequested: (url) => callbacksRef.current.onUrlSignatureRequested(url),
+        onTransactionCreated: (props) => callbacksRef.current.onTransactionCreated(props),
+        onTransactionCompleted: (props) => callbacksRef.current.onTransactionCompleted(props)
+      }
+    );
+  }, [
+    visible,
+    depositAddress,
+    externalTransactionId,
+    variant,
+    theme,
+    themeId,
+    colorCode,
+    overlayNode,
+    baseCurrencyCode,
+    baseCurrencyAmount,
+    lockAmount,
+    paymentMethod,
+    currencyCode,
+    externalCustomerId
+  ]);
+}
+function buildOverlayNode() {
+  if (typeof document === "undefined") return void 0;
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "display:flex;flex-direction:column;align-items:center;gap:12px";
+  wrap.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="139" height="20.61" viewBox="0 0 139 20.61"><path d="M15.08,20.61L10.49,20.61L10.49,0.00L17.96,0.00L18.81,0.02L19.62,0.10L20.38,0.22L21.11,0.39L21.79,0.60L22.43,0.87L23.03,1.18L23.58,1.53L24.08,1.92L24.53,2.35L24.93,2.82L25.29,3.33L25.59,3.88L25.84,4.47L26.03,5.09L26.17,5.75L26.25,6.44L26.28,7.17L26.28,7.17L26.28,7.62L26.25,8.33L26.17,9.01L26.03,9.66L25.84,10.27L25.59,10.86L25.29,11.41L24.93,11.93L24.53,12.40L24.08,12.83L23.58,13.23L23.03,13.58L22.43,13.89L21.79,14.15L21.11,14.37L20.38,14.54L19.62,14.66L18.81,14.73L17.96,14.76L17.96,14.76L15.08,14.76L15.08,20.61ZM18.19,3.98L15.08,3.98L15.08,10.78L18.19,10.78L18.53,10.77L18.87,10.73L19.18,10.68L19.48,10.59L19.76,10.49L20.02,10.36L20.27,10.21L20.50,10.04L20.70,9.85L20.89,9.64L21.06,9.42L21.21,9.17L21.34,8.91L21.45,8.63L21.53,8.34L21.59,8.04L21.62,7.72L21.63,7.39L21.63,7.39L21.62,7.05L21.59,6.72L21.53,6.40L21.45,6.10L21.34,5.82L21.21,5.56L21.06,5.31L20.89,5.09L20.70,4.88L20.50,4.69L20.27,4.53L20.02,4.38L19.76,4.26L19.48,4.16L19.18,4.08L18.87,4.02L18.53,3.99L18.19,3.98L18.19,3.98ZM31.76,20.61L27.16,20.61L27.16,0.00L35.20,0.00L36.03,0.02L36.82,0.09L37.58,0.19L38.30,0.34L38.98,0.53L39.62,0.77L40.23,1.05L40.78,1.37L41.28,1.73L41.74,2.13L42.15,2.57L42.51,3.05L42.82,3.58L43.07,4.15L43.26,4.76L43.40,5.42L43.49,6.12L43.52,6.86L43.52,6.86L43.52,7.31L43.49,8.04L43.40,8.73L43.26,9.38L43.07,9.98L42.82,10.54L42.51,11.06L42.51,11.06L42.15,11.53L41.75,11.97L41.30,12.36L40.80,12.72L40.26,13.03L39.68,13.30L39.68,13.30L44.89,20.61L39.57,20.61L35.12,14.06L31.76,14.06L31.76,20.61ZM35.56,3.89L31.76,3.89L31.76,10.44L35.56,10.44L35.89,10.43L36.21,10.40L36.51,10.34L36.79,10.26L37.06,10.16L37.31,10.04L37.55,9.89L37.77,9.73L37.97,9.55L38.15,9.35L38.32,9.13L38.46,8.89L38.59,8.64L38.69,8.37L38.77,8.09L38.82,7.79L38.86,7.49L38.87,7.17L38.86,6.85L38.82,6.54L38.77,6.25L38.69,5.97L38.59,5.70L38.46,5.45L38.32,5.21L38.15,4.99L37.97,4.79L37.77,4.61L37.55,4.44L37.31,4.30L37.06,4.17L36.79,4.07L36.51,3.99L36.21,3.94L35.89,3.90L35.56,3.89L35.56,3.89ZM50.25,20.61L45.66,20.61L45.66,0.17L50.25,0.17L50.25,20.61ZM64.88,20.61L57.41,20.61L51.19,0.17L55.92,0.17L60.71,16.88L61.66,16.88L66.09,0.17L70.68,0.17L64.88,20.61ZM71.44,20.61L66.85,20.61L73.60,0.17L81.02,0.17L88.02,20.61L83.26,20.61L81.61,15.54L73.07,15.54L71.44,20.61ZM74.27,11.73L80.35,11.73L77.80,3.92L76.76,3.92L74.27,11.73ZM92.94,20.61L88.68,20.61L88.68,0.17L96.21,0.17L103.91,16.88L104.30,16.88L104.30,0.17L108.62,0.17L108.62,20.61L101.03,20.61L93.33,3.89L92.94,3.89L92.94,20.61ZM113.87,20.61L109.28,20.61L116.02,0.17L123.44,0.17L130.44,20.61L125.68,20.61L124.03,15.54L115.49,15.54L113.87,20.61ZM116.70,11.73L122.77,11.73L120.22,3.92L119.19,3.92L116.70,11.73Z" fill="#ffffff"/></svg><span>Your secure checkout is loading</span>`;
+  return wrap;
+}
+function FiatOnRampForm({
+  tokenId,
+  currencyCode,
+  baseCurrencyCode = "usd",
+  defaultBaseCurrencyAmount = "100",
+  tokenSymbol,
+  theme,
+  themeId,
+  colorCode,
+  variant = "overlay",
+  autoStart = false,
+  lockAmount,
+  paymentMethod,
+  onCredited,
+  onError,
+  onDebugEvent
+}) {
+  const { address } = useAccount();
+  const [visible, setVisible] = useState(false);
+  const [isPreparing, setIsPreparing] = useState(false);
+  const [rowError, setRowError] = useState(null);
+  const {
+    status,
+    activeIntentId,
+    pending,
+    activeVerificationId,
+    error,
+    finalityProgress,
+    depositAddress,
+    minDepositBaseUnits,
+    selectedToken,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    finishPendingVerification,
+    handleWidgetClosed,
+    refreshPending
+  } = useFiatOnRamp({ tokenId, onCredited, onError, onDebugEvent });
+  const decimals = selectedToken?.decimals;
+  const displaySymbol = tokenSymbol ?? selectedToken?.symbol ?? currencyCode.toUpperCase();
+  const emitFormDebug = useCallback(
+    (event, payload) => {
+      onDebugEvent?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status,
+        tokenId,
+        payload
+      });
+    },
+    [onDebugEvent, status, tokenId]
+  );
+  const minFiatGate = minDepositBaseUnits !== void 0 && decimals !== void 0 ? Number(formatUnits(minDepositBaseUnits, decimals)) * 1.05 : void 0;
+  const isBelowMin = minFiatGate !== void 0 && Number(defaultBaseCurrencyAmount) < minFiatGate;
+  const isBusy = isPreparing || status === "awaiting-purchase";
+  const isInitializing = !!address && !depositAddress;
+  const isPrePurchase = status === "idle" || status === "awaiting-purchase";
+  const isVerifying = status === "awaiting-delivery" || status === "verifying";
+  const blockReasons = useMemo(
+    () => [
+      !address ? "wallet-not-connected" : null,
+      !depositAddress ? "deposit-address-not-loaded" : null,
+      isBusy ? `busy:${isPreparing ? "preparing" : status}` : null,
+      visible ? "widget-open" : null,
+      isBelowMin ? "below-minimum" : null
+    ].filter((reason) => Boolean(reason)),
+    [address, depositAddress, isBelowMin, isBusy, isPreparing, status, visible]
+  );
+  const canBuy = blockReasons.length === 0;
+  const handleOpen = useCallback(async () => {
+    if (!canBuy) {
+      emitFormDebug("form:open-blocked", {
+        reasons: blockReasons,
+        currencyCode,
+        tokenSymbol: displaySymbol,
+        tokenDecimals: decimals ?? null,
+        baseCurrencyCode,
+        defaultBaseCurrencyAmount,
+        depositAddress: depositAddress ?? null,
+        walletAddress: address ?? null,
+        status
+      });
+      return;
+    }
+    setIsPreparing(true);
+    emitFormDebug("form:open-click", {
+      currencyCode,
+      tokenSymbol: displaySymbol,
+      tokenDecimals: decimals ?? null,
+      baseCurrencyCode,
+      defaultBaseCurrencyAmount,
+      depositAddress: depositAddress ?? null,
+      walletConnected: Boolean(address)
+    });
+    try {
+      const intent = await prepareOnRampIntent({
+        currencyCode,
+        baseCurrencyCode,
+        baseCurrencyAmount: defaultBaseCurrencyAmount
+      });
+      emitFormDebug("form:intent-ready", {
+        transactionId: intent.transaction_id,
+        externalTransactionId: intent.external_transaction_id ?? null
+      });
+      setVisible(true);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to prepare MoonPay on-ramp");
+      emitFormDebug("form:intent-error", {
+        name: error2.name,
+        message: error2.message
+      });
+    } finally {
+      setIsPreparing(false);
+    }
+  }, [
+    address,
+    baseCurrencyCode,
+    blockReasons,
+    canBuy,
+    currencyCode,
+    decimals,
+    displaySymbol,
+    defaultBaseCurrencyAmount,
+    depositAddress,
+    emitFormDebug,
+    prepareOnRampIntent,
+    status
+  ]);
+  const handleClose = useCallback(async () => {
+    emitFormDebug("moonpay:onClose");
+    setVisible(false);
+    await handleWidgetClosed();
+  }, [emitFormDebug, handleWidgetClosed]);
+  const handleCloseOverlay = useCallback(async () => {
+    emitFormDebug("moonpay:onCloseOverlay");
+    setVisible(false);
+    await handleWidgetClosed();
+  }, [emitFormDebug, handleWidgetClosed]);
+  const handleReady = useCallback(async () => {
+    emitFormDebug("moonpay:onReady");
+  }, [emitFormDebug]);
+  const widgetElement = useMoonPayBuyWidget({
+    variant,
+    visible,
+    autoStart,
+    canBuy,
+    openWidget: handleOpen,
+    refreshPending,
+    theme,
+    themeId,
+    colorCode,
+    baseCurrencyCode,
+    baseCurrencyAmount: defaultBaseCurrencyAmount,
+    lockAmount,
+    paymentMethod,
+    currencyCode,
+    depositAddress,
+    externalCustomerId: address?.toLowerCase(),
+    externalTransactionId: activeIntentId,
+    onClose: handleClose,
+    onCloseOverlay: handleCloseOverlay,
+    onReady: handleReady,
+    onUrlSignatureRequested: signUrl,
+    onTransactionCreated: handleTransactionCreated,
+    onTransactionCompleted: handleTransactionCompleted
+  });
+  useEffect(() => {
+    if (variant !== "embedded" || !visible) return;
+    if (isVerifying || status === "credited") {
+      setVisible(false);
+      void refreshPending();
+    }
+  }, [variant, visible, isVerifying, status, refreshPending]);
+  return /* @__PURE__ */ jsxs("div", { "data-privana": true, className: "flex flex-col gap-4", children: [
+    pending.length > 0 && /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+      /* @__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;
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "border-border flex flex-col gap-1 rounded-md border p-2",
+            children: [
+              /* @__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"
+                ] }),
+                /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-xs", children: [
+                  record.quote_currency_amount ?? "?",
+                  " ",
+                  displaySymbol
+                ] })
+              ] }),
+              rowError?.id === record.transaction_id && /* @__PURE__ */ jsx("p", { className: "text-destructive text-xs", children: rowError.message }),
+              showRetry && /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: async () => {
+                    setRowError(null);
+                    try {
+                      await finishPendingVerification(record);
+                    } catch (err) {
+                      setRowError({
+                        id: record.transaction_id,
+                        message: err instanceof Error ? err.message : "Verification failed"
+                      });
+                    }
+                  },
+                  children: "Retry"
+                }
+              )
+            ]
+          },
+          record.transaction_id
+        );
+      })
+    ] }),
+    status === "credited" && /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-2 py-8 text-center", children: [
+      /* @__PURE__ */ jsx(CircleCheckIcon, { className: "text-primary size-8", "aria-hidden": true }),
+      /* @__PURE__ */ jsx("p", { className: "text-foreground text-sm font-medium", children: "Purchase credited" }),
+      /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm", children: [
+        "Your ",
+        displaySymbol,
+        " deposit is now available in your balance."
+      ] })
+    ] }),
+    autoStart ? !visible && isPrePurchase && /* @__PURE__ */ jsx(Skeleton, { className: "h-[656px] w-full rounded-md" }) : isInitializing ? /* @__PURE__ */ jsx(Skeleton, { className: "h-9 w-full rounded-md" }) : /* @__PURE__ */ jsxs(Button, { type: "button", onClick: handleOpen, disabled: !canBuy, children: [
+      (isBusy || visible) && /* @__PURE__ */ jsx(Loader2, { className: "animate-spin", "aria-hidden": true }),
+      "Buy"
+    ] }),
+    widgetElement,
+    error && /* @__PURE__ */ jsx("p", { className: "text-destructive text-sm", role: "alert", children: error.message }),
+    isBelowMin && minFiatGate !== void 0 && /* @__PURE__ */ jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
+      "Minimum purchase is ~$",
+      minFiatGate.toFixed(2),
+      "."
+    ] }),
+    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"
+    ] })
+  ] });
+}
+function parseFinalityProgress(message) {
+  if (!message) return null;
+  const match = message.match(/(\d+\/\d+)\s+confirmations/i);
+  return match ? `${match[1]} confirmations` : null;
 }
 
-export { AccountingApiError, Button, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, NETWORK_CONFIG, NetworkError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, ValidationError, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clearHostedAuthPendingTransaction, cn, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createPkceChallenge, createPkceVerifier, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getChainById, getChainId, getChainId2, getExplorerAddressUrl, getTransactionReceipt, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, shortenAddress, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useDepositVerification, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, waitForTransactionReceipt };
-//# sourceMappingURL=chunk-WV6CGHEF.js.map
-//# sourceMappingURL=chunk-WV6CGHEF.js.map
+export { AccountingApiError, Button, FiatOnRampForm, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, NETWORK_CONFIG, NetworkError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, ValidationError, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clearHostedAuthPendingTransaction, cn, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createPkceChallenge, createPkceVerifier, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getChainById, getChainId, getChainId2, getExplorerAddressUrl, getExplorerLabel, getTransactionReceipt, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, shortenAddress, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useDepositVerification, useFiatOnRamp, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, waitForTransactionReceipt };
+//# sourceMappingURL=chunk-54FC6TO3.js.map
+//# sourceMappingURL=chunk-54FC6TO3.js.map