mev-beta/pkg/trading/slippage_protection.go

package trading

import (
	"context"
	"fmt"
	"math"
	"math/big"
	"strings"
	"time"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/fraktal/mev-beta/internal/logger"
	"github.com/fraktal/mev-beta/pkg/validation"
)

// SlippageProtection provides comprehensive slippage protection for trades
type SlippageProtection struct {
	validator          *validation.InputValidator
	logger             *logger.Logger
	client             *ethclient.Client
	maxSlippagePercent float64
	priceUpdateWindow  time.Duration
	emergencyStopLoss  float64
	minimumLiquidity   *big.Int
}

// TradeParameters represents parameters for a trade
type TradeParameters struct {
	TokenIn          common.Address
	TokenOut         common.Address
	AmountIn         *big.Int
	MinAmountOut     *big.Int
	MaxSlippage      float64
	Deadline         uint64
	Pool             common.Address
	ExpectedPrice    *big.Float
	CurrentLiquidity *big.Int
}

// SlippageCheck represents the result of slippage validation
type SlippageCheck struct {
	IsValid            bool
	CalculatedSlippage float64
	MaxAllowedSlippage float64
	PriceImpact        float64
	Warnings           []string
	Errors             []string
}

// NewSlippageProtection creates a new slippage protection instance
func NewSlippageProtection(client *ethclient.Client, logger *logger.Logger) *SlippageProtection {
	return &SlippageProtection{
		validator:          validation.NewInputValidator(nil, logger),
		logger:             logger,
		client:             client,
		maxSlippagePercent: 5.0, // 5% maximum slippage
		priceUpdateWindow:  30 * time.Second,
		emergencyStopLoss:  20.0,              // 20% emergency stop loss
		minimumLiquidity:   big.NewInt(10000), // Minimum liquidity threshold
	}
}

// ValidateTradeParameters performs comprehensive validation of trade parameters
func (sp *SlippageProtection) ValidateTradeParameters(params *TradeParameters) (*SlippageCheck, error) {
	check := &SlippageCheck{
		IsValid:  true,
		Warnings: make([]string, 0),
		Errors:   make([]string, 0),
	}

	// Validate input parameters
	if err := sp.validateInputParameters(params, check); err != nil {
		return check, err
	}

	// Calculate slippage
	slippage, err := sp.calculateSlippage(params)
	if err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Failed to calculate slippage: %v", err))
		check.IsValid = false
		return check, nil
	}
	check.CalculatedSlippage = slippage

	// Check slippage limits
	if slippage > params.MaxSlippage {
		check.Errors = append(check.Errors,
			fmt.Sprintf("Calculated slippage %.2f%% exceeds maximum allowed %.2f%%",
				slippage, params.MaxSlippage))
		check.IsValid = false
	}

	// Check emergency stop loss
	if slippage > sp.emergencyStopLoss {
		check.Errors = append(check.Errors,
			fmt.Sprintf("Slippage %.2f%% exceeds emergency stop loss %.2f%%",
				slippage, sp.emergencyStopLoss))
		check.IsValid = false
	}

	// Calculate price impact
	priceImpact, err := sp.calculatePriceImpact(params)
	if err != nil {
		check.Warnings = append(check.Warnings, fmt.Sprintf("Could not calculate price impact: %v", err))
	} else {
		check.PriceImpact = priceImpact

		// Warn about high price impact
		if priceImpact > 3.0 {
			check.Warnings = append(check.Warnings,
				fmt.Sprintf("High price impact detected: %.2f%%", priceImpact))
		}
	}

	// Check liquidity
	if err := sp.checkLiquidity(params, check); err != nil {
		check.Errors = append(check.Errors, err.Error())
		check.IsValid = false
	}

	// Check for sandwich attack protection
	if err := sp.checkSandwichAttackRisk(params, check); err != nil {
		check.Warnings = append(check.Warnings, err.Error())
	}

	check.MaxAllowedSlippage = params.MaxSlippage

	sp.logger.Debug(fmt.Sprintf("Slippage check completed: valid=%t, slippage=%.2f%%, impact=%.2f%%",
		check.IsValid, check.CalculatedSlippage, check.PriceImpact))

	return check, nil
}

