@oasisprotocol/privana-sdk 0.3.0 → 0.4.1

package/dist/on-ramp.js

@@ -0,0 +1,955 @@
+"use client";
+import { usePrivanaContext, usePrivateReadRequest, useDepositVerification, waitForTransactionReceipt, Skeleton, Button } from './chunk-ZXFQJ5MG.js';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { parseAbiItem, zeroAddress, parseUnits, decodeEventLog, formatUnits } from 'viem';
+import { useConfig, useAccount } from 'wagmi';
+import { Loader2 } from 'lucide-react';
+import { MoonPayBuyWidget } from '@moonpay/moonpay-react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+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 [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;
+  }, []);
+  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 {
+          clearActiveVerification();
+          if (record && activeIntentIdRef.current === record.transaction_id) {
+            activeIntentIdRef.current = null;
+            setActiveIntentId(null);
+          }
+          void refreshPending();
+        }
+      })();
+      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;
+      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;
+        }
+        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,
+    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 FiatOnRampForm({
+  tokenId,
+  currencyCode,
+  baseCurrencyCode = "usd",
+  defaultBaseCurrencyAmount = "100",
+  tokenSymbol,
+  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,
+    error,
+    finalityProgress,
+    depositAddress,
+    minDepositBaseUnits,
+    selectedToken,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    finishPendingVerification,
+    handleWidgetClosed
+  } = 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 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]);
+  return /* @__PURE__ */ jsxs("div", { "data-privana": true, className: "flex flex-col gap-4", children: [
+    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"
+    ] }),
+    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),
+      "."
+    ] }),
+    pending.length > 0 && /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 rounded-md border p-3", children: [
+      /* @__PURE__ */ jsx("p", { className: "text-sm font-medium", children: "Pending payments" }),
+      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 showRetry = rowError?.id === record.transaction_id || isStalled;
+        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
+        );
+      })
+    ] }),
+    visible && depositAddress && activeIntentId && /* @__PURE__ */ jsx(
+      MoonPayBuyWidget,
+      {
+        variant: "overlay",
+        visible: true,
+        baseCurrencyCode,
+        baseCurrencyAmount: defaultBaseCurrencyAmount,
+        currencyCode,
+        walletAddress: depositAddress,
+        externalCustomerId: address?.toLowerCase(),
+        externalTransactionId: activeIntentId,
+        onClose: handleClose,
+        onCloseOverlay: handleCloseOverlay,
+        onReady: handleReady,
+        onUrlSignatureRequested: signUrl,
+        onTransactionCreated: handleTransactionCreated,
+        onTransactionCompleted: handleTransactionCompleted
+      }
+    )
+  ] });
+}
+function parseFinalityProgress(message) {
+  if (!message) return null;
+  const match = message.match(/(\d+\/\d+)\s+confirmations/i);
+  return match ? `${match[1]} confirmations` : null;
+}
+
+export { FiatOnRampForm, useFiatOnRamp };
+//# sourceMappingURL=on-ramp.js.map
+//# sourceMappingURL=on-ramp.js.map