Create Bank Payment Intent

curl -X POST "https://api.devdraft.ai/api/v0/payment-intents/bank" \
  -H "Content-Type: application/json" \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "x-client-secret: YOUR_CLIENT_SECRET" \
  -H "idempotency-key: $(uuidgen)" \
  -d '{
    "sourcePaymentRail": "ach_push",
    "sourceCurrency": "usd",
    "destinationCurrency": "usdc",
    "destinationNetwork": "ethereum",
    "destinationAddress": "0x742d35Cc6634C0532925a3b8D4C9db96c4b4d8e1",
    "amount": "1000.00",
    "customer_first_name": "John",
    "customer_last_name": "Doe",
    "customer_email": "john.doe@example.com",
    "customer_address": "123 Main St, New York, NY 10001",
    "customer_country": "United States",
    "customer_countryISO": "US",
    "customer_province": "New York",
    "customer_provinceISO": "NY",
    "phoneNumber": "+1-555-123-4567",
    "ach_reference": "INV12345"
  }'

{
  "statusCode": 400,
  "message": [
    "Please select a valid source payment rail",
    "Destination currency is required"
  ],
  "error": "Bad Request"
}

class PaymentStatusTracker {
  constructor(paymentIntents) {
    this.paymentIntents = paymentIntents;
    this.statusCallbacks = new Map();
  }

  async monitorPayment(paymentId, onStatusChange) {
    this.statusCallbacks.set(paymentId, onStatusChange);
    
    // Poll payment status every 30 seconds
    const pollInterval = setInterval(async () => {
      try {
        const payment = await this.getPaymentStatus(paymentId);
        const callback = this.statusCallbacks.get(paymentId);
        
        if (callback) {
          callback(payment.state, payment);
        }
        
        // Stop polling if payment is final
        if (['completed', 'failed', 'cancelled'].includes(payment.state)) {
          clearInterval(pollInterval);
          this.statusCallbacks.delete(paymentId);
        }
      } catch (error) {
        console.error(`Error polling payment ${paymentId}:`, error);
      }
    }, 30000);
    
    return pollInterval;
  }

  async getPaymentStatus(paymentId) {
    // Implementation would fetch current payment status
    // This is a placeholder
    return { id: paymentId, state: 'pending' };
  }
}

class PaymentRailOptimizer {
  constructor() {
    this.railCosts = {
      ach_push: { cost: 'low', speed: 'slow', limit: 25000 },
      wire: { cost: 'high', speed: 'fast', limit: 1000000 },
      sepa: { cost: 'low', speed: 'medium', limit: 999999 }
    };
  }

  suggestOptimalRail(amount, priority = 'cost', currency = 'usd') {
    const numericAmount = parseFloat(amount);
    
    // Currency-based filtering
    const availableRails = currency === 'eur' 
      ? ['sepa', 'wire'] 
      : ['ach_push', 'wire'];
    
    // Amount-based filtering
    const viableRails = availableRails.filter(rail => {
      const railInfo = this.railCosts[rail];
      return numericAmount <= railInfo.limit;
    });
    
    if (priority === 'speed' && viableRails.includes('wire')) {
      return {
        rail: 'wire',
        reason: 'Fastest processing for urgent payments'
      };
    }
    
    if (priority === 'cost') {
      if (currency === 'eur' && viableRails.includes('sepa')) {
        return {
          rail: 'sepa',
          reason: 'Lowest cost for EUR payments'
        };
      }
      
      if (currency === 'usd' && numericAmount < 25000 && viableRails.includes('ach_push')) {
        return {
          rail: 'ach_push',
          reason: 'Lowest cost for USD payments under $25K'
        };
      }
    }
    
    return {
      rail: viableRails[0] || 'wire',
      reason: 'Default option based on constraints'
    };
  }

  estimateFees(rail, amount) {
    const fees = {
      ach_push: Math.min(5.0, parseFloat(amount) * 0.005),
      wire: 25.0,
      sepa: Math.min(2.0, parseFloat(amount) * 0.002)
    };

    return {
      rail,
      fee: fees[rail] || 0,
      feePercentage: (fees[rail] / parseFloat(amount)) * 100
    };
  }
}