aboutsummaryrefslogtreecommitdiffstats
path: root/accounts/abi
diff options
context:
space:
mode:
Diffstat (limited to 'accounts/abi')
-rw-r--r--accounts/abi/abi.go8
-rw-r--r--accounts/abi/abi_test.go194
-rw-r--r--accounts/abi/error.go7
-rw-r--r--accounts/abi/method.go2
-rw-r--r--accounts/abi/packing.go2
-rw-r--r--accounts/abi/type.go9
6 files changed, 137 insertions, 85 deletions
diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go
index cce89de1b..32df6f19d 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 4b41d2eee..05535b3b5 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 91a0374fd..67739c21d 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 cad0cd27f..f3d1a44b5 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 2a16d3be1..c765dfdf3 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 cad7b8212..2235bad61 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)
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 13:27:10 +0800