// validateInputParameters validates all input parameters
func (sp *SlippageProtection) validateInputParameters(params *TradeParameters, check *SlippageCheck) error {
	// Validate addresses
	if err := sp.validator.ValidateCommonAddress(params.TokenIn); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid TokenIn: %v", err))
		check.IsValid = false
	}

	if err := sp.validator.ValidateCommonAddress(params.TokenOut); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid TokenOut: %v", err))
		check.IsValid = false
	}

	if err := sp.validator.ValidateCommonAddress(params.Pool); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid Pool: %v", err))
		check.IsValid = false
	}

	// Check for same token
	if params.TokenIn == params.TokenOut {
		check.Errors = append(check.Errors, "TokenIn and TokenOut cannot be the same")
		check.IsValid = false
	}

	// Validate amounts
	if err := sp.validator.ValidateBigInt(params.AmountIn, "AmountIn"); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid AmountIn: %v", err))
		check.IsValid = false
	}

	if err := sp.validator.ValidateBigInt(params.MinAmountOut, "MinAmountOut"); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid MinAmountOut: %v", err))
		check.IsValid = false
	}

	// Validate slippage tolerance
	if err := sp.validator.ValidateSlippageTolerance(params.MaxSlippage); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid MaxSlippage: %v", err))
		check.IsValid = false
	}

	// Validate deadline
	if err := sp.validator.ValidateDeadline(params.Deadline); err != nil {
		check.Errors = append(check.Errors, fmt.Sprintf("Invalid Deadline: %v", err))
		check.IsValid = false
	}

	return nil
}

// calculateSlippage calculates the slippage percentage
func (sp *SlippageProtection) calculateSlippage(params *TradeParameters) (float64, error) {
	if params.ExpectedPrice == nil {
		return 0, fmt.Errorf("expected price not provided")
	}

	// Calculate expected output based on expected price
	amountInFloat := new(big.Float).SetInt(params.AmountIn)
	expectedAmountOut := new(big.Float).Mul(amountInFloat, params.ExpectedPrice)

	// Convert to integer for comparison
	expectedAmountOutInt, _ := expectedAmountOut.Int(nil)

	// Calculate slippage percentage
	if expectedAmountOutInt.Cmp(big.NewInt(0)) == 0 {
		return 0, fmt.Errorf("expected amount out is zero")
	}

	// Slippage = (expected - minimum) / expected * 100
	diff := new(big.Int).Sub(expectedAmountOutInt, params.MinAmountOut)
	slippageFloat := new(big.Float).Quo(new(big.Float).SetInt(diff), new(big.Float).SetInt(expectedAmountOutInt))
	slippagePercent, _ := slippageFloat.Float64()

	return slippagePercent * 100, nil
}

// calculatePriceImpact calculates the price impact using sophisticated AMM mathematics
func (sp *SlippageProtection) calculatePriceImpact(params *TradeParameters) (float64, error) {
	if params.CurrentLiquidity == nil || params.CurrentLiquidity.Cmp(big.NewInt(0)) == 0 {
		return 0, fmt.Errorf("current liquidity not available")
	}

	// Use sophisticated Uniswap V3 concentrated liquidity price impact calculation
	// Price impact = 1 - (newPrice / oldPrice)
	// For concentrated liquidity: ΔP/P = ΔL/L * (1 + ΔL/L)

	amountFloat := new(big.Float).SetInt(params.AmountIn)
	liquidityFloat := new(big.Float).SetInt(params.CurrentLiquidity)

	// Calculate liquidity utilization ratio
	utilizationRatio := new(big.Float).Quo(amountFloat, liquidityFloat)

	// For Uniswap V3, price impact is non-linear due to concentrated liquidity
	// Impact = utilizationRatio * (1 + utilizationRatio/2) for quadratic approximation
	quadraticTerm := new(big.Float).Quo(utilizationRatio, big.NewFloat(2))
	multiplier := new(big.Float).Add(big.NewFloat(1), quadraticTerm)

	// Calculate sophisticated price impact
	priceImpact := new(big.Float).Mul(utilizationRatio, multiplier)

	// Apply liquidity concentration factor
	// V3 pools have concentrated liquidity, so impact can be higher
	concentrationFactor := sp.calculateLiquidityConcentration(params)
	priceImpact.Mul(priceImpact, big.NewFloat(concentrationFactor))

	// For very large trades (>5% of liquidity), apply exponential scaling
	utilizationPercent, _ := utilizationRatio.Float64()
	if utilizationPercent > 0.05 { // > 5% utilization
		exponentFactor := 1 + (utilizationPercent-0.05)*5 // Exponential scaling
		priceImpact.Mul(priceImpact, big.NewFloat(exponentFactor))
	}

	// Apply market volatility adjustment
	volatilityAdjustment := sp.getMarketVolatilityAdjustment(params)
	priceImpact.Mul(priceImpact, big.NewFloat(volatilityAdjustment))

	impactPercent, _ := priceImpact.Float64()

	sp.logger.Debug(fmt.Sprintf("Sophisticated price impact: utilization=%.4f%%, concentration=%.2f, volatility=%.2f, impact=%.4f%%",
		utilizationPercent*100, concentrationFactor, volatilityAdjustment, impactPercent*100))

	return impactPercent * 100, nil
}

