e9c24a65e5
- Update go.mod to Go 1.21 (from invalid 1.25) - Add missing dependencies: gorilla/websocket, stretchr/testify - Fix CallContract calls to use ethereum.CallMsg instead of map - Import ethereum package for CallMsg type These fixes resolve compilation errors in the pool discovery service that would prevent the application from building. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
399 lines
11 KiB
Go
399 lines
11 KiB
Go
package pools
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
"math/big"
|
|
"sync"
|
|
|
|
"github.com/ethereum/go-ethereum"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
|
|
|
"github.com/your-org/mev-bot/pkg/cache"
|
|
mevtypes "github.com/your-org/mev-bot/pkg/types"
|
|
)
|
|
|
|
// Known factory addresses on Arbitrum
|
|
var (
|
|
UniswapV2FactoryAddress = common.HexToAddress("0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9") // SushiSwap
|
|
UniswapV3FactoryAddress = common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984") // Uniswap V3
|
|
CamelotFactoryAddress = common.HexToAddress("0x6EcCab422D763aC031210895C81787E87B43A652") // Camelot
|
|
CurveRegistryAddress = common.HexToAddress("0x445FE580eF8d70FF569aB36e80c647af338db351") // Curve (mainnet, example)
|
|
)
|
|
|
|
// Top traded tokens on Arbitrum
|
|
var TopTokens = []common.Address{
|
|
common.HexToAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"), // WETH
|
|
common.HexToAddress("0xFF970a61A04b1cA14834A43f5dE4533eBDDB5CC8"), // USDC
|
|
common.HexToAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"), // USDT
|
|
common.HexToAddress("0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f"), // WBTC
|
|
common.HexToAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"), // DAI
|
|
common.HexToAddress("0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"), // LINK
|
|
common.HexToAddress("0xFA7F8980b0f1E64A2062791cc3b0871572f1F7f0"), // UNI
|
|
}
|
|
|
|
// DiscoveryConfig contains configuration for pool discovery
|
|
type DiscoveryConfig struct {
|
|
// Connection
|
|
RPCURL string
|
|
|
|
// Discovery parameters
|
|
StartBlock uint64
|
|
MaxPools int
|
|
MinLiquidity *big.Int
|
|
BatchSize int
|
|
ConcurrentFetches int
|
|
|
|
// Token pairs to discover
|
|
TokenPairs []TokenPair
|
|
}
|
|
|
|
// TokenPair represents a pair of tokens
|
|
type TokenPair struct {
|
|
Token0 common.Address
|
|
Token1 common.Address
|
|
}
|
|
|
|
// DefaultDiscoveryConfig returns default configuration
|
|
func DefaultDiscoveryConfig() *DiscoveryConfig {
|
|
// Generate pairs from top tokens
|
|
pairs := make([]TokenPair, 0)
|
|
for i := 0; i < len(TopTokens); i++ {
|
|
for j := i + 1; j < len(TopTokens); j++ {
|
|
pairs = append(pairs, TokenPair{
|
|
Token0: TopTokens[i],
|
|
Token1: TopTokens[j],
|
|
})
|
|
}
|
|
}
|
|
|
|
return &DiscoveryConfig{
|
|
RPCURL: "https://arb1.arbitrum.io/rpc",
|
|
StartBlock: 0,
|
|
MaxPools: 1000,
|
|
MinLiquidity: big.NewInt(1e18), // 1 ETH minimum
|
|
BatchSize: 100,
|
|
ConcurrentFetches: 10,
|
|
TokenPairs: pairs,
|
|
}
|
|
}
|
|
|
|
// Discovery discovers pools on Arbitrum
|
|
type Discovery struct {
|
|
config *DiscoveryConfig
|
|
client *ethclient.Client
|
|
cache *cache.PoolCache
|
|
logger *slog.Logger
|
|
|
|
mu sync.Mutex
|
|
poolsDiscovered int
|
|
}
|
|
|
|
// NewDiscovery creates a new pool discovery service
|
|
func NewDiscovery(config *DiscoveryConfig, cache *cache.PoolCache, logger *slog.Logger) (*Discovery, error) {
|
|
if config == nil {
|
|
config = DefaultDiscoveryConfig()
|
|
}
|
|
|
|
client, err := ethclient.Dial(config.RPCURL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to connect to RPC: %w", err)
|
|
}
|
|
|
|
return &Discovery{
|
|
config: config,
|
|
client: client,
|
|
cache: cache,
|
|
logger: logger.With("component", "pool_discovery"),
|
|
}, nil
|
|
}
|
|
|
|
// DiscoverAll discovers all pools from known DEXes
|
|
func (d *Discovery) DiscoverAll(ctx context.Context) error {
|
|
d.logger.Info("starting pool discovery")
|
|
|
|
// Discover UniswapV2-style pools (SushiSwap, Camelot, etc.)
|
|
if err := d.discoverUniswapV2Pools(ctx); err != nil {
|
|
d.logger.Error("uniswap v2 discovery failed", "error", err)
|
|
}
|
|
|
|
// Discover UniswapV3 pools
|
|
if err := d.discoverUniswapV3Pools(ctx); err != nil {
|
|
d.logger.Error("uniswap v3 discovery failed", "error", err)
|
|
}
|
|
|
|
d.logger.Info("pool discovery complete", "pools_discovered", d.poolsDiscovered, "total_cached", d.cache.Count())
|
|
return nil
|
|
}
|
|
|
|
// discoverUniswapV2Pools discovers UniswapV2-style pools
|
|
func (d *Discovery) discoverUniswapV2Pools(ctx context.Context) error {
|
|
d.logger.Info("discovering UniswapV2-style pools")
|
|
|
|
factories := []struct {
|
|
address common.Address
|
|
protocol string
|
|
}{
|
|
{UniswapV2FactoryAddress, mevtypes.ProtocolUniswapV2},
|
|
{CamelotFactoryAddress, mevtypes.ProtocolCamelot},
|
|
}
|
|
|
|
for _, factory := range factories {
|
|
d.logger.Info("querying factory", "protocol", factory.protocol, "address", factory.address.Hex())
|
|
|
|
// Query each token pair
|
|
for _, pair := range d.config.TokenPairs {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
default:
|
|
}
|
|
|
|
poolAddr, err := d.getUniswapV2Pool(ctx, factory.address, pair.Token0, pair.Token1)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if poolAddr == (common.Address{}) {
|
|
continue // Pool doesn't exist
|
|
}
|
|
|
|
// Fetch pool info
|
|
poolInfo, err := d.fetchUniswapV2PoolInfo(ctx, poolAddr, pair.Token0, pair.Token1, factory.protocol)
|
|
if err != nil {
|
|
d.logger.Debug("failed to fetch pool info", "pool", poolAddr.Hex(), "error", err)
|
|
continue
|
|
}
|
|
|
|
// Check minimum liquidity
|
|
if poolInfo.LiquidityUSD.Cmp(d.config.MinLiquidity) < 0 {
|
|
continue
|
|
}
|
|
|
|
// Add to cache
|
|
if err := d.cache.Add(poolInfo); err != nil {
|
|
d.logger.Warn("failed to add pool to cache", "pool", poolAddr.Hex(), "error", err)
|
|
continue
|
|
}
|
|
|
|
d.mu.Lock()
|
|
d.poolsDiscovered++
|
|
d.mu.Unlock()
|
|
|
|
d.logger.Debug("discovered pool",
|
|
"protocol", factory.protocol,
|
|
"pool", poolAddr.Hex(),
|
|
"token0", pair.Token0.Hex(),
|
|
"token1", pair.Token1.Hex(),
|
|
"liquidity", poolInfo.LiquidityUSD.String(),
|
|
)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// getUniswapV2Pool gets a UniswapV2 pool address for a token pair
|
|
func (d *Discovery) getUniswapV2Pool(ctx context.Context, factory common.Address, token0, token1 common.Address) (common.Address, error) {
|
|
// getPair(address,address) returns (address)
|
|
// This is a simplified version - in production, use generated bindings
|
|
calldata := append([]byte{0xe6, 0xa4, 0x39, 0x05}, // getPair selector
|
|
append(padLeft(token0.Bytes(), 32), padLeft(token1.Bytes(), 32)...)...)
|
|
|
|
result, err := d.client.CallContract(ctx, ethereum.CallMsg{
|
|
To: &factory,
|
|
Data: calldata,
|
|
}, nil)
|
|
if err != nil {
|
|
return common.Address{}, err
|
|
}
|
|
|
|
if len(result) == 0 {
|
|
return common.Address{}, nil
|
|
}
|
|
|
|
return common.BytesToAddress(result[12:]), nil
|
|
}
|
|
|
|
// fetchUniswapV2PoolInfo fetches pool information
|
|
func (d *Discovery) fetchUniswapV2PoolInfo(ctx context.Context, poolAddr, token0, token1 common.Address, protocol string) (*mevtypes.PoolInfo, error) {
|
|
// getReserves() returns (uint112,uint112,uint32)
|
|
// Simplified - in production use generated bindings
|
|
calldata := []byte{0x09, 0x02, 0xf1, 0xac} // getReserves selector
|
|
|
|
result, err := d.client.CallContract(ctx, ethereum.CallMsg{
|
|
To: &poolAddr,
|
|
Data: calldata,
|
|
}, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(result) < 64 {
|
|
return nil, fmt.Errorf("invalid reserves response")
|
|
}
|
|
|
|
reserve0 := new(big.Int).SetBytes(result[0:32])
|
|
reserve1 := new(big.Int).SetBytes(result[32:64])
|
|
|
|
// Estimate liquidity in USD (simplified - in production, use price oracle)
|
|
liquidityUSD := new(big.Int).Add(reserve0, reserve1)
|
|
|
|
return &mevtypes.PoolInfo{
|
|
Address: poolAddr,
|
|
Protocol: protocol,
|
|
Token0: token0,
|
|
Token1: token1,
|
|
Reserve0: reserve0,
|
|
Reserve1: reserve1,
|
|
Fee: 300, // 0.3% for UniswapV2
|
|
LiquidityUSD: liquidityUSD,
|
|
}, nil
|
|
}
|
|
|
|
// discoverUniswapV3Pools discovers UniswapV3 pools
|
|
func (d *Discovery) discoverUniswapV3Pools(ctx context.Context) error {
|
|
d.logger.Info("discovering UniswapV3 pools")
|
|
|
|
// UniswapV3 has multiple fee tiers
|
|
feeTiers := []uint32{100, 500, 3000, 10000}
|
|
|
|
for _, pair := range d.config.TokenPairs {
|
|
for _, fee := range feeTiers {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
default:
|
|
}
|
|
|
|
poolAddr, err := d.getUniswapV3Pool(ctx, pair.Token0, pair.Token1, fee)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if poolAddr == (common.Address{}) {
|
|
continue // Pool doesn't exist
|
|
}
|
|
|
|
// Fetch pool info
|
|
poolInfo, err := d.fetchUniswapV3PoolInfo(ctx, poolAddr, pair.Token0, pair.Token1, fee)
|
|
if err != nil {
|
|
d.logger.Debug("failed to fetch pool info", "pool", poolAddr.Hex(), "error", err)
|
|
continue
|
|
}
|
|
|
|
// Check minimum liquidity
|
|
if poolInfo.LiquidityUSD.Cmp(d.config.MinLiquidity) < 0 {
|
|
continue
|
|
}
|
|
|
|
// Add to cache
|
|
if err := d.cache.Add(poolInfo); err != nil {
|
|
d.logger.Warn("failed to add pool to cache", "pool", poolAddr.Hex(), "error", err)
|
|
continue
|
|
}
|
|
|
|
d.mu.Lock()
|
|
d.poolsDiscovered++
|
|
d.mu.Unlock()
|
|
|
|
d.logger.Debug("discovered pool",
|
|
"protocol", mevtypes.ProtocolUniswapV3,
|
|
"pool", poolAddr.Hex(),
|
|
"token0", pair.Token0.Hex(),
|
|
"token1", pair.Token1.Hex(),
|
|
"fee", fee,
|
|
"liquidity", poolInfo.LiquidityUSD.String(),
|
|
)
|
|
|
|
// Check if we've reached max pools
|
|
if d.poolsDiscovered >= d.config.MaxPools {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// getUniswapV3Pool gets a UniswapV3 pool address
|
|
func (d *Discovery) getUniswapV3Pool(ctx context.Context, token0, token1 common.Address, fee uint32) (common.Address, error) {
|
|
// getPool(address,address,uint24) returns (address)
|
|
// Simplified - in production use generated bindings
|
|
feeBytes := make([]byte, 32)
|
|
copy(feeBytes[29:], big.NewInt(int64(fee)).Bytes())
|
|
|
|
calldata := append([]byte{0x17, 0x79, 0x05, 0x7a}, // getPool selector
|
|
append(append(padLeft(token0.Bytes(), 32), padLeft(token1.Bytes(), 32)...), feeBytes...)...)
|
|
|
|
factoryAddr := UniswapV3FactoryAddress
|
|
result, err := d.client.CallContract(ctx, ethereum.CallMsg{
|
|
To: &factoryAddr,
|
|
Data: calldata,
|
|
}, nil)
|
|
if err != nil {
|
|
return common.Address{}, err
|
|
}
|
|
|
|
if len(result) == 0 {
|
|
return common.Address{}, nil
|
|
}
|
|
|
|
return common.BytesToAddress(result[12:]), nil
|
|
}
|
|
|
|
// fetchUniswapV3PoolInfo fetches UniswapV3 pool information
|
|
func (d *Discovery) fetchUniswapV3PoolInfo(ctx context.Context, poolAddr, token0, token1 common.Address, fee uint32) (*mevtypes.PoolInfo, error) {
|
|
// liquidity() returns (uint128)
|
|
// Simplified - in production use generated bindings
|
|
calldata := []byte{0x1a, 0x68, 0x65, 0x02} // liquidity selector
|
|
|
|
result, err := d.client.CallContract(ctx, ethereum.CallMsg{
|
|
To: &poolAddr,
|
|
Data: calldata,
|
|
}, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(result) < 16 {
|
|
return nil, fmt.Errorf("invalid liquidity response")
|
|
}
|
|
|
|
liquidity := new(big.Int).SetBytes(result[16:32])
|
|
|
|
return &mevtypes.PoolInfo{
|
|
Address: poolAddr,
|
|
Protocol: mevtypes.ProtocolUniswapV3,
|
|
Token0: token0,
|
|
Token1: token1,
|
|
Reserve0: liquidity, // Simplified
|
|
Reserve1: liquidity,
|
|
Fee: fee,
|
|
LiquidityUSD: liquidity,
|
|
}, nil
|
|
}
|
|
|
|
// padLeft pads bytes to the left with zeros
|
|
func padLeft(data []byte, length int) []byte {
|
|
if len(data) >= length {
|
|
return data
|
|
}
|
|
padded := make([]byte, length)
|
|
copy(padded[length-len(data):], data)
|
|
return padded
|
|
}
|
|
|
|
// GetStats returns discovery statistics
|
|
func (d *Discovery) GetStats() map[string]interface{} {
|
|
d.mu.Lock()
|
|
defer d.mu.Unlock()
|
|
|
|
return map[string]interface{}{
|
|
"pools_discovered": d.poolsDiscovered,
|
|
"pools_cached": d.cache.Count(),
|
|
}
|
|
}
|