feat: CopyAndDefault method for Gas added

Author: GrePod

client/config/client.go

@@ -281,6 +281,46 @@ func DefaultGas() Gas {
 	}
 }
 
+// CopyAndDefault copy Gas and sets default values for any unset configs.
+func (g *Gas) CopyAndDefault() *Gas {
+	switch g.TxType {
+	case 0:
+		return &Gas{
+			TxType:             0,
+			GasLimit:           g.GasLimit,
+			GasPriceMultiplier: g.GasPriceMultiplier,
+			GasPriceFixed:      g.GasPriceFixed,
+		}
+	default: // TxType 2
+		newGas := &Gas{
+			TxType:           2,
+			GasLimit:         g.GasLimit,
+			BaseFeePerGasCap: g.BaseFeePerGasCap,
+		}
+		if g.MaxPriorityMultiplier != nil {
+			newGas.MaxPriorityMultiplier = g.MaxPriorityMultiplier
+		} else {
+			newGas.MaxPriorityMultiplier = DefaultMaxPriorityMultiplier
+		}
+		if g.MinimalMaxPriorityFee != nil {
+			newGas.MinimalMaxPriorityFee = g.MinimalMaxPriorityFee
+		} else {
+			newGas.MinimalMaxPriorityFee = DefaultMinimalMaxPriorityFee
+		}
+		if g.MaximalMaxPriorityFee != nil {
+			newGas.MaximalMaxPriorityFee = g.MaximalMaxPriorityFee
+		} else {
+			newGas.MaximalMaxPriorityFee = DefaultMaximalMaxPriorityFee
+		}
+		if g.BaseFeeMultiplier != nil {
+			newGas.BaseFeeMultiplier = g.BaseFeeMultiplier
+		} else {
+			newGas.BaseFeeMultiplier = DefaultBaseFeeMultiplier
+		}
+		return newGas
+	}
+}
+
 // EnforceMaxPriorityFeeCaps returns capped fee.
 // A new value is returned and the underlying value of the fee is unchanged/
 func (g *Gas) EnforceMaxPriorityFeeCaps(fee *big.Int) *big.Int {
@@ -305,7 +345,6 @@ func (g *Gas) validate() error {
 
 	switch g.TxType {
 	case 0:
-
 		if g.GasPriceFixed.Cmp(common.Big0) != 0 && g.GasPriceMultiplier != 0.0 {
 			return errors.New("only one of gas_price_fixed and gas_price_multiplier can be set to a non-zero value for type 0 transaction")
 		}

utils/chain/tx_utils.go

@@ -336,6 +336,8 @@ func GetGasPrice(gasConfig *config.Gas, client *ethclient.Client, timeout time.D
 //
 // For type 2 transaction on i-th attempt,
 // the multipliers are increased by i, and caps are increased by 11% per attempt.
+//
+// Any unset values will be set to default.
 func GasConfigForAttempt(cfg *config.Gas, attempt int) *config.Gas {
 	switch cfg.TxType {
 	case 0:
@@ -352,63 +354,26 @@ func GasConfigForAttempt(cfg *config.Gas, attempt int) *config.Gas {
 			GasPriceMultiplier: max(1.0, cfg.GasPriceMultiplier) * float32(retryMultiplier),
 			GasPriceFixed:      cfg.GasPriceFixed,
 		}
-	case 2:
+	default: // type 2 and invalid types
 		attemptBig := big.NewInt(int64(attempt))
 
-		maxPriorityMultiplier := new(big.Int)
-		if cfg.MaxPriorityMultiplier != nil && cfg.MaxPriorityMultiplier.Cmp(common.Big0) == 1 {
-			maxPriorityMultiplier.Set(cfg.MaxPriorityMultiplier)
-			maxPriorityMultiplier.Add(maxPriorityMultiplier, attemptBig)
-		} else {
-			maxPriorityMultiplier.SetInt64(defaultTipMultiplier + int64(attempt))
-		}
-
-		baseFeeMultiplier := new(big.Int)
-		if cfg.BaseFeeMultiplier != nil && cfg.BaseFeeMultiplier.Cmp(common.Big0) == 1 {
-			baseFeeMultiplier.Set(cfg.BaseFeeMultiplier)
-			baseFeeMultiplier.Add(baseFeeMultiplier, attemptBig)
-		} else {
-			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)
-		}
+		c := cfg.CopyAndDefault()
 
-		minMaxPriorityFee := new(big.Int)
-		if cfg.MinimalMaxPriorityFee != nil && cfg.MinimalMaxPriorityFee.Cmp(common.Big0) == 1 {
-			minMaxPriorityFee.Set(cfg.MinimalMaxPriorityFee)
-		} else {
-			minMaxPriorityFee.Set(config.DefaultMinimalMaxPriorityFee)
-		}
+		c.MaxPriorityMultiplier.Add(c.MaxPriorityMultiplier, attemptBig)
+		c.BaseFeeMultiplier.Add(c.BaseFeeMultiplier, attemptBig)
 
 		// 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)
+			c.MaximalMaxPriorityFee.Mul(c.MaximalMaxPriorityFee, multiplier)
+			c.MaximalMaxPriorityFee.Div(c.MaximalMaxPriorityFee, normalizer)
 
-			minMaxPriorityFee.Mul(minMaxPriorityFee, multiplier)
-			minMaxPriorityFee.Div(minMaxPriorityFee, normalizer)
+			c.MinimalMaxPriorityFee.Mul(c.MinimalMaxPriorityFee, multiplier)
+			c.MinimalMaxPriorityFee.Div(c.MinimalMaxPriorityFee, normalizer)
 		}
 
-		return &config.Gas{
-			TxType:   2,
-			GasLimit: cfg.GasLimit,
-
-			BaseFeeMultiplier:     baseFeeMultiplier,
-			MaxPriorityMultiplier: maxPriorityMultiplier,
-			MaximalMaxPriorityFee: maxMaxPriorityFee,
-			MinimalMaxPriorityFee: minMaxPriorityFee,
-
-			BaseFeePerGasCap: cfg.BaseFeePerGasCap,
-		}
-	default:
-		return cfg
+		return c
 	}
 }

utils/chain/tx_utils_test.go

@@ -144,9 +144,20 @@ func TestGasConfigForAttemptType0(t *testing.T) {
 				TxType:                2,
 				MaxPriorityMultiplier: big.NewInt(0),
 				BaseFeeMultiplier:     big.NewInt(0),
+				BaseFeePerGasCap:      big.NewInt(0),
+				MaximalMaxPriorityFee: big.NewInt(0),
+				MinimalMaxPriorityFee: big.NewInt(0),
+			},
+			ri: 0,
+			expected: config2.Gas{
+				TxType:                2,
+				GasLimit:              0,
+				MaxPriorityMultiplier: big.NewInt(0),
+				BaseFeeMultiplier:     big.NewInt(0),
+				BaseFeePerGasCap:      big.NewInt(0),
+				MaximalMaxPriorityFee: big.NewInt(0),
+				MinimalMaxPriorityFee: big.NewInt(0),
 			},
-			ri:       0,
-			expected: config2.DefaultGas(),
 		},
 		{
 			name: "zero type 2,2 ",