Custom Payment Flow

// Create a new payment
const createPayment = async (orderId) => {
  const callbackUrl = encodeURIComponent('https://yoursite.com/webhook?order_id=' + orderId);
  
  const params = new URLSearchParams({
    callback: callbackUrl,
    apikey: 'YOUR_API_KEY',
    address: 'YOUR_WALLET_ADDRESS',
    post: 0,
    json: 0,
    pending: 1,
    multi_token: 0,
    convert: 1
  });
  
  const response = await fetch(`https://api.blockbee.io/btc/create/?${params}`);
  const data = await response.json();
  return data;
};

// Get ticker information and minimums
const getTickerInfo = async () => {
  const response = await fetch('https://api.blockbee.io/btc/info/?apikey=YOUR_API_KEY');
  const data = await response.json();
  return data;
};

// Convert USD to BTC for ecommerce payments
const convertAmount = async (usdAmount) => {
  const params = new URLSearchParams({
    apikey: 'YOUR_API_KEY',
    value: usdAmount,
    from: 'USD'
  });
  
  const response = await fetch(`https://api.blockbee.io/btc/convert/?${params}`);
  const data = await response.json();
  return data.value_coin; // BTC amount
};

// Get QR code for payment address
const getQRCode = async (address, amount = null) => {
  const params = new URLSearchParams({
    apikey: 'YOUR_API_KEY',
    address: address,
    size: 200
  });
  
  if (amount) {
    params.append('value', amount);
  }
  
  const response = await fetch(`https://api.blockbee.io/btc/qrcode/?${params}`);
  const data = await response.json();
  return data.qr_code; // Base64 image
};

// Display payment information - Exchange Deposits
const displayExchangeDeposit = async (paymentData) => {
  const tickerInfo = await getTickerInfo();
  const qrCode = await getQRCode(paymentData.address_in);
  
  const paymentContainer = document.getElementById('payment-container');
  paymentContainer.innerHTML = `
    <div class="payment-info">
      <h3>Deposit Bitcoin</h3>
      <div class="payment-details">
        <p><strong>Minimum Deposit:</strong> ${tickerInfo.minimum_transaction_coin} BTC</p>
        <p><strong>Send Bitcoin to:</strong></p>
        <div class="address-container">
          <code>${paymentData.address_in}</code>
          <button onclick="copyAddress('${paymentData.address_in}')">Copy</button>
        </div>
        <div class="qr-code">
          <img src="data:image/png;base64,${qrCode}" alt="Payment QR Code" />
        </div>
        <p class="warning">⚠️ Send only amounts above ${tickerInfo.minimum_transaction_coin} BTC</p>
      </div>
      <div class="payment-status">
        <p id="status">⏳ Waiting for deposit...</p>
      </div>
    </div>
  `;
};

// Display payment information - Ecommerce Payment
const displayEcommercePayment = async (paymentData, usdAmount) => {
  const btcAmount = await convertAmount(usdAmount);
  const tickerInfo = await getTickerInfo();
  const minimumAmount = tickerInfo.minimum_transaction_coin;
  
  // Validate minimum amount
  if (btcAmount < minimumAmount) {
    const paymentContainer = document.getElementById('payment-container');
    paymentContainer.innerHTML = `
      <div class="payment-error">
        <h3>❌ Payment Amount Too Low</h3>
        <div class="error-details">
          <p><strong>Your payment amount:</strong> ${btcAmount} BTC</p>
          <p><strong>Minimum required:</strong> ${minimumAmount} BTC</p>
          <p class="warning">⚠️ Payments below the minimum will be lost. Please increase your order amount.</p>
        </div>
      </div>
    `;
    return;
  }
  
  const qrCode = await getQRCode(paymentData.address_in, btcAmount);
  
  const paymentContainer = document.getElementById('payment-container');
  paymentContainer.innerHTML = `
    <div class="payment-info">
      <h3>Complete Your Payment</h3>
      <div class="payment-details">
        <p><strong>Amount:</strong> $${usdAmount} USD (${btcAmount} BTC)</p>
        <p><strong>Send exactly:</strong></p>
        <div class="amount-container">
          <code>${btcAmount} BTC</code>
          <button onclick="copyAmount('${btcAmount}')">Copy Amount</button>
        </div>
        <p><strong>To address:</strong></p>
        <div class="address-container">
          <code>${paymentData.address_in}</code>
          <button onclick="copyAddress('${paymentData.address_in}')">Copy Address</button>
        </div>
        <div class="qr-code">
          <img src="data:image/png;base64,${qrCode}" alt="Payment QR Code" />
          <p><small>QR code includes amount and address</small></p>
        </div>
        <p class="minimum-warning">⚠️ Minimum transaction amount: ${minimumAmount} BTC</p>
      </div>
      <div class="payment-status">
        <p id="status">⏳ Waiting for payment...</p>
      </div>
    </div>
  `;
};

const copyAddress = (address) => {
  navigator.clipboard.writeText(address);
  alert('Address copied to clipboard!');
};

const copyAmount = (amount) => {
  navigator.clipboard.writeText(amount);
  alert('Amount copied to clipboard!');
};

