Cryptocurrency Payment Integration: Bitcoin, Ethereum, Stablecoins

// Coinbase Commerce Integration
const https = require('https');

class CoinbaseCommercePayment {
    constructor(apiKey, webhookSecret) {
        this.apiKey = apiKey;
        this.webhookSecret = webhookSecret;
        this.baseUrl = 'https://api.commerce.coinbase.com';
    }
    
    async createCharge(product, amount, currency = 'USD') {
        const chargeData = JSON.stringify({
            name: product.name,
            description: product.description,
            pricing_type: 'fixed_price',
            local_price: {
                amount: amount.toString(),
                currency: currency
            },
            metadata: {
                order_id: product.orderId,
                customer_email: product.customerEmail
            }
        });
        
        const options = {
            hostname: this.baseUrl,
            path: '/charges',
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-CC-Api-Key': this.apiKey,
                'Content-Length': chargeData.length
            }
        };
        
        return new Promise((resolve, reject) => {
            const req = https.request(options, (res) => {
                let data = '';
                res.on('data', chunk => data += chunk);
                res.on('end', () => resolve(JSON.parse(data)));
            });
            
            req.on('error', reject);
            req.write(chargeData);
            req.end();
        });
    }
    
    async getCharge(chargeId) {
        const options = {
            hostname: this.baseUrl,
            path: `/charges/${chargeId}`,
            method: 'GET',
            headers: {
                'X-CC-Api-Key': this.apiKey
            }
        };
        
        return new Promise((resolve, reject) => {
            const req = https.request(options, (res) => {
                let data = '';
                res.on('data', chunk => data += chunk);
                res.on('end', () => resolve(JSON.parse(data)));
            });
            
            req.on('error', reject);
            req.end();
        });
    }
    
    async listCharges() {
        const options = {
            hostname: this.baseUrl,
            path: '/charges',
            method: 'GET',
            headers: {
                'X-CC-Api-Key': this.apiKey
            }
        };
        
        return new Promise((resolve, reject) => {
            const req = https.request(options, (res) => {
                let data = '';
                res.on('data', chunk => data += chunk);
                res.on('end', () => resolve(JSON.parse(data)));
            });
            
            req.on('error', reject);
            req.end();
        });
    }
    
    verifyWebhookSignature(payload, signature) {
        const crypto = require('crypto');
        const expectedSignature = crypto
            .createHmac('sha256', this.webhookSecret)
            .update(payload)
            .digest('hex');
        
        return signature === expectedSignature;
    }
}

// Usage
const coinbase = new CoinbaseCommercePayment(
    'api_key_xxx',
    'webhook_secret_xxx'
);

async function createPayment() {
    const charge = await coinbase.createCharge({
        name: 'Premium Subscription',
        description: 'Monthly premium access',
        orderId: 'order_123',
        customerEmail: '[email protected]'
    }, 29.99);
    
    console.log('Payment URL:', charge.data.hosted_url);
    console.log('Charge ID:', charge.data.id);
    console.log('Payment Address:', charge.data.addresses.bitcoin);
}

# BitPay Payment Integration
import requests
import hashlib
import hmac
import json
from datetime import datetime

