From 4880868c88b8d82cda8ea615bf82548667a95da2 Mon Sep 17 00:00:00 2001 From: Jeffrey Wilcke Date: Wed, 20 Apr 2016 21:30:02 +0200 Subject: [PATCH] accounts/abi: fixed string and fixed size bytes packing --- accounts/abi/abi.go | 8 +- accounts/abi/abi_test.go | 194 ++++++++++++++++++++++++--------------- accounts/abi/error.go | 7 +- accounts/abi/method.go | 2 +- accounts/abi/packing.go | 2 +- accounts/abi/type.go | 9 +- 6 files changed, 137 insertions(+), 85 deletions(-) diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index cce89de1b0..32df6f19d7 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -197,13 +197,13 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) { case reflect.Uint64: return uint64(bigNum.Uint64()), nil case reflect.Int8: - return uint8(bigNum.Int64()), nil + return int8(bigNum.Int64()), nil case reflect.Int16: - return uint16(bigNum.Int64()), nil + return int16(bigNum.Int64()), nil case reflect.Int32: - return uint32(bigNum.Int64()), nil + return int32(bigNum.Int64()), nil case reflect.Int64: - return uint64(bigNum.Int64()), nil + return int64(bigNum.Int64()), nil case reflect.Ptr: return bigNum, nil } diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index 4b41d2eee0..05535b3b50 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -18,7 +18,6 @@ package abi import ( "bytes" - "errors" "fmt" "log" "math/big" @@ -53,35 +52,35 @@ func TestTypeCheck(t *testing.T) { for i, test := range []struct { typ string input interface{} - err error + err string }{ - {"uint", big.NewInt(1), nil}, - {"int", big.NewInt(1), nil}, - {"uint30", big.NewInt(1), nil}, - {"uint30", uint8(1), varErr(reflect.Ptr, reflect.Uint8)}, - {"uint16", uint16(1), nil}, - {"uint16", uint8(1), varErr(reflect.Uint16, reflect.Uint8)}, - {"uint16[]", []uint16{1, 2, 3}, nil}, - {"uint16[]", [3]uint16{1, 2, 3}, nil}, - {"uint16[]", []uint32{1, 2, 3}, typeErr(formatSliceString(reflect.Uint16, -1), formatSliceString(reflect.Uint32, -1))}, - {"uint16[3]", [3]uint32{1, 2, 3}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint32, 3))}, - {"uint16[3]", [4]uint16{1, 2, 3}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint16, 4))}, - {"uint16[3]", []uint16{1, 2, 3}, nil}, - {"uint16[3]", []uint16{1, 2, 3, 4}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint16, 4))}, - {"address[]", []common.Address{common.Address{1}}, nil}, - {"address[1]", []common.Address{common.Address{1}}, nil}, - {"address[1]", [1]common.Address{common.Address{1}}, nil}, - {"address[2]", [1]common.Address{common.Address{1}}, typeErr(formatSliceString(reflect.Array, 2), formatSliceString(reflect.Array, 1))}, - {"bytes32", [32]byte{}, nil}, - {"bytes32", [33]byte{}, typeErr(formatSliceString(reflect.Uint8, 32), formatSliceString(reflect.Uint8, 33))}, - {"bytes32", common.Hash{1}, nil}, - {"bytes31", [31]byte{}, nil}, - {"bytes31", [32]byte{}, typeErr(formatSliceString(reflect.Uint8, 31), formatSliceString(reflect.Uint8, 32))}, - {"bytes", []byte{0, 1}, nil}, - {"bytes", [2]byte{0, 1}, nil}, - {"bytes", common.Hash{1}, nil}, - {"string", "hello world", nil}, - {"bytes32[]", [][32]byte{[32]byte{}}, nil}, + {"uint", big.NewInt(1), ""}, + {"int", big.NewInt(1), ""}, + {"uint30", big.NewInt(1), ""}, + {"uint30", uint8(1), "abi: cannot use uint8 as type ptr as argument"}, + {"uint16", uint16(1), ""}, + {"uint16", uint8(1), "abi: cannot use uint8 as type uint16 as argument"}, + {"uint16[]", []uint16{1, 2, 3}, ""}, + {"uint16[]", [3]uint16{1, 2, 3}, ""}, + {"uint16[]", []uint32{1, 2, 3}, "abi: cannot use []uint32 as type []uint16 as argument"}, + {"uint16[3]", [3]uint32{1, 2, 3}, "abi: cannot use [3]uint32 as type [3]uint16 as argument"}, + {"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, + {"uint16[3]", []uint16{1, 2, 3}, ""}, + {"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, + {"address[]", []common.Address{common.Address{1}}, ""}, + {"address[1]", []common.Address{common.Address{1}}, ""}, + {"address[1]", [1]common.Address{common.Address{1}}, ""}, + {"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"}, + {"bytes32", [32]byte{}, ""}, + {"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"}, + {"bytes32", common.Hash{1}, ""}, + {"bytes31", [31]byte{}, ""}, + {"bytes31", [32]byte{}, "abi: cannot use [32]uint8 as type [31]uint8 as argument"}, + {"bytes", []byte{0, 1}, ""}, + {"bytes", [2]byte{0, 1}, ""}, + {"bytes", common.Hash{1}, ""}, + {"string", "hello world", ""}, + {"bytes32[]", [][32]byte{[32]byte{}}, ""}, } { typ, err := NewType(test.typ) if err != nil { @@ -89,16 +88,16 @@ func TestTypeCheck(t *testing.T) { } err = typeCheck(typ, reflect.ValueOf(test.input)) - if err != nil && test.err == nil { + if err != nil && len(test.err) == 0 { t.Errorf("%d failed. Expected no err but got: %v", i, err) continue } - if err == nil && test.err != nil { + if err == nil && len(test.err) != 0 { t.Errorf("%d failed. Expected err: %v but got none", i, test.err) continue } - if err != nil && test.err != nil && err.Error() != test.err.Error() { + if err != nil && len(test.err) != 0 && err.Error() != test.err { t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err) } } @@ -110,63 +109,93 @@ func TestSimpleMethodUnpack(t *testing.T) { marshalledOutput []byte // evm return data expectedOut interface{} // the expected output outVar string // the output variable (e.g. uint32, *big.Int, etc) - err error // nil or error if expected + err string // empty or error if expected }{ { `[ { "type": "uint32" } ]`, pad([]byte{1}, 32, true), uint32(1), "uint32", - nil, + "", }, { `[ { "type": "uint32" } ]`, pad([]byte{1}, 32, true), nil, "uint16", - errors.New("abi: cannot unmarshal uint32 in to uint16"), + "abi: cannot unmarshal uint32 in to uint16", }, { `[ { "type": "uint17" } ]`, pad([]byte{1}, 32, true), nil, "uint16", - errors.New("abi: cannot unmarshal *big.Int in to uint16"), + "abi: cannot unmarshal *big.Int in to uint16", }, { `[ { "type": "uint17" } ]`, pad([]byte{1}, 32, true), big.NewInt(1), "*big.Int", + "", + }, + + { + `[ { "type": "int32" } ]`, + pad([]byte{1}, 32, true), + int32(1), + "int32", + "", + }, + { + `[ { "type": "int32" } ]`, + pad([]byte{1}, 32, true), nil, + "int16", + "abi: cannot unmarshal int32 in to int16", + }, + { + `[ { "type": "int17" } ]`, + pad([]byte{1}, 32, true), + nil, + "int16", + "abi: cannot unmarshal *big.Int in to int16", + }, + { + `[ { "type": "int17" } ]`, + pad([]byte{1}, 32, true), + big.NewInt(1), + "*big.Int", + "", }, + { `[ { "type": "address" } ]`, pad(pad([]byte{1}, 20, false), 32, true), common.Address{1}, "address", - nil, + "", }, { `[ { "type": "bytes32" } ]`, pad([]byte{1}, 32, false), pad([]byte{1}, 32, false), "bytes", - nil, + "", }, { `[ { "type": "bytes32" } ]`, pad([]byte{1}, 32, false), pad([]byte{1}, 32, false), "hash", - nil, + "", }, { `[ { "type": "bytes32" } ]`, pad([]byte{1}, 32, false), pad([]byte{1}, 32, false), "interface", - nil, + "", }, } { abiDefinition := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) @@ -194,6 +223,22 @@ func TestSimpleMethodUnpack(t *testing.T) { 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) @@ -217,15 +262,15 @@ func TestSimpleMethodUnpack(t *testing.T) { continue } - if err != nil && test.err == nil { + if err != nil && len(test.err) == 0 { t.Errorf("%d failed. Expected no err but got: %v", i, err) continue } - if err == nil && test.err != nil { + if err == nil && len(test.err) != 0 { t.Errorf("%d failed. Expected err: %v but got none", i, test.err) continue } - if err != nil && test.err != nil && err.Error() != test.err.Error() { + if err != nil && len(test.err) != 0 && err.Error() != test.err { t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err) continue } @@ -253,6 +298,7 @@ func TestPack(t *testing.T) { }{ {"uint16", uint16(2), pad([]byte{2}, 32, true)}, {"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})}, + {"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)}, {"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})}, {"address[]", []common.Address{common.Address{1}, common.Address{2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))}, {"bytes32[]", []common.Hash{common.Hash{1}, common.Hash{2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))}, @@ -346,26 +392,26 @@ func TestMethodPack(t *testing.T) { const jsondata = ` [ - { "type" : "function", "name" : "balance", "const" : true }, - { "type" : "function", "name" : "send", "const" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] } + { "type" : "function", "name" : "balance", "constant" : true }, + { "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] } ]` const jsondata2 = ` [ - { "type" : "function", "name" : "balance", "const" : true }, - { "type" : "function", "name" : "send", "const" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] }, - { "type" : "function", "name" : "test", "const" : false, "inputs" : [ { "name" : "number", "type" : "uint32" } ] }, - { "type" : "function", "name" : "string", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "string" } ] }, - { "type" : "function", "name" : "bool", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "bool" } ] }, - { "type" : "function", "name" : "address", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "address" } ] }, - { "type" : "function", "name" : "uint64[2]", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] }, - { "type" : "function", "name" : "uint64[]", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] }, - { "type" : "function", "name" : "foo", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] }, - { "type" : "function", "name" : "bar", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] }, - { "type" : "function", "name" : "slice", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32[2]" } ] }, - { "type" : "function", "name" : "slice256", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] }, - { "type" : "function", "name" : "sliceAddress", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] }, - { "type" : "function", "name" : "sliceMultiAddress", "const" : false, "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] } + { "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[]" } ] } ]` func TestReader(t *testing.T) { @@ -537,9 +583,9 @@ func ExampleJSON() { func TestInputVariableInputLength(t *testing.T) { const definition = `[ - { "type" : "function", "name" : "strOne", "const" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] }, - { "type" : "function", "name" : "bytesOne", "const" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] }, - { "type" : "function", "name" : "strTwo", "const" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "str1", "type" : "string" } ] } + { "type" : "function", "name" : "strOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] }, + { "type" : "function", "name" : "bytesOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] }, + { "type" : "function", "name" : "strTwo", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "str1", "type" : "string" } ] } ]` abi, err := JSON(strings.NewReader(definition)) @@ -701,7 +747,7 @@ func TestBareEvents(t *testing.T) { func TestMultiReturnWithStruct(t *testing.T) { const definition = `[ - { "name" : "multi", "const" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` + { "name" : "multi", "constant" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` abi, err := JSON(strings.NewReader(definition)) if err != nil { @@ -754,7 +800,7 @@ func TestMultiReturnWithStruct(t *testing.T) { func TestMultiReturnWithSlice(t *testing.T) { const definition = `[ - { "name" : "multi", "const" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` + { "name" : "multi", "constant" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` abi, err := JSON(strings.NewReader(definition)) if err != nil { @@ -790,8 +836,8 @@ func TestMultiReturnWithSlice(t *testing.T) { func TestMarshalArrays(t *testing.T) { const definition = `[ - { "name" : "bytes32", "const" : false, "outputs": [ { "type": "bytes32" } ] }, - { "name" : "bytes10", "const" : false, "outputs": [ { "type": "bytes10" } ] } + { "name" : "bytes32", "constant" : false, "outputs": [ { "type": "bytes32" } ] }, + { "name" : "bytes10", "constant" : false, "outputs": [ { "type": "bytes10" } ] } ]` abi, err := JSON(strings.NewReader(definition)) @@ -849,14 +895,14 @@ func TestMarshalArrays(t *testing.T) { func TestUnmarshal(t *testing.T) { const definition = `[ - { "name" : "int", "const" : false, "outputs": [ { "type": "uint256" } ] }, - { "name" : "bool", "const" : false, "outputs": [ { "type": "bool" } ] }, - { "name" : "bytes", "const" : false, "outputs": [ { "type": "bytes" } ] }, - { "name" : "fixed", "const" : false, "outputs": [ { "type": "bytes32" } ] }, - { "name" : "multi", "const" : false, "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] }, - { "name" : "addressSliceSingle", "const" : false, "outputs": [ { "type": "address[]" } ] }, - { "name" : "addressSliceDouble", "const" : false, "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] }, - { "name" : "mixedBytes", "const" : true, "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]` + { "name" : "int", "constant" : false, "outputs": [ { "type": "uint256" } ] }, + { "name" : "bool", "constant" : false, "outputs": [ { "type": "bool" } ] }, + { "name" : "bytes", "constant" : false, "outputs": [ { "type": "bytes" } ] }, + { "name" : "fixed", "constant" : false, "outputs": [ { "type": "bytes32" } ] }, + { "name" : "multi", "constant" : false, "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] }, + { "name" : "addressSliceSingle", "constant" : false, "outputs": [ { "type": "address[]" } ] }, + { "name" : "addressSliceDouble", "constant" : false, "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] }, + { "name" : "mixedBytes", "constant" : true, "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]` abi, err := JSON(strings.NewReader(definition)) if err != nil { diff --git a/accounts/abi/error.go b/accounts/abi/error.go index 91a0374fdd..67739c21dc 100644 --- a/accounts/abi/error.go +++ b/accounts/abi/error.go @@ -33,7 +33,7 @@ func formatSliceString(kind reflect.Kind, sliceSize int) string { // sliceTypeCheck checks that the given slice can by assigned to the reflection // type in t. func sliceTypeCheck(t Type, val reflect.Value) error { - if !(val.Kind() == reflect.Slice || val.Kind() == reflect.Array) { + if val.Kind() != reflect.Slice && val.Kind() != reflect.Array { return typeErr(formatSliceString(t.Kind, t.SliceSize), val.Type()) } if t.IsArray && val.Len() != t.SliceSize { @@ -48,14 +48,13 @@ func sliceTypeCheck(t Type, val reflect.Value) error { return sliceTypeCheck(*t.Elem, val.Index(0)) } - elemKind := val.Type().Elem().Kind() - if elemKind != t.Elem.Kind { + if elemKind := val.Type().Elem().Kind(); elemKind != t.Elem.Kind { return typeErr(formatSliceString(t.Elem.Kind, t.SliceSize), val.Type()) } return nil } -// typeCheck checks that thet given reflection val can be assigned to the reflection +// 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 { diff --git a/accounts/abi/method.go b/accounts/abi/method.go index cad0cd27ff..f3d1a44b55 100644 --- a/accounts/abi/method.go +++ b/accounts/abi/method.go @@ -58,7 +58,7 @@ func (m Method) pack(method Method, args ...interface{}) ([]byte, error) { } // check for a slice type (string, bytes, slice) - if input.Type.T == StringTy || input.Type.T == BytesTy || input.Type.IsSlice || input.Type.IsArray { + if input.Type.requiresLengthPrefix() { // calculate the offset offset := len(method.Inputs)*32 + len(variableInput) // set the offset diff --git a/accounts/abi/packing.go b/accounts/abi/packing.go index 2a16d3be1c..c765dfdf30 100644 --- a/accounts/abi/packing.go +++ b/accounts/abi/packing.go @@ -59,7 +59,7 @@ func packElement(t Type, reflectValue reflect.Value) []byte { reflectValue = mustArrayToByteSlice(reflectValue) } - return common.LeftPadBytes(reflectValue.Bytes(), 32) + return common.RightPadBytes(reflectValue.Bytes(), 32) } panic("abi: fatal error") } diff --git a/accounts/abi/type.go b/accounts/abi/type.go index cad7b82123..2235bad611 100644 --- a/accounts/abi/type.go +++ b/accounts/abi/type.go @@ -89,6 +89,7 @@ func NewType(t string) (typ Type, err error) { return Type{}, err } typ.Elem = &sliceType + typ.stringKind = sliceType.stringKind + t[len(res[1]):] return typ, nil } @@ -110,6 +111,7 @@ func NewType(t string) (typ Type, err error) { varSize = 256 t += "256" } + typ.stringKind = t switch varType { case "int": @@ -149,7 +151,6 @@ func NewType(t string) (typ Type, err error) { default: return Type{}, fmt.Errorf("unsupported arg type: %s", t) } - typ.stringKind = t return } @@ -181,3 +182,9 @@ func (t Type) pack(v reflect.Value) ([]byte, error) { return packElement(t, v), nil } + +// requireLengthPrefix returns whether the type requires any sort of length +// prefixing. +func (t Type) requiresLengthPrefix() bool { + return t.T != FixedBytesTy && (t.T == StringTy || t.T == BytesTy || t.IsSlice || t.IsArray) +}