diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index a3aa9446ef..2f687969bc 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -191,7 +191,7 @@ func TestMethodSignature(t *testing.T) { t.Errorf("expected ids to match %x != %x", m.Id(), idexp) } - uintt, _ := NewType("uint") + uintt, _ := NewType("uint256") m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil} exp = "foo(uint256)" if m.Sig() != exp { diff --git a/accounts/abi/error.go b/accounts/abi/error.go index 5585d8f6ae..2333b8bfa0 100644 --- a/accounts/abi/error.go +++ b/accounts/abi/error.go @@ -39,23 +39,23 @@ func formatSliceString(kind reflect.Kind, sliceSize int) string { // type in t. func sliceTypeCheck(t Type, val reflect.Value) error { if val.Kind() != reflect.Slice && val.Kind() != reflect.Array { - return typeErr(formatSliceString(t.Kind, t.SliceSize), val.Type()) + return typeErr(formatSliceString(t.Kind, t.Size), val.Type()) } if t.T == ArrayTy && val.Len() != t.Size { return typeErr(formatSliceString(t.Elem.Kind, t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len())) } - if t.Elem.IsSlice { + if t.Elem.T == SliceTy { if val.Len() > 0 { return sliceTypeCheck(*t.Elem, val.Index(0)) } - } else if t.Elem.IsArray { + } else if t.Elem.T == ArrayTy { return sliceTypeCheck(*t.Elem, val.Index(0)) } if elemKind := val.Type().Elem().Kind(); elemKind != t.Elem.Kind { - return typeErr(formatSliceString(t.Elem.Kind, t.SliceSize), val.Type()) + return typeErr(formatSliceString(t.Elem.Kind, t.Size), val.Type()) } return nil } @@ -63,7 +63,7 @@ func sliceTypeCheck(t Type, val reflect.Value) error { // typeCheck checks that the given reflection value can be assigned to the reflection // type in t. func typeCheck(t Type, value reflect.Value) error { - if t.IsSlice || t.IsArray { + if t.T == SliceTy || t.T == ArrayTy { return sliceTypeCheck(t, value) } diff --git a/accounts/abi/event_test.go b/accounts/abi/event_test.go index b5054a0329..7e2f13f763 100644 --- a/accounts/abi/event_test.go +++ b/accounts/abi/event_test.go @@ -31,7 +31,7 @@ func TestEventId(t *testing.T) { }{ { definition: `[ - { "type" : "event", "name" : "balance", "inputs": [{ "name" : "in", "type": "uint" }] }, + { "type" : "event", "name" : "balance", "inputs": [{ "name" : "in", "type": "uint256" }] }, { "type" : "event", "name" : "check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] } ]`, expectations: map[string]common.Hash{ diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go index de8344188e..e953b77c18 100644 --- a/accounts/abi/reflect.go +++ b/accounts/abi/reflect.go @@ -73,15 +73,9 @@ func mustArrayToByteSlice(value reflect.Value) reflect.Value { func set(dst, src reflect.Value, output Argument) error { dstType := dst.Type() srcType := src.Type() - switch { - case dstType.AssignableTo(src.Type()): + case dstType.AssignableTo(srcType): dst.Set(src) - case dstType.Kind() == reflect.Array && srcType.Kind() == reflect.Slice: - if dst.Len() < output.Type.SliceSize { - return fmt.Errorf("abi: cannot unmarshal src (len=%d) in to dst (len=%d)", output.Type.SliceSize, dst.Len()) - } - reflect.Copy(dst, src) case dstType.Kind() == reflect.Interface: dst.Set(src) case dstType.Kind() == reflect.Ptr: diff --git a/accounts/abi/type_test.go b/accounts/abi/type_test.go index cbba58fe1b..7e85a3c513 100644 --- a/accounts/abi/type_test.go +++ b/accounts/abi/type_test.go @@ -184,6 +184,13 @@ func TestTypeCheck(t *testing.T) { {"int240", big.NewInt(1), ""}, {"int248", big.NewInt(1), ""}, {"uint30", uint8(1), "abi: cannot use uint8 as type ptr as argument"}, + {"uint8", uint16(1), "abi: cannot use uint16 as type uint8 as argument"}, + {"uint8", uint32(1), "abi: cannot use uint32 as type uint8 as argument"}, + {"uint8", uint64(1), "abi: cannot use uint64 as type uint8 as argument"}, + {"uint8", int8(1), "abi: cannot use int8 as type uint8 as argument"}, + {"uint8", int16(1), "abi: cannot use int16 as type uint8 as argument"}, + {"uint8", int32(1), "abi: cannot use int32 as type uint8 as argument"}, + {"uint8", int64(1), "abi: cannot use int64 as type uint8 as argument"}, {"uint16", uint16(1), ""}, {"uint16", uint8(1), "abi: cannot use uint8 as type uint16 as argument"}, {"uint16[]", []uint16{1, 2, 3}, ""}, @@ -246,7 +253,7 @@ func TestTypeCheck(t *testing.T) { {"address", common.Address{}, ""}, } { typ, err := NewType(test.typ) - if err != nil { + if err != nil && len(test.err) == 0 { t.Fatal("unexpected parse error:", err) } else if err != nil && len(test.err) != 0 { if err.Error() != test.err { diff --git a/accounts/abi/unpack.go b/accounts/abi/unpack.go index 41d107fecf..93322e93bc 100644 --- a/accounts/abi/unpack.go +++ b/accounts/abi/unpack.go @@ -105,7 +105,7 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) // this value will become our slice or our array, depending on the type var refSlice reflect.Value - slice := output[start : size*32] + slice := output[start : start+size*32] if t.T == SliceTy { // declare our slice refSlice = reflect.MakeSlice(t.Type, size, size) diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go index 807c80f20b..692bb40727 100644 --- a/accounts/abi/unpack_test.go +++ b/accounts/abi/unpack_test.go @@ -32,42 +32,42 @@ func TestSimpleMethodUnpack(t *testing.T) { def string // definition of the **output** ABI params marshalledOutput []byte // evm return data expectedOut interface{} // the expected output - outVar interface{} // the output variable (e.g. uint32, *big.Int, etc) + outVar string // the output variable (e.g. uint32, *big.Int, etc) err string // empty or error if expected }{ { `[ { "type": "bool" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), bool(true), - bool(false), + "bool", "", }, { `[ { "type": "uint32" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), uint32(1), - uint32(0), + "uint32", "", }, { `[ { "type": "uint32" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), nil, - uint16(0), + "uint16", "abi: cannot unmarshal uint32 in to uint16", }, { `[ { "type": "uint17" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), nil, - uint16(0), + "uint16", "abi: cannot unmarshal *big.Int in to uint16", }, { `[ { "type": "uint17" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), big.NewInt(1), - big.NewInt(0), + "*big.Int", "", }, @@ -75,28 +75,28 @@ func TestSimpleMethodUnpack(t *testing.T) { `[ { "type": "int32" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), int32(1), - int32(0), + "int32", "", }, { `[ { "type": "int32" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), nil, - int16(0), + "int16", "abi: cannot unmarshal int32 in to int16", }, { `[ { "type": "int17" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), nil, - int16(0), + "int16", "abi: cannot unmarshal *big.Int in to int16", }, { `[ { "type": "int17" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"), big.NewInt(1), - big.NewInt(0), + "*big.Int", "", }, @@ -104,28 +104,42 @@ func TestSimpleMethodUnpack(t *testing.T) { `[ { "type": "address" } ]`, common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"), common.Address{1}, - common.Address{0}, + "address", "", }, { `[ { "type": "bytes32" } ]`, common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - [32]byte{}, + "fixedBytes32", "", }, + { + `[ { "type": "bytes" } ]`, + common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000"), + common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), + "bytes", + "", + }, + { + `[ { "type": "bytes" } ]`, + common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000"), + nil, + "fixedBytes32", + "abi: cannot unmarshal []uint8 in to [32]uint8", + }, { `[ { "type": "bytes32" } ]`, common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), - common.Hash{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - common.Hash{}, + common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), + "hash", "", }, { `[ { "type": "function" } ]`, common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), [24]byte{1}, - [24]byte{}, + "function", "", }, } { @@ -136,7 +150,73 @@ func TestSimpleMethodUnpack(t *testing.T) { continue } - err = abi.Unpack(&test.outVar, "method", test.marshalledOutput) + var outvar interface{} + switch test.outVar { + case "bool": + var v bool + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "uint8": + var v uint8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "uint16": + var v uint16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "uint32": + var v uint32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "uint64": + var v uint64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "int8": + var v int8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "int16": + var v int16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "int32": + var v int32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "int64": + var v int64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "*big.Int": + var v *big.Int + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "address": + var v common.Address + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "bytes": + var v []byte + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "fixedBytes32": + // this is a bit presumptive but will work for testing for now + var v [32]byte + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "hash": + var v common.Hash + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v.Bytes()[:] + case "function": + var v [24]byte + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + default: + t.Errorf("unsupported type '%v' please add it to the switch statement in this test", test.outVar) + continue + } if err != nil && len(test.err) == 0 { t.Errorf("%d failed. Expected no err but got: %v", i, err) @@ -152,167 +232,165 @@ func TestSimpleMethodUnpack(t *testing.T) { } if err == nil { - t.Logf("expected %T, got %T for %v\n", test.expectedOut, test.outVar, i) - if !reflect.DeepEqual(test.expectedOut, test.outVar) { - t.Errorf("%d failed. Output error: expected %v, got %v", i, test.expectedOut, test.outVar) + if !reflect.DeepEqual(test.expectedOut, outvar) { + t.Errorf("%d failed. Output error: expected %v, got %v", i, test.expectedOut, outvar) } } } } - func TestArraysAndSlicesUnpack(t *testing.T) { for i, test := range []struct { def string // definition of the **output** ABI params marshalledOutput []byte // evm return data expectedOut interface{} // the expected output - outVar interface{} // the output variable (e.g. uint32, *big.Int, etc) + outVar string // the output variable (e.g. uint32, *big.Int, etc) err string // empty or error if expected }{ { `[ { "type": "uint8[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []uint8{1, 2}, - []uint8{}, + "[]uint8", "", }, { `[ { "type": "uint8[][]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000E0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [][]uint8{{1, 2}, {1, 2}}, - [][]uint8{{}}, + "[][]uint8", "", }, { `[ { "type": "uint8[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]uint8{1, 2}, - [2]uint8{}, + "[2]uint8", "", }, { `[ { "type": "uint16[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []uint16{1, 2}, - []uint16{}, + "[]uint16", "", }, { `[ { "type": "uint16[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]uint16{1, 2}, - [2]uint16{}, + "[2]uint16", "", }, { `[ { "type": "uint32[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []uint32{1, 2}, - []uint32{}, + "[]uint32", "", }, { `[ { "type": "uint32[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]uint32{1, 2}, - [2]uint32{}, + "[2]uint32", "", }, { `[ { "type": "uint64[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []uint64{1, 2}, - []uint64{}, + "[]uint64", "", }, { `[ { "type": "uint64[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]uint64{1, 2}, - [2]uint64{}, + "[2]uint64", "", }, { `[ { "type": "uint256[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []*big.Int{big.NewInt(1), big.NewInt(2)}, - []*big.Int{}, + "[]*big.Int", "", }, { `[ { "type": "uint256[3]" } ]`, append(pad([]byte{1}, 32, true), append(pad([]byte{2}, 32, true), pad([]byte{3}, 32, true)...)...), [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}, - [3]*big.Int{}, + "[3]*big.Int", "", }, { `[ { "type": "int8[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []int8{1, 2}, - []int8{}, + "[]int8", "", }, { `[ { "type": "int8[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]int8{1, 2}, - [2]int8{}, + "[2]int8", "", }, { `[ { "type": "int16[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []int16{1, 2}, - []int16{}, + "[]int16", "", }, { `[ { "type": "int16[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]int16{1, 2}, - [2]int16{}, + "[2]int16", "", }, { `[ { "type": "int32[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []int32{1, 2}, - []int32{}, + "[]int32", "", }, { `[ { "type": "int32[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]int32{1, 2}, - [2]int32{}, + "[2]int32", "", }, { `[ { "type": "int64[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []int64{1, 2}, - []int64{}, + "[]int64", "", }, { `[ { "type": "int64[2]" } ]`, common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), [2]int64{1, 2}, - [2]int64{}, + "[2]int64", "", }, { `[ { "type": "int256[]" } ]`, common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"), []*big.Int{big.NewInt(1), big.NewInt(2)}, - []*big.Int{}, + "[]*big.Int", "", }, { `[ { "type": "int256[3]" } ]`, common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003"), [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}, - [3]*big.Int{}, + "[3]*big.Int", "", }, } { @@ -325,7 +403,88 @@ func TestArraysAndSlicesUnpack(t *testing.T) { continue } - err = abi.Unpack(&test.outVar, "method", test.marshalledOutput) + var outvar interface{} + switch test.outVar { + case "[][]uint8": + var v [][]uint8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]uint8": + var v []uint8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]uint8": + var v [2]uint8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]uint16": + var v []uint16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]uint16": + var v [2]uint16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]uint32": + var v []uint32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]uint32": + var v [2]uint32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]uint64": + var v []uint64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]uint64": + var v [2]uint64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]int8": + var v []int8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]int8": + var v [2]int8 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]int16": + var v []int16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]int16": + var v [2]int16 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]int32": + var v []int32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]int32": + var v [2]int32 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]int64": + var v []int64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[2]int64": + var v [2]int64 + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[3]*big.Int": + var v [3]*big.Int + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + case "[]*big.Int": + var v []*big.Int + err = abi.Unpack(&v, "method", test.marshalledOutput) + outvar = v + default: + t.Errorf("unsupported type '%v' please add it to the switch statement in this test", test.outVar) + continue + } if err != nil && len(test.err) == 0 { t.Errorf("%d failed. Expected no err but got: %v", i, err) @@ -341,8 +500,8 @@ func TestArraysAndSlicesUnpack(t *testing.T) { } if err == nil { - if !reflect.DeepEqual(test.expectedOut, test.outVar) { - t.Errorf("%d failed. Output error: expected %v, got %v", i, test.expectedOut, test.outVar) + if !reflect.DeepEqual(test.expectedOut, outvar) { + t.Errorf("%d failed. Output error: expected %v, got %v", i, test.expectedOut, outvar) } } @@ -474,11 +633,11 @@ func TestUnmarshal(t *testing.T) { t.Errorf("expected %x got %x", bytesOut, Bytes) } - // marshall dynamic bytes max length 63 + // marshall dynamic bytes max length 64 buff.Reset() buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")) buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000003f")) - bytesOut = common.RightPadBytes([]byte("hello"), 63) + bytesOut = common.RightPadBytes([]byte("hello"), 64) buff.Write(bytesOut) err = abi.Unpack(&Bytes, "bytes", buff.Bytes()) @@ -486,8 +645,8 @@ func TestUnmarshal(t *testing.T) { t.Error(err) } - if !bytes.Equal(Bytes, bytesOut) { - t.Errorf("expected %x got %x", bytesOut, Bytes) + if !bytes.Equal(Bytes, bytesOut[:len(bytesOut)-1]) { + t.Errorf("expected %x got %x", bytesOut[:len(bytesOut)-1], Bytes) } // marshal dynamic bytes output empty @@ -539,29 +698,6 @@ func TestUnmarshal(t *testing.T) { t.Error("expected error") } - // marshal mixed bytes - buff.Reset() - buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) - fixed := common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001") - buff.Write(fixed) - buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")) - bytesOut = common.RightPadBytes([]byte("hello"), 32) - buff.Write(bytesOut) - - var out []interface{} - err = abi.Unpack(&out, "mixedBytes", buff.Bytes()) - if err != nil { - t.Fatal("didn't expect error:", err) - } - - if !bytes.Equal(bytesOut, out[0].([]byte)) { - t.Errorf("expected %x, got %x", bytesOut, out[0]) - } - - if !bytes.Equal(fixed, out[1].([]byte)) { - t.Errorf("expected %x, got %x", fixed, out[1]) - } - buff.Reset() buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"))