From 78745551c077bf54151202138c2629f288769561 Mon Sep 17 00:00:00 2001 From: Determinant Date: Tue, 15 Sep 2020 23:55:34 -0400 Subject: WIP: geth-tavum --- accounts/abi/reflect.go | 226 ------------------------------------------------ 1 file changed, 226 deletions(-) delete mode 100644 accounts/abi/reflect.go (limited to 'accounts/abi/reflect.go') diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go deleted file mode 100644 index 73ca8fa..0000000 --- a/accounts/abi/reflect.go +++ /dev/null @@ -1,226 +0,0 @@ -// Copyright 2016 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package abi - -import ( - "fmt" - "reflect" - "strings" -) - -// indirect recursively dereferences the value until it either gets the value -// or finds a big.Int -func indirect(v reflect.Value) reflect.Value { - if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbigT { - return indirect(v.Elem()) - } - return v -} - -// indirectInterfaceOrPtr recursively dereferences the value until value is not interface. -func indirectInterfaceOrPtr(v reflect.Value) reflect.Value { - if (v.Kind() == reflect.Interface || v.Kind() == reflect.Ptr) && v.Elem().IsValid() { - return indirect(v.Elem()) - } - return v -} - -// reflectIntKind returns the reflect using the given size and -// unsignedness. -func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) { - switch size { - case 8: - if unsigned { - return reflect.Uint8, uint8T - } - return reflect.Int8, int8T - case 16: - if unsigned { - return reflect.Uint16, uint16T - } - return reflect.Int16, int16T - case 32: - if unsigned { - return reflect.Uint32, uint32T - } - return reflect.Int32, int32T - case 64: - if unsigned { - return reflect.Uint64, uint64T - } - return reflect.Int64, int64T - } - return reflect.Ptr, bigT -} - -// mustArrayToBytesSlice creates a new byte slice with the exact same size as value -// and copies the bytes in value to the new slice. -func mustArrayToByteSlice(value reflect.Value) reflect.Value { - slice := reflect.MakeSlice(reflect.TypeOf([]byte{}), value.Len(), value.Len()) - reflect.Copy(slice, value) - return slice -} - -// set attempts to assign src to dst by either setting, copying or otherwise. -// -// set is a bit more lenient when it comes to assignment and doesn't force an as -// strict ruleset as bare `reflect` does. -func set(dst, src reflect.Value) error { - dstType, srcType := dst.Type(), src.Type() - switch { - case dstType.Kind() == reflect.Interface && dst.Elem().IsValid(): - return set(dst.Elem(), src) - case dstType.Kind() == reflect.Ptr && dstType.Elem() != derefbigT: - return set(dst.Elem(), src) - case srcType.AssignableTo(dstType) && dst.CanSet(): - dst.Set(src) - case dstType.Kind() == reflect.Slice && srcType.Kind() == reflect.Slice: - return setSlice(dst, src) - default: - return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type()) - } - return nil -} - -// setSlice attempts to assign src to dst when slices are not assignable by default -// e.g. src: [][]byte -> dst: [][15]byte -func setSlice(dst, src reflect.Value) error { - slice := reflect.MakeSlice(dst.Type(), src.Len(), src.Len()) - for i := 0; i < src.Len(); i++ { - v := src.Index(i) - reflect.Copy(slice.Index(i), v) - } - - dst.Set(slice) - return nil -} - -// requireAssignable assures that `dest` is a pointer and it's not an interface. -func requireAssignable(dst, src reflect.Value) error { - if dst.Kind() != reflect.Ptr && dst.Kind() != reflect.Interface { - return fmt.Errorf("abi: cannot unmarshal %v into %v", src.Type(), dst.Type()) - } - return nil -} - -// requireUnpackKind verifies preconditions for unpacking `args` into `kind` -func requireUnpackKind(v reflect.Value, t reflect.Type, k reflect.Kind, - args Arguments) error { - - switch k { - case reflect.Struct: - case reflect.Slice, reflect.Array: - if minLen := args.LengthNonIndexed(); v.Len() < minLen { - return fmt.Errorf("abi: insufficient number of elements in the list/array for unpack, want %d, got %d", - minLen, v.Len()) - } - default: - return fmt.Errorf("abi: cannot unmarshal tuple into %v", t) - } - return nil -} - -// mapArgNamesToStructFields maps a slice of argument names to struct fields. -// first round: for each Exportable field that contains a `abi:""` tag -// and this field name exists in the given argument name list, pair them together. -// second round: for each argument name that has not been already linked, -// find what variable is expected to be mapped into, if it exists and has not been -// used, pair them. -// Note this function assumes the given value is a struct value. -func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[string]string, error) { - typ := value.Type() - - abi2struct := make(map[string]string) - struct2abi := make(map[string]string) - - // first round ~~~ - for i := 0; i < typ.NumField(); i++ { - structFieldName := typ.Field(i).Name - - // skip private struct fields. - if structFieldName[:1] != strings.ToUpper(structFieldName[:1]) { - continue - } - // skip fields that have no abi:"" tag. - var ok bool - var tagName string - if tagName, ok = typ.Field(i).Tag.Lookup("abi"); !ok { - continue - } - // check if tag is empty. - if tagName == "" { - return nil, fmt.Errorf("struct: abi tag in '%s' is empty", structFieldName) - } - // check which argument field matches with the abi tag. - found := false - for _, arg := range argNames { - if arg == tagName { - if abi2struct[arg] != "" { - return nil, fmt.Errorf("struct: abi tag in '%s' already mapped", structFieldName) - } - // pair them - abi2struct[arg] = structFieldName - struct2abi[structFieldName] = arg - found = true - } - } - // check if this tag has been mapped. - if !found { - return nil, fmt.Errorf("struct: abi tag '%s' defined but not found in abi", tagName) - } - } - - // second round ~~~ - for _, argName := range argNames { - - structFieldName := ToCamelCase(argName) - - if structFieldName == "" { - return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct") - } - - // this abi has already been paired, skip it... unless there exists another, yet unassigned - // struct field with the same field name. If so, raise an error: - // abi: [ { "name": "value" } ] - // struct { Value *big.Int , Value1 *big.Int `abi:"value"`} - if abi2struct[argName] != "" { - if abi2struct[argName] != structFieldName && - struct2abi[structFieldName] == "" && - value.FieldByName(structFieldName).IsValid() { - return nil, fmt.Errorf("abi: multiple variables maps to the same abi field '%s'", argName) - } - continue - } - - // return an error if this struct field has already been paired. - if struct2abi[structFieldName] != "" { - return nil, fmt.Errorf("abi: multiple outputs mapping to the same struct field '%s'", structFieldName) - } - - if value.FieldByName(structFieldName).IsValid() { - // pair them - abi2struct[argName] = structFieldName - struct2abi[structFieldName] = argName - } else { - // not paired, but annotate as used, to detect cases like - // abi : [ { "name": "value" }, { "name": "_value" } ] - // struct { Value *big.Int } - struct2abi[structFieldName] = argName - } - } - return abi2struct, nil -} -- cgit v1.2.3