```python
from typing import Dict, Any
import logging

class RiskEngine:
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.max_leverage = 10
        self.max_position_size_pct = 0.2  # 20% of equity
        self.required_stop_loss_pct = 0.02  # 2% stop loss

    def check_order(self, account_data: Dict[str, Any], order_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        Check if order meets risk parameters
        
        Args:
            account_data: Account balance and positions from /api/account
            order_data: Proposed order details
            
        Returns:
            dict: Risk check results
        """
        try:
            # Calculate available equity
            usdt_balance = next(
                (b for b in account_data["balances"] if b["asset"] == "USDT"),
                {"free": 0.0}
            )
            equity = float(usdt_balance["free"])
            
            # Check leverage
            leverage = order_data.get("leverage", 1)
            if leverage > self.max_leverage:
                return {
                    "approved": False,
                    "reason": f"Leverage exceeds maximum of {self.max_leverage}x"
                }
            
            # Check position size
            position_size = float(order_data["quantity"]) * float(order_data.get("price", 1))
            max_position_size = equity * self.max_position_size_pct
            if position_size > max_position_size:
                return {
                    "approved": False,
                    "reason": f"Position size exceeds {self.max_position_size_pct*100}% of equity"
                }
            
            # Check stop loss
            if not order_data.get("stopPrice"):
                return {
                    "approved": False,
                    "reason": "Stop loss is required"
                }
            
            return {
                "approved": True,
                "max_leverage": self.max_leverage,
                "max_position_size": max_position_size,
                "required_stop_loss": self.required_stop_loss_pct
            }
            
        except Exception as e:
            self.logger.error(f"Risk check error: {e}")
            return {
                "approved": False,
                "reason": "Error processing risk check"
            }
```