feat: create v2-prep branch with comprehensive planning

Restructured project for V2 refactor:

**Structure Changes:**
- Moved all V1 code to orig/ folder (preserved with git mv)
- Created docs/planning/ directory
- Added orig/README_V1.md explaining V1 preservation

**Planning Documents:**
- 00_V2_MASTER_PLAN.md: Complete architecture overview
  - Executive summary of critical V1 issues
  - High-level component architecture diagrams
  - 5-phase implementation roadmap
  - Success metrics and risk mitigation

- 07_TASK_BREAKDOWN.md: Atomic task breakdown
  - 99+ hours of detailed tasks
  - Every task < 2 hours (atomic)
  - Clear dependencies and success criteria
  - Organized by implementation phase

**V2 Key Improvements:**
- Per-exchange parsers (factory pattern)
- Multi-layer strict validation
- Multi-index pool cache
- Background validation pipeline
- Comprehensive observability

**Critical Issues Addressed:**
- Zero address tokens (strict validation + cache enrichment)
- Parsing accuracy (protocol-specific parsers)
- No audit trail (background validation channel)
- Inefficient lookups (multi-index cache)
- Stats disconnection (event-driven metrics)

Next Steps:
1. Review planning documents
2. Begin Phase 1: Foundation (P1-001 through P1-010)
3. Implement parsers in Phase 2
4. Build cache system in Phase 3
5. Add validation pipeline in Phase 4
6. Migrate and test in Phase 5

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

orig/pkg/arbitrum/market/market_discovery.go

@@ -0,0 +1,181 @@
+package market
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/fraktal/mev-beta/internal/logger"
+)
+
+// NewMarketDiscovery creates a new market discovery instance
+func NewMarketDiscovery(client interface{}, loggerInstance *logger.Logger, configPath string) (*MarketDiscovery, error) {
+	// Load configuration
+	config, err := LoadMarketConfig(configPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load config: %w", err)
+	}
+
+	// Initialize math calculator
+	// mathCalc := exchangeMath.NewMathCalculator()
+
+	md := &MarketDiscovery{
+		client: client,
+		logger: loggerInstance,
+		config: config,
+		// mathCalc:  mathCalc,
+		pools:     make(map[common.Address]*PoolInfoDetailed),
+		tokens:    make(map[common.Address]*TokenInfo),
+		factories: make(map[common.Address]*FactoryInfo),
+		routers:   make(map[common.Address]*RouterInfo),
+	}
+
+	// Initialize logging
+	if err := md.initializeLogging(); err != nil {
+		return nil, fmt.Errorf("failed to initialize logging: %w", err)
+	}
+
+	// Load initial configuration
+	if err := md.loadInitialMarkets(); err != nil {
+		return nil, fmt.Errorf("failed to load initial markets: %w", err)
+	}
+
+	loggerInstance.Info("Market discovery initialized with comprehensive pool detection")
+	return md, nil
+}
+
+// loadInitialMarkets loads initial tokens, factories, and priority pools
+func (md *MarketDiscovery) loadInitialMarkets() error {
+	md.mu.Lock()
+	defer md.mu.Unlock()
+
+	// Load tokens
+	for _, token := range md.config.Tokens {
+		tokenAddr := common.HexToAddress(token.Address)
+		md.tokens[tokenAddr] = &TokenInfo{
+			Address:  tokenAddr,
+			Symbol:   token.Symbol,
+			Decimals: uint8(token.Decimals),
+			Priority: token.Priority,
+		}
+	}
+
+	// Load factories
+	for _, factory := range md.config.Factories {
+		factoryAddr := common.HexToAddress(factory.Address)
+		md.factories[factoryAddr] = &FactoryInfo{
+			Address:      factoryAddr,
+			Type:         factory.Type,
+			InitCodeHash: common.HexToHash(factory.InitCodeHash),
+			FeeTiers:     factory.FeeTiers,
+			Priority:     factory.Priority,
+		}
+	}
+
+	// Load routers
+	for _, router := range md.config.Routers {
+		routerAddr := common.HexToAddress(router.Address)
+		factoryAddr := common.Address{}
+		if router.Factory != "" {
+			for _, f := range md.config.Factories {
+				if f.Type == router.Factory {
+					factoryAddr = common.HexToAddress(f.Address)
+					break
+				}
+			}
+		}
+
+		md.routers[routerAddr] = &RouterInfo{
+			Address:  routerAddr,
+			Factory:  factoryAddr,
+			Type:     router.Type,
+			Priority: router.Priority,
+		}
+	}
+
+	// Load priority pools
+	for _, poolConfig := range md.config.PriorityPools {
+		poolAddr := common.HexToAddress(poolConfig.Pool)
+		token0 := common.HexToAddress(poolConfig.Token0)
+		token1 := common.HexToAddress(poolConfig.Token1)
+
+		// Find factory
+		var factoryAddr common.Address
+		var factoryType string
+		for _, f := range md.config.Factories {
+			if f.Type == poolConfig.Factory {
+				factoryAddr = common.HexToAddress(f.Address)
+				factoryType = f.Type
+				break
+			}
+		}
+
+		pool := &PoolInfoDetailed{
+			Address:     poolAddr,
+			Factory:     factoryAddr,
+			FactoryType: factoryType,
+			Token0:      token0,
+			Token1:      token1,
+			Fee:         poolConfig.Fee,
+			Priority:    poolConfig.Priority,
+			Active:      true,
+			LastUpdated: time.Now(),
+		}
+
+		md.pools[poolAddr] = pool
+	}
+
+	loggerMsg := fmt.Sprintf("Loaded initial markets: %d tokens, %d factories, %d routers, %d priority pools",
+		len(md.tokens), len(md.factories), len(md.routers), len(md.pools))
+	md.logger.Info(loggerMsg)
+
+	return nil
+}
+
+// Helper methods
+func abs(x float64) float64 {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+// GetStatistics returns market discovery statistics
+func (md *MarketDiscovery) GetStatistics() map[string]interface{} {
+	md.mu.RLock()
+	defer md.mu.RUnlock()
+
+	return map[string]interface{}{
+		"pools_tracked":           len(md.pools),
+		"tokens_tracked":          len(md.tokens),
+		"factories_tracked":       len(md.factories),
+		"pools_discovered":        md.poolsDiscovered,
+		"arbitrage_opportunities": md.arbitrageOpps,
+		"last_scan_time":          md.lastScanTime,
+		"total_scan_time":         md.totalScanTime.String(),
+	}
+}
+
+// Close closes all log files and resources
+func (md *MarketDiscovery) Close() error {
+	var errors []error
+
+	// if md.marketScanLogger != nil {
+	// 	if err := md.marketScanLogger.(*os.File).Close(); err != nil {
+	// 		errors = append(errors, err)
+	// 	}
+	// }
+
+	// if md.arbLogger != nil {
+	// 	if err := md.arbLogger.(*os.File).Close(); err != nil {
+	// 		errors = append(errors, err)
+	// 	}
+	// }
+
+	if len(errors) > 0 {
+		return fmt.Errorf("errors closing resources: %v", errors)
+	}
+
+	return nil
+}