Crypto Payment Integration for iGaming Platforms

import { HDNodeWallet, ethers } from 'ethers';

// For Bitcoin, use bitcoinjs-lib. This example shows ETH/ERC-20.
// The concepts are identical for both chains.

class DepositService {
  private masterWallet: HDNodeWallet;

  constructor(mnemonic: string) {
    this.masterWallet = HDNodeWallet.fromPhrase(mnemonic);
  }

  // Generate a unique deposit address for each user
  generateDepositAddress(userId: string, index: number): string {
    // Derive child wallet: m/44'/60'/0'/0/{index}
    const child = this.masterWallet.derivePath(
      `m/44'/60'/0'/0/${index}`
    );
    return child.address;
  }

  // Monitor blockchain for deposits
  async watchDeposits(provider: ethers.Provider) {
    provider.on('block', async (blockNumber) => {
      const block = await provider.getBlock(blockNumber, true);
      if (!block?.transactions) return;

      for (const txHash of block.transactions) {
        const tx = await provider.getTransaction(txHash);
        if (!tx?.to) continue;

        // Check if this is one of our deposit addresses
        const userId = await this.lookupAddress(tx.to);
        if (!userId) continue;

        // Wait for confirmations
        const receipt = await tx.wait(3); // 3 confirmations

        if (receipt?.status === 1) {
          await this.creditDeposit({
            userId,
            amount: tx.value,
            txHash: tx.hash,
            confirmations: 3,
          });
        }
      }
    });
  }
}

const USDT_ADDRESS = '0xdAC17F958D2ee523a2206206994597C13D831ec7';
const USDT_ABI = [
  'event Transfer(address indexed from, address indexed to, uint256 value)',
];

async function watchUSDTDeposits(provider: ethers.Provider) {
  const contract = new ethers.Contract(USDT_ADDRESS, USDT_ABI, provider);

  contract.on('Transfer', async (from, to, value, event) => {
    const userId = await lookupDepositAddress(to);
    if (!userId) return;

    // USDT has 6 decimals
    const amount = Number(value) / 1e6;

    // Wait for confirmations
    const tx = await event.getTransaction();
    await tx.wait(12); // 12 confirmations for ERC-20

    await creditDeposit({
      userId,
      currency: 'USDT',
      amount,
      txHash: event.transactionHash,
    });
  });
}

interface WithdrawalRequest {
  id: string;
  userId: string;
  currency: string;
  amount: number;
  address: string;
  status: 'pending' | 'approved' | 'processing' | 'completed' | 'failed';
  createdAt: Date;
}

class WithdrawalService {
  async requestWithdrawal(req: WithdrawalRequest) {
    // 1. Validate address format
    if (!ethers.isAddress(req.address)) {
      throw new Error('Invalid withdrawal address');
    }

    // 2. Check user balance
    const balance = await this.getUserBalance(req.userId, req.currency);
    if (balance < req.amount) {
      throw new Error('Insufficient balance');
    }

    // 3. Debit balance immediately (prevent double-spend)
    await this.debitBalance(req.userId, req.currency, req.amount);

    // 4. Queue for processing
    await this.enqueueWithdrawal(req);

    // 5. Auto-approve small amounts, manual review for large
    if (req.amount < 1000) {
      await this.processWithdrawal(req.id);
    }
    // Large withdrawals go through manual approval
  }

  async processWithdrawal(id: string) {
    const req = await this.getWithdrawal(id);
    if (req.status !== 'approved' && req.status !== 'pending') return;

    try {
      req.status = 'processing';
      await this.updateWithdrawal(req);

      const txHash = await this.sendTransaction(
        req.address,
        req.amount,
        req.currency
      );

      req.status = 'completed';
      await this.updateWithdrawal(req);
    } catch (error) {
      // Refund on failure
      req.status = 'failed';
      await this.updateWithdrawal(req);
      await this.creditBalance(req.userId, req.currency, req.amount);
    }
  }
}