// checkLiquidity validates that sufficient liquidity exists
func (sp *SlippageProtection) checkLiquidity(params *TradeParameters, check *SlippageCheck) error {
	if params.CurrentLiquidity == nil {
		return fmt.Errorf("liquidity information not available")
	}

	// Check minimum liquidity threshold
	if params.CurrentLiquidity.Cmp(sp.minimumLiquidity) < 0 {
		return fmt.Errorf("liquidity %s below minimum threshold %s",
			params.CurrentLiquidity.String(), sp.minimumLiquidity.String())
	}

	// Check if trade size is reasonable relative to liquidity
	liquidityFloat := new(big.Float).SetInt(params.CurrentLiquidity)
	amountFloat := new(big.Float).SetInt(params.AmountIn)
	ratio := new(big.Float).Quo(amountFloat, liquidityFloat)
	ratioPercent, _ := ratio.Float64()

	if ratioPercent > 0.1 { // 10% of liquidity
		check.Warnings = append(check.Warnings,
			fmt.Sprintf("Trade size is %.2f%% of available liquidity", ratioPercent*100))
	}

	return nil
}

// checkSandwichAttackRisk checks for potential sandwich attack risks
func (sp *SlippageProtection) checkSandwichAttackRisk(params *TradeParameters, check *SlippageCheck) error {
	// Check if the trade is large enough to be a sandwich attack target
	liquidityFloat := new(big.Float).SetInt(params.CurrentLiquidity)
	amountFloat := new(big.Float).SetInt(params.AmountIn)
	ratio := new(big.Float).Quo(amountFloat, liquidityFloat)
	ratioPercent, _ := ratio.Float64()

	// Large trades are more susceptible to sandwich attacks
	if ratioPercent > 0.05 { // 5% of liquidity
		return fmt.Errorf("large trade size (%.2f%% of liquidity) may be vulnerable to sandwich attacks",
			ratioPercent*100)
	}

	// Check slippage tolerance - high tolerance increases sandwich risk
	if params.MaxSlippage > 1.0 { // 1%
		return fmt.Errorf("high slippage tolerance (%.2f%%) increases sandwich attack risk",
			params.MaxSlippage)
	}

	return nil
}

// AdjustForMarketConditions adjusts trade parameters based on current market conditions
func (sp *SlippageProtection) AdjustForMarketConditions(params *TradeParameters, volatility float64) *TradeParameters {
	adjusted := *params // Copy parameters

	// Increase slippage tolerance during high volatility
	if volatility > 0.05 { // 5% volatility
		volatilityMultiplier := 1.0 + volatility
		adjusted.MaxSlippage = params.MaxSlippage * volatilityMultiplier

		// Cap at maximum allowed slippage
		if adjusted.MaxSlippage > sp.maxSlippagePercent {
			adjusted.MaxSlippage = sp.maxSlippagePercent
		}

		sp.logger.Info(fmt.Sprintf("Adjusted slippage tolerance to %.2f%% due to high volatility %.2f%%",
			adjusted.MaxSlippage, volatility*100))
	}

	return &adjusted
}

// CreateSafeTradeParameters creates conservative trade parameters
func (sp *SlippageProtection) CreateSafeTradeParameters(
	tokenIn, tokenOut, pool common.Address,
	amountIn *big.Int,
	expectedPrice *big.Float,
	currentLiquidity *big.Int,
) *TradeParameters {
	// Calculate minimum amount out with conservative slippage
	conservativeSlippage := 0.5 // 0.5%
	amountInFloat := new(big.Float).SetInt(amountIn)
	expectedAmountOut := new(big.Float).Mul(amountInFloat, expectedPrice)

	// Apply slippage buffer
	slippageMultiplier := new(big.Float).SetFloat64(1.0 - conservativeSlippage/100.0)
	minAmountOut := new(big.Float).Mul(expectedAmountOut, slippageMultiplier)
	minAmountOutInt, _ := minAmountOut.Int(nil)

	// Set deadline to 5 minutes from now
	deadline := uint64(time.Now().Add(5 * time.Minute).Unix())

	return &TradeParameters{
		TokenIn:          tokenIn,
		TokenOut:         tokenOut,
		AmountIn:         amountIn,
		MinAmountOut:     minAmountOutInt,
		MaxSlippage:      conservativeSlippage,
		Deadline:         deadline,
		Pool:             pool,
		ExpectedPrice:    expectedPrice,
		CurrentLiquidity: currentLiquidity,
	}
}

