refactor: move all remaining files to orig/ directory

Completed clean root directory structure: - Root now contains only: .git, .env, docs/, orig/ - Moved all remaining files and directories to orig/: - Config files (.claude, .dockerignore, .drone.yml, etc.) - All .env variants (except active .env) - Git config (.gitconfig, .github, .gitignore, etc.) - Tool configs (.golangci.yml, .revive.toml, etc.) - Documentation (*.md files, @prompts) - Build files (Dockerfiles, Makefile, go.mod, go.sum) - Docker compose files - All source directories (scripts, tests, tools, etc.) - Runtime directories (logs, monitoring, reports) - Dependency files (node_modules, lib, cache) - Special files (--delete) - Removed empty runtime directories (bin/, data/) V2 structure is now clean: - docs/planning/ - V2 planning documents - orig/ - Complete V1 codebase preserved - .env - Active environment config (not in git) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-10 10:53:05 +01:00
parent 803de231ba
commit c54c569f30
718 changed files with 8304 additions and 8281 deletions
--- a/orig/test/integration/performance_benchmark_test.go
+++ b/orig/test/integration/performance_benchmark_test.go
@@ -0,0 +1,413 @@
+//go:build integration && legacy && forked
+// +build integration,legacy,forked
+
+package integration_test
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"runtime"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func BenchmarkArbitrageDetection(b *testing.B) {
+	client, cleanup := setupForkedArbitrum(b)
+	defer cleanup()
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	// Benchmark basic arbitrage detection logic
+	for i := 0; i < b.N; i++ {
+		// Simulate arbitrage detection calculations
+		pool1Price := big.NewInt(2000000000)          // 2000 USDC
+		pool2Price := big.NewInt(2010000000)          // 2010 USDC
+		swapAmount := big.NewInt(1000000000000000000) // 1 ETH
+
+		// Calculate price difference
+		priceDiff := new(big.Int).Sub(pool2Price, pool1Price)
+		if priceDiff.Sign() > 0 {
+			// Calculate potential profit
+			profit := new(big.Int).Mul(priceDiff, swapAmount)
+			profit.Div(profit, pool1Price)
+			_ = profit // Use result to prevent optimization
+		}
+	}
+}
+
+func BenchmarkPoolDiscovery(b *testing.B) {
+	client, cleanup := setupForkedArbitrum(b)
+	defer cleanup()
+
+	// Benchmark pool discovery logic
+	factories := []common.Address{
+		common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"), // Uniswap V3
+		common.HexToAddress("0xc35DADB65012eC5796536bD9864eD8773aBc74C4"), // SushiSwap V2
+		common.HexToAddress("0x6EcCab422D763aC031210895C81787E87B6EAeaa"), // Camelot V2
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		// Simulate pool discovery operations
+		for j, factory := range factories {
+			// Mock pool discovery timing
+			poolCount := 10 + j*5
+			pools := make([]common.Address, poolCount)
+			for k := 0; k < poolCount; k++ {
+				// Generate mock pool addresses
+				pools[k] = common.BigToAddress(big.NewInt(int64(k) + factory.Big().Int64()))
+			}
+			_ = pools // Use result
+		}
+	}
+}
+
+func BenchmarkConcurrentOpportunityScanning(b *testing.B) {
+	client, cleanup := setupForkedArbitrum(b)
+	defer cleanup()
+
+	// Real pool addresses for testing
+	pools := []common.Address{
+		common.HexToAddress("0xC31E54c7a869B9FcBEcc14363CF510d1c41fa443"), // WETH/USDC 0.05%
+		common.HexToAddress("0x17c14D2c404D167802b16C450d3c99F88F2c4F4d"), // WETH/USDC 0.3%
+		common.HexToAddress("0x641C00A822e8b671738d32a431a4Fb6074E5c79d"), // WETH/USDT 0.05%
+		common.HexToAddress("0xB1026b8e7276e7AC75410F1fcbbe21796e8f7526"), // WBTC/USDC 0.05%
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		// Simulate concurrent opportunity scanning
+		for _, pool := range pools {
+			// Mock price comparison between pools
+			price1 := big.NewInt(2000000000)
+			price2 := big.NewInt(2005000000)
+			swapAmount := big.NewInt(1000000000000000000)
+
+			// Calculate opportunity profitability
+			priceDiff := new(big.Int).Sub(price2, price1)
+			profit := new(big.Int).Mul(priceDiff, swapAmount)
+			profit.Div(profit, price1)
+
+			_ = profit // Use result
+			_ = pool   // Use pool
+		}
+	}
+}
+
+func BenchmarkMEVCompetitionAnalysis(b *testing.B) {
+	client, cleanup := setupForkedArbitrum(b)
+	defer cleanup()
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	// Benchmark MEV competition analysis
+	for i := 0; i < b.N; i++ {
+		// Simulate competition analysis calculations
+		estimatedProfit := big.NewInt(100000000000000000) // 0.1 ETH
+		gasLimit := big.NewInt(300000)
+		gasPrice := big.NewInt(20000000000) // 20 gwei
+		competitorCount := 5
+
+		// Calculate gas cost
+		gasCost := new(big.Int).Mul(gasPrice, gasLimit)
+
+		// Calculate competition factor
+		competitionFactor := big.NewInt(int64(competitorCount * 2))
+		adjustedGasPrice := new(big.Int).Add(gasPrice, competitionFactor)
+
+		// Calculate net profit
+		netProfit := new(big.Int).Sub(estimatedProfit, new(big.Int).Mul(adjustedGasPrice, gasLimit))
+
+		_ = netProfit // Use result
+	}
+}
+
+func TestConcurrentArbitrageDetection(t *testing.T) {
+	client, cleanup := setupForkedArbitrum(t)
+	defer cleanup()
+
+	t.Run("High Load Concurrent Processing", func(t *testing.T) {
+		numWorkers := 20
+		eventsPerWorker := 100
+		totalEvents := numWorkers * eventsPerWorker
+
+		var wg sync.WaitGroup
+		errors := make(chan error, totalEvents)
+		processed := make(chan int, totalEvents)
+
+		startTime := time.Now()
+
+		// Launch concurrent workers
+		for w := 0; w < numWorkers; w++ {
+			wg.Add(1)
+			go func(workerID int) {
+				defer wg.Done()
+
+				// Simulate processing events
+				for i := 0; i < eventsPerWorker; i++ {
+					// Mock event processing
+					price1 := big.NewInt(2000000000)
+					price2 := big.NewInt(2005000000)
+					swapAmount := big.NewInt(1000000000000000000)
+
+					// Calculate arbitrage opportunity
+					priceDiff := new(big.Int).Sub(price2, price1)
+					profit := new(big.Int).Mul(priceDiff, swapAmount)
+					profit.Div(profit, price1)
+
+					if profit.Sign() > 0 {
+						processed <- 1
+					} else {
+						processed <- 1
+					}
+				}
+			}(w)
+		}
+
+		// Wait for completion or timeout
+		done := make(chan bool)
+		go func() {
+			wg.Wait()
+			close(done)
+		}()
+
+		processedCount := 0
+		timeout := time.After(60 * time.Second)
+
+	processing:
+		for {
+			select {
+			case <-processed:
+				processedCount++
+				if processedCount == totalEvents {
+					break processing
+				}
+			case err := <-errors:
+				t.Errorf("Processing error: %v", err)
+			case <-timeout:
+				t.Fatalf("Test timed out after 60 seconds. Processed %d/%d events", processedCount, totalEvents)
+			case <-done:
+				break processing
+			}
+		}
+
+		duration := time.Since(startTime)
+		eventsPerSecond := float64(processedCount) / duration.Seconds()
+
+		t.Logf("Processed %d events in %v (%.2f events/sec)", processedCount, duration, eventsPerSecond)
+
+		// Performance assertions
+		assert.Equal(t, totalEvents, processedCount, "Should process all events")
+		assert.Greater(t, eventsPerSecond, 100.0, "Should process at least 100 events per second")
+		assert.Less(t, duration, 30*time.Second, "Should complete within 30 seconds")
+	})
+
+	t.Run("Memory Usage Under Load", func(t *testing.T) {
+		// Test memory efficiency with large number of events
+		eventCount := 10000
+
+		var memBefore, memAfter runtime.MemStats
+		runtime.GC()
+		runtime.ReadMemStats(&memBefore)
+
+		// Simulate processing large number of events
+		for i := 0; i < eventCount; i++ {
+			// Mock event processing that allocates memory
+			eventData := make([]byte, 256) // Simulate event data
+			result := make(map[string]*big.Int)
+			result["profit"] = big.NewInt(int64(i * 1000))
+			result["gas"] = big.NewInt(300000)
+
+			_ = eventData
+			_ = result
+		}
+
+		runtime.GC()
+		runtime.ReadMemStats(&memAfter)
+
+		memUsed := memAfter.Alloc - memBefore.Alloc
+		memPerEvent := float64(memUsed) / float64(eventCount)
+
+		t.Logf("Memory used: %d bytes for %d events (%.2f bytes/event)",
+			memUsed, eventCount, memPerEvent)
+
+		// Memory efficiency assertion
+		assert.Less(t, memPerEvent, 2048.0, "Should use less than 2KB per event on average")
+	})
+}
+
+func TestPoolDiscoveryPerformance(t *testing.T) {
+	client, cleanup := setupForkedArbitrum(t)
+	defer cleanup()
+
+	t.Run("Large Scale Pool Discovery", func(t *testing.T) {
+		// Test discovery across multiple factories
+		factories := map[string]common.Address{
+			"Uniswap V3":   common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+			"SushiSwap V2": common.HexToAddress("0xc35DADB65012eC5796536bD9864eD8773aBc74C4"),
+			"Camelot V2":   common.HexToAddress("0x6EcCab422D763aC031210895C81787E87B6EAeaa"),
+		}
+
+		totalPools := 0
+		startTime := time.Now()
+
+		for name, factory := range factories {
+			// Mock pool discovery
+			mockPoolCount := 25 + len(name) // Vary by factory
+			totalPools += mockPoolCount
+			t.Logf("%s: Discovered %d pools", name, mockPoolCount)
+
+			// Simulate discovery time
+			time.Sleep(100 * time.Millisecond)
+			_ = factory // Use factory
+		}
+
+		duration := time.Since(startTime)
+		poolsPerSecond := float64(totalPools) / duration.Seconds()
+
+		t.Logf("Total pools discovered: %d in %v (%.2f pools/sec)",
+			totalPools, duration, poolsPerSecond)
+
+		// Performance assertions
+		assert.Greater(t, totalPools, 50, "Should discover at least 50 pools across all factories")
+		assert.Less(t, duration, 30*time.Second, "Discovery should complete within 30 seconds")
+	})
+
+	t.Run("Concurrent Pool Discovery", func(t *testing.T) {
+		factories := []common.Address{
+			common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+			common.HexToAddress("0xc35DADB65012eC5796536bD9864eD8773aBc74C4"),
+			common.HexToAddress("0x6EcCab422D763aC031210895C81787E87B6EAeaa"),
+		}
+
+		var wg sync.WaitGroup
+		results := make(chan int, len(factories))
+		errors := make(chan error, len(factories))
+
+		startTime := time.Now()
+
+		for _, factory := range factories {
+			wg.Add(1)
+			go func(f common.Address) {
+				defer wg.Done()
+
+				// Mock concurrent discovery
+				mockPoolCount := 15 + int(f.Big().Int64()%20)
+				time.Sleep(50 * time.Millisecond) // Simulate network delay
+				results <- mockPoolCount
+			}(factory)
+		}
+
+		wg.Wait()
+		close(results)
+		close(errors)
+
+		// Check for errors
+		for err := range errors {
+			t.Errorf("Discovery error: %v", err)
+		}
+
+		// Count total pools
+		totalPools := 0
+		for count := range results {
+			totalPools += count
+		}
+
+		duration := time.Since(startTime)
+		t.Logf("Concurrent discovery: %d pools in %v", totalPools, duration)
+
+		assert.Greater(t, totalPools, 30, "Should discover pools concurrently")
+		assert.Less(t, duration, 20*time.Second, "Concurrent discovery should be faster")
+	})
+}
+
+func TestRealTimeEventProcessing(t *testing.T) {
+	client, cleanup := setupForkedArbitrum(t)
+	defer cleanup()
+
+	t.Run("Real-time Block Processing", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+		defer cancel()
+
+		processed := make(chan *MockSwapEvent, 100)
+		errors := make(chan error, 10)
+
+		// Mock real-time block processing
+		go func() {
+			blockNum := uint64(12345)
+			for {
+				select {
+				case <-time.After(1 * time.Second):
+					// Mock processing a block
+					blockNum++
+
+					// Generate mock swap events
+					for i := 0; i < 3; i++ {
+						mockEvent := &MockSwapEvent{
+							TxHash: common.HexToHash(fmt.Sprintf("0x%d%d", blockNum, i)),
+							Pool:   common.HexToAddress("0xC31E54c7a869B9FcBEcc14363CF510d1c41fa443"),
+						}
+						processed <- mockEvent
+					}
+				case <-ctx.Done():
+					return
+				}
+			}
+		}()
+
+		// Collect results
+		eventCount := 0
+		timeout := time.After(45 * time.Second)
+
+		for {
+			select {
+			case event := <-processed:
+				eventCount++
+				if mockEvent, ok := event.(*MockSwapEvent); ok {
+					t.Logf("Processed event: %s", mockEvent.TxHash.Hex())
+				}
+			case err := <-errors:
+				t.Errorf("Processing error: %v", err)
+			case <-timeout:
+				t.Logf("Processed %d events in real-time", eventCount)
+				return
+			case <-ctx.Done():
+				t.Logf("Processed %d events before context cancellation", eventCount)
+				return
+			}
+		}
+	})
+}
+
+// Helper functions and types for benchmarking
+
+// MockSwapEvent represents a swap event for testing
+type MockSwapEvent struct {
+	TxHash common.Hash
+	Pool   common.Address
+}
+
+// MockArbitrageService for testing
+type MockArbitrageService struct{}
+
+func (m *MockArbitrageService) ProcessSwapEvent(event *MockSwapEvent) error {
+	// Mock processing logic
+	time.Sleep(1 * time.Microsecond)
+	return nil
+}
+
+func (m *MockArbitrageService) IsSignificantSwap(event *MockSwapEvent) bool {
+	// Mock significance check
+	return event.TxHash[0]%2 == 0
+}