Multi-Currency & Cross-Border Payments: Architecture and Compliance

from datetime import datetime, timedelta
from typing import Optional
import requests
import json

class ExchangeRateManager:
    """Manage exchange rates for multi-currency payments"""
    
    def __init__(self, db_connection, cache_ttl_seconds: int = 60):
        self.db = db_connection
        self.cache_ttl = cache_ttl_seconds
        self.rate_cache = {}
    
    def get_exchange_rate(self, from_currency: str, 
                         to_currency: str) -> Optional[float]:
        """Get current exchange rate"""
        
        cache_key = f"{from_currency}_{to_currency}"
        
        # Check cache
        if cache_key in self.rate_cache:
            cached_rate, timestamp = self.rate_cache[cache_key]
            if (datetime.now() - timestamp).total_seconds() < self.cache_ttl:
                return cached_rate
        
        # Fetch from API
        try:
            response = requests.get(
                f"https://api.exchangerate-api.com/v4/latest/{from_currency}"
            )
            data = response.json()
            rate = data['rates'][to_currency]
            
            # Cache the rate
            self.rate_cache[cache_key] = (rate, datetime.now())
            
            # Store in database for historical tracking
            self.db.insert('exchange_rates', {
                'from_currency': from_currency,
                'to_currency': to_currency,
                'rate': rate,
                'timestamp': datetime.now()
            })
            
            return rate
        
        except Exception as e:
            print(f"Error fetching exchange rate: {e}")
            return None
    
    def lock_exchange_rate(self, from_currency: str, to_currency: str,
                          amount: float, lock_duration_seconds: int = 30) -> dict:
        """Lock exchange rate for transaction"""
        
        rate = self.get_exchange_rate(from_currency, to_currency)
        
        if not rate:
            return {'success': False, 'error': 'Unable to fetch rate'}
        
        converted_amount = amount * rate
        lock_id = f"lock_{datetime.now().timestamp()}"
        
        # Store locked rate
        self.db.insert('locked_rates', {
            'lock_id': lock_id,
            'from_currency': from_currency,
            'to_currency': to_currency,
            'rate': rate,
            'amount': amount,
            'converted_amount': converted_amount,
            'expires_at': datetime.now() + timedelta(seconds=lock_duration_seconds)
        })
        
        return {
            'success': True,
            'lock_id': lock_id,
            'rate': rate,
            'converted_amount': converted_amount,
            'expires_at': (datetime.now() + timedelta(seconds=lock_duration_seconds)).isoformat()
        }
    
    def get_historical_rates(self, from_currency: str, to_currency: str,
                            days: int = 30) -> list:
        """Get historical exchange rates"""
        
        rates = self.db.query(
            """SELECT rate, timestamp FROM exchange_rates 
               WHERE from_currency = ? AND to_currency = ? 
               AND timestamp > datetime('now', '-' || ? || ' days')
               ORDER BY timestamp DESC""",
            (from_currency, to_currency, days)
        )
        
        return rates
    
    def calculate_conversion_fee(self, amount: float, 
                                from_currency: str,
                                to_currency: str) -> dict:
        """Calculate conversion fees"""
        
        # Base fee: 1.5% for cross-border
        base_fee_percent = 0.015
        
        # Additional fee for less common currencies
        uncommon_currencies = ['ZWL', 'VEF', 'SLL']
        if to_currency in uncommon_currencies:
            base_fee_percent += 0.01
        
        fee = amount * base_fee_percent
        
        return {
            'amount': amount,
            'fee': fee,
            'fee_percent': base_fee_percent * 100,
            'total': amount + fee
        }

# Usage
rate_manager = ExchangeRateManager(db)

# Get current rate
rate = rate_manager.get_exchange_rate('USD', 'EUR')
print(f"USD to EUR: {rate}")

# Lock rate for transaction
locked = rate_manager.lock_exchange_rate('USD', 'EUR', 1000)
print(f"Locked rate: {locked['rate']}, expires: {locked['expires_at']}")

# Calculate fees
fees = rate_manager.calculate_conversion_fee(1000, 'USD', 'EUR')
print(f"Fee: ${fees['fee']:.2f}")

from enum import Enum