class BitPayPayment:
    def __init__(self, api_key, merchant_token, platform_info=None):
        self.api_key = api_key
        self.merchant_token = merchant_token
        self.base_url = "https://bitpay.com/api/v2"
        self.headers = {
            "Content-Type": "application/json",
            "X-BitPay-Platform-Info": platform_info or "MyPlatform/1.0"
        }
    
    def _generate_signature(self, data, url):
        """Generate BitPay signature"""
        # Implementation depends on specific endpoint
        pass
    
    def create_invoice(self, amount, currency, order_id, 
                       redirect_url=None, notification_url=None):
        """Create a BitPay invoice"""
        
        data = {
            "price": amount,
            "currency": currency,
            "orderId": order_id,
            "redirectURL": redirect_url,
            "notificationURL": notification_url,
            "itemDesc": "Product purchase",
            "notificationEmail": "[email protected]",
            "fullNotifications": True,
            "transactionSpeed": "medium",
            "buyer": {
                "email": "[email protected]"
            }
        }
        
        # Sign the request
        data_str = json.dumps(data, separators=(',', ':'))
        encoded = (self.merchant_token + data_str).encode('utf-8')
        signature = hmac.new(
            self.api_key.encode('utf-8'),
            encoded,
            hashlib.sha256
        ).hexdigest()
        
        self.headers["X-BitPay-Auth"] = f"BPSignature {signature}"
        
        response = requests.post(
            f"{self.base_url}/invoices",
            json=data,
            headers=self.headers
        )
        
        return response.json()
    
    def get_invoice(self, invoice_id):
        """Get invoice status"""
        
        response = requests.get(
            f"{self.base_url}/invoices/{invoice_id}",
            headers=self.headers
        )
        
        return response.json()
    
    def get_invoice_by_order_id(self, order_id):
        """Get invoice by order ID"""
        
        response = requests.get(
            f"{self.base_url}/invoices?orderId={order_id}",
            headers=self.headers
        )
        
        return response.json()

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract CryptoPaymentProcessor is ReentrancyGuard, Ownable {
    
    mapping(address => bool) public supportedTokens;
    mapping(address => uint256) public fees;
    
    struct Payment {
        address payer;
        address token;
        uint256 amount;
        uint256 fee;
        uint256 netAmount;
        string orderId;
        uint256 timestamp;
        PaymentStatus status;
    }
    
    enum PaymentStatus { Pending, Completed, Refunded }
    
    mapping(bytes32 => Payment) public payments;
    mapping(string => bytes32) public orderToPayment;
    
    event PaymentReceived(
        bytes32 indexed paymentId,
        address indexed payer,
        address token,
        uint256 amount,
        string orderId
    );
    
    event PaymentCompleted(
        bytes32 indexed paymentId,
        uint256 netAmount
    );
    
    constructor() Ownable(msg.sender) {
        supportedTokens[0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48] = true;
        supportedTokens[0xdAC17F958D2ee523a2206206994597C13D831ec7] = true;
        supportedTokens[0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2] = true;
        
        fees[0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48] = 50;
        fees[0xdAC17F958D2ee523a2206206994597C13D831ec7] = 50;
        fees[0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2] = 100;
    }
    
    function payWithToken(
        address token,
        uint256 amount,
        string memory orderId
    ) external nonReentrant returns (bytes32) {
        
        require(supportedTokens[token], "Token not supported");
        
        uint256 fee = (amount * fees[token]) / 10000;
        uint256 netAmount = amount - fee;
        
        require(
            IERC20(token).transferFrom(msg.sender, address(this), amount),
            "Token transfer failed"
        );
        
        bytes32 paymentId = keccak256(
            abi.encodePacked(msg.sender, token, amount, orderId, block.timestamp)
        );
        
        payments[paymentId] = Payment({
            payer: msg.sender,
            token: token,
            amount: amount,
            fee: fee,
            netAmount: netAmount,
            orderId: orderId,
            timestamp: block.timestamp,
            status: PaymentStatus.Completed
        });
        
        orderToPayment[orderId] = paymentId;
        
        emit PaymentReceived(paymentId, msg.sender, token, amount, orderId);
        emit PaymentCompleted(paymentId, netAmount);
        
        return paymentId;
    }
    
    function refund(bytes32 paymentId) external onlyOwner {
        Payment storage payment = payments[paymentId];
        require(payment.status == PaymentStatus.Completed, "Payment not completed");
        
        payment.status = PaymentStatus.Refunded;
        
        if (payment.token == address(0)) {
            payable(payment.payer).transfer(payment.amount);
        } else {
            IERC20(payment.token).transfer(payment.payer, payment.amount);
        }
    }
    
    function withdraw(address token, uint256 amount) external onlyOwner {
        if (token == address(0)) {
            payable(owner()).transfer(amount);
        } else {
            IERC20(token).transfer(owner(), amount);
        }
    }
    
    receive() external payable {}
}

// Bitcoin Payment Processing with HD Wallets
const { ECPairFactory } = require('ecpair');
const { payments, networks } = require('bitcore-lib');
const axios = require('axios');

class BitcoinPaymentProcessor {
    constructor(mnemonic, network = 'mainnet') {
        this.network = network === 'mainnet' ? networks.bitcoin : networks.bitcoinTestnet;
        this.ECPair = ECPairFactory(this.network);
        this.hdPrivateKey = this.ECPair.fromMnemonic(mnemonic);
    }
    
    deriveAddress(path = "m/84'/0'/0'/0/0") {
        const derived = this.hdPrivateKey.derivePath(path);
        const { address } = payments.p2wpkh({ pubkey: derived.publicKey });
        return address;
    }
    
    async generatePaymentAddress(orderId) {
        const index = this._getOrderIndex(orderId);
        const path = `m/84'/0'/0'/0/${index}`;
        
        return {
            address: this.deriveAddress(path),
            path: path,
            orderId: orderId,
            crypto: 'BTC',
            network: this.network === networks.bitcoin ? 'mainnet' : 'testnet'
        };
    }
    
    async checkPayment(address, expectedAmount) {
        const explorer = this.network === networks.bitcoin
            ? 'https://blockstream.info/api'
            : 'https://blockstream.info/testnet/api';
        
        try {
            const utxoResponse = await axios.get(`${explorer}/address/${address}/utxo`);
            const utxos = utxoResponse.data;
            
            if (utxos.length === 0) {
                return { paid: false, confirmations: 0 };
            }
            
            const paidUtxo = utxos.find(utxo => 
                utxo.value >= expectedAmount * 100000000
            );
            
            if (!paidUtxo) {
                return { paid: false, confirmations: 0 };
            }
            
            return {
                paid: true,
                txid: paidUtxo.txid,
                amount: paidUtxo.value / 100000000,
                confirmations: paidUtxo.status.confirmed ? 6 : 0,
                vout: paidUtxo.vout
            };
            
        } catch (error) {
            console.error('Error checking payment:', error);
            return { paid: false, error: error.message };
        }
    }
    
