Add support for parsing hex values in config (#728)

* Add support for parsing hex values in config

* Remove unnecessary helpers

* Use a hex value for the minGasPrice in unit tests

* Fix error wrapping lint errors

Author: zivkovicmilos

chains/ethereum/config.go

@@ -111,36 +111,33 @@ func parseChainConfig(chainCfg *core.ChainConfig) (*Config, error) {
 	}
 
 	if gasPrice, ok := chainCfg.Opts[MaxGasPriceOpt]; ok {
-		price := big.NewInt(0)
-		_, pass := price.SetString(gasPrice, 10)
-		if pass {
-			config.maxGasPrice = price
-			delete(chainCfg.Opts, MaxGasPriceOpt)
-		} else {
-			return nil, errors.New("unable to parse max gas price")
+		price, parseErr := utils.ParseUint256OrHex(&gasPrice)
+		if parseErr != nil {
+			return nil, fmt.Errorf("unable to parse max gas price, %w", parseErr)
 		}
+
+		config.maxGasPrice = price
+		delete(chainCfg.Opts, MaxGasPriceOpt)
 	}
 
 	if minGasPrice, ok := chainCfg.Opts[MinGasPriceOpt]; ok {
-		price := big.NewInt(0)
-		_, pass := price.SetString(minGasPrice, 10)
-		if pass {
-			config.minGasPrice = price
-			delete(chainCfg.Opts, MinGasPriceOpt)
-		} else {
-			return nil, errors.New("unable to parse min gas price")
+		price, parseErr := utils.ParseUint256OrHex(&minGasPrice)
+		if parseErr != nil {
+			return nil, fmt.Errorf("unable to parse min gas price, %w", parseErr)
 		}
+
+		config.minGasPrice = price
+		delete(chainCfg.Opts, MinGasPriceOpt)
 	}
 
 	if gasLimit, ok := chainCfg.Opts[GasLimitOpt]; ok {
-		limit := big.NewInt(0)
-		_, pass := limit.SetString(gasLimit, 10)
-		if pass {
-			config.gasLimit = limit
-			delete(chainCfg.Opts, GasLimitOpt)
-		} else {
-			return nil, errors.New("unable to parse gas limit")
+		limit, parseErr := utils.ParseUint256OrHex(&gasLimit)
+		if parseErr != nil {
+			return nil, fmt.Errorf("unable to parse gas limit, %w", parseErr)
 		}
+
+		config.gasLimit = limit
+		delete(chainCfg.Opts, GasLimitOpt)
 	}
 
 	if gasMultiplier, ok := chainCfg.Opts[GasMultiplier]; ok {

chains/ethereum/config_test.go

@@ -8,6 +8,7 @@ import (
 	"reflect"
 	"testing"
 
+	utils "github.com/ChainSafe/ChainBridge/shared/ethereum"
 	"github.com/ChainSafe/chainbridge-utils/core"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -71,6 +72,70 @@ func TestParseChainConfig(t *testing.T) {
 	}
 }
 
+// TestParseChainConfigHex tests the parseChainConfig with hex values
+func TestParseChainConfigHex(t *testing.T) {
+	commonHexValue := "0x1234"
+	expectedHex, parseErr := utils.ParseUint256OrHex(&commonHexValue)
+	if parseErr != nil {
+		t.Fatalf("unable to parse value %s, %v", commonHexValue, parseErr)
+	}
+
+	input := core.ChainConfig{
+		Name:         "chain",
+		Id:           1,
+		Endpoint:     "endpoint",
+		From:         "0x0",
+		KeystorePath: "./keys",
+		Insecure:     false,
+		Opts: map[string]string{
+			"bridge":             "0x1234",
+			"erc20Handler":       "0x1234",
+			"erc721Handler":      "0x1234",
+			"genericHandler":     "0x1234",
+			"gasLimit":           commonHexValue,
+			"gasMultiplier":      "1",
+			"maxGasPrice":        commonHexValue,
+			"minGasPrice":        commonHexValue,
+			"http":               "true",
+			"startBlock":         "10",
+			"blockConfirmations": "50",
+			"egsApiKey":          "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // fake key
+			"egsSpeed":           "fast",
+		},
+	}
+
+	out, err := parseChainConfig(&input)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := Config{
+		name:                   "chain",
+		id:                     1,
+		endpoint:               "endpoint",
+		from:                   "0x0",
+		keystorePath:           "./keys",
+		bridgeContract:         common.HexToAddress("0x1234"),
+		erc20HandlerContract:   common.HexToAddress("0x1234"),
+		erc721HandlerContract:  common.HexToAddress("0x1234"),
+		genericHandlerContract: common.HexToAddress("0x1234"),
+		gasLimit:               expectedHex,
+		maxGasPrice:            expectedHex,
+		minGasPrice:            expectedHex,
+		gasMultiplier:          big.NewFloat(1),
+		http:                   true,
+		startBlock:             big.NewInt(10),
+		blockConfirmations:     big.NewInt(50),
+		egsApiKey:              "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+		egsSpeed:               "fast",
+	}
+
+	if !reflect.DeepEqual(&expected, out) {
+		t.Fatalf("Output not expected.\n\tExpected: %#v\n\tGot: %#v\n", &expected, out)
+	}
+}
+
 //TestParseChainConfig tests parseChainConfig with all handlerContracts provided
 func TestParseChainConfigWithNoBlockConfirmations(t *testing.T) {
 

shared/ethereum/generic.go

@@ -4,6 +4,10 @@
 package utils
 
 import (
+	"fmt"
+	"math/big"
+	"strings"
+
 	"github.com/ChainSafe/ChainBridge/bindings/GenericHandler"
 	"github.com/ChainSafe/chainbridge-utils/msg"
 	"github.com/ethereum/go-ethereum/common"
@@ -31,3 +35,37 @@ func GetGenericResourceAddress(client *Client, handler common.Address, rId msg.R
 	}
 	return addr, nil
 }
+
+const (
+	decimalBase = 10
+	hexBase     = 16
+)
+
+// valueToBig converts a string value to a *big.Int in the provided base
+func valueToBig(value string, base int) (*big.Int, error) {
+	val, ok := new(big.Int).SetString(value, base)
+	if !ok {
+		return nil, fmt.Errorf("unable to parse value")
+	}
+
+	return val, nil
+}
+
+// ParseUint256OrHex parses a string value as either a base 10 number
+// or as a hex value
+func ParseUint256OrHex(value *string) (*big.Int, error) {
+	// Check if the value is valid
+	if value == nil {
+		return nil, fmt.Errorf("invalid value")
+	}
+
+	// Check if the value is hex
+	if strings.HasPrefix(*value, "0x") {
+		// Hex value, remove the prefix and parse it
+		clipped := (*value)[2:]
+		return valueToBig(clipped, hexBase)
+	}
+
+	// Decimal number, parse it
+	return valueToBig(*value, decimalBase)
+}