class RiskLevel(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class ComplianceChecker:
    """Implement AML/KYC compliance checks"""
    
    def __init__(self, db_connection):
        self.db = db_connection
        self.sanctions_list = self._load_sanctions_list()
    
    def _load_sanctions_list(self) -> set:
        """Load OFAC sanctions list"""
        # In production, fetch from OFAC API
        return {
            'iran', 'north korea', 'syria', 'cuba'
        }
    
    def perform_kyc_check(self, user_id: str, user_data: dict) -> dict:
        """Perform KYC verification"""
        
        # Check if user already verified
        existing_kyc = self.db.query(
            "SELECT * FROM kyc_records WHERE user_id = ?",
            (user_id,)
        )
        
        if existing_kyc and existing_kyc[0]['status'] == 'verified':
            return {'verified': True, 'level': existing_kyc[0]['level']}
        
        # Verify identity documents
        document_verified = self._verify_documents(user_data)
        
        # Verify address
        address_verified = self._verify_address(user_data)
        
        # Determine KYC level
        kyc_level = 'basic' if document_verified else 'enhanced'
        
        # Store KYC record
        self.db.insert('kyc_records', {
            'user_id': user_id,
            'status': 'verified' if document_verified and address_verified else 'pending',
            'level': kyc_level,
            'verified_at': datetime.now()
        })
        
        return {
            'verified': document_verified and address_verified,
            'level': kyc_level
        }
    
    def _verify_documents(self, user_data: dict) -> bool:
        """Verify identity documents"""
        # In production, use document verification service
        return 'passport' in user_data or 'driver_license' in user_data
    
    def _verify_address(self, user_data: dict) -> bool:
        """Verify address"""
        # In production, use address verification service
        return 'address' in user_data and 'postal_code' in user_data
    
    def check_sanctions(self, user_name: str, country: str) -> dict:
        """Check against sanctions lists"""
        
        # Check OFAC list
        is_sanctioned = country.lower() in self.sanctions_list
        
        if is_sanctioned:
            # Log for compliance
            self.db.insert('sanctions_checks', {
                'user_name': user_name,
                'country': country,
                'result': 'blocked',
                'timestamp': datetime.now()
            })
            
            return {'blocked': True, 'reason': 'Sanctioned country'}
        
        return {'blocked': False}
    
    def assess_transaction_risk(self, transaction: dict) -> dict:
        """Assess transaction risk level"""
        
        risk_score = 0
        risk_factors = []
        
        # Check amount
        if transaction['amount'] > 10000:
            risk_score += 30
            risk_factors.append('Large amount')
        
        # Check frequency
        recent_transactions = self.db.query(
            """SELECT COUNT(*) as count FROM transactions 
               WHERE user_id = ? AND timestamp > datetime('now', '-1 day')""",
            (transaction['user_id'],)
        )
        
        if recent_transactions[0]['count'] > 5:
            risk_score += 20
            risk_factors.append('High frequency')
        
        # Check destination country
        if transaction['destination_country'] in ['Iran', 'North Korea']:
            risk_score += 50
            risk_factors.append('High-risk destination')
        
        # Determine risk level
        if risk_score >= 50:
            risk_level = RiskLevel.HIGH
        elif risk_score >= 30:
            risk_level = RiskLevel.MEDIUM
        else:
            risk_level = RiskLevel.LOW
        
        return {
            'risk_level': risk_level.value,
            'risk_score': risk_score,
            'risk_factors': risk_factors
        }

# Usage
compliance = ComplianceChecker(db)

# Perform KYC
kyc_result = compliance.perform_kyc_check('user_123', {
    'passport': 'ABC123456',
    'address': '123 Main St',
    'postal_code': '12345'
})

# Check sanctions
sanctions_result = compliance.check_sanctions('John Doe', 'USA')

# Assess risk
risk = compliance.assess_transaction_risk({
    'user_id': 'user_123',
    'amount': 50000,
    'destination_country': 'UK'
})
print(f"Risk level: {risk['risk_level']}")

class PaymentSettlement:
    """Handle payment settlement and reconciliation"""
    
    def __init__(self, db_connection):
        self.db = db_connection
    
    def initiate_settlement(self, transaction_id: str,
                           amount: float, destination_bank: str) -> dict:
        """Initiate payment settlement"""
        
        # Create settlement record
        settlement_id = f"settle_{datetime.now().timestamp()}"
        
        self.db.insert('settlements', {
            'settlement_id': settlement_id,
            'transaction_id': transaction_id,
            'amount': amount,
            'destination_bank': destination_bank,
            'status': 'initiated',
            'initiated_at': datetime.now(),
            'expected_settlement_date': datetime.now() + timedelta(days=2)
        })
        
        # Send to correspondent bank
        self._send_to_correspondent_bank(settlement_id, amount, destination_bank)
        
        return {
            'settlement_id': settlement_id,
            'status': 'initiated',
            'expected_settlement_date': (datetime.now() + timedelta(days=2)).isoformat()
        }
    
    def _send_to_correspondent_bank(self, settlement_id: str,
                                   amount: float, destination_bank: str):
        """Send payment to correspondent bank"""
        
        # In production, send SWIFT message
        swift_message = {
            'settlement_id': settlement_id,
            'amount': amount,
            'destination_bank': destination_bank,
            'timestamp': datetime.now().isoformat()
        }
        
        # Log SWIFT message
        self.db.insert('swift_messages', {
            'settlement_id': settlement_id,
            'message': json.dumps(swift_message),
            'sent_at': datetime.now()
        })
    
    def reconcile_settlement(self, settlement_id: str,
                            bank_statement_amount: float) -> dict:
        """Reconcile settlement with bank statement"""
        
        settlement = self.db.query(
            "SELECT * FROM settlements WHERE settlement_id = ?",
            (settlement_id,)
        )
        
        if not settlement:
            return {'success': False, 'error': 'Settlement not found'}
        
        settlement = settlement[0]
        
        # Check if amounts match
        if abs(settlement['amount'] - bank_statement_amount) < 0.01:
            status = 'reconciled'
        else:
            status = 'discrepancy'
        
        # Update settlement
        self.db.update('settlements', settlement_id, {
            'status': status,
            'reconciled_at': datetime.now(),
            'bank_statement_amount': bank_statement_amount
        })
        
        return {
            'success': True,
            'status': status,
            'expected_amount': settlement['amount'],
            'actual_amount': bank_statement_amount
        }

# Usage
settlement = PaymentSettlement(db)

# Initiate settlement
result = settlement.initiate_settlement(
    transaction_id='txn_123',
    amount=1000,
    destination_bank='DEUTDEDD'
)

# Reconcile
reconcile_result = settlement.reconcile_settlement(
    settlement_id=result['settlement_id'],
    bank_statement_amount=1000
)