package abispec import ( "encoding/hex" "encoding/json" "fmt" "math/big" "reflect" "regexp" "strings" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" ) var methodPattern = regexp.MustCompile(`(^[a-zA-Z].*)\((.*)\)`) var maxSafeInteger = big.NewInt(int64(9007199254740991)) const transferInputs = `[{"type":"address"},{"type":"uint256"}]` const transferFunctionName = "transfer" var transferInDef = fmt.Sprintf(`[{ "name" : "%s", "type": "function", "inputs": %s}]`, transferFunctionName, transferInputs) var transferAbi, _ = abi.JSON(strings.NewReader(transferInDef)) func EncodeTransfer(to string, value string) (string, error) { amount, success := big.NewInt(0).SetString(value, 0) if !success { return "", fmt.Errorf("failed to convert %s to big.Int", value) } address := common.HexToAddress(to) result, err := transferAbi.Pack(transferFunctionName, address, amount) if err != nil { return "", fmt.Errorf("pack failed: %v", err) } return "0x" + hex.EncodeToString(result), nil } func Encode(method string, paramsJSON string) (string, error) { matches := methodPattern.FindStringSubmatch(method) if len(matches) != 3 { return "", fmt.Errorf("unrecognized method: %s", method) } methodName := matches[1] paramTypesString := strings.TrimSpace(matches[2]) // value of inputs looks like: `[{ "type": "uint32" },{ "type": "bool" }]` inputs := "[" var params []interface{} if len(paramTypesString) > 0 { var paramsRaw []json.RawMessage if err := json.Unmarshal([]byte(paramsJSON), ¶msRaw); err != nil { return "", fmt.Errorf("unable to unmarshal params: %v", err) } types := strings.Split(paramTypesString, ",") if len(paramsRaw) != len(types) { return "", fmt.Errorf("num of param type should equal to num of param value, actual value: %d, %d", len(types), len(paramsRaw)) } for i, typeName := range types { if i != 0 { inputs += "," } inputs += fmt.Sprintf(`{"type":"%s"}`, typeName) param, err := toGoTypeValue(typeName, paramsRaw[i]) if err != nil { return "", err } params = append(params, param.Interface()) } } inputs += "]" inDef := fmt.Sprintf(`[{ "name" : "%s", "type": "function", "inputs": %s}]`, methodName, inputs) inAbi, err := abi.JSON(strings.NewReader(inDef)) if err != nil { return "", fmt.Errorf("invalid ABI definition %s, %v", inDef, err) } var result []byte result, err = inAbi.Pack(methodName, params...) if err != nil { return "", fmt.Errorf("Pack failed: %v", err) } return "0x" + hex.EncodeToString(result), nil } // override result to make it looks like what status-mobile need func overrideResult(out []interface{}) []interface{} { for i, v := range out { outType := reflect.TypeOf(v) switch outType.String() { case "[]uint8": out[i] = "0x" + common.Bytes2Hex(v.([]uint8)) case bigIntType: vv := v.(*big.Int) if vv.Cmp(maxSafeInteger) == 1 { out[i] = vv.String() } } if outType.Kind() == reflect.Array && outType.Elem().Kind() == reflect.Array && outType.Elem().Elem().Kind() == reflect.Uint8 { //case e.g. [2][3]uint8 val := reflect.ValueOf(v) rowNum := val.Len() colNum := val.Index(0).Len() var ss = make([]string, rowNum) for i := 0; i < rowNum; i++ { bytes := make([]uint8, colNum) for j := 0; j < colNum; j++ { bytes[j] = uint8(val.Index(i).Index(j).Uint()) } ss[i] = common.Bytes2Hex(bytes) } out[i] = ss } else if outType.String() != "common.Address" && outType.Kind() == reflect.Array && outType.Elem().Kind() == reflect.Uint8 { val := reflect.ValueOf(v) len := val.Len() bytes := make([]uint8, len) for i := 0; i < len; i++ { bytes[i] = uint8(val.Index(i).Uint()) } out[i] = common.Bytes2Hex(bytes) } } return out } // bytesString e.g. 0x000000000000000000000000000000000000000000000000000000005bc741cd00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000013b86dbf1a83c9e6a492914a0ee39e8a5b7eb60700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002e516d533152484e4a57414b356e426f6f57454d34654d644268707a35666e325764557473457357754a4b79356147000000000000000000000000000000000000 // types e.g. []string{"uint256","bytes","address","uint256","uint256"} func Decode(bytesString string, types []string) ([]interface{}, error) { outputs := "[" for i, typeName := range types { if i != 0 { outputs += "," } outputs += fmt.Sprintf(`{"type":"%s"}`, typeName) } outputs += "]" def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, outputs) abi, err := abi.JSON(strings.NewReader(def)) if err != nil { return nil, fmt.Errorf("invalid ABI definition %s: %v", def, err) } if strings.HasPrefix(bytesString, "0x") { bytesString = bytesString[2:] } bytes, err := hex.DecodeString(bytesString) if err != nil { return nil, fmt.Errorf("invalid hex %s: %v", bytesString, err) } out, err := abi.Unpack("method", bytes) if err != nil { return nil, fmt.Errorf("unpack failed: %v", err) } return overrideResult(out), nil }