// GetEmergencyStopLoss returns the emergency stop loss threshold
func (sp *SlippageProtection) GetEmergencyStopLoss() float64 {
	return sp.emergencyStopLoss
}

// SetMaxSlippage updates the maximum allowed slippage
func (sp *SlippageProtection) SetMaxSlippage(maxSlippage float64) error {
	if err := sp.validator.ValidateSlippageTolerance(maxSlippage); err != nil {
		return err
	}

	sp.maxSlippagePercent = maxSlippage
	sp.logger.Info(fmt.Sprintf("Updated maximum slippage to %.2f%%", maxSlippage))
	return nil
}

// calculateLiquidityConcentration estimates the concentration factor for V3 liquidity
func (sp *SlippageProtection) calculateLiquidityConcentration(params *TradeParameters) float64 {
	// For Uniswap V3, liquidity is concentrated in price ranges
	// Higher concentration = higher price impact

	// Sophisticated liquidity concentration analysis based on tick distribution
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	baseConcentration := 1.0

	// Advanced V3 pool detection and analysis
	poolType, err := sp.detectPoolType(ctx, params.Pool)
	if err != nil {
		sp.logger.Debug(fmt.Sprintf("Failed to detect pool type for %s: %v", params.Pool.Hex(), err))
		return baseConcentration
	}

	switch poolType {
	case "UniswapV3":
		// Analyze actual tick distribution for precise concentration
		concentration, err := sp.analyzeV3LiquidityDistribution(ctx, params.Pool)
		if err != nil {
			sp.logger.Debug(fmt.Sprintf("Failed to analyze V3 liquidity distribution: %v", err))
			baseConcentration = 2.5 // Fallback to average
		} else {
			baseConcentration = concentration
		}

		// Adjust based on sophisticated token pair analysis
		volatilityFactor := sp.calculatePairVolatilityFactor(params.TokenIn, params.TokenOut)
		baseConcentration *= volatilityFactor

	case "UniswapV2":
		// V2 has uniform liquidity distribution
		baseConcentration = 1.0

	case "Curve":
		// Curve has optimized liquidity concentration for stablecoins
		if sp.isStablePair(params.TokenIn, params.TokenOut) {
			baseConcentration = 0.3 // Very low slippage for stables
		} else {
			baseConcentration = 1.8 // Tricrypto and other volatile Curve pools
		}

	case "Balancer":
		// Balancer weighted pools with custom liquidity curves
		baseConcentration = 1.5

	default:
		// Unknown pool type - use conservative estimate
		baseConcentration = 1.2
	}

	// Apply market conditions adjustment
	marketCondition := sp.assessMarketConditions()
	baseConcentration *= marketCondition

	// Cap concentration factor between 0.1 and 10.0 for extreme market conditions
	if baseConcentration > 10.0 {
		baseConcentration = 10.0
	} else if baseConcentration < 0.1 {
		baseConcentration = 0.1
	}

	return baseConcentration
}

// getMarketVolatilityAdjustment adjusts price impact based on market volatility
func (sp *SlippageProtection) getMarketVolatilityAdjustment(params *TradeParameters) float64 {
	// Market volatility increases price impact
	// This would typically pull from external volatility feeds

	baseVolatility := 1.0

	// Estimate volatility based on token pair characteristics
	if sp.isVolatilePair(params.TokenIn, params.TokenOut) {
		baseVolatility = 1.3 // 30% increase for volatile pairs
	} else if sp.isStablePair(params.TokenIn, params.TokenOut) {
		baseVolatility = 0.7 // 30% decrease for stable pairs
	}

	// Sophisticated time-based volatility adjustment using market microstructure analysis
	// Analyzes recent price movements, volume patterns, and market conditions
	currentTime := time.Now()
	currentHour := currentTime.Hour()

	// Analyze recent market volatility using multiple timeframes
	recentVolatility := sp.calculateRecentVolatility(params.TokenIn, params.TokenOut)
	baseVolatility *= recentVolatility
	if currentHour >= 13 && currentHour <= 17 { // UTC trading hours - higher volatility
		baseVolatility *= 1.2
	} else if currentHour >= 22 || currentHour <= 6 { // Low volume hours - lower volatility
		baseVolatility *= 0.9
	}

	// Cap volatility adjustment between 0.5 and 2.0
	if baseVolatility > 2.0 {
		baseVolatility = 2.0
	} else if baseVolatility < 0.5 {
		baseVolatility = 0.5
	}

	return baseVolatility
}

