Update module name to github.com/fraktal/mev-beta and fix channel closing issues in pipeline stages

pkg/events/parser.go

@@ -0,0 +1,219 @@
+package events
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/holiman/uint256"
+)
+
+// EventType represents the type of DEX event
+type EventType int
+
+const (
+	Unknown EventType = iota
+	Swap
+	AddLiquidity
+	RemoveLiquidity
+	NewPool
+)
+
+// String returns a string representation of the event type
+func (et EventType) String() string {
+	switch et {
+	case Unknown:
+		return "Unknown"
+	case Swap:
+		return "Swap"
+	case AddLiquidity:
+		return "AddLiquidity"
+	case RemoveLiquidity:
+		return "RemoveLiquidity"
+	case NewPool:
+		return "NewPool"
+	default:
+		return "Unknown"
+	}
+}
+
+// Event represents a parsed DEX event
+type Event struct {
+	Type           EventType
+	Protocol       string // UniswapV2, UniswapV3, SushiSwap, etc.
+	PoolAddress    common.Address
+	Token0         common.Address
+	Token1         common.Address
+	Amount0        *big.Int
+	Amount1        *big.Int
+	SqrtPriceX96   *uint256.Int
+	Liquidity      *uint256.Int
+	Tick           int
+	Timestamp      uint64
+	TransactionHash common.Hash
+	BlockNumber    uint64
+}
+
+// EventParser parses DEX events from Ethereum transactions
+type EventParser struct {
+	// Known DEX contract addresses
+	UniswapV2Factory   common.Address
+	UniswapV3Factory   common.Address
+	SushiSwapFactory   common.Address
+	
+	// Router addresses
+	UniswapV2Router01 common.Address
+	UniswapV2Router02 common.Address
+	UniswapV3Router   common.Address
+	SushiSwapRouter   common.Address
+	
+	// Known pool addresses (for quick lookup)
+	knownPools map[common.Address]string
+}
+
+// NewEventParser creates a new event parser
+func NewEventParser() *EventParser {
+	parser := &EventParser{
+		UniswapV2Factory:   common.HexToAddress("0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f"),
+		UniswapV3Factory:   common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+		SushiSwapFactory:   common.HexToAddress("0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac"),
+		UniswapV2Router01:  common.HexToAddress("0xf164fC0Ec4E93095b804a4795bBe1e041497b92a"),
+		UniswapV2Router02:  common.HexToAddress("0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"),
+		UniswapV3Router:    common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"),
+		SushiSwapRouter:    common.HexToAddress("0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F"),
+		knownPools:         make(map[common.Address]string),
+	}
+	
+	// Pre-populate some known pools for demonstration
+	parser.knownPools[common.HexToAddress("0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640")] = "UniswapV3"
+	parser.knownPools[common.HexToAddress("0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc")] = "UniswapV2"
+	
+	return parser
+}
+
+// ParseTransaction parses a transaction for DEX events
+func (ep *EventParser) ParseTransaction(tx *types.Transaction, blockNumber uint64, timestamp uint64) ([]*Event, error) {
+	events := make([]*Event, 0)
+	
+	// Check if this is a DEX interaction
+	if !ep.IsDEXInteraction(tx) {
+		return events, nil
+	}
+	
+	// Determine the protocol
+	protocol := ep.identifyProtocol(tx)
+	
+	// For now, we'll return mock data for demonstration
+	if tx.To() != nil {
+		event := &Event{
+			Type:           Swap,
+			Protocol:       protocol,
+			PoolAddress:    *tx.To(),
+			Token0:         common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), // USDC
+			Token1:         common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), // WETH
+			Amount0:        big.NewInt(1000000000),                                           // 1000 USDC
+			Amount1:        big.NewInt(500000000000000000),                                   // 0.5 WETH
+			SqrtPriceX96:   uint256.NewInt(2505414483750470000),
+			Liquidity:      uint256.NewInt(1000000000000000000),
+			Tick:           200000,
+			Timestamp:      timestamp,
+			TransactionHash: tx.Hash(),
+			BlockNumber:    blockNumber,
+		}
+		events = append(events, event)
+	}
+
+	return events, nil
+}
+
+// IsDEXInteraction checks if a transaction interacts with a known DEX contract
+func (ep *EventParser) IsDEXInteraction(tx *types.Transaction) bool {
+	if tx.To() == nil {
+		return false
+	}
+
+	to := *tx.To()
+	
+	// Check factory contracts
+	if to == ep.UniswapV2Factory ||
+		to == ep.UniswapV3Factory ||
+		to == ep.SushiSwapFactory {
+		return true
+	}
+	
+	// Check router contracts
+	if to == ep.UniswapV2Router01 ||
+		to == ep.UniswapV2Router02 ||
+		to == ep.UniswapV3Router ||
+		to == ep.SushiSwapRouter {
+		return true
+	}
+	
+	// Check known pools
+	if _, exists := ep.knownPools[to]; exists {
+		return true
+	}
+	
+	return false
+}
+
+// identifyProtocol identifies which DEX protocol a transaction is interacting with
+func (ep *EventParser) identifyProtocol(tx *types.Transaction) string {
+	if tx.To() == nil {
+		return "Unknown"
+	}
+
+	to := *tx.To()
+	
+	// Check factory contracts
+	if to == ep.UniswapV2Factory {
+		return "UniswapV2"
+	}
+	if to == ep.UniswapV3Factory {
+		return "UniswapV3"
+	}
+	if to == ep.SushiSwapFactory {
+		return "SushiSwap"
+	}
+	
+	// Check router contracts
+	if to == ep.UniswapV2Router01 || to == ep.UniswapV2Router02 {
+		return "UniswapV2"
+	}
+	if to == ep.UniswapV3Router {
+		return "UniswapV3"
+	}
+	if to == ep.SushiSwapRouter {
+		return "SushiSwap"
+	}
+	
+	// Check known pools
+	if protocol, exists := ep.knownPools[to]; exists {
+		return protocol
+	}
+	
+	// Try to identify from function signature in transaction data
+	if len(tx.Data()) >= 4 {
+		sig := common.Bytes2Hex(tx.Data()[:4])
+		switch sig {
+		case "0xac9650d8": // multicall (Uniswap V3)
+			return "UniswapV3"
+		case "0x88316456": // swap (Uniswap V2)
+			return "UniswapV2"
+		case "0x128acb08": // swap (SushiSwap)
+			return "SushiSwap"
+		}
+	}
+	
+	return "Unknown"
+}
+
+// AddKnownPool adds a pool address to the known pools map
+func (ep *EventParser) AddKnownPool(address common.Address, protocol string) {
+	ep.knownPools[address] = protocol
+}
+
+// GetKnownPools returns all known pools
+func (ep *EventParser) GetKnownPools() map[common.Address]string {
+	return ep.knownPools
+}