Make txArriveTimeout Configurable w/ CLI Flag

cmd/utils/flags.go

@@ -754,6 +754,12 @@ var (
 		Usage: "Gas price below which gpo will ignore transactions",
 		Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(),
 	}
+	// fetcher flag to set arrival timeout
+	TxArrivalWaitFlag = cli.IntFlag{
+		Name:  "txarrivalwait",
+		Usage: "Maximum number of milliseconds to wait for a transaction before requesting it (defaults to 100ms)",
+		Value: node.DefaultConfig.P2P.TxArrivalWait,
+	}
 
 	// Metrics flags
 	MetricsEnabledFlag = cli.BoolFlag{
@@ -1288,6 +1294,10 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 		cfg.NoDiscovery = true
 		cfg.DiscoveryV5 = false
 	}
+
+	if ctx.GlobalIsSet(TxArrivalWaitFlag.Name) {
+		cfg.TxArrivalWait = TxArrivalWaitFlag.Value
+	}
 }
 
 // SetNodeConfig applies node-related command line flags to the config.

docs/cli/server.md

@@ -146,6 +146,8 @@ The ```bor server``` command runs the Bor client.
 
 - ```v5disc```: Enables the experimental RLPx V5 (Topic Discovery) mechanism (default: false)
 
+- ```txarrivalwait```: Maximum number of milliseconds to wait before requesting an announced transaction (default: 100)
+
 ### Sealer Options
 
 - ```mine```: Enable mining (default: false)

eth/backend.go

@@ -266,6 +266,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 		EthAPI:             ethAPI,
 		PeerRequiredBlocks: config.PeerRequiredBlocks,
 		checker:            checker,
+		txArrivalWait:      time.Duration(eth.p2pServer.TxArrivalWait) * time.Millisecond,
 	}); err != nil {
 		return nil, err
 	}

eth/fetcher/tx_fetcher.go

@@ -53,10 +53,6 @@ const (
 	// re-request them.
 	maxTxUnderpricedSetSize = 32768
 
-	// txArriveTimeout is the time allowance before an announced transaction is
-	// explicitly requested.
-	txArriveTimeout = 100 * time.Millisecond
-
 	// txGatherSlack is the interval used to collate almost-expired announces
 	// with network fetches.
 	txGatherSlack = 20 * time.Millisecond
@@ -176,38 +172,41 @@ type TxFetcher struct {
 	step  chan struct{} // Notification channel when the fetcher loop iterates
 	clock mclock.Clock  // Time wrapper to simulate in tests
 	rand  *mrand.Rand   // Randomizer to use in tests instead of map range loops (soft-random)
+
+	txArrivalWait time.Duration // txArrivalWait is the time allowance before an announced transaction is explicitly requested.
 }
 
 // NewTxFetcher creates a transaction fetcher to retrieve transaction
 // based on hash announcements.
-func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error) *TxFetcher {
-	return NewTxFetcherForTests(hasTx, addTxs, fetchTxs, mclock.System{}, nil)
+func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, txArrivalWait time.Duration) *TxFetcher {
+	return NewTxFetcherForTests(hasTx, addTxs, fetchTxs, mclock.System{}, nil, txArrivalWait)
 }
 
 // NewTxFetcherForTests is a testing method to mock out the realtime clock with
 // a simulated version and the internal randomness with a deterministic one.
 func NewTxFetcherForTests(
 	hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error,
-	clock mclock.Clock, rand *mrand.Rand) *TxFetcher {
+	clock mclock.Clock, rand *mrand.Rand, txArrivalWait time.Duration) *TxFetcher {
 	return &TxFetcher{
-		notify:      make(chan *txAnnounce),
-		cleanup:     make(chan *txDelivery),
-		drop:        make(chan *txDrop),
-		quit:        make(chan struct{}),
-		waitlist:    make(map[common.Hash]map[string]struct{}),
-		waittime:    make(map[common.Hash]mclock.AbsTime),
-		waitslots:   make(map[string]map[common.Hash]struct{}),
-		announces:   make(map[string]map[common.Hash]struct{}),
-		announced:   make(map[common.Hash]map[string]struct{}),
-		fetching:    make(map[common.Hash]string),
-		requests:    make(map[string]*txRequest),
-		alternates:  make(map[common.Hash]map[string]struct{}),
-		underpriced: mapset.NewSet(),
-		hasTx:       hasTx,
-		addTxs:      addTxs,
-		fetchTxs:    fetchTxs,
-		clock:       clock,
-		rand:        rand,
+		notify:        make(chan *txAnnounce),
+		cleanup:       make(chan *txDelivery),
+		drop:          make(chan *txDrop),
+		quit:          make(chan struct{}),
+		waitlist:      make(map[common.Hash]map[string]struct{}),
+		waittime:      make(map[common.Hash]mclock.AbsTime),
+		waitslots:     make(map[string]map[common.Hash]struct{}),
+		announces:     make(map[string]map[common.Hash]struct{}),
+		announced:     make(map[common.Hash]map[string]struct{}),
+		fetching:      make(map[common.Hash]string),
+		requests:      make(map[string]*txRequest),
+		alternates:    make(map[common.Hash]map[string]struct{}),
+		underpriced:   mapset.NewSet(),
+		hasTx:         hasTx,
+		addTxs:        addTxs,
+		fetchTxs:      fetchTxs,
+		clock:         clock,
+		rand:          rand,
+		txArrivalWait: txArrivalWait,
 	}
 }
 
@@ -441,7 +440,7 @@ func (f *TxFetcher) loop() {
 			// ones into the retrieval queues
 			actives := make(map[string]struct{})
 			for hash, instance := range f.waittime {
-				if time.Duration(f.clock.Now()-instance)+txGatherSlack > txArriveTimeout {
+				if time.Duration(f.clock.Now()-instance)+txGatherSlack > f.txArrivalWait {
 					// Transaction expired without propagation, schedule for retrieval
 					if f.announced[hash] != nil {
 						panic("announce tracker already contains waitlist item")
@@ -698,12 +697,12 @@ func (f *TxFetcher) rescheduleWait(timer *mclock.Timer, trigger chan struct{}) {
 	for _, instance := range f.waittime {
 		if earliest > instance {
 			earliest = instance
-			if txArriveTimeout-time.Duration(now-earliest) < gatherSlack {
+			if f.txArrivalWait-time.Duration(now-earliest) < gatherSlack {
 				break
 			}
 		}
 	}
-	*timer = f.clock.AfterFunc(txArriveTimeout-time.Duration(now-earliest), func() {
+	*timer = f.clock.AfterFunc(f.txArrivalWait-time.Duration(now-earliest), func() {
 		trigger <- struct{}{}
 	})
 }