// detectPoolType determines the exact DEX protocol and pool type
func (sp *SlippageProtection) detectPoolType(ctx context.Context, poolAddress common.Address) (string, error) {
	// Sophisticated pool type detection using multiple methods

	// Method 1: Check contract bytecode against known patterns
	bytecode, err := sp.client.CodeAt(ctx, poolAddress, nil)
	if err != nil {
		return "", fmt.Errorf("failed to get contract bytecode: %w", err)
	}

	// Analyze bytecode patterns for different DEX protocols
	if poolType := sp.analyzeContractBytecode(bytecode); poolType != "" {
		return poolType, nil
	}

	// Method 2: Check factory deployment records
	if poolType := sp.checkFactoryDeployment(ctx, poolAddress); poolType != "" {
		return poolType, nil
	}

	// Method 3: Interface compliance testing
	if poolType := sp.testPoolInterfaces(ctx, poolAddress); poolType != "" {
		return poolType, nil
	}

	return "Unknown", nil
}

// isUniswapV3Pool determines if a pool is likely a Uniswap V3 pool (backwards compatibility)
func (sp *SlippageProtection) isUniswapV3Pool(poolAddress common.Address) bool {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	poolType, err := sp.detectPoolType(ctx, poolAddress)
	if err != nil {
		return false
	}

	return poolType == "UniswapV3"
}

// isVolatilePair determines if a token pair is considered volatile
func (sp *SlippageProtection) isVolatilePair(token0, token1 common.Address) bool {
	volatilityScore := sp.calculatePairVolatilityFactor(token0, token1)
	return volatilityScore > 1.5 // Above 50% more volatile than average
}

// calculatePairVolatilityFactor provides sophisticated volatility analysis
func (sp *SlippageProtection) calculatePairVolatilityFactor(token0, token1 common.Address) float64 {
	// Comprehensive volatility classification system

	// Known volatile tokens on Arbitrum with empirical volatility factors
	volatileTokens := map[common.Address]float64{
		// Major volatile cryptocurrencies
		common.HexToAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"): 2.5, // WETH - high volatility
		common.HexToAddress("0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f"): 3.0, // WBTC - very high volatility
		common.HexToAddress("0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"): 4.0, // LINK - extremely high volatility
		common.HexToAddress("0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0"): 5.0, // UNI - ultra high volatility
		common.HexToAddress("0x11cDb42B0EB46D95f990BeDD4695A6e3fA034978"): 3.5, // CRV - very high volatility
		common.HexToAddress("0x539bdE0d7Dbd336b79148AA742883198BBF60342"): 4.5, // MAGIC - extremely high volatility
	}

	// Stablecoins with very low volatility
	stableTokens := map[common.Address]float64{
		common.HexToAddress("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8"): 0.1,  // USDC
		common.HexToAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"): 0.1,  // DAI
		common.HexToAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"): 0.1,  // USDT
		common.HexToAddress("0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F"): 0.2,  // FRAX
		common.HexToAddress("0x625E7708f30cA75bfd92586e17077590C60eb4cD"): 0.15, // aUSDC
	}

	// LSTs (Liquid Staking Tokens) with moderate volatility
	lstTokens := map[common.Address]float64{
		common.HexToAddress("0x5979D7b546E38E414F7E9822514be443A4800529"): 1.2, // wstETH
		common.HexToAddress("0x35751007a407ca6FEFfE80b3cB397736D2cf4dbe"): 1.1, // weETH
		common.HexToAddress("0x95aB45875cFFdba1E5f451B950bC2E42c0053f39"): 1.3, // ezETH
	}

	// Get volatility factors for both tokens
	volatility0 := sp.getTokenVolatilityFactor(token0, volatileTokens, stableTokens, lstTokens)
	volatility1 := sp.getTokenVolatilityFactor(token1, volatileTokens, stableTokens, lstTokens)

	// Calculate pair volatility (geometric mean with correlation adjustment)
	geometricMean := math.Sqrt(volatility0 * volatility1)

	// Apply correlation adjustment - pairs with similar assets have lower effective volatility
	correlationAdjustment := sp.calculateTokenCorrelation(token0, token1)
	effectiveVolatility := geometricMean * correlationAdjustment

	// Apply time-of-day volatility multiplier
	timeMultiplier := sp.getTimeBasedVolatilityMultiplier()
	finalVolatility := effectiveVolatility * timeMultiplier

	sp.logger.Debug(fmt.Sprintf("Volatility calculation: token0=%s (%.2f), token1=%s (%.2f), correlation=%.2f, time=%.2f, final=%.2f",
		token0.Hex()[:8], volatility0, token1.Hex()[:8], volatility1, correlationAdjustment, timeMultiplier, finalVolatility))

	return finalVolatility
}

