description: Collection of useful Ethereum utility functions in Go.

Collection of Utility Functions

The utility functions’ implementation are found below in the full code section. They are generous in what they accept. Here we’ll be showing examples of usage.

Derive the Ethereum public address from a public key:

  1. publicKeyBytes, _ := hex.DecodeString("049a7df67f79246283fdc93af76d4f8cdd62c4886e8cd870944e817dd0b97934fdd7719d0810951e03418205868a5c1b40b192451367f28e0088dd75e15de40c05")
  2. address := util.PublicKeyBytesToAddress(publicKeyBytes)
  3. fmt.Println(address.Hex()) // 0x96216849c49358B10257cb55b28eA603c874b05E

Check if an address is a valid Ethereum address:

  1. valid := util.IsValidAddress("0x323b5d4c32345ced77393b3530b1eed0f346429d")
  2. fmt.Println(valid) // true

Check if an address is a zero address.

  1. zeroed := util.IsZeroAddress("0x0")
  2. fmt.Println(zeroed) // true

Convert a decimal to wei. The second argument is the number of decimals.

  1. wei := util.ToWei(0.02, 18)
  2. fmt.Println(wei) // 20000000000000000

Convert wei to decimals. The second argument is the number of decimals.

  1. wei := new(big.Int)
  2. wei.SetString("20000000000000000", 10)
  3. eth := util.ToDecimal(wei, 18)
  4. fmt.Println(eth) // 0.02

Calculate the gas cost given the gas limit and gas price.

  1. gasLimit := uint64(21000)
  2. gasPrice := new(big.Int)
  3. gasPrice.SetString("2000000000", 10)
  4. gasCost := util.CalcGasCost(gasLimit, gasPrice)
  5. fmt.Println(gasCost) // 42000000000000

Retrieve the R, S, and V values from a signature.

  1. sig := "0x789a80053e4927d0a898db8e065e948f5cf086e32f9ccaa54c1908e22ac430c62621578113ddbb62d509bf6049b8fb544ab06d36f916685a2eb8e57ffadde02301"
  2. r, s, v := util.SigRSV(sig)
  3. fmt.Println(hexutil.Encode(r[:])[2:]) // 789a80053e4927d0a898db8e065e948f5cf086e32f9ccaa54c1908e22ac430c6
  4. fmt.Println(hexutil.Encode(s[:])[2:]) // 2621578113ddbb62d509bf6049b8fb544ab06d36f916685a2eb8e57ffadde023
  5. fmt.Println(v)                        // 28

Full code

util.go

  1. package util
  3. import (
  4.     "math/big"
  5.     "reflect"
  6.     "regexp"
  7.     "strconv"
  9.     "github.com/ethereum/go-ethereum/common"
  10.     "github.com/ethereum/go-ethereum/common/hexutil"
  11.     "github.com/shopspring/decimal"
  12. )
  14. // IsValidAddress validate hex address
  15. func IsValidAddress(iaddress interface{}) bool {
  16.     re := regexp.MustCompile("^0x[0-9a-fA-F]{40}$")
  17.     switch v := iaddress.(type) {
  18.     case string:
  19.         return re.MatchString(v)
  20.     case common.Address:
  21.         return re.MatchString(v.Hex())
  22.     default:
  23.         return false
  24.     }
  25. }
  27. // IsZeroAddress validate if it's a 0 address
  28. func IsZeroAddress(iaddress interface{}) bool {
  29.     var address common.Address
  30.     switch v := iaddress.(type) {
  31.     case string:
  32.         address = common.HexToAddress(v)
  33.     case common.Address:
  34.         address = v
  35.     default:
  36.         return false
  37.     }
  39.     zeroAddressBytes := common.FromHex("0x0000000000000000000000000000000000000000")
  40.     addressBytes := address.Bytes()
  41.     return reflect.DeepEqual(addressBytes, zeroAddressBytes)
  42. }
  44. // ToDecimal wei to decimals
  45. func ToDecimal(ivalue interface{}, decimals int) decimal.Decimal {
  46.     value := new(big.Int)
  47.     switch v := ivalue.(type) {
  48.     case string:
  49.         value.SetString(v, 10)
  50.     case *big.Int:
  51.         value = v
  52.     }
  54.     mul := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(decimals)))
  55.     num, _ := decimal.NewFromString(value.String())
  56.     result := num.Div(mul)
  58.     return result
  59. }
  61. // ToWei decimals to wei
  62. func ToWei(iamount interface{}, decimals int) *big.Int {
  63.     amount := decimal.NewFromFloat(0)
  64.     switch v := iamount.(type) {
  65.     case string:
  66.         amount, _ = decimal.NewFromString(v)
  67.     case float64:
  68.         amount = decimal.NewFromFloat(v)
  69.     case int64:
  70.         amount = decimal.NewFromFloat(float64(v))
  71.     case decimal.Decimal:
  72.         amount = v
  73.     case *decimal.Decimal:
  74.         amount = *v
  75.     }
  77.     mul := decimal.NewFromFloat(float64(10)).Pow(decimal.NewFromFloat(float64(decimals)))
  78.     result := amount.Mul(mul)
  80.     wei := new(big.Int)
  81.     wei.SetString(result.String(), 10)
  83.     return wei
  84. }
  86. // CalcGasCost calculate gas cost given gas limit (units) and gas price (wei)
  87. func CalcGasCost(gasLimit uint64, gasPrice *big.Int) *big.Int {
  88.     gasLimitBig := big.NewInt(int64(gasLimit))
  89.     return gasLimitBig.Mul(gasLimitBig, gasPrice)
  90. }
  92. // SigRSV signatures R S V returned as arrays
  93. func SigRSV(isig interface{}) ([32]byte, [32]byte, uint8) {
  94.     var sig []byte
  95.     switch v := isig.(type) {
  96.     case []byte:
  97.         sig = v
  98.     case string:
  99.         sig, _ = hexutil.Decode(v)
  100.     }
  102.     sigstr := common.Bytes2Hex(sig)
  103.     rS := sigstr[0:64]
  104.     sS := sigstr[64:128]
  105.     R := [32]byte{}
  106.     S := [32]byte{}
  107.     copy(R[:], common.FromHex(rS))
  108.     copy(S[:], common.FromHex(sS))
  109.     vStr := sigstr[128:130]
  110.     vI, _ := strconv.Atoi(vStr)
  111.     V := uint8(vI + 27)
  113.     return R, S, V
  114. }

test file: util_test.go