claude-force: Skill for Claude Code

Risk Management Framework

Comprehensive risk management patterns for cryptocurrency trading bots.

Pre-Trade Validation Framework

from dataclasses import dataclass
from decimal import Decimal
from typing import List, Optional

@dataclass
class ValidationResult:
    passed: bool
    failed_checks: List[str]
    warnings: List[str]

class PreTradeValidator:
    """Multi-layer validation before order submission"""

    def __init__(self, config: dict):
        self.max_position_pct = config.get('max_position_pct', Decimal('0.02'))  # 2%
        self.max_concentration = config.get('max_concentration', Decimal('0.20'))  # 20%
        self.max_daily_loss_pct = config.get('max_daily_loss_pct', Decimal('0.05'))  # 5%
        self.min_margin_buffer = config.get('min_margin_buffer', Decimal('0.30'))  # 30%
        self.max_correlated_exposure = config.get('max_correlated_exposure', Decimal('0.40'))  # 40%

    def validate_order(self, order: 'Order', portfolio: 'Portfolio') -> ValidationResult:
        """Run all pre-trade validation checks"""
        failed = []
        warnings = []

        # Check 1: Position size limit (max 2% of portfolio per trade)
        if not self._check_position_size(order, portfolio):
            failed.append(f"Position size exceeds {self.max_position_pct*100}% limit")

        # Check 2: Concentration risk (max 20% in single asset)
        if not self._check_concentration(order, portfolio):
            failed.append(f"Concentration exceeds {self.max_concentration*100}% limit")

        # Check 3: Daily loss limit (max 5% daily loss)
        if not self._check_daily_loss_limit(portfolio):
            failed.append(f"Daily loss limit ({self.max_daily_loss_pct*100}%) triggered")

        # Check 4: Margin health (min 30% buffer)
        margin_check, margin_pct = self._check_margin_health(order, portfolio)
        if not margin_check:
            failed.append(f"Insufficient margin buffer: {margin_pct:.2%} < {self.min_margin_buffer:.2%}")
        elif margin_pct < Decimal('0.40'):
            warnings.append(f"Low margin buffer: {margin_pct:.2%}")

        # Check 5: Correlation exposure (max 40% in correlated assets)
        if not self._check_correlation_exposure(order, portfolio):
            failed.append(f"Correlated exposure exceeds {self.max_correlated_exposure*100}% limit")

        # Check 6: Fat finger detection
        if not self._check_fat_finger(order):
            failed.append("Order price deviates >5% from market - possible fat finger")

        return ValidationResult(
            passed=len(failed) == 0,
            failed_checks=failed,
            warnings=warnings
        )

    def _check_position_size(self, order: 'Order', portfolio: 'Portfolio') -> bool:
        position_value = order.quantity * order.price
        max_position_value = portfolio.total_value * self.max_position_pct
        return position_value <= max_position_value

    def _check_concentration(self, order: 'Order', portfolio: 'Portfolio') -> bool:
        current_exposure = portfolio.get_asset_exposure(order.symbol)
        new_exposure = current_exposure + (order.quantity * order.price)
        concentration = new_exposure / portfolio.total_value
        return concentration <= self.max_concentration