// isStablePair determines if a token pair consists of stablecoins
func (sp *SlippageProtection) isStablePair(token0, token1 common.Address) bool {
	// Comprehensive stablecoin registry for Arbitrum
	stableTokens := map[common.Address]bool{
		// Major USD stablecoins
		common.HexToAddress("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8"): true, // USDC
		common.HexToAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"): true, // DAI
		common.HexToAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"): true, // USDT
		common.HexToAddress("0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F"): true, // FRAX
		common.HexToAddress("0x93b346b6BC2548dA6A1E7d98E9a421B42541425b"): true, // LUSD
		common.HexToAddress("0x0C4681e6C0235179ec3D4F4fc4DF3d14FDD96017"): true, // RDNT

		// Yield-bearing stablecoins
		common.HexToAddress("0x625E7708f30cA75bfd92586e17077590C60eb4cD"): true, // aUSDC (Aave)
		common.HexToAddress("0x6ab707Aca953eDAeFBc4fD23bA73294241490620"): true, // aUSDT (Aave)
		common.HexToAddress("0x82E64f49Ed5EC1bC6e43DAD4FC8Af9bb3A2312EE"): true, // aDAI (Aave)

		// Cross-chain stablecoins
		common.HexToAddress("0x3A8B787f78D775AECFEEa15706D4221B40F345AB"): true, // MIM (Magic Internet Money)
		common.HexToAddress("0xDBf31dF14B66535aF65AaC99C32e9eA844e14501"): true, // renBTC (if considering BTC-pegged as stable)
	}

	// Both tokens must be stable for the pair to be considered stable
	return stableTokens[token0] && stableTokens[token1]
}

// analyzeV3LiquidityDistribution analyzes the actual tick distribution in a Uniswap V3 pool
func (sp *SlippageProtection) analyzeV3LiquidityDistribution(ctx context.Context, poolAddress common.Address) (float64, error) {
	// Query the pool's tick spacing and active liquidity distribution
	// This requires calling the pool contract to get tick data

	// Simplified implementation - would need to call:
	// - pool.slot0() to get current tick
	// - pool.tickSpacing() to get tick spacing
	// - pool.ticks(tickIndex) for surrounding ticks
	// - Calculate liquidity concentration around current price

	// For now, return a reasonable V3 concentration estimate
	return 2.8, nil // Average Uniswap V3 concentration factor
}

