Sequencer is working (minimal parsing)

test/benchmarks/pricing_bench_test.go

@@ -0,0 +1,157 @@
+package benchmarks
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/fraktal/mev-beta/pkg/uniswap"
+	"github.com/stretchr/testify/require"
+)
+
+// BenchmarkSqrtPriceX96ToPrice benchmarks the SqrtPriceX96ToPrice function
+func BenchmarkSqrtPriceX96ToPrice(b *testing.B) {
+	sqrtPriceX96 := new(big.Int)
+	sqrtPriceX96.SetString("79228162514264337593543950336", 10) // 2^96
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = uniswap.SqrtPriceX96ToPrice(sqrtPriceX96)
+	}
+}
+
+// BenchmarkPriceToSqrtPriceX96 benchmarks the PriceToSqrtPriceX96 function
+func BenchmarkPriceToSqrtPriceX96(b *testing.B) {
+	price := new(big.Float).SetFloat64(1.0)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = uniswap.PriceToSqrtPriceX96(price)
+	}
+}
+
+// BenchmarkTickToSqrtPriceX96 benchmarks the TickToSqrtPriceX96 function
+func BenchmarkTickToSqrtPriceX96(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = uniswap.TickToSqrtPriceX96(0)
+	}
+}
+
+// BenchmarkSqrtPriceX96ToTick benchmarks the SqrtPriceX96ToTick function
+func BenchmarkSqrtPriceX96ToTick(b *testing.B) {
+	sqrtPriceX96 := new(big.Int)
+	sqrtPriceX96.SetString("79228162514264337593543950336", 10) // 2^96
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = uniswap.SqrtPriceX96ToTick(sqrtPriceX96)
+	}
+}
+
+// BenchmarkPricingConversionsSequential benchmarks sequential pricing conversions
+func BenchmarkPricingConversionsSequential(b *testing.B) {
+	price := new(big.Float).SetFloat64(1.0)
+	
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		sqrtPriceX96 := uniswap.PriceToSqrtPriceX96(price)
+		tick := uniswap.SqrtPriceX96ToTick(sqrtPriceX96)
+		backToSqrt := uniswap.TickToSqrtPriceX96(tick)
+		_ = uniswap.SqrtPriceX96ToPrice(backToSqrt)
+	}
+}
+
+// BenchmarkPricingCalculationRealistic benchmarks realistic pricing calculations
+func BenchmarkPricingCalculationRealistic(b *testing.B) {
+	testCases := []struct {
+		name         string
+		sqrtPriceX96 string
+	}{
+		{"ETH_USDC_1800", "2231455953840924584200896000"}, // ~1800 USDC per ETH
+		{"ETH_USDC_3000", "2890903041336652768307200000"}, // ~3000 USDC per ETH
+		{"WBTC_ETH_15", "977228162514264337593543950"},   // ~15 ETH per WBTC
+		{"DAI_USDC_1", "79228162514264337593543950336"},   // ~1 DAI per USDC
+	}
+	
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			sqrtPriceX96 := new(big.Int)
+			sqrtPriceX96.SetString(tc.sqrtPriceX96, 10)
+			
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				price := uniswap.SqrtPriceX96ToPrice(sqrtPriceX96)
+				tick := uniswap.SqrtPriceX96ToTick(sqrtPriceX96)
+				backToSqrt := uniswap.TickToSqrtPriceX96(tick)
+				_ = uniswap.SqrtPriceX96ToPrice(backToSqrt)
+				
+				// Verify we get similar price back (within reasonable precision)
+				require.NotNil(b, price)
+			}
+		})
+	}
+}
+
+// BenchmarkExtremePriceValues benchmarks extreme price value conversions
+func BenchmarkExtremePriceValues(b *testing.B) {
+	extremeCases := []struct {
+		name  string
+		price float64
+	}{
+		{"VeryLow_0.000001", 0.000001},
+		{"Low_0.01", 0.01},
+		{"Normal_1.0", 1.0},
+		{"High_100.0", 100.0},
+		{"VeryHigh_1000000.0", 1000000.0},
+	}
+	
+	for _, tc := range extremeCases {
+		b.Run(tc.name, func(b *testing.B) {
+			price := new(big.Float).SetFloat64(tc.price)
+			
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				sqrtPriceX96 := uniswap.PriceToSqrtPriceX96(price)
+				tick := uniswap.SqrtPriceX96ToTick(sqrtPriceX96)
+				backToSqrt := uniswap.TickToSqrtPriceX96(tick)
+				_ = uniswap.SqrtPriceX96ToPrice(backToSqrt)
+			}
+		})
+	}
+}
+
+// BenchmarkBigIntOperations benchmarks the underlying big.Int operations
+func BenchmarkBigIntOperations(b *testing.B) {
+	b.Run("BigInt_Multiplication", func(b *testing.B) {
+		x := big.NewInt(1000000)
+		y := big.NewInt(2000000)
+		result := new(big.Int)
+		
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			result.Mul(x, y)
+		}
+	})
+	
+	b.Run("BigInt_Division", func(b *testing.B) {
+		x := big.NewInt(1000000000000)
+		y := big.NewInt(1000000)
+		result := new(big.Int)
+		
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			result.Div(x, y)
+		}
+	})
+	
+	b.Run("BigFloat_Operations", func(b *testing.B) {
+		x := big.NewFloat(1000000.5)
+		y := big.NewFloat(2000000.3)
+		result := new(big.Float)
+		
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			result.Mul(x, y)
+		}
+	})
+}