add Exponential Backoff with Jitter to loadtest --wait-for-receipt

Author: tclemos

cmd/loadtest/account.go

@@ -445,7 +445,7 @@ func (ap *AccountPool) FundAccounts(ctx context.Context) error {
 				Str("txHash", tx.Hash().Hex()).
 				Msg("transaction to fund account sent")
 
-			receipt, err := waitReceipt(ctx, ap.client, tx.Hash(), time.Minute)
+			receipt, err := waitReceipt(ctx, ap.client, tx.Hash())
 			if err != nil {
 				log.Error().
 					Str("address", tx.To().Hex()).
@@ -670,7 +670,7 @@ func (ap *AccountPool) ReturnFunds(ctx context.Context) error {
 				Str("txHash", tx.Hash().Hex()).
 				Msg("transaction to return funds sent")
 
-			_, err = waitReceipt(ctx, ap.client, tx.Hash(), time.Minute)
+			_, err = waitReceiptWithTimeout(ctx, ap.client, tx.Hash(), time.Minute)
 			if err != nil {
 				log.Error().
 					Str("address", tx.To().Hex()).
@@ -852,7 +852,7 @@ func (ap *AccountPool) fund(ctx context.Context, acc Account, forcedNonce *uint6
 
 	// Wait for the transaction to be mined
 	if waitToFund {
-		receipt, err := waitReceipt(ctx, ap.client, signedTx.Hash(), time.Minute)
+		receipt, err := waitReceipt(ctx, ap.client, signedTx.Hash())
 		if err != nil {
 			log.Error().
 				Str("address", acc.address.Hex()).

cmd/loadtest/app.go

@@ -89,6 +89,8 @@ type (
 		SendingAddressesFile          *string
 		Proxy                         *string
 		WaitForReceipt                *bool
+		ReceiptRetryMax               *uint
+		ReceiptRetryInitialDelayMs    *uint
 
 		// Computed
 		CurrentGasPrice       *big.Int
@@ -287,6 +289,8 @@ v3, uniswapv3 - Perform UniswapV3 swaps`)
 	ltp.InscriptionContent = LoadtestCmd.Flags().String("inscription-content", `data:,{"p":"erc-20","op":"mint","tick":"TEST","amt":"1"}`, "The inscription content that will be encoded as calldata. This must be paired up with --mode inscription")
 	ltp.Proxy = LoadtestCmd.Flags().String("proxy", "", "Use the proxy specified")
 	ltp.WaitForReceipt = LoadtestCmd.Flags().Bool("wait-for-receipt", false, "If set to true, the load test will wait for the transaction receipt to be mined. If set to false, the load test will not wait for the transaction receipt and will just send the transaction.")
+	ltp.ReceiptRetryMax = LoadtestCmd.Flags().Uint("receipt-retry-max", 30, "Maximum number of attempts to poll for transaction receipt when --wait-for-receipt is enabled.")
+	ltp.ReceiptRetryInitialDelayMs = LoadtestCmd.Flags().Uint("receipt-retry-initial-delay-ms", 100, "Initial delay in milliseconds for receipt polling retry. Uses exponential backoff with jitter.")
 
 	inputLoadTestParams = *ltp
 

cmd/loadtest/loadtest.go

@@ -900,7 +900,9 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 					recordSample(routineID, requestID, tErr, startReq, endReq, sendingTops.Nonce.Uint64())
 				}
 				if tErr == nil && *inputLoadTestParams.WaitForReceipt {
-					_, tErr = waitReceipt(ctx, c, ltTxHash, time.Minute)
+					receiptMaxRetries := *inputLoadTestParams.ReceiptRetryMax
+					receiptRetryInitialDelayMs := *inputLoadTestParams.ReceiptRetryInitialDelayMs
+					_, tErr = waitReceiptWithRetries(ctx, c, ltTxHash, receiptMaxRetries, receiptRetryInitialDelayMs)
 				}
 
 				if tErr != nil {

cmd/loadtest/tx.go

@@ -2,16 +2,83 @@ package loadtest
 
 import (
 	"context"
+	"fmt"
+	"math/rand"
 	"time"
 
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-func waitReceipt(ctx context.Context, client *ethclient.Client, txHash common.Hash, timeout time.Duration) (*types.Receipt, error) {
-	ctxTimeout, cancel := context.WithTimeout(ctx, timeout)
+// waitReceipt waits for a transaction receipt with default parameters.
+func waitReceipt(ctx context.Context, client *ethclient.Client, txHash common.Hash) (*types.Receipt, error) {
+	return internalWaitReceipt(ctx, client, txHash, 0, 0, 0)
+}
+
+// waitReceiptWithRetries waits for a transaction receipt with retries and exponential backoff.
+func waitReceiptWithRetries(ctx context.Context, client *ethclient.Client, txHash common.Hash, maxRetries uint, initialDelayMs uint) (*types.Receipt, error) {
+	return internalWaitReceipt(ctx, client, txHash, maxRetries, initialDelayMs, 0)
+}
+
+// waitReceiptWithTimeout waits for a transaction receipt with a specified timeout.
+func waitReceiptWithTimeout(ctx context.Context, client *ethclient.Client, txHash common.Hash, timeout time.Duration) (*types.Receipt, error) {
+	return internalWaitReceipt(ctx, client, txHash, 0, 0, timeout)
+}
+
+// waitReceiptWithRetriesAndTimeout waits for a transaction receipt with retries, exponential backoff, and a timeout.
+func internalWaitReceipt(ctx context.Context, client *ethclient.Client, txHash common.Hash, maxRetries uint, initialDelayMs uint, timeout time.Duration) (*types.Receipt, error) {
+	// Set defaults for zero values
+	effectiveTimeout := timeout
+	if effectiveTimeout == 0 {
+		effectiveTimeout = 1 * time.Minute // Default: 1 minute
+	}
+
+	// Create context with timeout
+	timeoutCtx, cancel := context.WithTimeout(ctx, effectiveTimeout)
 	defer cancel()
-	return bind.WaitMinedHash(ctxTimeout, client, txHash)
+
+	effectiveInitialDelayMs := initialDelayMs
+	if effectiveInitialDelayMs == 0 {
+		effectiveInitialDelayMs = 100 // Default: 100ms
+	} else if effectiveInitialDelayMs < 10 {
+		effectiveInitialDelayMs = 10 // Minimum 10ms
+	}
+
+	for attempt := uint(0); ; attempt++ {
+		receipt, err := client.TransactionReceipt(timeoutCtx, txHash)
+		if err == nil && receipt != nil {
+			return receipt, nil
+		}
+
+		// If maxRetries > 0 and we've reached the limit, exit
+		// Note: effectiveMaxRetries is always > 0 due to default above
+		if maxRetries > 0 && attempt >= maxRetries-1 {
+			return nil, fmt.Errorf("failed to get receipt after %d attempts: %w", maxRetries, err)
+		}
+
+		// Calculate delay
+		baseDelay := time.Duration(effectiveInitialDelayMs) * time.Millisecond
+		exponentialDelay := baseDelay * time.Duration(1<<attempt)
+
+		// Add cap to prevent extremely long delays
+		maxDelay := 30 * time.Second
+		if exponentialDelay > maxDelay {
+			exponentialDelay = maxDelay
+		}
+
+		maxJitter := exponentialDelay / 2
+		if maxJitter <= 0 {
+			maxJitter = 1 * time.Millisecond
+		}
+		jitter := time.Duration(rand.Int63n(int64(maxJitter)))
+		totalDelay := exponentialDelay + jitter
+
+		select {
+		case <-timeoutCtx.Done():
+			return nil, timeoutCtx.Err()
+		case <-time.After(totalDelay):
+			// Continue
+		}
+	}
 }

doc/polycli_loadtest.md

@@ -157,6 +157,8 @@ The codebase has a contract that used for load testing. It's written in Solidity
       --proxy string                           Use the proxy specified
       --rate-limit float                       An overall limit to the number of requests per second. Give a number less than zero to remove this limit all together (default 4)
       --recall-blocks uint                     The number of blocks that we'll attempt to fetch for recall (default 50)
+      --receipt-retry-initial-delay-ms uint    Initial delay in milliseconds for receipt polling retry. Uses exponential backoff with jitter. (default 100)
+      --receipt-retry-max uint                 Maximum number of attempts to poll for transaction receipt when --wait-for-receipt is enabled. (default 30)
   -n, --requests int                           Number of requests to perform for the benchmarking session. The default is to just perform a single request which usually leads to non-representative benchmarking results. (default 1)
   -r, --rpc-url string                         The RPC endpoint url (default "http://localhost:8545")
       --seed int                               A seed for generating random values and addresses (default 123456)