cerc-io/plugeth
18
0
Fork 1
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity

accounts/abi: fixed string and fixed size bytes packing

Browse Source
This commit is contained in:
Jeffrey Wilcke 2016-04-20 21:30:02 +02:00
parent c3d5250473
commit 4880868c88
6 changed files with 138 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
accounts/abi/abi.go
View File

@ -197,13 +197,13 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) {
case reflect.Uint64: case reflect.Uint64:
return uint64(bigNum.Uint64()), nil return uint64(bigNum.Uint64()), nil
case reflect.Int8: case reflect.Int8:
return uint8(bigNum.Int64()), nil return int8(bigNum.Int64()), nil
case reflect.Int16: case reflect.Int16:
return uint16(bigNum.Int64()), nil return int16(bigNum.Int64()), nil
case reflect.Int32: case reflect.Int32:
return uint32(bigNum.Int64()), nil return int32(bigNum.Int64()), nil
case reflect.Int64: case reflect.Int64:
return uint64(bigNum.Int64()), nil return int64(bigNum.Int64()), nil
case reflect.Ptr: case reflect.Ptr:
return bigNum, nil return bigNum, nil
} }

196
accounts/abi/abi_test.go
View File

@ -18,7 +18,6 @@ package abi
import ( import (
"bytes" "bytes"
"errors"
"fmt" "fmt"
"log" "log"
"math/big" "math/big"
@ -53,35 +52,35 @@ func TestTypeCheck(t *testing.T) {
for i, test := range []struct { for i, test := range []struct {
typ string typ string
input interface{} input interface{}
err error err string
}{ }{
{"uint", big.NewInt(1), nil}, {"uint", big.NewInt(1), ""},
{"int", big.NewInt(1), nil}, {"int", big.NewInt(1), ""},
{"uint30", big.NewInt(1), nil}, {"uint30", big.NewInt(1), ""},
{"uint30", uint8(1), varErr(reflect.Ptr, reflect.Uint8)}, {"uint30", uint8(1), "abi: cannot use uint8 as type ptr as argument"},
{"uint16", uint16(1), nil}, {"uint16", uint16(1), ""},
{"uint16", uint8(1), varErr(reflect.Uint16, reflect.Uint8)}, {"uint16", uint8(1), "abi: cannot use uint8 as type uint16 as argument"},
{"uint16[]", []uint16{1, 2, 3}, nil}, {"uint16[]", []uint16{1, 2, 3}, ""},
{"uint16[]", [3]uint16{1, 2, 3}, nil}, {"uint16[]", [3]uint16{1, 2, 3}, ""},
{"uint16[]", []uint32{1, 2, 3}, typeErr(formatSliceString(reflect.Uint16, -1), formatSliceString(reflect.Uint32, -1))}, {"uint16[]", []uint32{1, 2, 3}, "abi: cannot use []uint32 as type []uint16 as argument"},
{"uint16[3]", [3]uint32{1, 2, 3}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint32, 3))}, {"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}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint16, 4))}, {"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"uint16[3]", []uint16{1, 2, 3}, nil}, {"uint16[3]", []uint16{1, 2, 3}, ""},
{"uint16[3]", []uint16{1, 2, 3, 4}, typeErr(formatSliceString(reflect.Uint16, 3), formatSliceString(reflect.Uint16, 4))}, {"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"address[]", []common.Address{common.Address{1}}, nil}, {"address[]", []common.Address{common.Address{1}}, ""},
{"address[1]", []common.Address{common.Address{1}}, nil}, {"address[1]", []common.Address{common.Address{1}}, ""},
{"address[1]", [1]common.Address{common.Address{1}}, nil}, {"address[1]", [1]common.Address{common.Address{1}}, ""},
{"address[2]", [1]common.Address{common.Address{1}}, typeErr(formatSliceString(reflect.Array, 2), formatSliceString(reflect.Array, 1))}, {"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"},
{"bytes32", [32]byte{}, nil}, {"bytes32", [32]byte{}, ""},
{"bytes32", [33]byte{}, typeErr(formatSliceString(reflect.Uint8, 32), formatSliceString(reflect.Uint8, 33))}, {"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
{"bytes32", common.Hash{1}, nil}, {"bytes32", common.Hash{1}, ""},
{"bytes31", [31]byte{}, nil}, {"bytes31", [31]byte{}, ""},
{"bytes31", [32]byte{}, typeErr(formatSliceString(reflect.Uint8, 31), formatSliceString(reflect.Uint8, 32))}, {"bytes31", [32]byte{}, "abi: cannot use [32]uint8 as type [31]uint8 as argument"},
{"bytes", []byte{0, 1}, nil}, {"bytes", []byte{0, 1}, ""},
{"bytes", [2]byte{0, 1}, nil}, {"bytes", [2]byte{0, 1}, ""},
{"bytes", common.Hash{1}, nil}, {"bytes", common.Hash{1}, ""},
{"string", "hello world", nil}, {"string", "hello world", ""},
{"bytes32[]", [][32]byte{[32]byte{}}, nil}, {"bytes32[]", [][32]byte{[32]byte{}}, ""},
} { } {
typ, err := NewType(test.typ) typ, err := NewType(test.typ)
if err != nil { if err != nil {
@ -89,16 +88,16 @@ func TestTypeCheck(t *testing.T) {
} }
err = typeCheck(typ, reflect.ValueOf(test.input)) 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) t.Errorf("%d failed. Expected no err but got: %v", i, err)
continue 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) t.Errorf("%d failed. Expected err: %v but got none", i, test.err)
continue 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) 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 marshalledOutput []byte // evm return data
expectedOut interface{} // the expected output expectedOut interface{} // the expected output
outVar string // the output variable (e.g. uint32, *big.Int, etc) 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" } ]`, `[ { "type": "uint32" } ]`,
pad([]byte{1}, 32, true), pad([]byte{1}, 32, true),
uint32(1), uint32(1),
"uint32", "uint32",
nil, "",
}, },
{ {
`[ { "type": "uint32" } ]`, `[ { "type": "uint32" } ]`,
pad([]byte{1}, 32, true), pad([]byte{1}, 32, true),
nil, nil,
"uint16", "uint16",
errors.New("abi: cannot unmarshal uint32 in to uint16"), "abi: cannot unmarshal uint32 in to uint16",
}, },
{ {
`[ { "type": "uint17" } ]`, `[ { "type": "uint17" } ]`,
pad([]byte{1}, 32, true), pad([]byte{1}, 32, true),
nil, nil,
"uint16", "uint16",
errors.New("abi: cannot unmarshal *big.Int in to uint16"), "abi: cannot unmarshal *big.Int in to uint16",
}, },
{ {
`[ { "type": "uint17" } ]`, `[ { "type": "uint17" } ]`,
pad([]byte{1}, 32, true), pad([]byte{1}, 32, true),
big.NewInt(1), big.NewInt(1),
"*big.Int", "*big.Int",
nil, "",
}, },
{
`[ { "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" } ]`, `[ { "type": "address" } ]`,
pad(pad([]byte{1}, 20, false), 32, true), pad(pad([]byte{1}, 20, false), 32, true),
common.Address{1}, common.Address{1},
"address", "address",
nil, "",
}, },
{ {
`[ { "type": "bytes32" } ]`, `[ { "type": "bytes32" } ]`,
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
"bytes", "bytes",
nil, "",
}, },
{ {
`[ { "type": "bytes32" } ]`, `[ { "type": "bytes32" } ]`,
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
"hash", "hash",
nil, "",
}, },
{ {
`[ { "type": "bytes32" } ]`, `[ { "type": "bytes32" } ]`,
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
pad([]byte{1}, 32, false), pad([]byte{1}, 32, false),
"interface", "interface",
nil, "",
}, },
} { } {
abiDefinition := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) abiDefinition := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def)
@ -194,6 +223,22 @@ func TestSimpleMethodUnpack(t *testing.T) {
var v uint64 var v uint64
err = abi.Unpack(&v, "method", test.marshalledOutput) err = abi.Unpack(&v, "method", test.marshalledOutput)
outvar = v 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": case "*big.Int":
var v *big.Int var v *big.Int
err = abi.Unpack(&v, "method", test.marshalledOutput) err = abi.Unpack(&v, "method", test.marshalledOutput)
@ -217,15 +262,15 @@ func TestSimpleMethodUnpack(t *testing.T) {
continue 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) t.Errorf("%d failed. Expected no err but got: %v", i, err)
continue 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) t.Errorf("%d failed. Expected err: %v but got none", i, test.err)
continue 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) t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
continue continue
} }
@ -253,6 +298,7 @@ func TestPack(t *testing.T) {
}{ }{
{"uint16", uint16(2), pad([]byte{2}, 32, true)}, {"uint16", uint16(2), pad([]byte{2}, 32, true)},
{"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})}, {"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})}, {"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))}, {"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))}, {"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 = ` const jsondata = `
[ [
{ "type" : "function", "name" : "balance", "const" : true }, { "type" : "function", "name" : "balance", "constant" : true },
{ "type" : "function", "name" : "send", "const" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] } { "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] }
]` ]`
const jsondata2 = ` const jsondata2 = `
[ [
{ "type" : "function", "name" : "balance", "const" : true }, { "type" : "function", "name" : "balance", "constant" : true },
{ "type" : "function", "name" : "send", "const" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] }, { "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] },
{ "type" : "function", "name" : "test", "const" : false, "inputs" : [ { "name" : "number", "type" : "uint32" } ] }, { "type" : "function", "name" : "test", "constant" : false, "inputs" : [ { "name" : "number", "type" : "uint32" } ] },
{ "type" : "function", "name" : "string", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "string" } ] }, { "type" : "function", "name" : "string", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "string" } ] },
{ "type" : "function", "name" : "bool", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "bool" } ] }, { "type" : "function", "name" : "bool", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "bool" } ] },
{ "type" : "function", "name" : "address", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "address" } ] }, { "type" : "function", "name" : "address", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "address" } ] },
{ "type" : "function", "name" : "uint64[2]", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] }, { "type" : "function", "name" : "uint64[2]", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] },
{ "type" : "function", "name" : "uint64[]", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] }, { "type" : "function", "name" : "uint64[]", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] },
{ "type" : "function", "name" : "foo", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] }, { "type" : "function", "name" : "foo", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] },
{ "type" : "function", "name" : "bar", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] }, { "type" : "function", "name" : "bar", "constant" : 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" : "slice", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32[2]" } ] },
{ "type" : "function", "name" : "slice256", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] }, { "type" : "function", "name" : "slice256", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] },
{ "type" : "function", "name" : "sliceAddress", "const" : false, "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] }, { "type" : "function", "name" : "sliceAddress", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] },
{ "type" : "function", "name" : "sliceMultiAddress", "const" : false, "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] } { "type" : "function", "name" : "sliceMultiAddress", "constant" : false, "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] }
]` ]`
func TestReader(t *testing.T) { func TestReader(t *testing.T) {
@ -537,9 +583,9 @@ func ExampleJSON() {
func TestInputVariableInputLength(t *testing.T) { func TestInputVariableInputLength(t *testing.T) {
const definition = `[ const definition = `[
{ "type" : "function", "name" : "strOne", "const" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] }, { "type" : "function", "name" : "strOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] },
{ "type" : "function", "name" : "bytesOne", "const" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] }, { "type" : "function", "name" : "bytesOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] },
{ "type" : "function", "name" : "strTwo", "const" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "str1", "type" : "string" } ] } { "type" : "function", "name" : "strTwo", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "str1", "type" : "string" } ] }
]` ]`
abi, err := JSON(strings.NewReader(definition)) abi, err := JSON(strings.NewReader(definition))
@ -701,7 +747,7 @@ func TestBareEvents(t *testing.T) {
func TestMultiReturnWithStruct(t *testing.T) { func TestMultiReturnWithStruct(t *testing.T) {
const definition = `[ 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)) abi, err := JSON(strings.NewReader(definition))
if err != nil { if err != nil {
@ -754,7 +800,7 @@ func TestMultiReturnWithStruct(t *testing.T) {
func TestMultiReturnWithSlice(t *testing.T) { func TestMultiReturnWithSlice(t *testing.T) {
const definition = `[ 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)) abi, err := JSON(strings.NewReader(definition))
if err != nil { if err != nil {
@ -790,8 +836,8 @@ func TestMultiReturnWithSlice(t *testing.T) {
func TestMarshalArrays(t *testing.T) { func TestMarshalArrays(t *testing.T) {
const definition = `[ const definition = `[
{ "name" : "bytes32", "const" : false, "outputs": [ { "type": "bytes32" } ] }, { "name" : "bytes32", "constant" : false, "outputs": [ { "type": "bytes32" } ] },
{ "name" : "bytes10", "const" : false, "outputs": [ { "type": "bytes10" } ] } { "name" : "bytes10", "constant" : false, "outputs": [ { "type": "bytes10" } ] }
]` ]`
abi, err := JSON(strings.NewReader(definition)) abi, err := JSON(strings.NewReader(definition))
@ -849,14 +895,14 @@ func TestMarshalArrays(t *testing.T) {
func TestUnmarshal(t *testing.T) { func TestUnmarshal(t *testing.T) {
const definition = `[ const definition = `[
{ "name" : "int", "const" : false, "outputs": [ { "type": "uint256" } ] }, { "name" : "int", "constant" : false, "outputs": [ { "type": "uint256" } ] },
{ "name" : "bool", "const" : false, "outputs": [ { "type": "bool" } ] }, { "name" : "bool", "constant" : false, "outputs": [ { "type": "bool" } ] },
{ "name" : "bytes", "const" : false, "outputs": [ { "type": "bytes" } ] }, { "name" : "bytes", "constant" : false, "outputs": [ { "type": "bytes" } ] },
{ "name" : "fixed", "const" : false, "outputs": [ { "type": "bytes32" } ] }, { "name" : "fixed", "constant" : false, "outputs": [ { "type": "bytes32" } ] },
{ "name" : "multi", "const" : false, "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] }, { "name" : "multi", "constant" : false, "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] },
{ "name" : "addressSliceSingle", "const" : false, "outputs": [ { "type": "address[]" } ] }, { "name" : "addressSliceSingle", "constant" : false, "outputs": [ { "type": "address[]" } ] },
{ "name" : "addressSliceDouble", "const" : false, "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] }, { "name" : "addressSliceDouble", "constant" : false, "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] },
{ "name" : "mixedBytes", "const" : true, "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]` { "name" : "mixedBytes", "constant" : true, "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]`
abi, err := JSON(strings.NewReader(definition)) abi, err := JSON(strings.NewReader(definition))
if err != nil { if err != nil {

7
accounts/abi/error.go
View File

@ -33,7 +33,7 @@ func formatSliceString(kind reflect.Kind, sliceSize int) string {
// sliceTypeCheck checks that the given slice can by assigned to the reflection // sliceTypeCheck checks that the given slice can by assigned to the reflection
// type in t. // type in t.
func sliceTypeCheck(t Type, val reflect.Value) error { 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()) return typeErr(formatSliceString(t.Kind, t.SliceSize), val.Type())
} }
if t.IsArray && val.Len() != t.SliceSize { 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)) return sliceTypeCheck(*t.Elem, val.Index(0))
} }
elemKind := val.Type().Elem().Kind() if elemKind := val.Type().Elem().Kind(); elemKind != t.Elem.Kind {
if elemKind != t.Elem.Kind {
return typeErr(formatSliceString(t.Elem.Kind, t.SliceSize), val.Type()) return typeErr(formatSliceString(t.Elem.Kind, t.SliceSize), val.Type())
} }
return nil 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. // type in t.
func typeCheck(t Type, value reflect.Value) error { func typeCheck(t Type, value reflect.Value) error {
if t.IsSlice || t.IsArray { if t.IsSlice || t.IsArray {

2
accounts/abi/method.go
View File

@ -58,7 +58,7 @@ func (m Method) pack(method Method, args ...interface{}) ([]byte, error) {
} }
// check for a slice type (string, bytes, slice) // 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 // calculate the offset
offset := len(method.Inputs)*32 + len(variableInput) offset := len(method.Inputs)*32 + len(variableInput)
// set the offset // set the offset

2
accounts/abi/packing.go
View File

@ -59,7 +59,7 @@ func packElement(t Type, reflectValue reflect.Value) []byte {
reflectValue = mustArrayToByteSlice(reflectValue) reflectValue = mustArrayToByteSlice(reflectValue)
} }
return common.LeftPadBytes(reflectValue.Bytes(), 32) return common.RightPadBytes(reflectValue.Bytes(), 32)
} }
panic("abi: fatal error") panic("abi: fatal error")
} }

9
accounts/abi/type.go
View File

@ -89,6 +89,7 @@ func NewType(t string) (typ Type, err error) {
return Type{}, err return Type{}, err
} }
typ.Elem = &sliceType typ.Elem = &sliceType
typ.stringKind = sliceType.stringKind + t[len(res[1]):]
return typ, nil return typ, nil
} }
@ -110,6 +111,7 @@ func NewType(t string) (typ Type, err error) {
varSize = 256 varSize = 256
t += "256" t += "256"
} }
typ.stringKind = t
switch varType { switch varType {
case "int": case "int":
@ -149,7 +151,6 @@ func NewType(t string) (typ Type, err error) {
default: default:
return Type{}, fmt.Errorf("unsupported arg type: %s", t) return Type{}, fmt.Errorf("unsupported arg type: %s", t)
} }
typ.stringKind = t
return return
} }
@ -181,3 +182,9 @@ func (t Type) pack(v reflect.Value) ([]byte, error) {
return packElement(t, v), nil 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)
}