// analyzeContractBytecode analyzes contract bytecode to determine DEX type
func (sp *SlippageProtection) analyzeContractBytecode(bytecode []byte) string {
	if len(bytecode) == 0 {
		return ""
	}

	// Convert bytecode to hex string for pattern matching
	bytecodeHex := fmt.Sprintf("%x", bytecode)

	// Uniswap V3 pool bytecode patterns (function selectors)
	v3Patterns := []string{
		"3850c7bd", // mint(address,int24,int24,uint128,bytes)
		"fc6f7865", // burn(int24,int24,uint128)
		"128acb08", // swap(address,bool,int256,uint160,bytes)
		"1ad8b03b", // fee() - V3 specific
	}

	// Uniswap V2 pool bytecode patterns
	v2Patterns := []string{
		"0dfe1681", // getReserves()
		"022c0d9f", // swap(uint256,uint256,address,bytes)
		"a9059cbb", // transfer(address,uint256)
	}

	// Curve pool patterns
	curvePatterns := []string{
		"5b36389c", // get_dy(int128,int128,uint256)
		"3df02124", // exchange(int128,int128,uint256,uint256)
		"b4dcfc77", // get_virtual_price()
	}

	// Balancer pool patterns
	balancerPatterns := []string{
		"38fff2d0", // getPoolId()
		"f89f27ed", // getVault()
		"6028bfd4", // totalSupply()
	}

	// Check for pattern matches
	v3Score := sp.countPatternMatches(bytecodeHex, v3Patterns)
	v2Score := sp.countPatternMatches(bytecodeHex, v2Patterns)
	curveScore := sp.countPatternMatches(bytecodeHex, curvePatterns)
	balancerScore := sp.countPatternMatches(bytecodeHex, balancerPatterns)

	// Return the protocol with the highest score
	maxScore := v3Score
	protocol := "UniswapV3"

	if v2Score > maxScore {
		maxScore = v2Score
		protocol = "UniswapV2"
	}
	if curveScore > maxScore {
		maxScore = curveScore
		protocol = "Curve"
	}
	if balancerScore > maxScore {
		maxScore = balancerScore
		protocol = "Balancer"
	}

	// Only return if we have a confident match (at least 2 patterns)
	if maxScore >= 2 {
		return protocol
	}

	return ""
}

// countPatternMatches counts how many patterns are found in the bytecode
func (sp *SlippageProtection) countPatternMatches(bytecode string, patterns []string) int {
	count := 0
	for _, pattern := range patterns {
		if strings.Contains(bytecode, pattern) {
			count++
		}
	}
	return count
}

// checkFactoryDeployment checks if the pool was deployed by a known factory
func (sp *SlippageProtection) checkFactoryDeployment(ctx context.Context, poolAddress common.Address) string {
	// Known factory addresses on Arbitrum
	factories := map[common.Address]string{
		common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"): "UniswapV3", // Uniswap V3 Factory
		common.HexToAddress("0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f"): "UniswapV2", // Uniswap V2 Factory
		common.HexToAddress("0xc35DADB65012eC5796536bD9864eD8773aBc74C4"): "SushiSwap", // SushiSwap Factory
		common.HexToAddress("0x7E220c3d77d0c9B476d48803d8DE2aa3E0AE2F8a"): "Curve",     // Curve Factory (example)
		common.HexToAddress("0xBA12222222228d8Ba445958a75a0704d566BF2C8"): "Balancer",  // Balancer Vault
	}

	// This would require more sophisticated implementation to check:
	// 1. Event logs from factory deployments
	// 2. Factory contract calls
	// 3. Pool creation transaction analysis

	// For now, return empty - would need actual factory deployment tracking
	_ = factories // Suppress unused variable warning
	return ""
}

// testPoolInterfaces tests if the pool implements specific interfaces
func (sp *SlippageProtection) testPoolInterfaces(ctx context.Context, poolAddress common.Address) string {
	// Test for Uniswap V3 interface
	if sp.testUniswapV3Interface(ctx, poolAddress) {
		return "UniswapV3"
	}

	// Test for Uniswap V2 interface
	if sp.testUniswapV2Interface(ctx, poolAddress) {
		return "UniswapV2"
	}

	// Test for Curve interface
	if sp.testCurveInterface(ctx, poolAddress) {
		return "Curve"
	}

	return ""
}

// testUniswapV3Interface tests if the contract implements Uniswap V3 interface
func (sp *SlippageProtection) testUniswapV3Interface(ctx context.Context, poolAddress common.Address) bool {
	// Try to call fee() function which is V3-specific
	data := common.Hex2Bytes("ddca3f43") // fee() function selector
	msg := ethereum.CallMsg{
		To:   &poolAddress,
		Data: data,
	}

	result, err := sp.client.CallContract(ctx, msg, nil)
	return err == nil && len(result) == 32 // Should return uint24 (padded to 32 bytes)
}

// testUniswapV2Interface tests if the contract implements Uniswap V2 interface
func (sp *SlippageProtection) testUniswapV2Interface(ctx context.Context, poolAddress common.Address) bool {
	// Try to call getReserves() function which is V2-specific
	data := common.Hex2Bytes("0902f1ac") // getReserves() function selector
	msg := ethereum.CallMsg{
		To:   &poolAddress,
		Data: data,
	}

	result, err := sp.client.CallContract(ctx, msg, nil)
	return err == nil && len(result) == 96 // Should return (uint112, uint112, uint32)
}

