go-ethereum/accounts/abi/type.go

// 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 (
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"strings"
)

const (
	IntTy byte = iota
	UintTy
	BoolTy
	StringTy
	SliceTy
	ArrayTy
	AddressTy
	FixedBytesTy
	BytesTy
	HashTy
	FixedPointTy
	FunctionTy
)

// Type is the reflection of the supported argument type
type Type struct {
	Elem *Type

	Kind reflect.Kind
	Type reflect.Type
	Size int
	T    byte // Our own type checking

	stringKind string // holds the unparsed string for deriving signatures
}

var (
	// typeRegex parses the abi sub types
	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
)

// NewType creates a new reflection type of abi type given in t.
func NewType(t string) (typ Type, err error) {
	// check that array brackets are equal if they exist
	if strings.Count(t, "[") != strings.Count(t, "]") {
		return Type{}, fmt.Errorf("invalid arg type in abi")
	}

	typ.stringKind = t

	// if there are brackets, get ready to go into slice/array mode and
	// recursively create the type
	if strings.Count(t, "[") != 0 {
		i := strings.LastIndex(t, "[")
		// recursively embed the type
		embeddedType, err := NewType(t[:i])
		if err != nil {
			return Type{}, err
		}
		// grab the last cell and create a type from there
		sliced := t[i:]
		// grab the slice size with regexp
		re := regexp.MustCompile("[0-9]+")
		intz := re.FindAllString(sliced, -1)

		if len(intz) == 0 {
			// is a slice
			typ.T = SliceTy
			typ.Kind = reflect.Slice
			typ.Elem = &embeddedType
			typ.Type = reflect.SliceOf(embeddedType.Type)
		} else if len(intz) == 1 {
			// is a array
			typ.T = ArrayTy
			typ.Kind = reflect.Array
			typ.Elem = &embeddedType
			typ.Size, err = strconv.Atoi(intz[0])
			if err != nil {
				return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
			}
			typ.Type = reflect.ArrayOf(typ.Size, embeddedType.Type)
		} else {
			return Type{}, fmt.Errorf("invalid formatting of array type")
		}
		return typ, err
	} else {
		// parse the type and size of the abi-type.
		parsedType := typeRegex.FindAllStringSubmatch(t, -1)[0]
		// varSize is the size of the variable
		var varSize int
		if len(parsedType[3]) > 0 {
			var err error
			varSize, err = strconv.Atoi(parsedType[2])
			if err != nil {
				return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
			}
		} else {
			if parsedType[0] == "uint" || parsedType[0] == "int" {
				// this should fail because it means that there's something wrong with
				// the abi type (the compiler should always format it to the size...always)
				return Type{}, fmt.Errorf("unsupported arg type: %s", t)
			}
		}
		// varType is the parsed abi type
		varType := parsedType[1]

		switch varType {
		case "int":
			typ.Kind, typ.Type = reflectIntKindAndType(false, varSize)
			typ.Size = varSize
			typ.T = IntTy
		case "uint":
			typ.Kind, typ.Type = reflectIntKindAndType(true, varSize)
			typ.Size = varSize
			typ.T = UintTy
		case "bool":
			typ.Kind = reflect.Bool
			typ.T = BoolTy
			typ.Type = reflect.TypeOf(bool(false))
		case "address":
			typ.Kind = reflect.Array
			typ.Type = address_t
			typ.Size = 20
			typ.T = AddressTy
		case "string":
			typ.Kind = reflect.String
			typ.Type = reflect.TypeOf("")
			typ.T = StringTy
		case "bytes":
			if varSize == 0 {
				typ.T = BytesTy
				typ.Kind = reflect.Slice
				typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0)))
			} else {
				typ.T = FixedBytesTy
				typ.Kind = reflect.Array
				typ.Size = varSize
				typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0)))
			}
		case "function":
			typ.Kind = reflect.Array
			typ.T = FunctionTy
			typ.Size = 24
			typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0)))
		default:
			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
		}
	}

	return
}

// String implements Stringer
func (t Type) String() (out string) {
	return t.stringKind
}

func (t Type) pack(v reflect.Value) ([]byte, error) {
	// dereference pointer first if it's a pointer
	v = indirect(v)

	if err := typeCheck(t, v); err != nil {
		return nil, err
	}

	if t.T == SliceTy || t.T == ArrayTy {
		var packed []byte

		for i := 0; i < v.Len(); i++ {
			val, err := t.Elem.pack(v.Index(i))
			if err != nil {
				return nil, err
			}
			packed = append(packed, val...)
		}
		if t.T == SliceTy {
			return packBytesSlice(packed, v.Len()), nil
		} else if t.T == ArrayTy {
			return packed, 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 == StringTy || t.T == BytesTy || t.T == SliceTy
}