package typeddata import ( "bytes" "encoding/json" "errors" "fmt" "math/big" "sort" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" ) var ( bytes32Type, _ = abi.NewType("bytes32", nil) int256Type, _ = abi.NewType("int256", nil) errNotInteger = errors.New("not an integer") ) // ValidateAndHash generates a hash of TypedData and verifies that chainId in the typed data matches currently selected chain. func ValidateAndHash(typed TypedData, chain *big.Int) (common.Hash, error) { if err := typed.ValidateChainID(chain); err != nil { return common.Hash{}, err } return encodeData(typed) } // deps runs breadth-first traversal starting from target and collects all // found composite dependencies types into result slice. target always will be first // in the result array. all other dependencies are sorted alphabetically. // for example: Z{c C, a A} A{c C} and the target is Z. // result would be Z, A, B, C func deps(target string, types Types) []string { unique := map[string]struct{}{} unique[target] = struct{}{} visited := []string{target} deps := []string{} for len(visited) > 0 { current := visited[0] fields := types[current] for i := range fields { f := fields[i] if _, defined := types[f.Type]; defined { if _, exist := unique[f.Type]; !exist { visited = append(visited, f.Type) unique[f.Type] = struct{}{} } } } visited = visited[1:] deps = append(deps, current) } sort.Slice(deps[1:], func(i, j int) bool { return deps[1:][i] < deps[1:][j] }) return deps } func typeString(target string, types Types) string { b := new(bytes.Buffer) for _, dep := range deps(target, types) { b.WriteString(dep) b.WriteString("(") fields := types[dep] first := true for i := range fields { if !first { b.WriteString(",") } else { first = false } f := fields[i] b.WriteString(f.Type) b.WriteString(" ") b.WriteString(f.Name) } b.WriteString(")") } return b.String() } func typeHash(target string, types Types) (rst common.Hash) { return crypto.Keccak256Hash([]byte(typeString(target, types))) } func hashStruct(target string, data map[string]json.RawMessage, types Types) (rst common.Hash, err error) { fields := types[target] typeh := typeHash(target, types) args := abi.Arguments{{Type: bytes32Type}} vals := []interface{}{typeh} for i := range fields { f := fields[i] val, typ, err := toABITypeAndValue(f, data, types) if err != nil { return rst, err } vals = append(vals, val) args = append(args, abi.Argument{Name: f.Name, Type: typ}) } packed, err := args.Pack(vals...) if err != nil { return rst, err } return crypto.Keccak256Hash(packed), nil } func toABITypeAndValue(f Field, data map[string]json.RawMessage, types Types) (val interface{}, typ abi.Type, err error) { if f.Type == "string" { var str string if err = json.Unmarshal(data[f.Name], &str); err != nil { return } return crypto.Keccak256Hash([]byte(str)), bytes32Type, nil } else if f.Type == "bytes" { var bytes hexutil.Bytes if err = json.Unmarshal(data[f.Name], &bytes); err != nil { return } return crypto.Keccak256Hash(bytes), bytes32Type, nil } else if _, exist := types[f.Type]; exist { var obj map[string]json.RawMessage if err = json.Unmarshal(data[f.Name], &obj); err != nil { return } val, err = hashStruct(f.Type, obj, types) if err != nil { return } return val, bytes32Type, nil } return atomicType(f, data) } func atomicType(f Field, data map[string]json.RawMessage) (val interface{}, typ abi.Type, err error) { typ, err = abi.NewType(f.Type, nil) if err != nil { return } if typ.T == abi.SliceTy || typ.T == abi.ArrayTy || typ.T == abi.FunctionTy { return val, typ, errors.New("arrays, slices and functions are not supported") } else if typ.T == abi.FixedBytesTy { return toFixedBytes(f, data[f.Name]) } else if typ.T == abi.AddressTy { val, err = toAddress(f, data[f.Name]) } else if typ.T == abi.IntTy || typ.T == abi.UintTy { return toInt(f, data[f.Name]) } else if typ.T == abi.BoolTy { val, err = toBool(f, data[f.Name]) } else { err = fmt.Errorf("type %s is not supported", f.Type) } return } func toFixedBytes(f Field, data json.RawMessage) (rst [32]byte, typ abi.Type, err error) { var bytes hexutil.Bytes if err = json.Unmarshal(data, &bytes); err != nil { return } typ = bytes32Type rst = [32]byte{} // reduce the length to the advertised size if len(bytes) > typ.Size { bytes = bytes[:typ.Size] } copy(rst[:], bytes) return rst, typ, nil } func toInt(f Field, data json.RawMessage) (val *big.Int, typ abi.Type, err error) { val = new(big.Int) if err = json.Unmarshal(data, &val); err != nil { var buf string err = json.Unmarshal(data, &buf) if err != nil { return } var ok bool val, ok = val.SetString(buf, 0) if !ok { err = errNotInteger return } } return val, int256Type, nil } func toAddress(f Field, data json.RawMessage) (rst common.Address, err error) { err = json.Unmarshal(data, &rst) return } func toBool(f Field, data json.RawMessage) (rst bool, err error) { err = json.Unmarshal(data, &rst) return }