Added gasLimit to override as a config parameter

README.md

@@ -99,6 +99,7 @@ There are a set of parameters that are configurable. These include:
 - Gas Price: The value of gas price if you want to set manually. If you don't provide any value or simply keep it to 1, the razor client will automatically calculate the optimum gas price and send it.
 - Log Level: Normally debug logs are not logged into the log file. But if you want you can set `logLevel` to `debug` and fetch the debug logs.
 - Gas Limit: The value with which the gas limit will be multiplied while sending every transaction.
+- Gas Limit Override: This value would be used as a gas limit for all the transactions instead of estimating for each transaction. 
 - RPC Timeout: This is the threshold number of seconds after which any contract and client calls will time out.
 
 The config is set while the build is generated, but if you need to change any of the above parameter, you can use the `setConfig` command.

cmd/config-utils.go

@@ -49,6 +49,10 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 	if err != nil {
 		return config, err
 	}
+	gasLimitOverride, err := cmdUtils.GetGasLimitOverride()
+	if err != nil {
+		return config, err
+	}
 	rpcTimeout, err := cmdUtils.GetRPCTimeout()
 	if err != nil {
 		return config, err
@@ -60,6 +64,7 @@ func (*UtilsStruct) GetConfigData() (types.Configurations, error) {
 	config.GasPrice = gasPrice
 	config.LogLevel = logLevel
 	config.GasLimitMultiplier = gasLimit
+	config.GasLimitOverride = gasLimitOverride
 	config.RPCTimeout = rpcTimeout
 	utils.RPCTimeout = rpcTimeout
 
@@ -189,6 +194,23 @@ func (*UtilsStruct) GetGasLimit() (float32, error) {
 	return gasLimit, nil
 }
 
+//This function returns the gas limit to override
+func (*UtilsStruct) GetGasLimitOverride() (uint64, error) {
+	gasLimitOverride, err := flagSetUtils.GetRootUint64GasLimitOverride()
+	if err != nil {
+		return uint64(core.DefaultGasLimitOverride), err
+	}
+	if gasLimitOverride == 0 {
+		if viper.IsSet("gasLimitOverride") {
+			gasLimitOverride = viper.GetUint64("gasLimitOverride")
+		} else {
+			gasLimitOverride = uint64(core.DefaultGasLimitOverride)
+			log.Debug("GasLimitOverride is not set, taking its default value ", gasLimitOverride)
+		}
+	}
+	return gasLimitOverride, nil
+}
+
 //This function returns the RPC timeout
 func (*UtilsStruct) GetRPCTimeout() (int64, error) {
 	rpcTimeout, err := flagSetUtils.GetRootInt64RPCTimeout()

cmd/config-utils_test.go

@@ -26,26 +26,29 @@ func TestGetConfigData(t *testing.T) {
 		WaitTime:           1,
 		LogLevel:           "debug",
 		GasLimitMultiplier: 3,
+		GasLimitOverride:   1000000,
 		RPCTimeout:         10,
 	}
 
 	type args struct {
-		provider         string
-		providerErr      error
-		gasMultiplier    float32
-		gasMultiplierErr error
-		bufferPercent    int32
-		bufferPercentErr error
-		waitTime         int32
-		waitTimeErr      error
-		gasPrice         int32
-		gasPriceErr      error
-		logLevel         string
-		logLevelErr      error
-		gasLimit         float32
-		rpcTimeout       int64
-		rpcTimeoutErr    error
-		gasLimitErr      error
+		provider            string
+		providerErr         error
+		gasMultiplier       float32
+		gasMultiplierErr    error
+		bufferPercent       int32
+		bufferPercentErr    error
+		waitTime            int32
+		waitTimeErr         error
+		gasPrice            int32
+		gasPriceErr         error
+		logLevel            string
+		logLevelErr         error
+		gasLimit            float32
+		gasLimitOverride    uint64
+		gasLimitOverrideErr error
+		rpcTimeout          int64
+		rpcTimeoutErr       error
+		gasLimitErr         error
 	}
 	tests := []struct {
 		name    string
@@ -56,13 +59,14 @@ func TestGetConfigData(t *testing.T) {
 		{
 			name: "Test 1: When GetConfigData function executes successfully",
 			args: args{
-				provider:      "",
-				gasMultiplier: 1,
-				bufferPercent: 20,
-				waitTime:      1,
-				logLevel:      "debug",
-				gasLimit:      3,
-				rpcTimeout:    10,
+				provider:         "",
+				gasMultiplier:    1,
+				bufferPercent:    20,
+				waitTime:         1,
+				logLevel:         "debug",
+				gasLimit:         3,
+				gasLimitOverride: 1000000,
+				rpcTimeout:       10,
 			},
 			want:    configData,
 			wantErr: nil,
@@ -131,6 +135,14 @@ func TestGetConfigData(t *testing.T) {
 			want:    config,
 			wantErr: errors.New("rpcTimeout error"),
 		},
+		{
+			name: "When there is an error in getitng gasLimitOverride",
+			args: args{
+				gasLimitOverrideErr: errors.New("gasLimitOverride error"),
+			},
+			want:    config,
+			wantErr: errors.New("gasLimitOverride error"),
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -143,6 +155,7 @@ func TestGetConfigData(t *testing.T) {
 			cmdUtilsMock.On("GetGasPrice").Return(tt.args.gasPrice, tt.args.gasPriceErr)
 			cmdUtilsMock.On("GetLogLevel").Return(tt.args.logLevel, tt.args.logLevelErr)
 			cmdUtilsMock.On("GetGasLimit").Return(tt.args.gasLimit, tt.args.gasLimitErr)
+			cmdUtilsMock.On("GetGasLimitOverride").Return(tt.args.gasLimitOverride, tt.args.gasLimitOverrideErr)
 			cmdUtilsMock.On("GetBufferPercent").Return(tt.args.bufferPercent, tt.args.bufferPercentErr)
 			cmdUtilsMock.On("GetRPCTimeout").Return(tt.args.rpcTimeout, tt.args.rpcTimeoutErr)
 
@@ -287,6 +300,67 @@ func TestGetGasLimit(t *testing.T) {
 	}
 }
 
+func TestGetGasLimitOverride(t *testing.T) {
+	type args struct {
+		gasLimitOverride    uint64
+		gasLimitOverrideErr error
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint64
+		wantErr error
+	}{
+		{
+			name: "Test 1: When getGasLimitOverride function executes successfully",
+			args: args{
+				gasLimitOverride: 5000000,
+			},
+			want:    5000000,
+			wantErr: nil,
+		},
+		{
+			name: "Test 2: When gasLimitOverride is 0",
+			args: args{
+				gasLimitOverride: 0,
+			},
+			want:    0,
+			wantErr: nil,
+		},
+		{
+			name: "Test 3: When there is an error in getting gasLimitOverride",
+			args: args{
+				gasLimitOverrideErr: errors.New("gasLimitOverride error"),
+			},
+			want:    0,
+			wantErr: errors.New("gasLimitOverride error"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			flagSetUtilsMock := new(mocks.FlagSetInterface)
+			flagSetUtils = flagSetUtilsMock
+
+			flagSetUtilsMock.On("GetRootUint64GasLimitOverride").Return(tt.args.gasLimitOverride, tt.args.gasLimitOverrideErr)
+			utils := &UtilsStruct{}
+
+			got, err := utils.GetGasLimitOverride()
+			if got != tt.want {
+				t.Errorf("getGasLimitOverride() got = %v, want %v", got, tt.want)
+			}
+			if err == nil || tt.wantErr == nil {
+				if err != tt.wantErr {
+					t.Errorf("Error for getGasLimitOverride function, got = %v, want = %v", err, tt.wantErr)
+				}
+			} else {
+				if err.Error() != tt.wantErr.Error() {
+					t.Errorf("Error for getGasLimitOverride function, got = %v, want = %v", err, tt.wantErr)
+				}
+			}
+		})
+	}
+}
+
 func TestGetGasPrice(t *testing.T) {
 	type args struct {
 		gasPrice    int32

cmd/interface.go

@@ -194,6 +194,7 @@ type FlagSetInterface interface {
 	GetInt32Wait(flagSet *pflag.FlagSet) (int32, error)
 	GetInt32GasPrice(flagSet *pflag.FlagSet) (int32, error)
 	GetFloat32GasLimit(flagSet *pflag.FlagSet) (float32, error)
+	GetUint64GasLimitOverride(flagSet *pflag.FlagSet) (uint64, error)
 	GetStringLogLevel(flagSet *pflag.FlagSet) (string, error)
 	GetInt64RPCTimeout(flagSet *pflag.FlagSet) (int64, error)
 	GetUint32BountyId(flagSet *pflag.FlagSet) (uint32, error)
@@ -204,6 +205,7 @@ type FlagSetInterface interface {
 	GetRootInt32GasPrice() (int32, error)
 	GetRootStringLogLevel() (string, error)
 	GetRootFloat32GasLimit() (float32, error)
+	GetRootUint64GasLimitOverride() (uint64, error)
 	GetRootInt64RPCTimeout() (int64, error)
 	GetStringFrom(flagSet *pflag.FlagSet) (string, error)
 	GetStringTo(flagSet *pflag.FlagSet) (string, error)
@@ -241,6 +243,7 @@ type UtilsCmdInterface interface {
 	GetGasPrice() (int32, error)
 	GetLogLevel() (string, error)
 	GetGasLimit() (float32, error)
+	GetGasLimitOverride() (uint64, error)
 	GetBufferPercent() (int32, error)
 	GetRPCTimeout() (int64, error)
 	GetConfigData() (types.Configurations, error)

cmd/root.go

@@ -20,6 +20,7 @@ var (
 	GasPrice           int32
 	LogLevel           string
 	GasLimitMultiplier float32
+	GasLimitOverride   uint64
 	LogFile            string
 	RPCTimeout         int64
 )
@@ -61,6 +62,7 @@ func init() {
 	rootCmd.PersistentFlags().Int32VarP(&GasPrice, "gasprice", "", -1, "gas price")
 	rootCmd.PersistentFlags().StringVarP(&LogLevel, "logLevel", "", "", "log level")
 	rootCmd.PersistentFlags().Float32VarP(&GasLimitMultiplier, "gasLimit", "", -1, "gas limit percentage increase")
+	rootCmd.PersistentFlags().Uint64VarP(&GasLimitOverride, "gasLimitOverride", "", 0, "gas limit to be over ridden for a transaction")
 	rootCmd.PersistentFlags().StringVarP(&LogFile, "logFile", "", "", "name of log file")
 	rootCmd.PersistentFlags().Int64VarP(&RPCTimeout, "rpcTimeout", "", 0, "RPC timeout if its not responding")
 	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
@@ -110,5 +112,6 @@ func setLogLevel() {
 	log.Debugf("Gas Price: %d", config.GasPrice)
 	log.Debugf("Log Level: %s", config.LogLevel)
 	log.Debugf("Gas Limit: %.2f", config.GasLimitMultiplier)
+	log.Debugf("Gas Limit Override: %d", config.GasLimitOverride)
 	log.Debugf("RPC Timeout: %d", config.RPCTimeout)
 }

cmd/setConfig.go

@@ -54,6 +54,10 @@ func (*UtilsStruct) SetConfig(flagSet *pflag.FlagSet) error {
 	if err != nil {
 		return err
 	}
+	gasLimitOverride, err := flagSetUtils.GetUint64GasLimitOverride(flagSet)
+	if err != nil {
+		return err
+	}
 	gasLimit, err := flagSetUtils.GetFloat32GasLimit(flagSet)
 	if err != nil {
 		return err
@@ -117,17 +121,21 @@ func (*UtilsStruct) SetConfig(flagSet *pflag.FlagSet) error {
 	if gasLimit != -1 {
 		viper.Set("gasLimit", gasLimit)
 	}
+	if gasLimitOverride != 0 {
+		viper.Set("gasLimitOverride", gasLimitOverride)
+	}
 	if rpcTimeout != 0 {
 		viper.Set("rpcTimeout", rpcTimeout)
 	}
-	if provider == "" && gasMultiplier == -1 && bufferPercent == 0 && waitTime == -1 && gasPrice == -1 && logLevel == "" && gasLimit == -1 && rpcTimeout == 0 {
+	if provider == "" && gasMultiplier == -1 && bufferPercent == 0 && waitTime == -1 && gasPrice == -1 && logLevel == "" && gasLimit == -1 && gasLimitOverride == 0 && rpcTimeout == 0 {
 		viper.Set("provider", core.DefaultProvider)
 		viper.Set("gasmultiplier", core.DefaultGasMultiplier)
 		viper.Set("buffer", core.DefaultBufferPercent)
 		viper.Set("wait", core.DefaultWaitTime)
 		viper.Set("gasprice", core.DefaultGasPrice)
 		viper.Set("logLevel", core.DefaultLogLevel)
 		viper.Set("gasLimit", core.DefaultGasLimit)
+		viper.Set("gasLimitOverride", core.DefaultGasLimitOverride)
 		viper.Set("rpcTimeout", core.DefaultRPCTimeout)
 		//viper.Set("exposeMetricsPort", "")
 		log.Info("Config values set to default. Use setConfig to modify the values.")
@@ -152,6 +160,7 @@ func init() {
 		GasPrice           int32
 		LogLevel           string
 		GasLimitMultiplier float32
+		GasLimitOverride   uint64
 		RPCTimeout         int64
 		ExposeMetrics      string
 		CertFile           string
@@ -164,6 +173,7 @@ func init() {
 	setConfig.Flags().Int32VarP(&GasPrice, "gasprice", "", -1, "custom gas price")
 	setConfig.Flags().StringVarP(&LogLevel, "logLevel", "", "", "log level")
 	setConfig.Flags().Float32VarP(&GasLimitMultiplier, "gasLimit", "", -1, "gas limit percentage increase")
+	setConfig.Flags().Uint64VarP(&GasLimitOverride, "gasLimitOverride", "", 0, "gas limit to be over ridden for a transaction")
 	setConfig.Flags().Int64VarP(&RPCTimeout, "rpcTimeout", "", 0, "RPC timeout if its not responding")
 	setConfig.Flags().StringVarP(&ExposeMetrics, "exposeMetrics", "", "", "port number")
 	setConfig.Flags().StringVarP(&CertFile, "certFile", "", "", "ssl certificate path")