lightning-auth-and-payment/dist/hooks/use-btcpay-payment.js

Lightning Network authentication and payment processing library for modern web applications

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.useBTCPayPayment = useBTCPayPayment;
const react_1 = require("react");
/**
 * BTCPay payment hook for managing Lightning payments
 */
function useBTCPayPayment() {
    const [paymentState, setPaymentState] = (0, react_1.useState)({ status: 'idle' });
    const [copied, setCopied] = (0, react_1.useState)(false);
    /**
     * Create a Lightning invoice
     */
    const createInvoice = (0, react_1.useCallback)(async (params) => {
        try {
            setPaymentState({ status: 'creating' });
            const response = await fetch('/api/payment/create-invoice', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(params),
            });
            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.error || 'Failed to create invoice');
            }
            const data = await response.json();
            setPaymentState({
                status: 'waiting',
                invoiceId: data.invoiceId,
                btcpayInvoiceId: data.btcpayInvoiceId,
                bolt11: data.bolt11,
                checkoutLink: data.checkoutLink,
                amountSats: data.amountSats,
                description: data.description,
                expiresAt: new Date(data.expiresAt),
            });
            // Start polling for status updates
            console.log('🚀 Starting polling for invoice:', data.invoiceId);
            startStatusPolling(data.invoiceId);
        }
        catch (error) {
            console.error('Error creating invoice:', error);
            setPaymentState({
                status: 'error',
                error: error instanceof Error ? error.message : 'Failed to create invoice',
            });
        }
    }, []);
    /**
     * Check invoice status
     */
    const checkStatus = (0, react_1.useCallback)(async (invoiceId) => {
        try {
            console.log('📡 Checking status for invoice:', invoiceId);
            const response = await fetch(`/api/payment/status?id=${invoiceId}`);
            if (!response.ok) {
                throw new Error('Failed to check status');
            }
            const data = await response.json();
            console.log('📊 Status response:', data);
            setPaymentState(prev => ({
                ...prev,
                status: data.status === 'settled' ? 'settled' :
                    data.status === 'expired' ? 'expired' : 'waiting',
                btcpayStatus: data.btcpayStatus,
            }));
            // Stop polling if payment is settled or expired
            if (data.status === 'settled' || data.status === 'expired') {
                console.log('✅ Payment completed, stopping polling');
                stopStatusPolling();
            }
        }
        catch (error) {
            console.error('❌ Error checking status:', error);
        }
    }, []);
    /**
     * Start polling for status updates
     */
    const [pollingInterval, setPollingInterval] = (0, react_1.useState)(null);
    const startStatusPolling = (0, react_1.useCallback)((invoiceId) => {
        console.log('🔄 Starting payment polling for invoice:', invoiceId);
        // Clear any existing polling
        setPollingInterval(prev => {
            if (prev) {
                clearInterval(prev);
            }
            return null;
        });
        // Start new polling
        const interval = setInterval(() => {
            console.log('🔍 Polling payment status for:', invoiceId);
            checkStatus(invoiceId);
        }, 3000); // Poll every 3 seconds
        setPollingInterval(interval);
    }, [checkStatus]);
    const stopStatusPolling = (0, react_1.useCallback)(() => {
        setPollingInterval(prev => {
            if (prev) {
                clearInterval(prev);
            }
            return null;
        });
    }, []);
    /**
     * Copy BOLT11 to clipboard
     */
    const copyBolt11 = (0, react_1.useCallback)(async () => {
        if (paymentState.bolt11) {
            try {
                await navigator.clipboard.writeText(paymentState.bolt11);
                setCopied(true);
                setTimeout(() => setCopied(false), 2000);
            }
            catch (error) {
                console.error('Failed to copy BOLT11:', error);
            }
        }
    }, [paymentState.bolt11]);
    /**
     * Calculate time left until expiration
     */
    const timeLeft = (0, react_1.useMemo)(() => {
        if (!paymentState.expiresAt || paymentState.status !== 'waiting') {
            return 0;
        }
        const now = Date.now();
        const expires = paymentState.expiresAt.getTime();
        const remaining = Math.max(0, Math.floor((expires - now) / 1000));
        return remaining;
    }, [paymentState.expiresAt, paymentState.status]);
    /**
     * Reset payment state
     */
    const resetPayment = (0, react_1.useCallback)(() => {
        stopStatusPolling();
        setPaymentState({ status: 'idle' });
        setCopied(false);
    }, []);
    /**
     * Cleanup on unmount
     */
    (0, react_1.useEffect)(() => {
        return () => {
            stopStatusPolling();
        };
    }, [stopStatusPolling]);
    return {
        // State
        paymentState,
        copied,
        timeLeft,
        // Actions
        createInvoice,
        checkStatus,
        copyBolt11,
        resetPayment,
        // Status helpers
        isCreating: paymentState.status === 'creating',
        isWaiting: paymentState.status === 'waiting',
        isSettled: paymentState.status === 'settled',
        isExpired: paymentState.status === 'expired',
        hasError: paymentState.status === 'error',
    };
}
//# sourceMappingURL=use-btcpay-payment.js.map