types.go

package abispec

import (
	"encoding/json"
	"fmt"
	"math/big"
	"reflect"
	"regexp"
	"strconv"
	"strings"

	"github.com/ethereum/go-ethereum/common"
)

const bigIntType = "*big.Int"

var zero = big.NewInt(0)

var arrayTypePattern = regexp.MustCompile(`(\[([\d]*)\])`)

var bytesType = reflect.TypeOf([]byte{})

var typeMap = map[string]reflect.Type{
	"uint8":   reflect.TypeOf(uint8(0)),
	"int8":    reflect.TypeOf(int8(0)),
	"uint16":  reflect.TypeOf(uint16(0)),
	"int16":   reflect.TypeOf(int16(0)),
	"uint32":  reflect.TypeOf(uint32(0)),
	"int32":   reflect.TypeOf(int32(0)),
	"uint64":  reflect.TypeOf(uint64(0)),
	"int64":   reflect.TypeOf(int64(0)),
	"bytes":   bytesType,
	"bytes1":  reflect.TypeOf([1]byte{}),
	"bytes2":  reflect.TypeOf([2]byte{}),
	"bytes3":  reflect.TypeOf([3]byte{}),
	"bytes4":  reflect.TypeOf([4]byte{}),
	"bytes5":  reflect.TypeOf([5]byte{}),
	"bytes6":  reflect.TypeOf([6]byte{}),
	"bytes7":  reflect.TypeOf([7]byte{}),
	"bytes8":  reflect.TypeOf([8]byte{}),
	"bytes9":  reflect.TypeOf([9]byte{}),
	"bytes10": reflect.TypeOf([10]byte{}),
	"bytes11": reflect.TypeOf([11]byte{}),
	"bytes12": reflect.TypeOf([12]byte{}),
	"bytes13": reflect.TypeOf([13]byte{}),
	"bytes14": reflect.TypeOf([14]byte{}),
	"bytes15": reflect.TypeOf([15]byte{}),
	"bytes16": reflect.TypeOf([16]byte{}),
	"bytes17": reflect.TypeOf([17]byte{}),
	"bytes18": reflect.TypeOf([18]byte{}),
	"bytes19": reflect.TypeOf([19]byte{}),
	"bytes20": reflect.TypeOf([20]byte{}),
	"bytes21": reflect.TypeOf([21]byte{}),
	"bytes22": reflect.TypeOf([22]byte{}),
	"bytes23": reflect.TypeOf([23]byte{}),
	"bytes24": reflect.TypeOf([24]byte{}),
	"bytes25": reflect.TypeOf([25]byte{}),
	"bytes26": reflect.TypeOf([26]byte{}),
	"bytes27": reflect.TypeOf([27]byte{}),
	"bytes28": reflect.TypeOf([28]byte{}),
	"bytes29": reflect.TypeOf([29]byte{}),
	"bytes30": reflect.TypeOf([30]byte{}),
	"bytes31": reflect.TypeOf([31]byte{}),
	"bytes32": reflect.TypeOf([32]byte{}),
	"address": reflect.TypeOf(common.Address{}),
	"bool":    reflect.TypeOf(false),
	"string":  reflect.TypeOf(""),
}

func toGoType(solidityType string) (reflect.Type, error) {
	if t, ok := typeMap[solidityType]; ok {
		return t, nil
	}

	if arrayTypePattern.MatchString(solidityType) { // type of array
		index := arrayTypePattern.FindStringIndex(solidityType)[0]
		arrayType, err := toGoType(solidityType[0:index])
		if err != nil {
			return nil, err
		}
		matches := arrayTypePattern.FindAllStringSubmatch(solidityType, -1)
		for i := 0; i <= len(matches)-1; i++ {
			sizeStr := matches[i][2]
			if sizeStr == "" {
				arrayType = reflect.SliceOf(arrayType)
			} else {
				length, err := strconv.Atoi(sizeStr)
				if err != nil {
					return nil, err
				}
				arrayType = reflect.ArrayOf(length, arrayType)
			}
		}
		return arrayType, nil
	}

	// uint and int are aliases for uint256 and int256, respectively.
	// source: https://docs.soliditylang.org/en/v0.8.11/types.html
	//TODO should we support type: uint ?? currently, go-ethereum doesn't support type uint
	if strings.HasPrefix(solidityType, "uint") || strings.HasPrefix(solidityType, "int") {
		return reflect.TypeOf(zero), nil
	}

	return nil, fmt.Errorf("unsupported type: %s", solidityType)
}

func toGoTypeValue(solidityType string, raw json.RawMessage) (*reflect.Value, error) {
	goType, err := toGoType(solidityType)
	if err != nil {
		return nil, err
	}

	value := reflect.New(goType)

	if goType == bytesType { // to support case like: Encode("sam(bytes)", `["dave"]`)
		var s string
		err = json.Unmarshal(raw, &s)
		if err != nil {
			return nil, err
		}
		bytes := []byte(s)
		value.Elem().SetBytes(bytes)
		return &value, nil
	}

	err = json.Unmarshal(raw, value.Interface())
	if err != nil {
		if goType.String() == bigIntType {
			var s string
			err = json.Unmarshal(raw, &s)
			if err != nil {
				return nil, err
			}
			v, success := big.NewInt(0).SetString(s, 0)
			if !success {
				return nil, fmt.Errorf("convert to go type value failed, value: %s", s)
			}
			value = reflect.ValueOf(v)

		} else if goType.Kind() == reflect.Array { // to support case like: Encode("f(bytes10)", `["1234567890"]`)
			elemKind := goType.Elem().Kind()
			if elemKind == reflect.Uint8 {
				var s string
				err = json.Unmarshal(raw, &s)
				if err != nil {
					return nil, err
				}
				bytes := []byte(s)
				for i, b := range bytes {
					value.Elem().Index(i).Set(reflect.ValueOf(b))
				}
				return &value, nil
			}

			if elemKind == reflect.Array { // to support case like: Encode("bar(bytes3[2])", `[["abc","def"]]`)
				var ss []string
				err = json.Unmarshal(raw, &ss)
				if err != nil {
					return nil, err
				}

				var bytes [][]byte
				for _, s := range ss {
					bytes = append(bytes, []byte(s))
				}

				// convert []byte to []int
				// note: Array and slice values encode as JSON arrays, except that []byte encodes as a base64-encoded string, and a nil slice encodes as the null JSON object.
				var ints = make([][]int, len(bytes))
				for i, r := range bytes {
					ints[i] = make([]int, len(r))
					for j, b := range r {
						ints[i][j] = int(b)
					}
				}

				jsonString, err := json.Marshal(ints)
				if err != nil {
					return nil, err
				}
				if err = json.Unmarshal(jsonString, value.Interface()); err != nil {
					return nil, err
				}
			}

		}
	}

	return &value, err
}