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>
This commit is contained in:
Administrator
481
orig/pkg/risk/profit_validator.go
Normal file
481
orig/pkg/risk/profit_validator.go
Normal file
@@ -0,0 +1,481 @@
|
||||
package risk
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/big"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
|
||||
"github.com/fraktal/mev-beta/internal/logger"
|
||||
)
|
||||
|
||||
// ProfitValidator validates profitability of MEV opportunities
|
||||
type ProfitValidator struct {
|
||||
logger *logger.Logger
|
||||
mu sync.RWMutex
|
||||
|
||||
// Profit thresholds
|
||||
minProfitUSD float64 // Minimum profit in USD
|
||||
minProfitETH *big.Int // Minimum profit in ETH
|
||||
minProfitMargin float64 // Minimum profit margin percentage
|
||||
maxSlippage float64 // Maximum acceptable slippage
|
||||
maxGasPrice *big.Int // Maximum gas price willing to pay
|
||||
|
||||
// Historical performance tracking
|
||||
totalOpportunities uint64
|
||||
profitableOps uint64
|
||||
unprofitableOps uint64
|
||||
totalProfitETH *big.Int
|
||||
totalGasCostETH *big.Int
|
||||
averageGasCost *big.Int
|
||||
|
||||
// Performance metrics
|
||||
validationSuccessRate float64
|
||||
averageProfitMargin float64
|
||||
averageSlippage float64
|
||||
|
||||
// Token price tracking
|
||||
tokenPrices map[common.Address]*TokenPrice
|
||||
priceMu sync.RWMutex
|
||||
|
||||
// Validation configuration
|
||||
strictValidation bool // Whether to use strict validation rules
|
||||
}
|
||||
|
||||
// TokenPrice represents real-time token pricing data
|
||||
type TokenPrice struct {
|
||||
Address common.Address
|
||||
PriceUSD float64
|
||||
LastUpdated time.Time
|
||||
Confidence float64 // Price confidence 0-1
|
||||
Volume24h float64
|
||||
Volatility float64
|
||||
}
|
||||
|
||||
// ProfitValidationResult represents the result of a profit validation
|
||||
type ProfitValidationResult struct {
|
||||
OpportunityID string
|
||||
Valid bool
|
||||
Reason string
|
||||
ExpectedProfitETH *big.Int
|
||||
ExpectedProfitUSD float64
|
||||
GasCostETH *big.Int
|
||||
GasCostUSD float64
|
||||
NetProfitETH *big.Int
|
||||
NetProfitUSD float64
|
||||
ProfitMargin float64
|
||||
Slippage float64
|
||||
GasPrice *big.Int
|
||||
Acceptable bool
|
||||
Recommendation string
|
||||
Confidence float64
|
||||
RiskScore float64
|
||||
ValidationTime time.Duration
|
||||
}
|
||||
|
||||
// NewProfitValidator creates a new profit validator
|
||||
func NewProfitValidator(logger *logger.Logger) *ProfitValidator {
|
||||
return &ProfitValidator{
|
||||
logger: logger,
|
||||
minProfitUSD: 5.0, // $5 minimum profit
|
||||
minProfitETH: big.NewInt(10000000000000000), // 0.01 ETH minimum profit
|
||||
minProfitMargin: 0.005, // 0.5% minimum margin
|
||||
maxSlippage: 0.01, // 1% maximum slippage
|
||||
maxGasPrice: big.NewInt(20000000000), // 20 gwei max gas price
|
||||
totalOpportunities: 0,
|
||||
profitableOps: 0,
|
||||
unprofitableOps: 0,
|
||||
totalProfitETH: big.NewInt(0),
|
||||
totalGasCostETH: big.NewInt(0),
|
||||
averageGasCost: big.NewInt(0),
|
||||
validationSuccessRate: 0.0,
|
||||
averageProfitMargin: 0.0,
|
||||
averageSlippage: 0.0,
|
||||
tokenPrices: make(map[common.Address]*TokenPrice),
|
||||
strictValidation: true, // Default to strict validation
|
||||
}
|
||||
}
|
||||
|
||||
// ValidateProfit validates the profitability of an MEV opportunity
|
||||
func (pv *ProfitValidator) ValidateProfit(opportunityID string, expectedProfitETH *big.Int, gasCostETH *big.Int, slippage float64, gasPrice *big.Int) *ProfitValidationResult {
|
||||
startTime := time.Now()
|
||||
|
||||
pv.mu.Lock()
|
||||
pv.totalOpportunities++
|
||||
pv.mu.Unlock()
|
||||
|
||||
result := &ProfitValidationResult{
|
||||
OpportunityID: opportunityID,
|
||||
Valid: false,
|
||||
Reason: "",
|
||||
ExpectedProfitETH: expectedProfitETH,
|
||||
ExpectedProfitUSD: 0.0,
|
||||
GasCostETH: gasCostETH,
|
||||
GasCostUSD: 0.0,
|
||||
NetProfitETH: big.NewInt(0),
|
||||
NetProfitUSD: 0.0,
|
||||
ProfitMargin: 0.0,
|
||||
Slippage: slippage,
|
||||
GasPrice: gasPrice,
|
||||
Acceptable: false,
|
||||
Recommendation: "",
|
||||
Confidence: 0.0,
|
||||
RiskScore: 0.0,
|
||||
ValidationTime: 0,
|
||||
}
|
||||
|
||||
// Calculate USD values using token prices
|
||||
expectedProfitUSD := pv.convertETHToUSD(expectedProfitETH)
|
||||
gasCostUSD := pv.convertETHToUSD(gasCostETH)
|
||||
|
||||
result.ExpectedProfitUSD = expectedProfitUSD
|
||||
result.GasCostUSD = gasCostUSD
|
||||
|
||||
// Calculate net profit
|
||||
netProfitETH := new(big.Int).Sub(expectedProfitETH, gasCostETH)
|
||||
if netProfitETH.Sign() < 0 {
|
||||
netProfitETH = big.NewInt(0)
|
||||
}
|
||||
|
||||
result.NetProfitETH = netProfitETH
|
||||
result.NetProfitUSD = pv.convertETHToUSD(netProfitETH)
|
||||
|
||||
// Calculate profit margin
|
||||
if expectedProfitETH.Sign() > 0 {
|
||||
margin := new(big.Float).Quo(new(big.Float).SetInt(netProfitETH), new(big.Float).SetInt(expectedProfitETH))
|
||||
marginFloat, _ := margin.Float64()
|
||||
result.ProfitMargin = marginFloat * 100 // Convert to percentage
|
||||
}
|
||||
|
||||
// Perform validation checks
|
||||
valid, reason := pv.performValidationChecks(expectedProfitETH, netProfitETH, gasCostETH, slippage, gasPrice)
|
||||
result.Valid = valid
|
||||
result.Reason = reason
|
||||
|
||||
// Determine if opportunity is acceptable
|
||||
acceptable, recommendation := pv.isAcceptable(expectedProfitETH, netProfitETH, gasCostETH, slippage, gasPrice)
|
||||
result.Acceptable = acceptable
|
||||
result.Recommendation = recommendation
|
||||
|
||||
// Calculate confidence based on validation results
|
||||
result.Confidence = pv.calculateConfidence(valid, acceptable, result.ProfitMargin, slippage)
|
||||
result.RiskScore = pv.calculateRiskScore(slippage, gasPrice)
|
||||
|
||||
// Update statistics
|
||||
pv.mu.Lock()
|
||||
if valid && acceptable {
|
||||
pv.profitableOps++
|
||||
pv.totalProfitETH.Add(pv.totalProfitETH, netProfitETH)
|
||||
pv.totalGasCostETH.Add(pv.totalGasCostETH, gasCostETH)
|
||||
} else {
|
||||
pv.unprofitableOps++
|
||||
}
|
||||
pv.updateValidationMetrics()
|
||||
pv.mu.Unlock()
|
||||
|
||||
result.ValidationTime = time.Since(startTime)
|
||||
|
||||
// Log validation result
|
||||
if result.Valid && result.Acceptable {
|
||||
pv.logger.Info(fmt.Sprintf("✅ Profit validation PASSED for %s: Net profit %s ETH ($%.2f), Margin %.2f%%",
|
||||
opportunityID, formatEther(result.NetProfitETH), result.NetProfitUSD, result.ProfitMargin))
|
||||
} else {
|
||||
pv.logger.Debug(fmt.Sprintf("❌ Profit validation FAILED for %s: %s", opportunityID, result.Reason))
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// performValidationChecks performs all validation checks
|
||||
func (pv *ProfitValidator) performValidationChecks(expectedProfitETH, netProfitETH, gasCostETH *big.Int, slippage float64, gasPrice *big.Int) (bool, string) {
|
||||
// Check minimum profit in ETH
|
||||
if expectedProfitETH.Cmp(pv.minProfitETH) < 0 {
|
||||
return false, fmt.Sprintf("Expected profit %s ETH below minimum %s ETH",
|
||||
formatEther(expectedProfitETH), formatEther(pv.minProfitETH))
|
||||
}
|
||||
|
||||
// Check minimum profit in USD
|
||||
expectedProfitUSD := pv.convertETHToUSD(expectedProfitETH)
|
||||
if expectedProfitUSD < pv.minProfitUSD {
|
||||
return false, fmt.Sprintf("Expected profit $%.2f below minimum $%.2f",
|
||||
expectedProfitUSD, pv.minProfitUSD)
|
||||
}
|
||||
|
||||
// Check net profit is positive
|
||||
if netProfitETH.Sign() <= 0 {
|
||||
return false, fmt.Sprintf("Net profit %s ETH is not positive",
|
||||
formatEther(netProfitETH))
|
||||
}
|
||||
|
||||
// Check slippage tolerance
|
||||
if slippage > pv.maxSlippage {
|
||||
return false, fmt.Sprintf("Slippage %.2f%% exceeds maximum %.2f%%",
|
||||
slippage*100, pv.maxSlippage*100)
|
||||
}
|
||||
|
||||
// Check gas price limits
|
||||
if gasPrice.Cmp(pv.maxGasPrice) > 0 {
|
||||
return false, fmt.Sprintf("Gas price %s gwei exceeds maximum %s gwei",
|
||||
formatGwei(gasPrice), formatGwei(pv.maxGasPrice))
|
||||
}
|
||||
|
||||
// Check gas cost vs profit ratio
|
||||
if gasCostETH.Sign() > 0 && expectedProfitETH.Sign() > 0 {
|
||||
gasRatio := new(big.Float).Quo(new(big.Float).SetInt(gasCostETH), new(big.Float).SetInt(expectedProfitETH))
|
||||
gasRatioFloat, _ := gasRatio.Float64()
|
||||
if gasRatioFloat > 0.5 { // Gas cost > 50% of expected profit
|
||||
return false, fmt.Sprintf("Gas cost %s ETH (%.1f%%) too high relative to profit %s ETH",
|
||||
formatEther(gasCostETH), gasRatioFloat*100, formatEther(expectedProfitETH))
|
||||
}
|
||||
}
|
||||
|
||||
return true, "All validation checks passed"
|
||||
}
|
||||
|
||||
// isAcceptable determines if an opportunity is acceptable
|
||||
func (pv *ProfitValidator) isAcceptable(expectedProfitETH, netProfitETH, gasCostETH *big.Int, slippage float64, gasPrice *big.Int) (bool, string) {
|
||||
// Calculate profit margin
|
||||
var profitMargin float64
|
||||
if expectedProfitETH.Sign() > 0 {
|
||||
margin := new(big.Float).Quo(new(big.Float).SetInt(netProfitETH), new(big.Float).SetInt(expectedProfitETH))
|
||||
marginFloat, _ := margin.Float64()
|
||||
profitMargin = marginFloat * 100 // Convert to percentage
|
||||
}
|
||||
|
||||
// Check minimum profit margin
|
||||
if profitMargin < pv.minProfitMargin*100 {
|
||||
return false, fmt.Sprintf("Profit margin %.2f%% below minimum %.2f%%",
|
||||
profitMargin, pv.minProfitMargin*100)
|
||||
}
|
||||
|
||||
// For strict validation, apply additional checks
|
||||
if pv.strictValidation {
|
||||
// Check if net profit is at least 2x gas cost
|
||||
doubleGasCost := new(big.Int).Mul(gasCostETH, big.NewInt(2))
|
||||
if netProfitETH.Cmp(doubleGasCost) < 0 {
|
||||
return false, fmt.Sprintf("Net profit %s ETH not at least 2x gas cost %s ETH",
|
||||
formatEther(netProfitETH), formatEther(gasCostETH))
|
||||
}
|
||||
|
||||
// Check if profit margin is at least 2x minimum
|
||||
if profitMargin < pv.minProfitMargin*200 {
|
||||
return false, fmt.Sprintf("Profit margin %.2f%% not at least 2x minimum %.2f%%",
|
||||
profitMargin, pv.minProfitMargin*200)
|
||||
}
|
||||
}
|
||||
|
||||
return true, "Opportunity is acceptable"
|
||||
}
|
||||
|
||||
// calculateConfidence calculates confidence in the validation result
|
||||
func (pv *ProfitValidator) calculateConfidence(valid, acceptable bool, profitMargin, slippage float64) float64 {
|
||||
if !valid || !acceptable {
|
||||
return 0.1 // Low confidence for invalid opportunities
|
||||
}
|
||||
|
||||
// Start with base confidence
|
||||
confidence := 0.5
|
||||
|
||||
// Increase confidence based on profit margin
|
||||
if profitMargin > pv.minProfitMargin*300 { // 3x minimum margin
|
||||
confidence += 0.3
|
||||
} else if profitMargin > pv.minProfitMargin*200 { // 2x minimum margin
|
||||
confidence += 0.2
|
||||
} else if profitMargin > pv.minProfitMargin*150 { // 1.5x minimum margin
|
||||
confidence += 0.1
|
||||
}
|
||||
|
||||
// Increase confidence for low slippage
|
||||
if slippage < pv.maxSlippage*0.3 { // 30% of max slippage
|
||||
confidence += 0.1
|
||||
} else if slippage < pv.maxSlippage*0.5 { // 50% of max slippage
|
||||
confidence += 0.05
|
||||
}
|
||||
|
||||
// Cap at maximum confidence
|
||||
if confidence > 0.95 {
|
||||
confidence = 0.95
|
||||
}
|
||||
|
||||
return confidence
|
||||
}
|
||||
|
||||
// calculateRiskScore calculates a risk score for the opportunity
|
||||
func (pv *ProfitValidator) calculateRiskScore(slippage float64, gasPrice *big.Int) float64 {
|
||||
// Base risk (0-0.2)
|
||||
baseRisk := 0.1
|
||||
|
||||
// Slippage risk (0-0.3)
|
||||
slippageRisk := slippage / pv.maxSlippage * 0.3
|
||||
if slippageRisk > 0.3 {
|
||||
slippageRisk = 0.3
|
||||
}
|
||||
|
||||
// Gas price risk (0-0.3)
|
||||
gasRisk := 0.0
|
||||
if gasPrice != nil && pv.maxGasPrice != nil && pv.maxGasPrice.Sign() > 0 {
|
||||
gasRatio := new(big.Float).Quo(new(big.Float).SetInt(gasPrice), new(big.Float).SetInt(pv.maxGasPrice))
|
||||
gasRatioFloat, _ := gasRatio.Float64()
|
||||
gasRisk = gasRatioFloat * 0.3
|
||||
if gasRisk > 0.3 {
|
||||
gasRisk = 0.3
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate total risk score
|
||||
totalRisk := baseRisk + slippageRisk + gasRisk
|
||||
if totalRisk > 1.0 {
|
||||
totalRisk = 1.0
|
||||
}
|
||||
|
||||
return totalRisk
|
||||
}
|
||||
|
||||
// updateValidationMetrics updates validation metrics
|
||||
func (pv *ProfitValidator) updateValidationMetrics() {
|
||||
if pv.totalOpportunities > 0 {
|
||||
pv.validationSuccessRate = float64(pv.profitableOps) / float64(pv.totalOpportunities)
|
||||
}
|
||||
|
||||
// Update average metrics (simplified)
|
||||
if pv.profitableOps > 0 {
|
||||
avgProfitMargin := new(big.Float).Quo(new(big.Float).SetInt(pv.totalProfitETH), big.NewFloat(float64(pv.profitableOps)))
|
||||
avgMarginFloat, _ := avgProfitMargin.Float64()
|
||||
pv.averageProfitMargin = avgMarginFloat * 100 // Convert to percentage
|
||||
}
|
||||
}
|
||||
|
||||
// convertETHToUSD converts ETH amount to USD using current token prices
|
||||
func (pv *ProfitValidator) convertETHToUSD(ethAmount *big.Int) float64 {
|
||||
if ethAmount == nil {
|
||||
return 0.0
|
||||
}
|
||||
|
||||
// Get current ETH price in USD
|
||||
ethPrice := pv.getTokenPriceUSD(common.HexToAddress("0x82af49447d8a07e3bd95bd0d56f35241523fbab1")) // WETH
|
||||
if ethPrice == 0.0 {
|
||||
ethPrice = 2000.0 // Default to $2000 ETH
|
||||
}
|
||||
|
||||
// Convert ETH to USD
|
||||
ethFloat := new(big.Float).SetInt(ethAmount)
|
||||
ethDivisor := new(big.Float).SetFloat64(1e18) // Convert wei to ETH
|
||||
ethETH := new(big.Float).Quo(ethFloat, ethDivisor)
|
||||
|
||||
usdFloat := new(big.Float).Mul(ethETH, big.NewFloat(ethPrice))
|
||||
usdValue, _ := usdFloat.Float64()
|
||||
|
||||
return usdValue
|
||||
}
|
||||
|
||||
// getTokenPriceUSD gets the USD price of a token
|
||||
func (pv *ProfitValidator) getTokenPriceUSD(tokenAddr common.Address) float64 {
|
||||
pv.priceMu.RLock()
|
||||
defer pv.priceMu.RUnlock()
|
||||
|
||||
if price, exists := pv.tokenPrices[tokenAddr]; exists {
|
||||
// Check if price is recent (within 5 minutes)
|
||||
if time.Since(price.LastUpdated) < 5*time.Minute {
|
||||
return price.PriceUSD
|
||||
}
|
||||
}
|
||||
|
||||
// Return known prices for common tokens
|
||||
knownPrices := map[common.Address]float64{
|
||||
common.HexToAddress("0x82af49447d8a07e3bd95bd0d56f35241523fbab1"): 2000.0, // WETH
|
||||
common.HexToAddress("0xaf88d065e77c8cc2239327c5edb3a432268e5831"): 1.0, // USDC
|
||||
common.HexToAddress("0xff970a61a04b1ca14834a43f5de4533ebddb5cc8"): 1.0, // USDC.e
|
||||
common.HexToAddress("0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"): 1.0, // USDT
|
||||
common.HexToAddress("0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f"): 43000.0, // WBTC
|
||||
common.HexToAddress("0x912ce59144191c1204e64559fe8253a0e49e6548"): 0.75, // ARB
|
||||
common.HexToAddress("0xfc5a1a6eb076a2c7ad06ed22c90d7e710e35ad0a"): 45.0, // GMX
|
||||
common.HexToAddress("0xf97f4df75117a78c1a5a0dbb814af92458539fb4"): 12.0, // LINK
|
||||
common.HexToAddress("0xfa7f8980b0f1e64a2062791cc3b0871572f1f7f0"): 8.0, // UNI
|
||||
common.HexToAddress("0xba5ddd1f9d7f570dc94a51479a000e3bce967196"): 85.0, // AAVE
|
||||
}
|
||||
|
||||
if price, exists := knownPrices[tokenAddr]; exists {
|
||||
return price
|
||||
}
|
||||
|
||||
// Default to $0 for unknown tokens
|
||||
return 0.0
|
||||
}
|
||||
|
||||
// UpdateTokenPrice updates the price of a token
|
||||
func (pv *ProfitValidator) UpdateTokenPrice(tokenAddr common.Address, priceUSD float64, confidence float64) {
|
||||
pv.priceMu.Lock()
|
||||
defer pv.priceMu.Unlock()
|
||||
|
||||
pv.tokenPrices[tokenAddr] = &TokenPrice{
|
||||
Address: tokenAddr,
|
||||
PriceUSD: priceUSD,
|
||||
LastUpdated: time.Now(),
|
||||
Confidence: confidence,
|
||||
Volume24h: 0.0, // Would be populated from real data
|
||||
Volatility: 0.0, // Would be populated from real data
|
||||
}
|
||||
}
|
||||
|
||||
// GetStatistics returns validation statistics
|
||||
func (pv *ProfitValidator) GetStatistics() map[string]interface{} {
|
||||
pv.mu.RLock()
|
||||
defer pv.mu.RUnlock()
|
||||
|
||||
return map[string]interface{}{
|
||||
"total_opportunities": pv.totalOpportunities,
|
||||
"profitable_opportunities": pv.profitableOps,
|
||||
"unprofitable_opportunities": pv.unprofitableOps,
|
||||
"validation_success_rate": pv.validationSuccessRate * 100, // Convert to percentage
|
||||
"average_profit_margin": pv.averageProfitMargin,
|
||||
"average_slippage": pv.averageSlippage * 100, // Convert to percentage
|
||||
"total_profit_eth": formatEther(pv.totalProfitETH),
|
||||
"total_gas_cost_eth": formatEther(pv.totalGasCostETH),
|
||||
"tracked_tokens": len(pv.tokenPrices),
|
||||
"strict_validation": pv.strictValidation,
|
||||
}
|
||||
}
|
||||
|
||||
// SetStrictValidation enables or disables strict validation
|
||||
func (pv *ProfitValidator) SetStrictValidation(strict bool) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.strictValidation = strict
|
||||
}
|
||||
|
||||
// SetMinProfitUSD sets the minimum profit threshold in USD
|
||||
func (pv *ProfitValidator) SetMinProfitUSD(minProfit float64) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.minProfitUSD = minProfit
|
||||
}
|
||||
|
||||
// SetMinProfitETH sets the minimum profit threshold in ETH
|
||||
func (pv *ProfitValidator) SetMinProfitETH(minProfit *big.Int) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.minProfitETH = minProfit
|
||||
}
|
||||
|
||||
// SetMinProfitMargin sets the minimum profit margin percentage
|
||||
func (pv *ProfitValidator) SetMinProfitMargin(minMargin float64) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.minProfitMargin = minMargin
|
||||
}
|
||||
|
||||
// SetMaxSlippage sets the maximum acceptable slippage
|
||||
func (pv *ProfitValidator) SetMaxSlippage(maxSlippage float64) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.maxSlippage = maxSlippage
|
||||
}
|
||||
|
||||
// SetMaxGasPrice sets the maximum gas price willing to pay
|
||||
func (pv *ProfitValidator) SetMaxGasPrice(maxGasPrice *big.Int) {
|
||||
pv.mu.Lock()
|
||||
defer pv.mu.Unlock()
|
||||
pv.maxGasPrice = maxGasPrice
|
||||
}
|
||||
Reference in New Issue
Block a user