accounts/abi: Deduplicate code in unpacker

accounts/abi/abi.go

@@ -136,7 +136,7 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 
 // MethodById looks up a method by the 4-byte id
 // returns nil if none found
-func (abi *ABI) MethodById(sigdata []byte) (*Method, error){
+func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
 	for _, method := range abi.Methods {
 		if bytes.Equal(method.Id(), sigdata[:4]) {
 			return &method, nil

accounts/abi/abi_test.go

@@ -689,7 +689,7 @@ func TestABI_MethodById(t *testing.T) {
 	}
 	for name, m := range abi.Methods {
 		a := fmt.Sprintf("%v", m)
-		m2,err := abi.MethodById(m.Id())
+		m2, err := abi.MethodById(m.Id())
 		if err != nil {
 			t.Fatal(err)
 		}

accounts/abi/argument.go

@@ -67,10 +67,10 @@ func (arguments Arguments) LengthNonIndexed() int {
 	return out
 }
 
-func (arguments Arguments) NonIndexed() Arguments{
+func (arguments Arguments) NonIndexed() Arguments {
 	var ret []Argument
-	for _,arg := range arguments{
+	for _, arg := range arguments {
-		if !arg.Indexed{
+		if !arg.Indexed {
 			ret = append(ret, arg)
 		}
 	}
@@ -84,21 +84,27 @@ func (arguments Arguments) isTuple() bool {
 
 // Unpack performs the operation hexdata -> Go format
 func (arguments Arguments) Unpack(v interface{}, data []byte) error {
-	if arguments.isTuple() {
-		return arguments.unpackTuple(v, data)
-	}
-	return arguments.unpackAtomic(v, data)
-}
 
-func (arguments Arguments) unpackTuple(v interface{}, output []byte) error {
 	// make sure the passed value is arguments pointer
-	valueOf := reflect.ValueOf(v)
+	if reflect.Ptr != reflect.ValueOf(v).Kind() {
-	if reflect.Ptr != valueOf.Kind() {
 		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
 	}
 
+	marshalledValues, err := arguments.UnpackValues(data)
+	if err != nil {
+		return err
+	}
+
+	if arguments.isTuple() {
+		return arguments.unpackTuple(v, marshalledValues)
+	}
+	return arguments.unpackAtomic(v, marshalledValues)
+}
+
+func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interface{}) error {
+
 	var (
-		value = valueOf.Elem()
+		value = reflect.ValueOf(v).Elem()
 		typ   = value.Type()
 		kind  = value.Kind()
 	)
@@ -120,25 +126,9 @@ func (arguments Arguments) unpackTuple(v interface{}, output []byte) error {
 			exists[field] = true
 		}
 	}
-	// `i` counts the nonindexed arguments.
-	// `j` counts the number of complex types.
-	// both `i` and `j` are used to to correctly compute `data` offset.
-
-	j := 0
 	for i, arg := range arguments.NonIndexed() {
 
-		marshalledValue, err := toGoType((i+j)*32, arg.Type, output)
+		reflectValue := reflect.ValueOf(marshalledValues[i])
-		if err != nil {
-			return err
-		}
-
-		if arg.Type.T == ArrayTy {
-			// combined index ('i' + 'j') need to be adjusted only by size of array, thus
-			// we need to decrement 'j' because 'i' was incremented
-			j += arg.Type.Size - 1
-		}
-
-		reflectValue := reflect.ValueOf(marshalledValue)
 
 		switch kind {
 		case reflect.Struct:
@@ -171,37 +161,29 @@ func (arguments Arguments) unpackTuple(v interface{}, output []byte) error {
 }
 
 // unpackAtomic unpacks ( hexdata -> go ) a single value
-func (arguments Arguments) unpackAtomic(v interface{}, output []byte) error {
+func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues []interface{}) error {
-	// make sure the passed value is arguments pointer
-	valueOf := reflect.ValueOf(v)
-	if reflect.Ptr != valueOf.Kind() {
-		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
-	}
-	arg := arguments[0]
-	if arg.Indexed {
-		return fmt.Errorf("abi: attempting to unpack indexed variable into element.")
-	}
 
-	value := valueOf.Elem()
+	if len(marshalledValues) != 1 {
-	marshalledValue, err := toGoType(0, arg.Type, output)
+		return fmt.Errorf("abi: wrong length, expected single value, got %d", len(marshalledValues))
-	if err != nil {
-		return err
 	}
-	return set(value, reflect.ValueOf(marshalledValue), arg)
+
+	elem := reflect.ValueOf(v).Elem()
+	reflectValue := reflect.ValueOf(marshalledValues[0])
+	return set(elem, reflectValue, arguments.NonIndexed()[0])
 }
 
 // UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
 // 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.
-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
 
-	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 we have a static array, like [3]uint256, these are coded as
@@ -212,7 +194,7 @@ func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error){
 			virtualArgs += arg.Type.Size - 1
 		}
 
-		if err != nil{
+		if err != nil {
 			return nil, err
 		}
 		retval = append(retval, marshalledValue)
@@ -226,7 +208,6 @@ func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
 	return arguments.Pack(args...)
 }
 
-
 // Pack performs the operation Go format -> Hexdata
 func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
 	// Make sure arguments match up and pack them

accounts/abi/unpackv2_test.go

@@ -57,7 +57,6 @@ func TestUnpackV2(t *testing.T) {
 	}
 }
 
-
 func TestMultiReturnWithArrayV2(t *testing.T) {
 	const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
 	abi, err := JSON(strings.NewReader(definition))