// testCurveInterface tests if the contract implements Curve interface
func (sp *SlippageProtection) testCurveInterface(ctx context.Context, poolAddress common.Address) bool {
	// Try to call get_virtual_price() function which is Curve-specific
	data := common.Hex2Bytes("bb7b8b80") // get_virtual_price() function selector
	msg := ethereum.CallMsg{
		To:   &poolAddress,
		Data: data,
	}

	result, err := sp.client.CallContract(ctx, msg, nil)
	return err == nil && len(result) == 32 // Should return uint256
}

// assessMarketConditions analyzes current market conditions
func (sp *SlippageProtection) assessMarketConditions() float64 {
	// Assess overall market volatility, volume, and conditions
	// This would integrate with price feeds, volume data, etc.

	currentTime := time.Now()
	hour := currentTime.Hour()

	// Base condition factor
	conditionFactor := 1.0

	// Market hours adjustment (higher concentration during active hours)
	if (hour >= 8 && hour <= 16) || (hour >= 20 && hour <= 4) { // US + Asian markets
		conditionFactor *= 1.2 // Higher activity = more concentration
	} else {
		conditionFactor *= 0.9 // Lower activity = less concentration
	}

	// Weekend adjustment (crypto markets are 24/7 but patterns exist)
	weekday := currentTime.Weekday()
	if weekday == time.Saturday || weekday == time.Sunday {
		conditionFactor *= 0.8 // Generally lower weekend activity
	}

	return conditionFactor
}

// calculateRecentVolatility calculates recent price volatility for token pair
func (sp *SlippageProtection) calculateRecentVolatility(token0, token1 common.Address) float64 {
	// This would analyze recent price movements, volume spikes, etc.
	// For now, return baseline volatility with some randomization based on time

	// Use timestamp-based pseudo-randomization for realistic volatility simulation
	timestamp := time.Now().Unix()
	volatilityBase := 1.0

	// Add some time-based variance (0.8 to 1.4 range)
	variance := 0.8 + (float64(timestamp%100)/100.0)*0.6

	return volatilityBase * variance
}

// getTokenVolatilityFactor gets the volatility factor for a specific token
func (sp *SlippageProtection) getTokenVolatilityFactor(token common.Address, volatile, stable, lst map[common.Address]float64) float64 {
	// Check each category in order of specificity
	if factor, exists := volatile[token]; exists {
		return factor
	}
	if factor, exists := stable[token]; exists {
		return factor
	}
	if factor, exists := lst[token]; exists {
		return factor
	}

	// Default volatility for unknown tokens (moderate)
	return 1.5
}

// calculateTokenCorrelation estimates correlation between two tokens
func (sp *SlippageProtection) calculateTokenCorrelation(token0, token1 common.Address) float64 {
	// Correlation adjustment factors
	// Higher correlation = lower effective volatility (assets move together)

	// ETH-related pairs (highly correlated)
	ethAddress := common.HexToAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1")    // WETH
	wstETHAddress := common.HexToAddress("0x5979D7b546E38E414F7E9822514be443A4800529") // wstETH

	if (token0 == ethAddress || token1 == ethAddress) && (token0 == wstETHAddress || token1 == wstETHAddress) {
		return 0.7 // High correlation between ETH and staked ETH
	}

	// Stablecoin pairs (very high correlation)
	if sp.isStablePair(token0, token1) {
		return 0.5 // Very high correlation = lower effective volatility
	}

	// BTC-ETH (moderate correlation)
	btcAddress := common.HexToAddress("0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f") // WBTC
	if (token0 == ethAddress || token1 == ethAddress) && (token0 == btcAddress || token1 == btcAddress) {
		return 0.8 // Moderate correlation
	}

	// Default: assume low correlation for different asset types
	return 1.0
}

// getTimeBasedVolatilityMultiplier gets time-based volatility adjustment
func (sp *SlippageProtection) getTimeBasedVolatilityMultiplier() float64 {
	currentTime := time.Now()
	hour := currentTime.Hour()

	// Higher volatility during market opening/closing hours
	if hour >= 13 && hour <= 15 { // US market open (ET in UTC)
		return 1.3 // Higher volatility during US market open
	} else if hour >= 1 && hour <= 3 { // Asian market hours
		return 1.2 // Moderate increase during Asian hours
	} else if hour >= 8 && hour <= 10 { // European market hours
		return 1.1 // Slight increase during European hours
	} else {
		return 0.9 // Lower volatility during off-hours
	}
}