    _getOrderIndex(orderId) {
        let hash = 0;
        for (let i = 0; i < orderId.length; i++) {
            hash = ((hash << 5) - hash) + orderId.charCodeAt(i);
            hash = hash & hash;
        }
        return Math.abs(hash) % 10000;
    }
}

// React Crypto Payment Component
import React, { useState, useEffect } from 'react';

interface CryptoPaymentProps {
    amount: number;
    currency: string;
    orderId: string;
    supportedCryptos: string[];
    onPaymentComplete: (txHash: string) => void;
}

export const CryptoPayment: React.FC<CryptoPaymentProps> = ({
    amount,
    currency,
    orderId,
    supportedCryptos,
    onPaymentComplete
}) => {
    const [selectedCrypto, setSelectedCrypto] = useState<string>('');
    const [paymentAddress, setPaymentAddress] = useState<string>('');
    const [paymentAmount, setPaymentAmount] = useState<string>('');
    const [paymentStatus, setPaymentStatus] = useState<'pending' | 'processing' | 'confirmed'>('pending');

    useEffect(() => {
        if (selectedCrypto && amount) {
            fetchPaymentDetails();
        }
    }, [selectedCrypto, amount]);

    const fetchPaymentDetails = async () => {
        const response = await fetch('/api/crypto/payment-details', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                crypto: selectedCrypto,
                amount,
                currency,
                orderId
            })
        });

        const data = await response.json();
        setPaymentAddress(data.address);
        setPaymentAmount(data.cryptoAmount);
    };

    const copyToClipboard = () => {
        navigator.clipboard.writeText(paymentAddress);
    };

    const checkPaymentStatus = async () => {
        const response = await fetch(`/api/crypto/check-payment?orderId=${orderId}`);
        const data = await response.json();

        if (data.confirmed) {
            setPaymentStatus('confirmed');
            onPaymentComplete(data.txHash);
        }
    };

    return (
        <div className="crypto-payment-widget">
            <h3>Pay with Cryptocurrency</h3>

            <div className="crypto-selector">
                <label>Select Cryptocurrency:</label>
                <select
                    value={selectedCrypto}
                    onChange={(e) => setSelectedCrypto(e.target.value)}
                >
                    <option value="">Choose...</option>
                    {supportedCryptos.map(crypto => (
                        <option key={crypto} value={crypto}>
                            {crypto.toUpperCase()}
                        </option>
                    ))}
                </select>
            </div>

            {paymentAddress && (
                <div className="payment-details">
                    <div className="payment-amount">
                        <label>Send exactly:</label>
                        <span className="amount-value">
                            {paymentAmount} {selectedCrypto.toUpperCase()}
                        </span>
                    </div>

                    <div className="payment-address">
                        <label>To address:</label>
                        <code>{paymentAddress}</code>
                        <button onClick={copyToClipboard}>Copy</button>
                    </div>

                    <button onClick={checkPaymentStatus}>
                        Check Payment Status
                    </button>

                    {paymentStatus === 'confirmed' && (
                        <div className="payment-success">
                            ✓ Payment confirmed!
                        </div>
                    )}
                </div>
            )}
        </div>
    );
};

# Crypto Transaction Tax Reporting

class CryptoTaxCalculator:
    def __init__(self):
        self.transactions = []
    
    def add_transaction(self, tx_type, crypto, amount, 
                        usd_value, date):
        
        transaction = {
            'date': date,
            'type': tx_type,
            'crypto': crypto,
            'amount': amount,
            'usd_value': usd_value,
            'id': len(self.transactions) + 1
        }
        
        self.transactions.append(transaction)
        
        if tx_type in ['sell', 'trade', 'payment']:
            cost_basis = self._calculate_cost_basis(crypto, amount)
            gain_loss = usd_value - cost_basis
            transaction['cost_basis'] = cost_basis
            transaction['gain_loss'] = gain_loss
        
        return transaction
    
    def _calculate_cost_basis(self, crypto, amount):
        purchases = [
            t for t in self.transactions
            if t['type'] in ['buy', 'receive']
            and t['crypto'] == crypto
        ]
        
        remaining = amount
        total_cost = 0
        
        for purchase in purchases:
            if remaining <= 0:
                break
                
            available = purchase.get('remaining', purchase['amount'])
            
            if available >= remaining:
                total_cost += remaining * (purchase['usd_value'] / purchase['amount'])
                purchase['remaining'] = available - remaining
                remaining = 0
            else:
                total_cost += available * (purchase['usd_value'] / purchase['amount'])
                remaining -= available
                purchase['remaining'] = 0
        
        return total_cost
    
    def generate_tax_report(self, year):
        year_transactions = [
            t for t in self.transactions
            if t['date'].year == year
        ]
        
        total_gain_loss = sum(
            t.get('gain_loss', 0) 
            for t in year_transactions
        )
        
        return {
            'year': year,
            'transactions': year_transactions,
            'total_gain_loss': total_gain_loss
        }