diff options
| -rw-r--r-- | accounts/abi/abi.go | 12 | ||||
| -rw-r--r-- | accounts/abi/abi_test.go | 65 | ||||
| -rw-r--r-- | accounts/abi/argument.go | 71 | ||||
| -rw-r--r-- | accounts/abi/event_test.go | 10 | ||||
| -rw-r--r-- | accounts/abi/reflect.go | 17 |
5 files changed, 128 insertions, 47 deletions
diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 7229a67bf..cbcf4ca92 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -17,6 +17,7 @@ package abi import ( + "bytes" "encoding/json" "fmt" "io" @@ -133,3 +134,14 @@ func (abi *ABI) UnmarshalJSON(data []byte) error { return nil } + +// MethodById looks up a method by the 4-byte id +// returns nil if none found +func (abi *ABI) MethodById(sigdata []byte) *Method { + for _, method := range abi.Methods { + if bytes.Equal(method.Id(), sigdata[:4]) { + return &method + } + } + return nil +} diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index 1ae351730..2d43b631c 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -25,6 +25,8 @@ import ( "strings" "testing" + "reflect" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" ) @@ -74,12 +76,24 @@ func TestReader(t *testing.T) { } // deep equal fails for some reason - //t.Skip() - // Check with String() instead - expS := fmt.Sprintf("%v",exp) - gotS := fmt.Sprintf("%v", abi) - if expS != gotS { - t.Errorf("\nGot abi: \n%v\ndoes not match expected \n%v", abi, exp) + for name, expM := range exp.Methods { + gotM, exist := abi.Methods[name] + if !exist { + t.Errorf("Missing expected method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } + } + + for name, gotM := range abi.Methods { + expM, exist := exp.Methods[name] + if !exist { + t.Errorf("Found extra method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } } } @@ -643,3 +657,42 @@ func TestUnpackEvent(t *testing.T) { t.Logf("len(data): %d; received event: %+v", len(data), ev) } } + +func TestABI_MethodById(t *testing.T) { + const abiJSON = `[ + {"type":"function","name":"receive","constant":false,"inputs":[{"name":"memo","type":"bytes"}],"outputs":[],"payable":true,"stateMutability":"payable"}, + {"type":"event","name":"received","anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}]}, + {"type":"function","name":"fixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"fixedArrBytes","constant":true,"inputs":[{"name":"str","type":"bytes"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"mixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"}]}, + {"type":"function","name":"doubleFixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"multipleMixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"balance","constant":true}, + {"type":"function","name":"send","constant":false,"inputs":[{"name":"amount","type":"uint256"}]}, + {"type":"function","name":"test","constant":false,"inputs":[{"name":"number","type":"uint32"}]}, + {"type":"function","name":"string","constant":false,"inputs":[{"name":"inputs","type":"string"}]}, + {"type":"function","name":"bool","constant":false,"inputs":[{"name":"inputs","type":"bool"}]}, + {"type":"function","name":"address","constant":false,"inputs":[{"name":"inputs","type":"address"}]}, + {"type":"function","name":"uint64[2]","constant":false,"inputs":[{"name":"inputs","type":"uint64[2]"}]}, + {"type":"function","name":"uint64[]","constant":false,"inputs":[{"name":"inputs","type":"uint64[]"}]}, + {"type":"function","name":"foo","constant":false,"inputs":[{"name":"inputs","type":"uint32"}]}, + {"type":"function","name":"bar","constant":false,"inputs":[{"name":"inputs","type":"uint32"},{"name":"string","type":"uint16"}]}, + {"type":"function","name":"_slice","constant":false,"inputs":[{"name":"inputs","type":"uint32[2]"}]}, + {"type":"function","name":"__slice256","constant":false,"inputs":[{"name":"inputs","type":"uint256[2]"}]}, + {"type":"function","name":"sliceAddress","constant":false,"inputs":[{"name":"inputs","type":"address[]"}]}, + {"type":"function","name":"sliceMultiAddress","constant":false,"inputs":[{"name":"a","type":"address[]"},{"name":"b","type":"address[]"}]} + ] +` + abi, err := JSON(strings.NewReader(abiJSON)) + if err != nil { + t.Fatal(err) + } + for name, m := range abi.Methods { + a := fmt.Sprintf("%v", m) + b := fmt.Sprintf("%v", abi.MethodById(m.Id())) + if a != b { + t.Errorf("Method %v (id %v) not 'findable' by id in ABI", name, common.ToHex(m.Id())) + } + } + +} diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go index c41c2c6b0..ad17fbf2b 100644 --- a/accounts/abi/argument.go +++ b/accounts/abi/argument.go @@ -34,7 +34,7 @@ type Argument struct { type Arguments []Argument // UnmarshalJSON implements json.Unmarshaler interface -func (a *Argument) UnmarshalJSON(data []byte) error { +func (argument *Argument) UnmarshalJSON(data []byte) error { var extarg struct { Name string Type string @@ -45,38 +45,43 @@ func (a *Argument) UnmarshalJSON(data []byte) error { return fmt.Errorf("argument json err: %v", err) } - a.Type, err = NewType(extarg.Type) + argument.Type, err = NewType(extarg.Type) if err != nil { return err } - a.Name = extarg.Name - a.Indexed = extarg.Indexed + argument.Name = extarg.Name + argument.Indexed = extarg.Indexed return nil } -func countNonIndexedArguments(args []Argument) int { +// LengthNonIndexed returns the number of arguments when not counting 'indexed' ones. Only events +// can ever have 'indexed' arguments, it should always be false on arguments for method input/output +func (arguments Arguments) LengthNonIndexed() int { out := 0 - for i := range args { - if !args[i].Indexed { + for _, arg := range arguments { + if !arg.Indexed { out++ } } return out } -func (a *Arguments) isTuple() bool { - return a != nil && len(*a) > 1 + +// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[] +func (arguments Arguments) isTuple() bool { + return len(arguments) > 1 } -func (a *Arguments) Unpack(v interface{}, data []byte) error { - if a.isTuple() { - return a.unpackTuple(v, data) +// Unpack performs the operation hexdata -> Go format +func (arguments Arguments) Unpack(v interface{}, data []byte) error { + if arguments.isTuple() { + return arguments.unpackTuple(v, data) } - return a.unpackAtomic(v, data) + return arguments.unpackAtomic(v, data) } -func (a *Arguments) unpackTuple(v interface{}, output []byte) error { - // make sure the passed value is a pointer +func (arguments Arguments) unpackTuple(v interface{}, output []byte) error { + // make sure the passed value is arguments pointer valueOf := reflect.ValueOf(v) if reflect.Ptr != valueOf.Kind() { return fmt.Errorf("abi: Unpack(non-pointer %T)", v) @@ -87,17 +92,16 @@ func (a *Arguments) unpackTuple(v interface{}, output []byte) error { typ = value.Type() kind = value.Kind() ) -/* !TODO add this back - if err := requireUnpackKind(value, typ, kind, (*a), false); err != nil { + + if err := requireUnpackKind(value, typ, kind, arguments); err != nil { return err } -*/ // `i` counts the nonindexed arguments. // `j` counts the number of complex types. // both `i` and `j` are used to to correctly compute `data` offset. i, j := -1, 0 - for _, arg := range(*a) { + for _, arg := range arguments { if arg.Indexed { // can't read, continue @@ -130,14 +134,16 @@ func (a *Arguments) unpackTuple(v interface{}, output []byte) error { } case reflect.Slice, reflect.Array: if value.Len() < i { - return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(*a), value.Len()) + return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len()) } v := value.Index(i) if err := requireAssignable(v, reflectValue); err != nil { return err } - reflectValue := reflect.ValueOf(marshalledValue) - return set(v.Elem(), reflectValue, arg) + + if err := set(v.Elem(), reflectValue, arg); err != nil { + return err + } default: return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", typ) } @@ -145,13 +151,14 @@ func (a *Arguments) unpackTuple(v interface{}, output []byte) error { return nil } -func (a *Arguments) unpackAtomic(v interface{}, output []byte) error { - // make sure the passed value is a pointer +// unpackAtomic unpacks ( hexdata -> go ) a single value +func (arguments Arguments) unpackAtomic(v interface{}, output []byte) error { + // make sure the passed value is arguments pointer valueOf := reflect.ValueOf(v) if reflect.Ptr != valueOf.Kind() { return fmt.Errorf("abi: Unpack(non-pointer %T)", v) } - arg := (*a)[0] + arg := arguments[0] if arg.Indexed { return fmt.Errorf("abi: attempting to unpack indexed variable into element.") } @@ -162,19 +169,13 @@ func (a *Arguments) unpackAtomic(v interface{}, output []byte) error { if err != nil { return err } - if err := set(value, reflect.ValueOf(marshalledValue), arg); err != nil { - return err - } - return nil + return set(value, reflect.ValueOf(marshalledValue), arg) } -func (arguments *Arguments) Pack(args ...interface{}) ([]byte, error) { +// Unpack performs the operation Go format -> Hexdata +func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) { // Make sure arguments match up and pack them - if arguments == nil { - return nil, fmt.Errorf("arguments are nil, programmer error!") - } - - abiArgs := *arguments + abiArgs := arguments if len(args) != len(abiArgs) { return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs)) } diff --git a/accounts/abi/event_test.go b/accounts/abi/event_test.go index 93740f6a5..cca61e433 100644 --- a/accounts/abi/event_test.go +++ b/accounts/abi/event_test.go @@ -225,7 +225,7 @@ func TestEventTupleUnpack(t *testing.T) { err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert) if tc.error == "" { assert.Nil(err, "Should be able to unpack event data.") - assert.Equal(tc.expected, tc.dest) + assert.Equal(tc.expected, tc.dest, tc.name) } else { assert.EqualError(err, tc.error) } @@ -243,11 +243,10 @@ func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, ass } /* -!TODO enable these when the fix is in. Taken from +Taken from https://github.com/ethereum/go-ethereum/pull/15568 - */ -/* + type testResult struct { Values [2]*big.Int Value1 *big.Int @@ -309,10 +308,9 @@ func TestEventIndexedWithArrayUnpack(t *testing.T) { b.Write(packNum(reflect.ValueOf(32))) b.Write(packNum(reflect.ValueOf(len(stringOut)))) b.Write(common.RightPadBytes([]byte(stringOut), 32)) - fmt.Println(b.Bytes()) + var rst testStruct require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) require.Equal(t, [2]uint8{0, 0}, rst.Value1) require.Equal(t, stringOut, rst.Value2) } -*/ diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go index fbcd576e5..7a9cdacd5 100644 --- a/accounts/abi/reflect.go +++ b/accounts/abi/reflect.go @@ -93,3 +93,20 @@ func requireAssignable(dst, src reflect.Value) error { } 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 +} |