feat: increase gas tip caps on retry

Author: GrePod

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [UNRELEASED]
+
+### Changed
+
+- For type 2 gas configs, both MaximalMaxPriorityFe and MinimalMaxPriorityFee are increased by 11% on each retry to ensure valid replacement transactions
+
 ## [v1.0.6] - 2026-2-13
 
 ### Added

client/config/client.go

@@ -258,18 +258,26 @@ type Gas struct {
 	BaseFeePerGasCap  *big.Int `toml:"base_fee_per_gas_cap"` // LEAVE UNSET UNLESS YOU KNOW WHAT YOU ARE DOING.
 }
 
+var (
+	DefaultMaxPriorityMultiplier = big.NewInt(2)
+	DefaultMaximalMaxPriorityFee = big.NewInt(5000e9) // 5000 Gwei
+	DefaultMinimalMaxPriorityFee = big.NewInt(100e9)  // 100 Gwei
+
+	DefaultBaseFeeMultiplier = big.NewInt(4)
+)
+
 // DefaultGas
 func DefaultGas() Gas {
 	return Gas{
 		TxType: 2,
 
 		GasLimit: 0,
 
-		MaxPriorityMultiplier: big.NewInt(2),
-		MinimalMaxPriorityFee: big.NewInt(100e9),
-		MaximalMaxPriorityFee: big.NewInt(5000e9),
+		MaxPriorityMultiplier: DefaultMaxPriorityMultiplier,
+		MinimalMaxPriorityFee: DefaultMinimalMaxPriorityFee,
+		MaximalMaxPriorityFee: DefaultMaximalMaxPriorityFee,
 
-		BaseFeeMultiplier: big.NewInt(4),
+		BaseFeeMultiplier: DefaultBaseFeeMultiplier,
 	}
 }
 

utils/chain/tx_utils.go

