42244ab42b
- Fixed duplicate package declarations in arbitrum parser - Resolved missing methods in events parser (ParseTransaction, AddKnownPool) - Fixed logger test assertion failures by updating expected log format - Updated NewPipeline constructor calls to include ethClient parameter - Fixed nil pointer dereference in pipeline processing - Corrected known pool mappings for protocol identification - Removed duplicate entries in parser initialization - Added proper error handling and validation in parsers These changes resolve the build failures and integration test crashes that were preventing proper testing of the MEV bot functionality. Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
387 lines
12 KiB
Go
387 lines
12 KiB
Go
package arbitrum
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/fraktal/mev-beta/internal/logger"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// createValidRLPTransaction creates a valid RLP-encoded transaction for testing
|
|
func createValidRLPTransaction() []byte {
|
|
tx := types.NewTransaction(
|
|
0, // nonce
|
|
common.HexToAddress("0x742d35Cc"), // to
|
|
big.NewInt(1000), // value
|
|
21000, // gas
|
|
big.NewInt(1000000000), // gas price
|
|
[]byte{}, // data
|
|
)
|
|
|
|
rlpData, _ := tx.MarshalBinary()
|
|
return rlpData
|
|
}
|
|
|
|
// createValidSwapCalldata creates valid swap function calldata
|
|
func createValidSwapCalldata() []byte {
|
|
// Create properly formatted ABI-encoded calldata for swapExactTokensForTokens
|
|
data := make([]byte, 256) // More space for proper ABI encoding
|
|
|
|
// amountIn (1000 tokens) - right-aligned in 32 bytes
|
|
amountIn := big.NewInt(1000000000000000000)
|
|
amountInBytes := amountIn.Bytes()
|
|
copy(data[32-len(amountInBytes):32], amountInBytes)
|
|
|
|
// amountOutMin (900 tokens) - right-aligned in 32 bytes
|
|
amountOutMin := big.NewInt(900000000000000000)
|
|
amountOutMinBytes := amountOutMin.Bytes()
|
|
copy(data[64-len(amountOutMinBytes):64], amountOutMinBytes)
|
|
|
|
// path offset (0xa0 = 160 decimal, pointer to array) - right-aligned
|
|
pathOffset := big.NewInt(160)
|
|
pathOffsetBytes := pathOffset.Bytes()
|
|
copy(data[96-len(pathOffsetBytes):96], pathOffsetBytes)
|
|
|
|
// recipient address - right-aligned in 32 bytes
|
|
recipient := common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F")
|
|
copy(data[96+12:128], recipient.Bytes())
|
|
|
|
// deadline - right-aligned in 32 bytes
|
|
deadline := big.NewInt(1234567890)
|
|
deadlineBytes := deadline.Bytes()
|
|
copy(data[160-len(deadlineBytes):160], deadlineBytes)
|
|
|
|
// Add array length and tokens for path (simplified)
|
|
// Array length = 2
|
|
arrayLen := big.NewInt(2)
|
|
arrayLenBytes := arrayLen.Bytes()
|
|
copy(data[192-len(arrayLenBytes):192], arrayLenBytes)
|
|
|
|
// Token addresses would go here, but we'll keep it simple
|
|
|
|
return data
|
|
}
|
|
|
|
// createValidExactInputSingleData creates valid exactInputSingle calldata
|
|
func createValidExactInputSingleData() []byte {
|
|
// Create properly formatted ABI-encoded calldata for exactInputSingle
|
|
data := make([]byte, 256) // More space for proper ABI encoding
|
|
|
|
// tokenIn at position 0-31 (address in last 20 bytes)
|
|
copy(data[12:32], common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").Bytes()) // USDC
|
|
|
|
// tokenOut at position 32-63 (address in last 20 bytes)
|
|
copy(data[44:64], common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").Bytes()) // WETH
|
|
|
|
// recipient at position 96-127 (address in last 20 bytes)
|
|
copy(data[108:128], common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F").Bytes())
|
|
|
|
// deadline at position 128-159 (uint64 in last 8 bytes)
|
|
binary.BigEndian.PutUint64(data[152:160], 1234567890)
|
|
|
|
// amountIn at position 160-191
|
|
amountIn := big.NewInt(1000000000) // 1000 USDC (6 decimals)
|
|
amountInBytes := amountIn.Bytes()
|
|
copy(data[192-len(amountInBytes):192], amountInBytes)
|
|
|
|
return data
|
|
}
|
|
|
|
func TestL2MessageParser_ParseL2Message(t *testing.T) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
tests := []struct {
|
|
name string
|
|
messageData []byte
|
|
messageNumber *big.Int
|
|
timestamp uint64
|
|
expectError bool
|
|
expectedType L2MessageType
|
|
}{
|
|
{
|
|
name: "Empty message",
|
|
messageData: []byte{},
|
|
messageNumber: big.NewInt(1),
|
|
timestamp: 1234567890,
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "Short message",
|
|
messageData: []byte{0x00, 0x00, 0x00},
|
|
messageNumber: big.NewInt(2),
|
|
timestamp: 1234567890,
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "L2 Transaction message",
|
|
messageData: append([]byte{0x00, 0x00, 0x00, 0x03}, createValidRLPTransaction()...),
|
|
messageNumber: big.NewInt(3),
|
|
timestamp: 1234567890,
|
|
expectError: false,
|
|
expectedType: L2Transaction,
|
|
},
|
|
{
|
|
name: "L2 Batch message",
|
|
messageData: append([]byte{0x00, 0x00, 0x00, 0x07}, make([]byte, 64)...),
|
|
messageNumber: big.NewInt(4),
|
|
timestamp: 1234567890,
|
|
expectError: false,
|
|
expectedType: L2BatchSubmission,
|
|
},
|
|
{
|
|
name: "Unknown message type",
|
|
messageData: append([]byte{0x00, 0x00, 0x00, 0xFF}, make([]byte, 32)...),
|
|
messageNumber: big.NewInt(5),
|
|
timestamp: 1234567890,
|
|
expectError: false,
|
|
expectedType: L2Unknown,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := parser.ParseL2Message(tt.messageData, tt.messageNumber, tt.timestamp)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
assert.Equal(t, tt.expectedType, result.Type)
|
|
assert.Equal(t, tt.messageNumber, result.MessageNumber)
|
|
assert.Equal(t, tt.timestamp, result.Timestamp)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestL2MessageParser_ParseDEXInteraction(t *testing.T) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
// Create a mock transaction for testing
|
|
createMockTx := func(to common.Address, data []byte) *types.Transaction {
|
|
return types.NewTransaction(
|
|
0,
|
|
to,
|
|
big.NewInt(0),
|
|
21000,
|
|
big.NewInt(1000000000),
|
|
data,
|
|
)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
tx *types.Transaction
|
|
expectError bool
|
|
expectSwap bool
|
|
}{
|
|
{
|
|
name: "Contract creation transaction",
|
|
tx: types.NewContractCreation(0, big.NewInt(0), 21000, big.NewInt(1000000000), []byte{}),
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "Unknown router address",
|
|
tx: createMockTx(common.HexToAddress("0x1234567890123456789012345678901234567890"), []byte{0x38, 0xed, 0x17, 0x39}),
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "Uniswap V3 router with exactInputSingle",
|
|
tx: createMockTx(
|
|
common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"), // Uniswap V3 Router
|
|
append([]byte{0x41, 0x4b, 0xf3, 0x89}, createValidExactInputSingleData()...), // exactInputSingle with proper data
|
|
),
|
|
expectError: false,
|
|
expectSwap: true,
|
|
},
|
|
{
|
|
name: "SushiSwap router - expect error due to complex ABI",
|
|
tx: createMockTx(
|
|
common.HexToAddress("0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506"), // SushiSwap Router
|
|
[]byte{0x38, 0xed, 0x17, 0x39}, // swapExactTokensForTokens selector only
|
|
),
|
|
expectError: true, // Expected to fail due to insufficient ABI data
|
|
expectSwap: false,
|
|
},
|
|
{
|
|
name: "Unknown function selector",
|
|
tx: createMockTx(
|
|
common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"), // Uniswap V3 Router
|
|
[]byte{0xFF, 0xFF, 0xFF, 0xFF}, // Unknown selector
|
|
),
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := parser.ParseDEXInteraction(tt.tx)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
|
|
if tt.expectSwap {
|
|
assert.NotEmpty(t, result.Protocol)
|
|
assert.Equal(t, *tt.tx.To(), result.Router)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestL2MessageParser_IsSignificantSwap(t *testing.T) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
tests := []struct {
|
|
name string
|
|
interaction *DEXInteraction
|
|
minAmountUSD float64
|
|
expectSignificant bool
|
|
}{
|
|
{
|
|
name: "Small swap - not significant",
|
|
interaction: &DEXInteraction{
|
|
AmountIn: big.NewInt(100000000000000000), // 0.1 ETH
|
|
},
|
|
minAmountUSD: 10.0,
|
|
expectSignificant: false,
|
|
},
|
|
{
|
|
name: "Large swap - significant",
|
|
interaction: &DEXInteraction{
|
|
AmountIn: big.NewInt(2000000000000000000), // 2 ETH
|
|
},
|
|
minAmountUSD: 10.0,
|
|
expectSignificant: true,
|
|
},
|
|
{
|
|
name: "Nil amount - not significant",
|
|
interaction: &DEXInteraction{
|
|
AmountIn: nil,
|
|
},
|
|
minAmountUSD: 10.0,
|
|
expectSignificant: false,
|
|
},
|
|
{
|
|
name: "Zero amount - not significant",
|
|
interaction: &DEXInteraction{
|
|
AmountIn: big.NewInt(0),
|
|
},
|
|
minAmountUSD: 10.0,
|
|
expectSignificant: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := parser.IsSignificantSwap(tt.interaction, tt.minAmountUSD)
|
|
assert.Equal(t, tt.expectSignificant, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestL2MessageParser_ParseExactInputSingle(t *testing.T) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
// Create test data for exactInputSingle call
|
|
// This is a simplified version - real data would be properly ABI encoded
|
|
data := make([]byte, 256)
|
|
|
|
// tokenIn at position 0-31 (address in last 20 bytes)
|
|
copy(data[12:32], common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").Bytes()) // USDC
|
|
|
|
// tokenOut at position 32-63 (address in last 20 bytes)
|
|
copy(data[44:64], common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").Bytes()) // WETH
|
|
|
|
// recipient at position 96-127 (address in last 20 bytes)
|
|
copy(data[108:128], common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F").Bytes())
|
|
|
|
// deadline at position 128-159 (uint64 in last 8 bytes)
|
|
binary.BigEndian.PutUint64(data[152:160], 1234567890)
|
|
|
|
// amountIn at position 160-191
|
|
amountIn := big.NewInt(1000000000) // 1000 USDC (6 decimals)
|
|
amountInBytes := amountIn.Bytes()
|
|
copy(data[192-len(amountInBytes):192], amountInBytes)
|
|
|
|
interaction := &DEXInteraction{}
|
|
result, err := parser.parseExactInputSingle(interaction, data)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), result.TokenIn)
|
|
assert.Equal(t, common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), result.TokenOut)
|
|
assert.Equal(t, common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F"), result.Recipient)
|
|
assert.Equal(t, uint64(1234567890), result.Deadline)
|
|
// Note: AmountIn comparison might need adjustment based on how the data is packed
|
|
}
|
|
|
|
func TestL2MessageParser_InitialSetup(t *testing.T) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
// Test that we can add and identify known pools
|
|
// This test verifies the internal pool tracking functionality
|
|
|
|
// The parser should have some pre-configured pools
|
|
assert.NotNil(t, parser)
|
|
|
|
// Verify parser was created with proper initialization
|
|
assert.NotNil(t, parser.logger)
|
|
}
|
|
|
|
func BenchmarkL2MessageParser_ParseL2Message(b *testing.B) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
// Create test message data
|
|
messageData := append([]byte{0x00, 0x00, 0x00, 0x03}, make([]byte, 100)...)
|
|
messageNumber := big.NewInt(1)
|
|
timestamp := uint64(1234567890)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, err := parser.ParseL2Message(messageData, messageNumber, timestamp)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkL2MessageParser_ParseDEXInteraction(b *testing.B) {
|
|
logger := logger.New("info", "text", "")
|
|
parser := NewL2MessageParser(logger)
|
|
|
|
// Create mock transaction
|
|
tx := types.NewTransaction(
|
|
0,
|
|
common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"), // Uniswap V3 Router
|
|
big.NewInt(0),
|
|
21000,
|
|
big.NewInt(1000000000),
|
|
[]byte{0x41, 0x4b, 0xf3, 0x89}, // exactInputSingle selector
|
|
)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
_, err := parser.ParseDEXInteraction(tx)
|
|
if err != nil && err.Error() != "insufficient data for exactInputSingle" {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|