// Express.js webhook handler - handles both GET and POST
app.all('/webhook', express.json(), (req, res) => {
  // Handle both GET (default) and POST (if post=1 was set)
  const webhookData = req.method === 'GET' ? req.query : req.body;
  const { 
    uuid,
    address_in, 
    address_out, 
    txid_in, 
    txid_out, 
    confirmations, 
    value_coin, 
    value_coin_convert,
    value_forwarded_coin,
    value_forwarded_coin_convert,
    fee_coin,
    coin,
    price,
    pending,
    order_id,
    user_id
  } = webhookData;
  
  // Note: order_id and user_id come from custom parameters you added to callback URL
  
  // Check if we've already processed this transaction
  const alreadyProcessed = checkTransactionInDatabase(uuid);
  
  if (!alreadyProcessed) {
    if (pending === 1) {
      // Payment detected but not confirmed
      console.log(`Pending payment for ${order_id || user_id}: ${value_coin} ${coin.toUpperCase()} to ${address_in}`);
      console.log(`UUID: ${uuid}, Price: $${price}`);
      
      // Store transaction in database with UUID
      storeTransaction({
        uuid: uuid,
        address_in: address_in,
        address_out: address_out,
        txid_in: txid_in,
        amount: value_coin,
        coin: coin,
        price: price,
        status: 'pending',
        value_coin_convert: value_coin_convert,
        processed_at: new Date()
      });
      
      // Notify user (WebSocket, email, etc.)
      notifyUser(address_in, 'pending', {
        uuid: uuid,
        amount: value_coin,
        coin: coin,
        usd_value: value_coin_convert ? JSON.parse(value_coin_convert).USD : null
      });
      
    } else if (pending === 0) {
      // Payment confirmed
      console.log(`Confirmed payment for ${order_id || user_id}: ${value_coin} ${coin.toUpperCase()} to ${address_in}`);
      console.log(`UUID: ${uuid}, Forwarded: ${value_forwarded_coin}, Fee: ${fee_coin}`);
      
      // Update database
      updateTransaction(uuid, {
        txid_out: txid_out,
        confirmations: confirmations,
        value_forwarded_coin: value_forwarded_coin,
        value_forwarded_coin_convert: value_forwarded_coin_convert,
        fee_coin: fee_coin,
        status: 'confirmed',
        confirmed_at: new Date()
      });
      
      // Process order, send confirmation email, etc.
      processSuccessfulPayment(uuid, {
        orderId: order_id,
        userId: user_id,
        amount: value_coin,
        forwarded_amount: value_forwarded_coin,
        fee: fee_coin,
        coin: coin,
        confirmations: confirmations
      });
      
      // Notify user
      notifyUser(address_in, 'confirmed', {
        uuid: uuid,
        amount: value_coin,
        forwarded_amount: value_forwarded_coin,
        coin: coin,
        confirmations: confirmations
      });
    }
  } else {
    console.log(`Duplicate webhook received for UUID: ${uuid}`);
  }
  
  // Always respond with *ok* or HTTP 200 to stop retries
  res.status(200).send('*ok*');
});

// Check payment status using logs endpoint
const checkPaymentStatus = async (callbackUrl) => {
  const encodedCallback = encodeURIComponent(callbackUrl);
  const params = new URLSearchParams({
    apikey: 'YOUR_API_KEY',
    callback: encodedCallback
  });
  
  const response = await fetch(`https://api.blockbee.io/btc/logs/?${params}`);
  const data = await response.json();
  
  // Check if API request was successful
  if (data.status !== 'success') {
    console.error('API request failed:', data);
    return { error: 'API request failed' };
  }
  
  if (data.callbacks && data.callbacks.length > 0) {
    const processedTransactions = [];
    
    // Process each transaction
    for (const callback of data.callbacks) {
      // Check if transaction is confirmed (pending = 0 in logs)
      const confirmedLog = callback.logs.find(log => log.pending === 0);
      const isConfirmed = confirmedLog !== undefined;
      
      processedTransactions.push({
        uuid: callback.uuid || `${callback.txid_in}-${callback.value_coin}`, // Use UUID or fallback
        txid: callback.txid_in,
        amount: callback.value_coin,
        confirmations: callback.confirmations,
        status: callback.result,
        isConfirmed: isConfirmed,
        lastUpdate: callback.last_update
      });
    }
    
    return { transactions: processedTransactions };
  }
  
  return { transactions: [] };
};

// Process payments with duplicate prevention
const processPayments = async (callbackUrl) => {
  const result = await checkPaymentStatus(callbackUrl);
  
  if (result.error) {
    console.error('Failed to check payment status:', result.error);
    return;
  }
  
  for (const transaction of result.transactions) {
    // Check if we've already processed this transaction UUID
    const alreadyProcessed = await checkTransactionInDatabase(transaction.uuid);
    
    if (!alreadyProcessed) {
      if (transaction.isConfirmed && transaction.status === 'done') {
        console.log(`New confirmed payment: ${transaction.amount} BTC`);
        
        // Store transaction in database with UUID
        await storeTransaction({
          uuid: transaction.uuid,
          txid: transaction.txid,
          amount: transaction.amount,
          confirmations: transaction.confirmations,
          status: 'confirmed',
          processed_at: new Date()
        });
        
        // Process the payment (fulfill order, send confirmation, etc.)
        await processConfirmedPayment(transaction);
        
      } else if (transaction.status === 'pending') {
        console.log(`New pending payment: ${transaction.amount} BTC`);
        
        // Store as pending transaction
        await storeTransaction({
          uuid: transaction.uuid,
          txid: transaction.txid,
          amount: transaction.amount,
          confirmations: transaction.confirmations,
          status: 'pending',
          processed_at: new Date()
        });
        
        // Notify user of pending payment
        await notifyPendingPayment(transaction);
      }
    }
  }
};

// Helper functions (implement based on your database)
const checkTransactionInDatabase = async (uuid) => {
  // Check if transaction UUID exists in your database
  // Return true if exists, false if new
};

const storeTransaction = async (transactionData) => {
  // Store transaction in your database
  // Include the UUID to prevent duplicate processing
};

const processConfirmedPayment = async (transaction) => {
  // Process confirmed payment (fulfill order, send email, etc.)
};

const notifyPendingPayment = async (transaction) => {
  // Notify user of pending payment
};