mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

accounts/abi: address review concerns

Browse Source
pull/15770/head
Martin Holst Swende 7 years ago
parent f0f594d045
commit 08c5d4dd27
No known key found for this signature in database
GPG Key ID: 683B438C05A5DDF0
4 changed files with 5 additions and 352 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      accounts/abi/abi.go
  2. 2
      accounts/abi/abi_test.go
  3. 18
      accounts/abi/argument.go
  4. 335
      accounts/abi/unpackv2_test.go

2
accounts/abi/abi.go
Unescape View File

@ -142,5 +142,5 @@ func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
return &method, nil return &method, nil
} }
} }
return nil, fmt.Errorf("ABI spec does not contain method signature in data: 0x%x", sigdata[:4]) return nil, fmt.Errorf("no method with id: %#x", sigdata[:4])
} }

2
accounts/abi/abi_test.go
Unescape View File

@ -691,7 +691,7 @@ func TestABI_MethodById(t *testing.T) {
a := fmt.Sprintf("%v", m) a := fmt.Sprintf("%v", m)
m2, err := abi.MethodById(m.Id()) m2, err := abi.MethodById(m.Id())
if err != nil { if err != nil {
t.Fatal(err) t.Fatalf("Failed to look up ABI method: %v", err)
} }
b := fmt.Sprintf("%v", m2) b := fmt.Sprintf("%v", m2)
if a != b { if a != b {

18
accounts/abi/argument.go
Unescape View File

@ -67,6 +67,7 @@ func (arguments Arguments) LengthNonIndexed() int {
return out return out
} }
// NonIndexed returns the arguments with indexed arguments filtered out
func (arguments Arguments) NonIndexed() Arguments { func (arguments Arguments) NonIndexed() Arguments {
var ret []Argument var ret []Argument
for _, arg := range arguments { for _, arg := range arguments {
@ -89,12 +90,10 @@ func (arguments Arguments) Unpack(v interface{}, data []byte) error {
if reflect.Ptr != reflect.ValueOf(v).Kind() { if reflect.Ptr != reflect.ValueOf(v).Kind() {
return fmt.Errorf("abi: Unpack(non-pointer %T)", v) return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
} }
marshalledValues, err := arguments.UnpackValues(data) marshalledValues, err := arguments.UnpackValues(data)
if err != nil { if err != nil {
return err return err
} }
if arguments.isTuple() { if arguments.isTuple() {
return arguments.unpackTuple(v, marshalledValues) return arguments.unpackTuple(v, marshalledValues)
} }
@ -162,11 +161,9 @@ func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interfa
// unpackAtomic unpacks ( hexdata -> go ) a single value // unpackAtomic unpacks ( hexdata -> go ) a single value
func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues []interface{}) error { func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues []interface{}) error {
if len(marshalledValues) != 1 { if len(marshalledValues) != 1 {
return fmt.Errorf("abi: wrong length, expected single value, got %d", len(marshalledValues)) return fmt.Errorf("abi: wrong length, expected single value, got %d", len(marshalledValues))
} }
elem := reflect.ValueOf(v).Elem() elem := reflect.ValueOf(v).Elem()
reflectValue := reflect.ValueOf(marshalledValues[0]) reflectValue := reflect.ValueOf(marshalledValues[0])
return set(elem, reflectValue, arguments.NonIndexed()[0]) return set(elem, reflectValue, arguments.NonIndexed()[0])
@ -176,24 +173,18 @@ func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues []interf
// without supplying a struct to unpack into. Instead, this method returns a list containing the // without supplying a struct to unpack into. Instead, this method returns a list containing the
// values. An atomic argument will be a list with one element. // values. An atomic argument will be a list with one element.
func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) { func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
retval := make([]interface{}, 0, arguments.LengthNonIndexed()) retval := make([]interface{}, 0, arguments.LengthNonIndexed())
virtualArgs := 0 virtualArgs := 0
for index, arg := range arguments.NonIndexed() { for index, arg := range arguments.NonIndexed() {
marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data) marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data)
if arg.Type.T == ArrayTy { if arg.Type.T == ArrayTy {
//If we have a static array, like [3]uint256, these are coded as // If we have a static array, like [3]uint256, these are coded as
// just like uint256,uint256,uint256. // just like uint256,uint256,uint256.
// This means that we need to add two 'virtual' arguments when // This means that we need to add two 'virtual' arguments when
// we count the index from now on // we count the index from now on
virtualArgs += arg.Type.Size - 1 virtualArgs += arg.Type.Size - 1
} }
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -202,7 +193,7 @@ func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
return retval, nil return retval, nil
} }
// UnpackValues performs the operation Go format -> Hexdata // PackValues performs the operation Go format -> Hexdata
// It is the semantic opposite of UnpackValues // It is the semantic opposite of UnpackValues
func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) { func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
return arguments.Pack(args...) return arguments.Pack(args...)
@ -215,7 +206,6 @@ func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
if len(args) != len(abiArgs) { if len(args) != len(abiArgs) {
return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs)) return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs))
} }
// variable input is the output appended at the end of packed // variable input is the output appended at the end of packed
// output. This is used for strings and bytes types input. // output. This is used for strings and bytes types input.
var variableInput []byte var variableInput []byte
@ -229,7 +219,6 @@ func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
inputOffset += 32 inputOffset += 32
} }
} }
var ret []byte var ret []byte
for i, a := range args { for i, a := range args {
input := abiArgs[i] input := abiArgs[i]
@ -238,7 +227,6 @@ func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
// check for a slice type (string, bytes, slice) // check for a slice type (string, bytes, slice)
if input.Type.requiresLengthPrefix() { if input.Type.requiresLengthPrefix() {
// calculate the offset // calculate the offset

335
accounts/abi/unpackv2_test.go
Unescape View File

@ -1,335 +0,0 @@
// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
package abi
import (
"bytes"
"encoding/hex"
"fmt"
"math/big"
"reflect"
"strconv"
"strings"
"testing"
"github.com/ethereum/go-ethereum/common"
)
func TestUnpackV2(t *testing.T) {
for i, test := range unpackTests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def)
abi, err := JSON(strings.NewReader(def))
if err != nil {
t.Fatalf("invalid ABI definition %s: %v", def, err)
}
encb, err := hex.DecodeString(test.enc)
if err != nil {
t.Fatalf("invalid hex: %s" + test.enc)
}
out, err := abi.Methods["method"].Outputs.UnpackValues(encb)
if err != nil {
t.Fatal(err)
}
if len(test.err) != 0 {
// The new stuff doesn't have these types of errors
return
}
if !reflect.DeepEqual(test.want, out[0]) {
t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out[0])
}
})
}
}
func TestMultiReturnWithArrayV2(t *testing.T) {
const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
abi, err := JSON(strings.NewReader(definition))
if err != nil {
t.Fatal(err)
}
buff := new(bytes.Buffer)
buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000007"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000006"))
out, err := abi.Methods["multi"].Outputs.UnpackValues(buff.Bytes())
ret1Exp := [3]uint64{9, 8, 7}
ret2Exp := uint64(6)
if !reflect.DeepEqual(out[0], ret1Exp) {
t.Error("array result", out[0], "!= Expected", ret1Exp)
}
if out[1] != ret2Exp {
t.Error("int result", out[1], "!= Expected", ret2Exp)
}
}
func TestUnmarshalV2(t *testing.T) {
const definition = `[
{ "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" : "intArraySingle", "constant" : false, "outputs": [ { "type": "uint256[3]" } ] },
{ "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 {
t.Fatal(err)
}
buff := new(bytes.Buffer)
// marshall mixed bytes (mixedBytes)
p0Exp := common.Hex2Bytes("01020000000000000000")
p1Exp := common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000ddeeff")
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000ddeeff"))
buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000a"))
buff.Write(common.Hex2Bytes("0102000000000000000000000000000000000000000000000000000000000000"))
mixedBytes, err := abi.Methods["mixedBytes"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
} else {
p0 := mixedBytes[0].([]byte)
p1 := mixedBytes[1].([32]byte)
if !bytes.Equal(p0, p0Exp) {
t.Errorf("unexpected value unpacked: want %x, got %x", p0Exp, p0)
}
if !bytes.Equal(p1[:], p1Exp) {
t.Errorf("unexpected value unpacked: want %x, got %x", p1Exp, p1)
}
}
// marshal int
integer, err := abi.Methods["int"].Outputs.UnpackValues(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
if err != nil {
t.Error(err)
}
if len(integer) == 0 {
t.Error("Expected one integer")
}
intval := integer[0].(*big.Int)
if intval == nil || intval.Cmp(big.NewInt(1)) != 0 {
t.Error("expected Int to be 1 got", intval)
}
// marshal bool
boolreturns, err := abi.Methods["bool"].Outputs.UnpackValues(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
if err != nil {
t.Error(err)
}
boolval := boolreturns[0].(bool)
if !boolval {
t.Error("expected Bool to be true")
}
// marshal dynamic bytes max length 32
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
bytesOut := common.RightPadBytes([]byte("hello"), 32)
buff.Write(bytesOut)
bytesreturns, err := abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
bytesval := bytesreturns[0].([]byte)
if !bytes.Equal(bytesval, bytesOut) {
t.Errorf("expected %x got %x", bytesOut, bytesval)
}
// marshall dynamic bytes max length 64
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040"))
bytesOut = common.RightPadBytes([]byte("hello"), 64)
buff.Write(bytesOut)
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
bytesval = bytesreturns[0].([]byte)
if !bytes.Equal(bytesval, bytesOut) {
t.Errorf("expected %x got %x", bytesOut, bytesval)
}
// marshall dynamic bytes max length 64
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000003f"))
bytesOut = common.RightPadBytes([]byte("hello"), 64)
buff.Write(bytesOut)
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
bytesval = bytesreturns[0].([]byte)
if !bytes.Equal(bytesval, bytesOut[:len(bytesOut)-1]) {
t.Errorf("expected %x got %x", bytesOut[:len(bytesOut)-1], bytesval)
}
// marshal dynamic bytes output empty (nil)
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(nil)
if err == nil {
t.Error("expected error")
}
// marshal dynamic bytes output empty
buff.Reset()
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err == nil {
t.Error("expected error")
}
// marshal dynamic bytes length 5
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005"))
buff.Write(common.RightPadBytes([]byte("hello"), 32))
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
bytesval = bytesreturns[0].([]byte)
if !bytes.Equal(bytesval, []byte("hello")) {
t.Errorf("expected %x got %x", bytesOut, bytesval)
}
// marshal dynamic bytes length 5
buff.Reset()
buff.Write(common.RightPadBytes([]byte("hello"), 32))
hashreturns, err := abi.Methods["fixed"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
hashval := hashreturns[0].([32]byte)
helloHash := common.BytesToHash(common.RightPadBytes([]byte("hello"), 32))
if common.Hash(hashval) != helloHash {
t.Errorf("Expected %x to equal %x", hashval, helloHash)
}
// marshal error
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
bytesreturns, err = abi.Methods["bytes"].Outputs.UnpackValues(buff.Bytes())
if err == nil {
// Error abi: cannot marshal in to go slice: offset 32 would go over slice boundary (len=64)
t.Error("expected error")
}
bytesreturns, err = abi.Methods["multi"].Outputs.UnpackValues(make([]byte, 64))
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000003"))
// marshal int array
intArrayReturns, err := abi.Methods["intArraySingle"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Error(err)
}
intArray := intArrayReturns[0].([3]*big.Int)
var testAgainstIntArray = [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}
for i, intval := range intArray {
if intval.Cmp(testAgainstIntArray[i]) != 0 {
t.Errorf("expected %v, got %v", testAgainstIntArray[i], intval)
}
}
// marshal address slice
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020")) // offset
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // size
buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
outAddrReturns, err := abi.Methods["addressSliceSingle"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Fatal("didn't expect error:", err)
}
outAddr := outAddrReturns[0].([]common.Address)
if len(outAddr) != 1 {
t.Fatal("expected 1 item, got", len(outAddr))
}
if outAddr[0] != (common.Address{1}) {
t.Errorf("expected %x, got %x", common.Address{1}, outAddr[0])
}
// marshal multiple address slice
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) // offset
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000080")) // offset
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // size
buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002")) // size
buff.Write(common.Hex2Bytes("0000000000000000000000000200000000000000000000000000000000000000"))
buff.Write(common.Hex2Bytes("0000000000000000000000000300000000000000000000000000000000000000"))
outAddrStructReturns, err := abi.Methods["addressSliceDouble"].Outputs.UnpackValues(buff.Bytes())
if err != nil {
t.Fatal("didn't expect error:", err)
}
A := outAddrStructReturns[0].([]common.Address)
B := outAddrStructReturns[1].([]common.Address)
if len(A) != 1 {
t.Fatal("expected 1 item, got", len(A))
}
if A[0] != (common.Address{1}) {
t.Errorf("expected %x, got %x", common.Address{1}, A[0])
}
if len(B) != 2 {
t.Fatal("expected 1 item, got", len(B))
}
if B[0] != (common.Address{2}) {
t.Errorf("expected %x, got %x", common.Address{2}, B[0])
}
if B[1] != (common.Address{3}) {
t.Errorf("expected %x, got %x", common.Address{3}, B[1])
}
// marshal invalid address slice
buff.Reset()
buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000100"))
err = abi.Unpack(&outAddr, "addressSliceSingle", buff.Bytes())
_, err = abi.Methods["addressSliceSingle"].Outputs.UnpackValues(buff.Bytes())
if err == nil {
t.Fatal("expected error:", err)
}
}
Write Preview
Loading…
Cancel
Save