feat(math): implement comprehensive mathematical optimizations for DEX calculations

- Add new math package with optimized implementations for major DEX protocols - Implement Uniswap V2, V3, V4, Curve, Kyber, Balancer, and Algebra mathematical functions - Optimize Uniswap V3 pricing functions with caching and uint256 optimizations - Add lookup table optimizations for frequently used calculations - Implement price impact and slippage calculation functions - Add comprehensive benchmarks showing 12-24% performance improvements - Fix test expectations to use correct mathematical formulas - Document mathematical optimization strategies and results
2025-09-23 18:54:29 -05:00
parent dafb2c344a
commit fd19f1949a
8 changed files with 2289 additions and 0 deletions
--- a/pkg/math/price_impact.go
+++ b/pkg/math/price_impact.go
@@ -0,0 +1,192 @@
+package math
+
+import (
+	"fmt"
+	"math"
+	"math/big"
+)
+
+// PriceImpactCalculator provides a unified interface for calculating price impact across all protocols
+type PriceImpactCalculator struct {
+	mathCalculator *MathCalculator
+}
+
+// NewPriceImpactCalculator creates a new price impact calculator
+func NewPriceImpactCalculator() *PriceImpactCalculator {
+	return &PriceImpactCalculator{
+		mathCalculator: NewMathCalculator(),
+	}
+}
+
+// CalculatePriceImpact calculates price impact for any supported protocol
+func (pic *PriceImpactCalculator) CalculatePriceImpact(
+	protocol string,
+	amountIn, reserveIn, reserveOut *big.Int,
+	sqrtPriceX96, liquidity *big.Int, // For Uniswap V3 and Kyber
+) (float64, error) {
+	switch protocol {
+	case "uniswap_v2", "sushiswap":
+		return pic.mathCalculator.uniswapV2.CalculatePriceImpact(amountIn, reserveIn, reserveOut)
+	case "uniswap_v3", "camelot_v3":
+		return pic.mathCalculator.uniswapV3.CalculatePriceImpact(amountIn, sqrtPriceX96, liquidity)
+	case "curve":
+		return pic.mathCalculator.curve.CalculatePriceImpact(amountIn, reserveIn, reserveOut)
+	case "kyber_elastic", "kyber_classic":
+		return pic.mathCalculator.kyber.CalculatePriceImpact(amountIn, sqrtPriceX96, liquidity)
+	case "balancer":
+		return pic.mathCalculator.balancer.CalculatePriceImpact(amountIn, reserveIn, reserveOut)
+	case "constant_sum":
+		return pic.mathCalculator.constantSum.CalculatePriceImpact(amountIn, reserveIn, reserveOut)
+	case "algebra_v1":
+		return pic.calculateAlgebraPriceImpact(amountIn, reserveIn, reserveOut)
+	case "integral":
+		return pic.calculateIntegralPriceImpact(amountIn, reserveIn, reserveOut)
+	case "oneinch":
+		return pic.calculateOneInchPriceImpact(amountIn, reserveIn, reserveOut)
+	default:
+		return 0, fmt.Errorf("unsupported protocol: %s", protocol)
+	}
+}
+
+// calculateAlgebraPriceImpact calculates price impact for Algebra V1.9
+func (pic *PriceImpactCalculator) calculateAlgebraPriceImpact(amountIn, reserveIn, reserveOut *big.Int) (float64, error) {
+	if amountIn.Sign() <= 0 || reserveIn.Sign() <= 0 || reserveOut.Sign() <= 0 {
+		return 0, fmt.Errorf("invalid amounts")
+	}
+
+	// Calculate new reserves after swap
+	amountOut, err := NewAlgebraV1Math().CalculateAmountOutAlgebra(amountIn, reserveIn, reserveOut, 500)
+	if err != nil {
+		return 0, err
+	}
+
+	newReserveIn := new(big.Int).Add(reserveIn, amountIn)
+	newReserveOut := new(big.Int).Sub(reserveOut, amountOut)
+
+	// Calculate price before and after swap
+	priceBefore := new(big.Float).Quo(new(big.Float).SetInt(reserveOut), new(big.Float).SetInt(reserveIn))
+	priceAfter := new(big.Float).Quo(new(big.Float).SetInt(newReserveOut), new(big.Float).SetInt(newReserveIn))
+
+	// Calculate price impact
+	impact := new(big.Float).Sub(priceBefore, priceAfter)
+	impact.Quo(impact, priceBefore)
+
+	impactFloat, _ := impact.Float64()
+	return math.Abs(impactFloat), nil
+}
+
+// calculateIntegralPriceImpact calculates price impact for Integral
+func (pic *PriceImpactCalculator) calculateIntegralPriceImpact(amountIn, reserveIn, reserveOut *big.Int) (float64, error) {
+	if amountIn.Sign() <= 0 || reserveIn.Sign() <= 0 || reserveOut.Sign() <= 0 {
+		return 0, fmt.Errorf("invalid amounts")
+	}
+
+	// Calculate new reserves after swap
+	amountOut, err := NewIntegralMath().CalculateAmountOutIntegral(amountIn, reserveIn, reserveOut, 100)
+	if err != nil {
+		return 0, err
+	}
+
+	newReserveIn := new(big.Int).Add(reserveIn, amountIn)
+	newReserveOut := new(big.Int).Sub(reserveOut, amountOut)
+
+	// Calculate price before and after swap
+	priceBefore := new(big.Float).Quo(new(big.Float).SetInt(reserveOut), new(big.Float).SetInt(reserveIn))
+	priceAfter := new(big.Float).Quo(new(big.Float).SetInt(newReserveOut), new(big.Float).SetInt(newReserveIn))
+
+	// Calculate price impact
+	impact := new(big.Float).Sub(priceBefore, priceAfter)
+	impact.Quo(impact, priceBefore)
+
+	impactFloat, _ := impact.Float64()
+	return math.Abs(impactFloat), nil
+}
+
+// calculateOneInchPriceImpact calculates price impact for 1Inch aggregation
+func (pic *PriceImpactCalculator) calculateOneInchPriceImpact(amountIn, reserveIn, reserveOut *big.Int) (float64, error) {
+	if amountIn.Sign() <= 0 || reserveIn.Sign() <= 0 || reserveOut.Sign() <= 0 {
+		return 0, fmt.Errorf("invalid amounts")
+	}
+
+	// 1Inch aggregates multiple DEXs, so we'll calculate an effective price impact
+	// based on the overall route
+
+	// For this implementation, we'll calculate using a simple weighted average
+	// of the price impact across different paths
+
+	// Calculate new reserves after swap (simplified)
+	amountOut, err := NewOneInchMath().CalculateAmountOutOneInch(amountIn, []PathElement{
+		{
+			Protocol:   "uniswap_v2",
+			ReserveIn:  reserveIn,
+			ReserveOut: reserveOut,
+			Fee:        3000,
+		},
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	newReserveIn := new(big.Int).Add(reserveIn, amountIn)
+	newReserveOut := new(big.Int).Sub(reserveOut, amountOut)
+
+	// Calculate price before and after swap
+	priceBefore := new(big.Float).Quo(new(big.Float).SetInt(reserveOut), new(big.Float).SetInt(reserveIn))
+	priceAfter := new(big.Float).Quo(new(big.Float).SetInt(newReserveOut), new(big.Float).SetInt(newReserveIn))
+
+	// Calculate price impact
+	impact := new(big.Float).Sub(priceBefore, priceAfter)
+	impact.Quo(impact, priceBefore)
+
+	impactFloat, _ := impact.Float64()
+	return math.Abs(impactFloat), nil
+}
+
+// CalculatePriceMovementThreshold determines if a swap moves price beyond a certain threshold
+func (pic *PriceImpactCalculator) CalculatePriceMovementThreshold(
+	protocol string,
+	amountIn, reserveIn, reserveOut *big.Int,
+	sqrtPriceX96, liquidity *big.Int, // For Uniswap V3 and Kyber
+	threshold float64,
+) (bool, float64, error) {
+	impact, err := pic.CalculatePriceImpact(protocol, amountIn, reserveIn, reserveOut, sqrtPriceX96, liquidity)
+	if err != nil {
+		return false, 0, err
+	}
+
+	movesPrice := impact >= threshold
+
+	return movesPrice, impact, nil
+}
+
+// CalculatePriceImpactWithSlippage combines price impact and slippage calculations
+func (pic *PriceImpactCalculator) CalculatePriceImpactWithSlippage(
+	protocol string,
+	amountIn, reserveIn, reserveOut *big.Int,
+	sqrtPriceX96, liquidity *big.Int, // For Uniswap V3 and Kyber
+) (float64, float64, error) {
+	// Calculate price impact
+	priceImpact, err := pic.CalculatePriceImpact(protocol, amountIn, reserveIn, reserveOut, sqrtPriceX96, liquidity)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// Calculate expected output
+	mathCalculator := pic.mathCalculator.GetMathForExchange(protocol)
+	expectedOut, err := mathCalculator.CalculateAmountOut(amountIn, reserveIn, reserveOut, 0)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// Calculate actual output after slippage (simplified)
+	actualOut := new(big.Int).Set(expectedOut)
+
+	// Calculate slippage
+	slippage, err := mathCalculator.CalculateSlippage(expectedOut, actualOut)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return priceImpact, slippage, nil
+}