Jesse/loadtest legacy mode

cmd/loadtest/loadtest.go

@@ -21,6 +21,7 @@ import (
 	"crypto/ecdsa"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"math"
@@ -236,16 +237,19 @@ type (
 		ForceContractDeploy                 *bool
 		ForceGasLimit                       *uint64
 		ForceGasPrice                       *uint64
+		ForcePriorityGasPrice               *uint64
 		ShouldProduceSummary                *bool
 		SummaryOutputMode                   *string
+		LegacyTransactionMode               *bool
 
 		// Computed
-		CurrentGas      *big.Int
-		CurrentNonce    *uint64
-		ECDSAPrivateKey *ecdsa.PrivateKey
-		FromETHAddress  *ethcommon.Address
-		ToETHAddress    *ethcommon.Address
-		SendAmount      *big.Int
+		CurrentGas       *big.Int
+		CurrentGasTipCap *big.Int
+		CurrentNonce     *uint64
+		ECDSAPrivateKey  *ecdsa.PrivateKey
+		FromETHAddress   *ethcommon.Address
+		ToETHAddress     *ethcommon.Address
+		SendAmount       *big.Int
 
 		ToAvailAddress   *gstypes.MultiAddress
 		FromAvailAddress *gssignature.KeyringPair
@@ -302,9 +306,11 @@ r - random modes
 	ltp.ForceContractDeploy = LoadtestCmd.PersistentFlags().Bool("force-contract-deploy", false, "Some loadtest modes don't require a contract deployment. Set this flag to true to force contract deployments. This will still respect the --del-address and --il-address flags.")
 	ltp.ForceGasLimit = LoadtestCmd.PersistentFlags().Uint64("gas-limit", 0, "In environments where the gas limit can't be computed on the fly, we can specify it manually")
 	ltp.ForceGasPrice = LoadtestCmd.PersistentFlags().Uint64("gas-price", 0, "In environments where the gas price can't be estimated, we can specify it manually")
+	ltp.ForcePriorityGasPrice = LoadtestCmd.PersistentFlags().Uint64("priority-gas-price", 0, "Specify Gas Tip Price in the case of EIP-1559")
 	ltp.ShouldProduceSummary = LoadtestCmd.PersistentFlags().Bool("summarize", false, "Should we produce an execution summary after the load test has finished. If you're running a large loadtest, this can take a long time")
 	ltp.BatchSize = LoadtestCmd.PersistentFlags().Uint64("batch-size", 999, "Number of batches to perform at a time for receipt fetching. Default is 999 requests at a time.")
 	ltp.SummaryOutputMode = LoadtestCmd.PersistentFlags().String("output-mode", "text", "Format mode for summary output (json | text)")
+	ltp.LegacyTransactionMode = LoadtestCmd.PersistentFlags().Bool("legacy", false, "Send a legacy transaction instead of an EIP1559 transaction.")
 	inputLoadTestParams = *ltp
 
 	// TODO batch size
@@ -321,6 +327,13 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 	}
 	log.Trace().Interface("gasprice", gas).Msg("Retreived current gas price")
 
+	gasTipCap, err := c.SuggestGasTipCap(ctx)
+	if err != nil {
+		log.Error().Err(err).Msg("Unable to retrieve gas tip cap")
+		return err
+	}
+	log.Trace().Interface("gastipcap", gasTipCap).Msg("Retreived current gas tip cap")
+
 	privateKey, err := ethcrypto.HexToECDSA(*inputLoadTestParams.PrivateKey)
 	if err != nil {
 		log.Error().Err(err).Msg("Couldn't process the hex private key")
@@ -357,12 +370,18 @@ func initializeLoadTestParams(ctx context.Context, c *ethclient.Client) error {
 		return err
 	}
 
+	if *inputLoadTestParams.LegacyTransactionMode && *inputLoadTestParams.ForcePriorityGasPrice > 0 {
+		log.Error().Msg("Cannot set priority gas price in legacy mode")
+		return errors.New("cannot set priority gas price in legacy mode")
+	}
+
 	inputLoadTestParams.ToETHAddress = &toAddr
 	inputLoadTestParams.SendAmount = amt
 	inputLoadTestParams.CurrentGas = gas
 	inputLoadTestParams.CurrentNonce = &nonce
 	inputLoadTestParams.ECDSAPrivateKey = privateKey
 	inputLoadTestParams.FromETHAddress = &ethAddress
+	inputLoadTestParams.CurrentGasTipCap = gasTipCap
 
 	rand.Seed(*inputLoadTestParams.Seed)
 
@@ -599,8 +618,8 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 	}
 
 	tops, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
-	tops = configureTransactOpts(tops)
 	tops.GasLimit = 10000000
+	tops = configureTransactOpts(tops)
 
 	if err != nil {
 		log.Error().Err(err).Msg("Unable create transaction signer")
@@ -667,8 +686,6 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 		}
 
 		tops.Nonce = new(big.Int).SetUint64(currentNonce)
-		tops = configureTransactOpts(tops)
-		tops.GasLimit = 10000000
 
 		_, err = erc20Contract.Mint(tops, metrics.UnitMegaether)
 		if err != nil {
@@ -720,8 +737,6 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 		}
 
 		tops.Nonce = new(big.Int).SetUint64(currentNonce)
-		tops = configureTransactOpts(tops)
-		tops.GasLimit = 10000000
 
 		err = blockUntilSuccessful(ctx, c, func() error {
 			_, err = erc721Contract.MintBatch(tops, *ltp.FromETHAddress, new(big.Int).SetUint64(1))
@@ -785,6 +800,12 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 			var retryForNonce bool = false
 			var myNonceValue uint64
 
+			header, _err := c.HeaderByNumber(ctx, nil)
+			if _err != nil {
+				log.Error().Err(err).Msg("Unable to get head")
+				return
+			}
+
 			for j = 0; j < requests; j = j + 1 {
 				if rl != nil {
 					err = rl.Wait(ctx)
@@ -813,7 +834,7 @@ func mainLoop(ctx context.Context, c *ethclient.Client, rpc *ethrpc.Client) erro
 				}
 				switch localMode {
 				case loadTestModeTransaction:
-					startReq, endReq, err = loadtestTransaction(ctx, c, myNonceValue)
+					startReq, endReq, err = loadtestTransaction(ctx, c, myNonceValue, header)
 				case loadTestModeDeploy:
 					startReq, endReq, err = loadtestDeploy(ctx, c, myNonceValue)
 				case loadTestModeCall:
@@ -949,7 +970,7 @@ func blockUntilSuccessful(ctx context.Context, c *ethclient.Client, f func() err
 	}
 }
 
-func loadtestTransaction(ctx context.Context, c *ethclient.Client, nonce uint64) (t1 time.Time, t2 time.Time, err error) {
+func loadtestTransaction(ctx context.Context, c *ethclient.Client, nonce uint64, header *ethtypes.Header) (t1 time.Time, t2 time.Time, err error) {
 	ltp := inputLoadTestParams
 
 	gasPrice := ltp.CurrentGas
@@ -964,8 +985,37 @@ func loadtestTransaction(ctx context.Context, c *ethclient.Client, nonce uint64)
 	privateKey := ltp.ECDSAPrivateKey
 
 	gasLimit := uint64(21000)
-	tx := ethtypes.NewTransaction(nonce, *to, amount, gasLimit, gasPrice, nil)
-	stx, err := ethtypes.SignTx(tx, ethtypes.NewEIP155Signer(chainID), privateKey)
+	var tx *ethtypes.Transaction
+	if err != nil {
+		log.Error().Err(err).Msg("Unable to get head")
+		return
+	}
+	if *ltp.LegacyTransactionMode {
+		tx = ethtypes.NewTransaction(nonce, *to, amount, gasLimit, gasPrice, nil)
+	} else {
+		gasTipCap := ltp.CurrentGasTipCap
+		gasFeeCap := new(big.Int).Add(gasTipCap, header.BaseFee)
+		dynamicFeeTx := &ethtypes.DynamicFeeTx{
+			ChainID:   chainID,
+			Nonce:     nonce,
+			To:        to,
+			Gas:       gasLimit,
+			GasFeeCap: gasFeeCap,
+			GasTipCap: gasTipCap,
+			Data:      nil,
+			Value:     amount,
+		}
+		tx = ethtypes.NewTx(dynamicFeeTx)
+	}
+
+	tops, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
+	if err != nil {
+		log.Error().Err(err).Msg("Unable create transaction signer")
+		return
+	}
+	tops = configureTransactOpts(tops)
+
+	stx, err := tops.Signer(*ltp.FromETHAddress, tx)
 	if err != nil {
 		log.Error().Err(err).Msg("Unable to sign transaction")
 		return
@@ -1488,8 +1538,12 @@ func loadtestAvailStore(ctx context.Context, c *gsrpc.SubstrateAPI, nonce uint64
 
 func configureTransactOpts(tops *bind.TransactOpts) *bind.TransactOpts {
 	ltp := inputLoadTestParams
-	if ltp.ForceGasPrice != nil && *ltp.ForceGasPrice != 0 {
-		tops.GasPrice = big.NewInt(0).SetUint64(*ltp.ForceGasPrice)
+	if *ltp.LegacyTransactionMode {
+		if ltp.ForceGasPrice != nil && *ltp.ForceGasPrice != 0 {
+			tops.GasPrice = big.NewInt(0).SetUint64(*ltp.ForceGasPrice)
+		} else {
+			tops.GasPrice = ltp.CurrentGas
+		}
 	}
 	if ltp.ForceGasLimit != nil && *ltp.ForceGasLimit != 0 {
 		tops.GasLimit = *ltp.ForceGasLimit