feat: [loadtest] add --max-base-fee-wei flag (#681)

* loadtest: add --max-base-fee-gwei flag

* replace logic to get current base fee

* max-base-fee-gwei is now max-base-fee-wei

* make gen-doc

* log review

Author: tclemos

cmd/loadtest/account.go

@@ -141,7 +141,7 @@ func NewAccountPool(ctx context.Context, client *ethclient.Client, fundingPrivat
 		return nil, fmt.Errorf("unable to get latestBlockNumber: %w", err)
 	}
 
-	return &AccountPool{
+	ap := &AccountPool{
 		currentAccountIndex: 0,
 		client:              client,
 		accounts:            make([]Account, 0),
@@ -151,7 +151,21 @@ func NewAccountPool(ctx context.Context, client *ethclient.Client, fundingPrivat
 		accountsPositions:   make(map[common.Address]int),
 		latestBlockNumber:   latestBlockNumber,
 		clientRateLimiter:   rate.NewLimiter(rate.Every(50*time.Millisecond), 1),
-	}, nil
+	}
+
+	if !ap.isFundingEnabled() {
+		if ap.isCallOnly() {
+			log.Debug().
+				Msg("sending account funding is disabled in call only mode")
+		}
+
+		if !ap.hasFundingAmount() {
+			log.Debug().
+				Msg("sending account funding is disabled due to funding amount being zero")
+		}
+	}
+
+	return ap, nil
 }
 
 // Adds N random accounts to the pool
@@ -489,7 +503,6 @@ func (ap *AccountPool) ReturnFunds(ctx context.Context) error {
 
 	if !ap.isFundingEnabled() {
 		log.Debug().
-			Uint64("fundingAmount", ap.fundingAmount.Uint64()).
 			Msg("account funding is disabled, skipping returning funds from sending accounts")
 		return nil
 	}
@@ -780,21 +793,13 @@ func (ap *AccountPool) Next(ctx context.Context) (Account, error) {
 	if ap.currentAccountIndex >= len(ap.accounts) {
 		ap.currentAccountIndex = 0
 	}
-	log.Debug().
-		Str("address", account.address.Hex()).
-		Str("nonce", fmt.Sprintf("%d", account.nonce)).
-		Msg("account returned from pool")
 	return account, nil
 }
 
 // Checks multiple conditions of the account and funds it if needed
 func (ap *AccountPool) fundAccountIfNeeded(ctx context.Context, account Account, forcedNonce *uint64, waitToFund bool) (*types.Transaction, error) {
 	// If funding amount is zero, skip funding entirely
 	if !ap.isFundingEnabled() {
-		log.Debug().
-			Uint64("fundingAmount", ap.fundingAmount.Uint64()).
-			Stringer("address", account.address).
-			Msg("funding disabled - skipping account funding for account")
 		return nil, nil
 	}
 
@@ -952,23 +957,25 @@ func (ap *AccountPool) createEOATransferTx(ctx context.Context, sender *ecdsa.Pr
 }
 
 func (ap *AccountPool) isFundingEnabled() bool {
-	callOnly := *inputLoadTestParams.EthCallOnly
-	if callOnly {
-		log.Debug().
-			Msg("sending account funding is disabled in call only mode")
+	if ap.isCallOnly() {
 		return false
 	}
 
-	hasFundingAmount := ap.fundingAmount != nil && ap.fundingAmount.Cmp(big.NewInt(0)) > 0
-	if !hasFundingAmount {
-		log.Debug().
-			Msg("sending account funding is disabled due to funding amount being zero")
+	if !ap.hasFundingAmount() {
 		return false
 	}
 
 	return true
 }
 
+func (ap *AccountPool) isCallOnly() bool {
+	return *inputLoadTestParams.EthCallOnly
+}
+
+func (ap *AccountPool) hasFundingAmount() bool {
+	return ap.fundingAmount != nil && ap.fundingAmount.Cmp(big.NewInt(0)) > 0
+}
+
 func (ap *AccountPool) isRefundingEnabled() bool {
 	if !ap.isFundingEnabled() {
 		log.Debug().

cmd/loadtest/app.go

@@ -88,6 +88,7 @@ type (
 		WaitForReceipt                *bool
 		ReceiptRetryMax               *uint
 		ReceiptRetryInitialDelayMs    *uint
+		MaxBaseFeeWei                 *uint64
 
 		// Computed
 		CurrentGasPrice       *big.Int
@@ -251,6 +252,7 @@ func initFlags() {
 	ltp.PreFundSendingAccounts = LoadtestCmd.Flags().Bool("pre-fund-sending-accounts", false, "If set to true, the sending accounts will be funded at the start of the execution, otherwise all accounts will be funded when used for the first time.")
 	ltp.RefundRemainingFunds = LoadtestCmd.Flags().Bool("refund-remaining-funds", false, "If set to true, the funded amount will be refunded to the funding account. Otherwise, the funded amount will remain in the sending accounts.")
 	ltp.SendingAccountsFile = LoadtestCmd.Flags().String("sending-accounts-file", "", "The file containing the sending accounts private keys, one per line. This is useful for avoiding pool account queue but also to keep the same sending accounts for different execution cycles.")
+	ltp.MaxBaseFeeWei = LoadtestCmd.Flags().Uint64("max-base-fee-wei", 0, "The maximum base fee in wei. If the base fee exceeds this value, sending tx will be paused and while paused, existing in-flight transactions continue to confirmation, but no additional SendTransaction calls occur. This is useful to avoid sending transactions when the network is congested.")
 
 	// Local flags.
 	ltp.Modes = LoadtestCmd.Flags().StringSliceP("mode", "m", []string{"t"}, `The testing mode to use. It can be multiple like: "d,t"

cmd/loadtest/loadtest.go

@@ -14,6 +14,7 @@ import (
 	"net/http"
 	"net/url"
 	"slices"
+	"sync/atomic"
 
 	"os"
 	"os/signal"
@@ -378,9 +379,15 @@ func initializeAccountPool(ctx context.Context, c *ethclient.Client, privateKey
 		return fmt.Errorf("unable to set account pool. %w", err)
 	}
 
-	// Check if we need to pre-fund sending accounts
-	if sendingAccountsCount == 0 || callOnly {
-		log.Info().Msg("No sending accounts to pre-fund or call-only mode is enabled. Skipping pre-funding of sending accounts.")
+	// check if there are sending accounts to pre fund
+	if sendingAccountsCount == 0 {
+		log.Info().Msg("No sending accounts to pre-fund. Skipping pre-funding of sending accounts.")
+		return nil
+	}
+
+	// checks if call only is enabled
+	if callOnly {
+		log.Info().Msg("call only mode is enabled. Skipping pre-funding of sending accounts.")
 		return nil
 	}
 
@@ -651,9 +658,9 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 	if *ltp.RateLimit <= 0.0 {
 		rl = nil
 	}
-	rateLimitCtx, cancel := context.WithCancel(ctx)
 
-	defer cancel()
+	rateLimitCtx, rateLimitCancel := context.WithCancel(ctx)
+	defer rateLimitCancel()
 	if *ltp.AdaptiveRateLimit && rl != nil {
 		go updateRateLimit(rateLimitCtx, rl, rpc, accountPool, steadyStateTxPoolSize, adaptiveRateLimitIncrement, time.Duration(*ltp.AdaptiveCycleDuration)*time.Second, *ltp.AdaptiveBackoffFactor)
 	}
@@ -776,6 +783,8 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 		return err
 	}
 
+	mustCheckMaxBaseFee, maxBaseFeeCtxCancel, waitBaseFeeToDrop := setupBaseFeeMonitoring(ctx, c, ltp)
+
 	log.Debug().Msg("Starting main load test loop")
 	var wg sync.WaitGroup
 	for routineID := int64(0); routineID < maxRoutines; routineID++ {
@@ -830,6 +839,21 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 					return
 				}
 				sendingTops.Nonce = new(big.Int).SetUint64(account.nonce)
+
+				if mustCheckMaxBaseFee {
+					waiting := false
+					for waitBaseFeeToDrop.Load() {
+						if !waiting {
+							waiting = true
+							log.Debug().
+								Int64("routineID", routineID).
+								Int64("requestID", requestID).
+								Msg("go routine is waiting for base fee to drop")
+						}
+						time.Sleep(time.Second)
+					}
+				}
+
 				sendingTops = configureTransactOpts(ctx, c, sendingTops)
 
 				switch localMode {
@@ -925,21 +949,99 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 					Stringer("txhash", ltTxHash).
 					Any("nonce", sendingTops.Nonce).
 					Str("mode", localMode.String()).
+					Str("sendingAddress", sendingTops.From.String()).
 					Msg("Request")
 			}
 			wg.Done()
 		}(routineID)
 	}
 	log.Trace().Msg("Finished starting go routines. Waiting..")
 	wg.Wait()
-	cancel()
+	rateLimitCancel()
+	maxBaseFeeCtxCancel()
 	if *ltp.EthCallOnly {
 		return nil
 	}
 
 	return nil
 }
 
+func setupBaseFeeMonitoring(ctx context.Context, c *ethclient.Client, ltp loadTestParams) (bool, context.CancelFunc, *atomic.Bool) {
+	// monitor max base fee if configured
+	maxBaseFeeCtx, maxBaseFeeCtxCancel := context.WithCancel(ctx)
+	mustCheckMaxBaseFee := *ltp.MaxBaseFeeWei > 0
+	var waitBaseFeeToDrop atomic.Bool
+	waitBaseFeeToDrop.Store(false)
+	if mustCheckMaxBaseFee {
+		log.Info().
+			Msg("max base fee monitoring enabled")
+
+		wg := sync.WaitGroup{}
+		wg.Add(1)
+		// start a goroutine to monitor the base fee while load test is running
+		go func(ctx context.Context, c *ethclient.Client, waitToDrop *atomic.Bool, maxBaseFeeWei uint64) {
+			firstRun := true
+			for {
+				select {
+				case <-ctx.Done():
+					return
+				default:
+					currentBaseFeeIsGreaterThanMax, currentBaseFeeWei, err := isCurrentBaseFeeGreaterThanMaxBaseFee(ctx, c, maxBaseFeeWei)
+					if err != nil {
+						log.Error().
+							Err(err).
+							Msg("Error checking base fee during load test")
+					} else {
+						if currentBaseFeeIsGreaterThanMax {
+							if !waitToDrop.Load() {
+								log.Warn().
+									Msgf("PAUSE: base fee %d Wei > limit %d Wei", currentBaseFeeWei.Uint64(), maxBaseFeeWei)
+								waitToDrop.Store(true)
+							}
+						} else if waitToDrop.Load() {
+							log.Info().
+								Msgf("RESUME: base fee %d Wei ≤ limit %d Wei", currentBaseFeeWei.Uint64(), maxBaseFeeWei)
+							waitToDrop.Store(false)
+						}
+
+						if firstRun {
+							firstRun = false
+							wg.Done()
+						}
+					}
+					time.Sleep(time.Second)
+				}
+			}
+		}(maxBaseFeeCtx, c, &waitBaseFeeToDrop, *ltp.MaxBaseFeeWei)
+
+		// wait for first run to complete so we know if we need to wait or not for base fee to drop
+		wg.Wait()
+	}
+	return mustCheckMaxBaseFee, maxBaseFeeCtxCancel, &waitBaseFeeToDrop
+}
+
+func isCurrentBaseFeeGreaterThanMaxBaseFee(ctx context.Context, c *ethclient.Client, maxBaseFee uint64) (bool, *big.Int, error) {
+	header, err := c.HeaderByNumber(ctx, nil)
+	if errors.Is(err, context.Canceled) {
+		log.Debug().Msg("max base fee monitoring context canceled")
+		return false, nil, nil
+	} else if err != nil {
+		log.Error().Err(err).Msg("Unable to get latest block header to check base fee")
+		return false, nil, err
+	}
+
+	if header.BaseFee != nil {
+		currentBaseFee := header.BaseFee
+		if currentBaseFee.Cmp(new(big.Int).SetUint64(maxBaseFee)) > 0 {
+			return true, currentBaseFee, nil
+		} else {
+			return false, currentBaseFee, nil
+		}
+	}
+
+	return false, nil, nil
+}
+
 func getLoadTestContract(ctx context.Context, c *ethclient.Client, tops *bind.TransactOpts, cops *bind.CallOpts) (ltAddr ethcommon.Address, ltContract *tester.LoadTester, err error) {
 	ltAddr = ethcommon.HexToAddress(*inputLoadTestParams.LoadtestContractAddress)
 

doc/polycli_loadtest.md

@@ -107,6 +107,7 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --inscription-content string             The inscription content that will be encoded as calldata. This must be paired up with --mode inscription (default "data:,{\"p\":\"erc-20\",\"op\":\"mint\",\"tick\":\"TEST\",\"amt\":\"1\"}")
       --legacy                                 Send a legacy transaction instead of an EIP1559 transaction.
       --loadtest-contract-address string       The address of a pre-deployed load test contract
+      --max-base-fee-wei uint                  The maximum base fee in wei. If the base fee exceeds this value, sending tx will be paused and while paused, existing in-flight transactions continue to confirmation, but no additional SendTransaction calls occur. This is useful to avoid sending transactions when the network is congested.
   -m, --mode strings                           The testing mode to use. It can be multiple like: "d,t"
                                                2, erc20 - Send ERC20 tokens
                                                7, erc721 - Mint ERC721 tokens