opt: bidder timer

miner/bidder.go

@@ -13,14 +13,18 @@
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/miner/validatorclient"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
 const maxBid int64 = 3
 
+var bidSimulationLeftOver = 50 * time.Millisecond
+var bidSendLeftOver = 20 * time.Millisecond
+
 type ValidatorConfig struct {
 	Address common.Address
 	URL     string
@@ -44,26 +48,33 @@
 	bestWorksMu sync.RWMutex
 	bestWorks   map[int64]*environment
 
-	newBidCh chan *environment
-	exitCh   chan struct{}
+	chainHeadCh  chan core.ChainHeadEvent
+	chainHeadSub event.Subscription
 
-	wg sync.WaitGroup
+	exitCh chan struct{}
 
 	wallet accounts.Wallet
 }
 
-func NewBidder(config *MevConfig, delayLeftOver time.Duration, engine consensus.Engine, eth Backend) *Bidder {
+func NewBidder(config *MevConfig, chain *core.BlockChain, delayLeftOver time.Duration, engine consensus.Engine, eth Backend) *Bidder {
 	b := &Bidder{
 		config:        config,
 		delayLeftOver: delayLeftOver,
 		engine:        engine,
 		chain:         eth.BlockChain(),
 		validators:    make(map[common.Address]*validator),
 		bestWorks:     make(map[int64]*environment),
-		newBidCh:      make(chan *environment, 10),
+		chainHeadCh:   make(chan core.ChainHeadEvent, chainHeadChanSize),
 		exitCh:        make(chan struct{}),
 	}
 
+	if config.BidSendLeftOver == 0 {
+		config.BidSendLeftOver = bidSendLeftOver
+		log.Info("Bidder: use default bid send left over", "duration", bidSendLeftOver)
+	}
+
+	b.chainHeadSub = chain.SubscribeChainHeadEvent(b.chainHeadCh)
+
 	if !config.BuilderEnabled {
 		return b
 	}
@@ -83,75 +94,77 @@
 		log.Warn("Bidder: No valid validators")
 	}
 
-	b.wg.Add(2)
 	go b.mainLoop()
 	go b.reconnectLoop()
 
 	return b
 }
 
 func (b *Bidder) mainLoop() {
-	defer b.wg.Done()
+	defer b.chainHeadSub.Unsubscribe()
 
-	timer := time.NewTimer(0)
-	defer timer.Stop()
-	<-timer.C // discard the initial tick
+	if !b.enabled() {
+		return
+	}
 
-	var (
-		bidNum          int64 = 0
-		betterBidBefore time.Time
-		currentHeight   = b.chain.CurrentBlock().Number.Int64()
-	)
-	for {
-		select {
-		case work := <-b.newBidCh:
-			if work.header.Number.Int64() > currentHeight {
-				currentHeight = work.header.Number.Int64()
-
-				bidNum = 0
-				parentHeader := b.chain.GetHeaderByHash(work.header.ParentHash)
-				var bidSimulationLeftOver time.Duration
-				b.validatorsMu.RLock()
-				if b.validators[work.coinbase] != nil {
-					bidSimulationLeftOver = b.validators[work.coinbase].BidSimulationLeftOver
+	for chainHeadEvent := range b.chainHeadCh {
+		currentNumber := chainHeadEvent.Block.Number().Int64()
+		b.deleteBestWork(currentNumber)
+
+		nextBlockNumber := currentNumber + 1
+		betterBidBefore := bidutil.BidBetterBefore(chainHeadEvent.Block.Header(), b.chain.Config().Parlia.Period,
+			b.delayLeftOver, bidSimulationLeftOver)
+
+		if betterBidBefore.Before(time.Now()) {
+			continue
+		}
+
+		first := time.NewTimer(time.Until(betterBidBefore.Add(-3 * b.config.BidSendLeftOver)))
+		second := time.NewTimer(time.Until(betterBidBefore.Add(-2 * b.config.BidSendLeftOver)))
+		third := time.NewTimer(time.Until(betterBidBefore.Add(-b.config.BidSendLeftOver)))
+		exit := time.NewTimer(time.Until(betterBidBefore))
+
+	LOOP:
+		for {
+			select {
+			case <-first.C:
+				work := b.getBestWork(nextBlockNumber)
+				if work != nil {
+					log.Info("Bidder: try to bid (first)", "number", nextBlockNumber)
+					go b.bid(work)
 				}
-				b.validatorsMu.RUnlock()
-				betterBidBefore = bidutil.BidBetterBefore(parentHeader, b.chain.Config().Parlia.Period, b.delayLeftOver,
-					bidSimulationLeftOver)
-
-				if time.Now().After(betterBidBefore) {
-					timer.Reset(0)
-				} else {
-					timer.Reset(time.Until(betterBidBefore) / time.Duration(maxBid))
+			case <-second.C:
+				work := b.getBestWork(nextBlockNumber)
+				if work != nil {
+					log.Info("Bidder: try to bid (second)", "number", nextBlockNumber)
+					go b.bid(work)
 				}
-			}
-			if bidNum < maxBid && b.isBestWork(work) {
-				// update the bestWork and do bid
-				b.setBestWork(work)
-			}
-		case <-timer.C:
-			go func() {
-				w := b.getBestWork(currentHeight)
-				if w != nil {
-					b.bid(w)
-					bidNum++
-					if bidNum < maxBid && time.Now().Before(betterBidBefore) {
-						timer.Reset(time.Until(betterBidBefore) / time.Duration(maxBid-bidNum))
-					}
+			case <-third.C:
+				work := b.getBestWork(nextBlockNumber)
+				if work != nil {
+					log.Info("Bidder: try to bid (third)", "number", nextBlockNumber)
+					go b.bid(work)
 				}
-			}()
-		case <-b.exitCh:
-			return
+			case <-exit.C:
+				break LOOP
+			case <-b.exitCh:
+				return
+			case <-b.chainHeadSub.Err():
+				log.Error("Bidder: chain head sub error")
+				return
+			}
 		}
 	}
 }
 
 func (b *Bidder) reconnectLoop() {
-	defer b.wg.Done()
-
 	ticker := time.NewTicker(10 * time.Minute)
 	defer ticker.Stop()
 
+	if !b.enabled() {
+		return
+	}
+
 	for {
 		select {
 		case <-ticker.C:
@@ -209,16 +222,13 @@
 		return
 	}
 
-	if work.profit.Cmp(common.Big0) <= 0 {
-		return
+	if b.isBestWork(work) {
+		b.setBestWork(work)
 	}
-
-	b.newBidCh <- work
 }
 
 func (b *Bidder) exit() {
 	close(b.exitCh)
-	b.wg.Wait()
 }
 
 // bid notifies the next in-turn validator the work
@@ -275,10 +285,12 @@
 		}
 	}
 
+	startSend := time.Now()
 	_, err := cli.SendBid(context.Background(), bidArgs)
+	log.Info("Bidder: send bid", "number", work.header.Number, "duration", time.Since(startSend).Milliseconds())
 	if err != nil {
-		b.deleteBestWork(work)
-		log.Error("Bidder: bidding failed", "err", err)
+		log.Error("Bidder: bidding failed", "number", work.header.Number, "txs", len(work.txs),
+			"validator", work.coinbase, "err", err)
 
 		var bidErr rpc.Error
 		ok := errors.As(err, &bidErr)
@@ -289,8 +301,7 @@
 		return
 	}
 
-	b.deleteBestWork(work)
-	log.Info("Bidder: bidding success", "number", work.header.Number, "txs", len(work.txs))
+	log.Info("Bidder: bidding success", "number", work.header.Number, "txs", len(work.txs), "validator", work.coinbase)
 }
 
 // isBestWork returns the work is better than the current best work
@@ -299,6 +310,10 @@
 		return false
 	}
 
+	if work.profit.Cmp(common.Big0) <= 0 {
+		return false
+	}
+
 	last := b.getBestWork(work.header.Number.Int64())
 	if last == nil {
 		return true
@@ -316,11 +331,11 @@
 }
 
 // deleteBestWork sets the best work
-func (b *Bidder) deleteBestWork(work *environment) {
+func (b *Bidder) deleteBestWork(number int64) {
 	b.bestWorksMu.Lock()
 	defer b.bestWorksMu.Unlock()
 
-	delete(b.bestWorks, work.header.Number.Int64())
+	delete(b.bestWorks, number)
 }
 
 // getBestWork returns the best work

miner/miner_mev.go

@@ -25,6 +25,7 @@ type MevConfig struct {
 	Builders              []BuilderConfig // The list of builders
 	ValidatorCommission   uint64          // 100 means the validator claims 1% from block reward
 	BidSimulationLeftOver time.Duration
+	BidSendLeftOver       time.Duration
 
 	BuilderEnabled bool              // Whether to enable bidder or not
 	Validators     []ValidatorConfig // The list of validators

miner/worker.go

@@ -281,7 +281,7 @@ func newWorker(config *Config, chainConfig *params.ChainConfig, engine consensus
 		exitCh:             make(chan struct{}),
 		resubmitIntervalCh: make(chan time.Duration),
 		recentMinedBlocks:  recentMinedBlocks,
-		bidder:             NewBidder(&config.Mev, config.DelayLeftOver, engine, eth),
+		bidder:             NewBidder(&config.Mev, eth.BlockChain(), config.DelayLeftOver, engine, eth),
 		bundleCache:        NewBundleCache(),
 	}
 	// Subscribe events for blockchain