概述: 一组用Go的好用的工具函数。

工具函数集

函数的实现可以在这里. 它们一般接口比较通用. 这里我们先看几个例子。

检查地址是否是有效的以太坊地址:

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

检查地址是否为零地址:

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

将小数转换为wei(整数）。 第二个参数是小数位数。

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

将wei（整数）转换为小数。 第二个参数是小数位数。

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

根据燃气上限和燃气价格计算燃气花费。

  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

从签名中提取R，S和V值。

  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

完整代码

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