---name: banking-expertversion: 1.1.0description: >-category: professionaltags: [banking, finance, core-banking, regulations, payments]allowed-tools: ---

Banking Expert

Expert guidance for banking systems, core banking platforms, regulatory compliance, and banking technology.

Core Concepts

Banking Systems

• Core banking systems (CBS)
• Account management
• Transaction processing
• Payment systems (ACH, SWIFT, SEPA)
• Loan management
• Risk management systems

Regulations

• Basel III/IV capital requirements
• Know Your Customer (KYC)
• Anti-Money Laundering (AML)
• GDPR for banking
• PSD2 (Payment Services Directive)
• Dodd-Frank Act

Key Technologies

• Real-time payment processing
• Mobile banking
• Open banking APIs
• Digital wallets
• Blockchain in banking
• AI for fraud detection

Account Management

from decimal import Decimal
from datetime import datetime
from enum import Enum

class AccountType(Enum):
    CHECKING = "checking"
    SAVINGS = "savings"
    CREDIT = "credit"
    LOAN = "loan"

class Account:
    def __init__(self, account_number: str, account_type: AccountType,
                 customer_id: str, balance: Decimal = Decimal('0')):
        self.account_number = account_number
        self.type = account_type
        self.customer_id = customer_id
        self.balance = balance
        self.status = "ACTIVE"
        self.created_at = datetime.now()

    def deposit(self, amount: Decimal) -> dict:
        """Deposit funds with validation"""
        if amount <= 0:
            raise ValueError("Amount must be positive")

        self.balance += amount

        return {
            "transaction_id": self.generate_transaction_id(),
            "type": "DEPOSIT",
            "amount": amount,
            "balance": self.balance,
            "timestamp": datetime.now()
        }

    def withdraw(self, amount: Decimal) -> dict:
        """Withdraw funds with balance check"""
        if amount <= 0:
            raise ValueError("Amount must be positive")

        if self.balance < amount:
            raise ValueError("Insufficient funds")

        self.balance -= amount

        return {
            "transaction_id": self.generate_transaction_id(),
            "type": "WITHDRAWAL",
            "amount": amount,
            "balance": self.balance,
            "timestamp": datetime.now()
        }

    def transfer(self, to_account: 'Account', amount: Decimal) -> dict:
        """Transfer funds between accounts"""
        # Withdraw from source
        withdrawal = self.withdraw(amount)

        try:
            # Deposit to destination
            deposit = to_account.deposit(amount)

            return {
                "transaction_id": self.generate_transaction_id(),
                "type": "TRANSFER",
                "from_account": self.account_number,
                "to_account": to_account.account_number,
                "amount": amount,
                "timestamp": datetime.now()
            }
        except Exception as e:
            # Rollback on failure
            self.deposit(amount)
            raise e

KYC/AML Compliance

class KYCService:
    def verify_customer(self, customer_data: dict) -> dict:
        """Perform KYC verification"""
        verification_results = {
            "identity_verified": False,
            "address_verified": False,
            "sanctions_clear": False,
            "pep_check_clear": False,
            "risk_level": "HIGH"
        }

        # Identity verification
        verification_results["identity_verified"] = self.verify_identity(
            customer_data["id_document"]
        )

        # Address verification
        verification_results["address_verified"] = self.verify_address(
            customer_data["proof_of_address"]
        )

        # Sanctions screening
        verification_results["sanctions_clear"] = self.screen_sanctions(
            customer_data["name"],
            customer_data["date_of_birth"]
        )

        # PEP (Politically Exposed Person) check
        verification_results["pep_check_clear"] = self.check_pep(
            customer_data["name"]
        )

        # Calculate risk level
        verification_results["risk_level"] = self.calculate_risk_level(
            verification_results
        )

        return verification_results

class AMLMonitoring:
    def monitor_transaction(self, transaction: dict) -> dict:
        """Monitor transaction for suspicious activity"""
        flags = []

        # Large transaction
        if transaction["amount"] > 10000:
            flags.append("LARGE_TRANSACTION")

        # Rapid succession of transactions
        if self.check_velocity(transaction["account_id"]):
            flags.append("HIGH_VELOCITY")

        # Unusual pattern
        if self.check_pattern(transaction):
            flags.append("UNUSUAL_PATTERN")

        # International transfer to high-risk country
        if transaction.get("international") and \
           self.is_high_risk_country(transaction.get("destination")):
            flags.append("HIGH_RISK_COUNTRY")

        if flags:
            self.file_suspicious_activity_report(transaction, flags)

        return {
            "flagged": len(flags) > 0,
            "flags": flags,
            "risk_score": self.calculate_aml_risk_score(flags)
        }

Payment Processing

class PaymentProcessor:
    def process_ach_payment(self, payment: dict) -> dict:
        """Process ACH payment"""
        # Validate routing and account numbers
        if not self.validate_routing_number(payment["routing_number"]):
            raise ValueError("Invalid routing number")

        # Create ACH file
        ach_batch = self.create_ach_batch([payment])

        # Submit to ACH network
        submission_result = self.submit_to_ach_network(ach_batch)

        return {
            "payment_id": payment["id"],
            "status": "PENDING",
            "expected_settlement": self.calculate_settlement_date(),
            "trace_number": submission_result["trace_number"]
        }

    def process_wire_transfer(self, wire: dict) -> dict:
        """Process SWIFT wire transfer"""
        # Generate SWIFT message
        swift_message = self.create_swift_mt103(wire)

        # Send via SWIFT network
        result = self.send_swift_message(swift_message)

        return {
            "wire_id": wire["id"],
            "status": "SENT",
            "swift_reference": result["reference"],
            "fee": self.calculate_wire_fee(wire["amount"])
        }

Interest Calculation

class InterestCalculator:
    @staticmethod
    def calculate_simple_interest(principal: Decimal, rate: Decimal,
                                  days: int) -> Decimal:
        """Calculate simple interest"""
        return principal * rate * days / 365

    @staticmethod
    def calculate_compound_interest(principal: Decimal, annual_rate: Decimal,
                                   years: int, compounds_per_year: int = 12) -> Decimal:
        """Calculate compound interest"""
        rate_per_period = annual_rate / compounds_per_year
        num_periods = years * compounds_per_year

        return principal * ((1 + rate_per_period) ** num_periods - 1)

    @staticmethod
    def calculate_loan_payment(principal: Decimal, annual_rate: Decimal,
                              months: int) -> Decimal:
        """Calculate monthly loan payment"""
        monthly_rate = annual_rate / 12

        payment = principal * (monthly_rate * (1 + monthly_rate) ** months) / \
                  ((1 + monthly_rate) ** months - 1)

        return payment.quantize(Decimal('0.01'))

Best Practices

• Implement two-factor authentication
• Use encryption for sensitive data (at rest and in transit)
• Maintain complete audit trails
• Implement real-time fraud detection
• Ensure ACID compliance for transactions
• Regular security audits and penetration testing
• Implement rate limiting on APIs
• Use tokenization for sensitive data
• Maintain disaster recovery and business continuity plans
• Regular regulatory compliance reviews

Anti-Patterns

❌ Storing sensitive data unencrypted ❌ No transaction logging/audit trail ❌ Synchronous payment processing ❌ Ignoring regulatory compliance ❌ No fraud detection mechanisms ❌ Using floats for money calculations ❌ No backup and recovery procedures

Resources

• Basel Committee: https://www.bis.org/bcbs/
• SWIFT Standards: https://www.swift.com/standards
• PSD2: https://ec.europa.eu/info/law/payment-services-psd-2
• FFIEC: https://www.ffiec.gov/