@@ -31,6 +31,9 @@ const (
 	defaultTipMultiplier = 2
 
 	baseFeeCapMultiplier = 4
+
+	multiplierBumpTimes100 = 111
+	normalizer             = 100
 )
 
 var (
@@ -331,7 +334,8 @@ func GetGasPrice(gasConfig *config.Gas, client *ethclient.Client, timeout time.D
 // up to a maximum of 10x the original value.
 // If GasPriceFixed is used, the retry multiplier will not be applied.
 //
-// For type 2 transaction, MaxPriorityFeePerGas on the n-the attempt is n-th power of 1,2 times the MaxPriorityFeePerGas of the initial attempt.
+// For type 2 transaction on i-th attempt,
+// the multipliers are increased by i, and caps are increased by 11% per attempt.
 func GasConfigForAttempt(cfg *config.Gas, attempt int) *config.Gas {
 	switch cfg.TxType {
 	case 0:
@@ -364,16 +368,43 @@ func GasConfigForAttempt(cfg *config.Gas, attempt int) *config.Gas {
 			baseFeeMultiplier.Set(cfg.BaseFeeMultiplier)
 			baseFeeMultiplier.Add(baseFeeMultiplier, attemptBig)
 		} else {
-			baseFeeMultiplier = big.NewInt(3 + int64(attempt))
+			baseFeeMultiplier.Add(config.DefaultBaseFeeMultiplier, attemptBig)
+		}
+
+		maxMaxPriorityFee := new(big.Int)
+		if cfg.MaximalMaxPriorityFee != nil && cfg.MaximalMaxPriorityFee.Cmp(common.Big0) == 1 {
+			maxMaxPriorityFee.Set(cfg.MaximalMaxPriorityFee)
+		} else {
+			maxMaxPriorityFee.Set(config.DefaultMaximalMaxPriorityFee)
+		}
+
+		minMaxPriorityFee := new(big.Int)
+		if cfg.MinimalMaxPriorityFee != nil && cfg.MinimalMaxPriorityFee.Cmp(common.Big0) == 1 {
+			minMaxPriorityFee.Set(cfg.MinimalMaxPriorityFee)
+		} else {
+			minMaxPriorityFee.Set(config.DefaultMinimalMaxPriorityFee)
+		}
+
+		// Increase caps by 11% per retry
+		if attempt > 0 {
+			multiplier := new(big.Int).Exp(big.NewInt(multiplierBumpTimes100), attemptBig, nil)
+			normalizer := new(big.Int).Exp(big.NewInt(normalizer), attemptBig, nil)
+
+			maxMaxPriorityFee.Mul(maxMaxPriorityFee, multiplier)
+			maxMaxPriorityFee.Div(maxMaxPriorityFee, normalizer)
+
+			minMaxPriorityFee.Mul(minMaxPriorityFee, multiplier)
+			minMaxPriorityFee.Div(minMaxPriorityFee, normalizer)
 		}
+
 		return &config.Gas{
 			TxType:   2,
 			GasLimit: cfg.GasLimit,
 
 			BaseFeeMultiplier:     baseFeeMultiplier,
 			MaxPriorityMultiplier: maxPriorityMultiplier,
-			MaximalMaxPriorityFee: cfg.MaximalMaxPriorityFee,
-			MinimalMaxPriorityFee: cfg.MinimalMaxPriorityFee,
+			MaximalMaxPriorityFee: maxMaxPriorityFee,
+			MinimalMaxPriorityFee: minMaxPriorityFee,
 
 			BaseFeePerGasCap: cfg.BaseFeePerGasCap,
 		}

utils/chain/tx_utils_test.go

@@ -133,53 +133,61 @@ func TestGasConfigForAttemptType0(t *testing.T) {
 			},
 		},
 		{
-			name: "empty type 2",
-			cfg:  config2.Gas{TxType: 2},
-			ri:   0,
-			expected: config2.Gas{
-				TxType:                2,
-				GasLimit:              0,
-				MaxPriorityMultiplier: big.NewInt(2),
-				BaseFeeMultiplier:     big.NewInt(3),
-				BaseFeePerGasCap:      nil,
-			},
+			name:     "empty type 2",
+			cfg:      config2.Gas{TxType: 2},
+			ri:       0,
+			expected: config2.DefaultGas(),
 		},
 		{
 			name: "zero type 2",
 			cfg: config2.Gas{
 				TxType:                2,
 				MaxPriorityMultiplier: big.NewInt(0),
 				BaseFeeMultiplier:     big.NewInt(0),
+			},
+			ri:       0,
+			expected: config2.DefaultGas(),
+		},
+		{
+			name: "zero type 2,2 ",
+			cfg: config2.Gas{
+				TxType:                2,
+				MaxPriorityMultiplier: big.NewInt(6),
+				BaseFeeMultiplier:     big.NewInt(2),
 				BaseFeePerGasCap:      big.NewInt(0),
 			},
-			ri: 0,
+			ri: 2,
 			expected: config2.Gas{
 				TxType:                2,
 				GasLimit:              0,
-				MaxPriorityMultiplier: big.NewInt(2),
-				BaseFeeMultiplier:     big.NewInt(3),
+				MaxPriorityMultiplier: big.NewInt(8),
+				BaseFeeMultiplier:     big.NewInt(4),
 				BaseFeePerGasCap:      big.NewInt(0),
+				MaximalMaxPriorityFee: big.NewInt(6160500000000),
+				MinimalMaxPriorityFee: big.NewInt(123210000000),
 			},
 		},
 		{
-			name: "zero type 2",
+			name: "type 2",
 			cfg: config2.Gas{
 				TxType:                2,
-				MaxPriorityMultiplier: big.NewInt(6),
+				GasLimit:              0,
 				BaseFeeMultiplier:     big.NewInt(2),
-				BaseFeePerGasCap:      big.NewInt(0),
+				MaxPriorityMultiplier: big.NewInt(6),
+				MaximalMaxPriorityFee: big.NewInt(1000),
+				MinimalMaxPriorityFee: big.NewInt(100),
 			},
 			ri: 2,
 			expected: config2.Gas{
 				TxType:                2,
 				GasLimit:              0,
-				MaxPriorityMultiplier: big.NewInt(8),
 				BaseFeeMultiplier:     big.NewInt(4),
-				BaseFeePerGasCap:      big.NewInt(0),
+				MaxPriorityMultiplier: big.NewInt(8),
+				MaximalMaxPriorityFee: big.NewInt(1232),
+				MinimalMaxPriorityFee: big.NewInt(123),
 			},
 		},
 	}
-
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			got := chain.GasConfigForAttempt(&test.cfg, test.ri)
@@ -196,8 +204,10 @@ func TestGasConfigForAttemptType0(t *testing.T) {
 				}
 			case 2:
 				require.Equal(t, test.expected.BaseFeeMultiplier, got.BaseFeeMultiplier)
-				require.Equal(t, test.expected.MaxPriorityMultiplier, got.MaxPriorityMultiplier)
+				require.Equal(t, test.expected.MaxPriorityMultiplier, got.MaxPriorityMultiplier, "primul")
 				require.Equal(t, test.expected.BaseFeePerGasCap, got.BaseFeePerGasCap)
+				require.Equal(t, test.expected.MaximalMaxPriorityFee, got.MaximalMaxPriorityFee, "mincap")
+				require.Equal(t, test.expected.MinimalMaxPriorityFee, got.MinimalMaxPriorityFee, "maxcap")
 			}
 		})
 	}