rpc/smartcontract: merge contract parameter types

Merged two types:
	- smartcontract.ParamType
	- rpc.StackParamType
into single one:
	- smartcontract.ParamType
as they duplicated the functionality.

NOTE: type smartcontract.MapType was added (as in C# implementation).

From now, list of supported smartcontract parameter types:
	UnknownType
	SignatureType
	BoolType
	IntegerType
	Hash160Type
	Hash256Type
	ByteArrayType
	PublicKeyType
	StringType
	ArrayType
	MapType
	InteropInterfaceType
	VoidType

cli/smartcontract/smart_contract.go

@@ -296,10 +296,10 @@ func initSmartContract(ctx *cli.Context) error {
 	// TODO: Fix the missing neo-go.yml file with the `init` command when the package manager is in place.
 	if !ctx.Bool("skip-details") {
 		details := parseContractDetails()
-		details.ReturnType = request.ByteArray
+		details.ReturnType = smartcontract.ByteArrayType
-		details.Parameters = make([]request.StackParamType, 2)
+		details.Parameters = make([]smartcontract.ParamType, 2)
-		details.Parameters[0] = request.String
+		details.Parameters[0] = smartcontract.StringType
-		details.Parameters[1] = request.Array
+		details.Parameters[1] = smartcontract.ArrayType
 
 		project := &ProjectConfig{Contract: details}
 		b, err := yaml.Marshal(project)

pkg/rpc/request/param.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 
 	"github.com/CityOfZion/neo-go/pkg/encoding/address"
+	"github.com/CityOfZion/neo-go/pkg/smartcontract"
 	"github.com/CityOfZion/neo-go/pkg/util"
 	"github.com/pkg/errors"
 )
@@ -24,7 +25,7 @@ type (
 	// FuncParam represents a function argument parameter used in the
 	// invokefunction RPC method.
 	FuncParam struct {
-		Type  StackParamType `json:"type"`
+		Type  smartcontract.ParamType `json:"type"`
 		Value Param                       `json:"value"`
 	}
 )

pkg/rpc/request/param_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/CityOfZion/neo-go/pkg/encoding/address"
+	"github.com/CityOfZion/neo-go/pkg/smartcontract"
 	"github.com/CityOfZion/neo-go/pkg/util"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -41,7 +42,7 @@ func TestParam_UnmarshalJSON(t *testing.T) {
 				{
 					Type: FuncParamT,
 					Value: FuncParam{
-						Type: String,
+						Type: smartcontract.StringType,
 						Value: Param{
 							Type:  StringT,
 							Value: "jajaja",
@@ -146,7 +147,7 @@ func TestParamGetUint160FromAddress(t *testing.T) {
 
 func TestParamGetFuncParam(t *testing.T) {
 	fp := FuncParam{
-		Type: String,
+		Type: smartcontract.StringType,
 		Value: Param{
 			Type:  StringT,
 			Value: "jajaja",

pkg/rpc/request/scdetails.go

@@ -1,5 +1,7 @@
 package request
 
+import "github.com/CityOfZion/neo-go/pkg/smartcontract"
+
 // ContractDetails contains contract metadata.
 type ContractDetails struct {
 	Author               string
@@ -10,6 +12,6 @@ type ContractDetails struct {
 	HasStorage           bool
 	HasDynamicInvocation bool
 	IsPayable            bool
-	ReturnType           StackParamType
+	ReturnType           smartcontract.ParamType
-	Parameters           []StackParamType
+	Parameters           []smartcontract.ParamType
 }

pkg/rpc/request/stack_param.go

@@ -1,291 +0,0 @@
-package request
-
-import (
-	"encoding/binary"
-	"encoding/hex"
-	"encoding/json"
-	"strconv"
-
-	"github.com/CityOfZion/neo-go/pkg/util"
-	"github.com/pkg/errors"
-)
-
-// StackParamType represents different types of stack values.
-type StackParamType int
-
-// All possible StackParamType values are listed here.
-const (
-	Unknown          StackParamType = -1
-	Signature        StackParamType = 0x00
-	Boolean          StackParamType = 0x01
-	Integer          StackParamType = 0x02
-	Hash160          StackParamType = 0x03
-	Hash256          StackParamType = 0x04
-	ByteArray        StackParamType = 0x05
-	PublicKey        StackParamType = 0x06
-	String           StackParamType = 0x07
-	Array            StackParamType = 0x10
-	InteropInterface StackParamType = 0xf0
-	Void             StackParamType = 0xff
-)
-
-// String implements the stringer interface.
-func (t StackParamType) String() string {
-	switch t {
-	case Signature:
-		return "Signature"
-	case Boolean:
-		return "Boolean"
-	case Integer:
-		return "Integer"
-	case Hash160:
-		return "Hash160"
-	case Hash256:
-		return "Hash256"
-	case ByteArray:
-		return "ByteArray"
-	case PublicKey:
-		return "PublicKey"
-	case String:
-		return "String"
-	case Array:
-		return "Array"
-	case InteropInterface:
-		return "InteropInterface"
-	case Void:
-		return "Void"
-	default:
-		return "Unknown"
-	}
-}
-
-// StackParamTypeFromString converts string into the StackParamType.
-func StackParamTypeFromString(s string) (StackParamType, error) {
-	switch s {
-	case "Signature":
-		return Signature, nil
-	case "Boolean":
-		return Boolean, nil
-	case "Integer":
-		return Integer, nil
-	case "Hash160":
-		return Hash160, nil
-	case "Hash256":
-		return Hash256, nil
-	case "ByteArray":
-		return ByteArray, nil
-	case "PublicKey":
-		return PublicKey, nil
-	case "String":
-		return String, nil
-	case "Array":
-		return Array, nil
-	case "InteropInterface":
-		return InteropInterface, nil
-	case "Void":
-		return Void, nil
-	default:
-		return Unknown, errors.Errorf("unknown stack parameter type: %s", s)
-	}
-}
-
-// MarshalJSON implements the json.Marshaler interface.
-func (t *StackParamType) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + t.String() + `"`), nil
-}
-
-// UnmarshalJSON sets StackParamType from JSON-encoded data.
-func (t *StackParamType) UnmarshalJSON(data []byte) (err error) {
-	var (
-		s = string(data)
-		l = len(s)
-	)
-	if l < 2 || s[0] != '"' || s[l-1] != '"' {
-		*t = Unknown
-		return errors.Errorf("invalid type: %s", s)
-	}
-	*t, err = StackParamTypeFromString(s[1 : l-1])
-	return
-}
-
-// MarshalYAML implements the YAML Marshaler interface.
-func (t *StackParamType) MarshalYAML() (interface{}, error) {
-	return t.String(), nil
-}
-
-// UnmarshalYAML implements the YAML Unmarshaler interface.
-func (t *StackParamType) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var name string
-
-	err := unmarshal(&name)
-	if err != nil {
-		return err
-	}
-	*t, err = StackParamTypeFromString(name)
-	return err
-}
-
-// StackParam represent a stack parameter.
-type StackParam struct {
-	Type  StackParamType `json:"type"`
-	Value interface{}    `json:"value"`
-}
-
-type rawStackParam struct {
-	Type  StackParamType  `json:"type"`
-	Value json.RawMessage `json:"value"`
-}
-
-// UnmarshalJSON implements Unmarshaler interface.
-func (p *StackParam) UnmarshalJSON(data []byte) (err error) {
-	var (
-		r rawStackParam
-		i int64
-		s string
-		b []byte
-	)
-
-	if err = json.Unmarshal(data, &r); err != nil {
-		return
-	}
-
-	switch p.Type = r.Type; r.Type {
-	case ByteArray:
-		if err = json.Unmarshal(r.Value, &s); err != nil {
-			return
-		}
-		if b, err = hex.DecodeString(s); err != nil {
-			return
-		}
-		p.Value = b
-	case String:
-		if err = json.Unmarshal(r.Value, &s); err != nil {
-			return
-		}
-		p.Value = s
-	case Integer:
-		if err = json.Unmarshal(r.Value, &i); err == nil {
-			p.Value = i
-			return
-		}
-		// sometimes integer comes as string
-		if err = json.Unmarshal(r.Value, &s); err != nil {
-			return
-		}
-		if i, err = strconv.ParseInt(s, 10, 64); err != nil {
-			return
-		}
-		p.Value = i
-	case Array:
-		// https://github.com/neo-project/neo/blob/3d59ecca5a8deb057bdad94b3028a6d5e25ac088/neo/Network/RPC/RpcServer.cs#L67
-		var rs []StackParam
-		if err = json.Unmarshal(r.Value, &rs); err != nil {
-			return
-		}
-		p.Value = rs
-	case Hash160:
-		var h util.Uint160
-		if err = json.Unmarshal(r.Value, &h); err != nil {
-			return
-		}
-		p.Value = h
-	case Hash256:
-		var h util.Uint256
-		if err = json.Unmarshal(r.Value, &h); err != nil {
-			return
-		}
-		p.Value = h
-	default:
-		return errors.New("not implemented")
-	}
-	return
-}
-
-// StackParams is an array of StackParam (TODO: drop it?).
-type StackParams []StackParam
-
-// TryParseArray converts an array of StackParam into an array of more appropriate things.
-func (p StackParams) TryParseArray(vals ...interface{}) error {
-	var (
-		err error
-		i   int
-		par StackParam
-	)
-	if len(p) != len(vals) {
-		return errors.New("receiver array doesn't fit the StackParams length")
-	}
-	for i, par = range p {
-		if err = par.TryParse(vals[i]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// TryParse converts one StackParam into something more appropriate.
-func (p StackParam) TryParse(dest interface{}) error {
-	var (
-		err  error
-		ok   bool
-		data []byte
-	)
-	switch p.Type {
-	case ByteArray:
-		if data, ok = p.Value.([]byte); !ok {
-			return errors.Errorf("failed to cast %s to []byte", p.Value)
-		}
-		switch dest := dest.(type) {
-		case *util.Uint160:
-			if *dest, err = util.Uint160DecodeBytesBE(data); err != nil {
-				return err
-			}
-			return nil
-		case *[]byte:
-			*dest = data
-			return nil
-		case *util.Uint256:
-			if *dest, err = util.Uint256DecodeBytesLE(data); err != nil {
-				return err
-			}
-			return nil
-		case *int64, *int32, *int16, *int8, *int, *uint64, *uint32, *uint16, *uint8, *uint:
-			i := bytesToUint64(data)
-			switch dest := dest.(type) {
-			case *int64:
-				*dest = int64(i)
-			case *int32:
-				*dest = int32(i)
-			case *int16:
-				*dest = int16(i)
-			case *int8:
-				*dest = int8(i)
-			case *int:
-				*dest = int(i)
-			case *uint64:
-				*dest = i
-			case *uint32:
-				*dest = uint32(i)
-			case *uint16:
-				*dest = uint16(i)
-			case *uint8:
-				*dest = uint8(i)
-			case *uint:
-				*dest = uint(i)
-			}
-		case *string:
-			*dest = string(data)
-			return nil
-		default:
-			return errors.Errorf("cannot cast stackparam of type %s to type %s", p.Type, dest)
-		}
-	default:
-		return errors.New("cannot define stackparam type")
-	}
-	return nil
-}
-
-func bytesToUint64(b []byte) uint64 {
-	data := make([]byte, 8)
-	copy(data[8-len(b):], util.ArrayReverse(b))
-	return binary.BigEndian.Uint64(data)
-}

pkg/rpc/request/stack_param_test.go

@@ -1,200 +0,0 @@
-package request
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-
-	"github.com/CityOfZion/neo-go/pkg/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var testCases = []struct {
-	input  string
-	result StackParam
-}{
-	{
-		input:  `{"type":"Integer","value":12345}`,
-		result: StackParam{Type: Integer, Value: int64(12345)},
-	},
-	{
-		input:  `{"type":"Integer","value":"12345"}`,
-		result: StackParam{Type: Integer, Value: int64(12345)},
-	},
-	{
-		input:  `{"type":"ByteArray","value":"010203"}`,
-		result: StackParam{Type: ByteArray, Value: []byte{0x01, 0x02, 0x03}},
-	},
-	{
-		input:  `{"type":"String","value":"Some string"}`,
-		result: StackParam{Type: String, Value: "Some string"},
-	},
-	{
-		input: `{"type":"Array","value":[
-{"type": "String", "value": "str 1"},
-{"type": "Integer", "value": 2}]}`,
-		result: StackParam{
-			Type: Array,
-			Value: []StackParam{
-				{Type: String, Value: "str 1"},
-				{Type: Integer, Value: int64(2)},
-			},
-		},
-	},
-	{
-		input: `{"type": "Hash160", "value": "0bcd2978634d961c24f5aea0802297ff128724d6"}`,
-		result: StackParam{
-			Type: Hash160,
-			Value: util.Uint160{
-				0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-				0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-			},
-		},
-	},
-	{
-		input: `{"type": "Hash256", "value": "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"}`,
-		result: StackParam{
-			Type: Hash256,
-			Value: util.Uint256{
-				0x2d, 0xf3, 0x45, 0xf2, 0x45, 0xc5, 0x98, 0x9e,
-				0x69, 0x95, 0x45, 0x06, 0xa5, 0x9e, 0x40, 0x12,
-				0xc1, 0x68, 0x54, 0x48, 0x08, 0xfc, 0xcc, 0x5b,
-				0x15, 0x18, 0xab, 0xa0, 0x8f, 0x30, 0x37, 0xf0,
-			},
-		},
-	},
-}
-
-var errorCases = []string{
-	`{"type": "ByteArray","value":`,        // incorrect JSON
-	`{"type": "ByteArray","value":1}`,      // incorrect Value
-	`{"type": "ByteArray","value":"12zz"}`, // incorrect ByteArray value
-	`{"type": "String","value":`,           // incorrect JSON
-	`{"type": "String","value":1}`,         // incorrect Value
-	`{"type": "Integer","value": "nn"}`,    // incorrect Integer value
-	`{"type": "Integer","value": []}`,      // incorrect Integer value
-	`{"type": "Array","value": 123}`,       // incorrect Array value
-	`{"type": "Hash160","value": "0bcd"}`,  // incorrect Uint160 value
-	`{"type": "Hash256","value": "0bcd"}`,  // incorrect Uint256 value
-	`{"type": "Stringg","value": ""}`,      // incorrect type
-	`{"type": {},"value": ""}`,             // incorrect value
-
-	`{"type": "InteropInterface","value": ""}`, // ununmarshable type
-}
-
-func TestStackParam_UnmarshalJSON(t *testing.T) {
-	var s StackParam
-	for _, tc := range testCases {
-		assert.NoError(t, json.Unmarshal([]byte(tc.input), &s))
-		assert.Equal(t, s, tc.result)
-	}
-
-	for _, input := range errorCases {
-		assert.Error(t, json.Unmarshal([]byte(input), &s))
-	}
-}
-
-var tryParseTestCases = []struct {
-	input    interface{}
-	expected interface{}
-}{
-	{
-		input: []byte{
-			0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-			0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-		},
-		expected: util.Uint160{
-			0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-			0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-		},
-	},
-	{
-		input: []byte{
-			0xf0, 0x37, 0x30, 0x8f, 0xa0, 0xab, 0x18, 0x15,
-			0x5b, 0xcc, 0xfc, 0x08, 0x48, 0x54, 0x68, 0xc1,
-			0x12, 0x40, 0x9e, 0xa5, 0x06, 0x45, 0x95, 0x69,
-			0x9e, 0x98, 0xc5, 0x45, 0xf2, 0x45, 0xf3, 0x2d,
-		},
-		expected: util.Uint256{
-			0x2d, 0xf3, 0x45, 0xf2, 0x45, 0xc5, 0x98, 0x9e,
-			0x69, 0x95, 0x45, 0x06, 0xa5, 0x9e, 0x40, 0x12,
-			0xc1, 0x68, 0x54, 0x48, 0x08, 0xfc, 0xcc, 0x5b,
-			0x15, 0x18, 0xab, 0xa0, 0x8f, 0x30, 0x37, 0xf0,
-		},
-	},
-	{
-		input:    []byte{0, 1, 2, 3, 4, 9, 8, 6},
-		expected: []byte{0, 1, 2, 3, 4, 9, 8, 6},
-	},
-	{
-		input:    []byte{0x63, 0x78, 0x29, 0xcd, 0x0b},
-		expected: int64(50686687331),
-	},
-	{
-		input:    []byte("this is a test string"),
-		expected: "this is a test string",
-	},
-}
-
-func TestStackParam_TryParse(t *testing.T) {
-	for _, tc := range tryParseTestCases {
-		t.Run(reflect.TypeOf(tc.expected).String(), func(t *testing.T) {
-			input := StackParam{
-				Type:  ByteArray,
-				Value: tc.input,
-			}
-
-			val := reflect.New(reflect.TypeOf(tc.expected))
-			assert.NoError(t, input.TryParse(val.Interface()))
-			assert.Equal(t, tc.expected, val.Elem().Interface())
-		})
-	}
-
-	t.Run("[]Uint160", func(t *testing.T) {
-		exp1 := util.Uint160{1, 2, 3, 4, 5}
-		exp2 := util.Uint160{9, 8, 7, 6, 5}
-
-		params := StackParams{
-			{
-				Type:  ByteArray,
-				Value: exp1.BytesBE(),
-			},
-			{
-				Type:  ByteArray,
-				Value: exp2.BytesBE(),
-			},
-		}
-
-		var out1, out2 util.Uint160
-
-		assert.NoError(t, params.TryParseArray(&out1, &out2))
-		assert.Equal(t, exp1, out1)
-		assert.Equal(t, exp2, out2)
-	})
-}
-
-func TestStackParamType_String(t *testing.T) {
-	types := []StackParamType{
-		Signature,
-		Boolean,
-		Integer,
-		Hash160,
-		Hash256,
-		ByteArray,
-		PublicKey,
-		String,
-		Array,
-		InteropInterface,
-		Void,
-	}
-
-	for _, exp := range types {
-		actual, err := StackParamTypeFromString(exp.String())
-		assert.NoError(t, err)
-		assert.Equal(t, exp, actual)
-	}
-
-	actual, err := StackParamTypeFromString(Unknown.String())
-	assert.Error(t, err)
-	assert.Equal(t, Unknown, actual)
-}

pkg/rpc/request/txBuilder.go

@@ -148,31 +148,31 @@ func expandArrayIntoScript(script *io.BinWriter, slice []Param) error {
 			return err
 		}
 		switch fp.Type {
-		case ByteArray, Signature:
+		case smartcontract.ByteArrayType, smartcontract.SignatureType:
 			str, err := fp.Value.GetBytesHex()
 			if err != nil {
 				return err
 			}
 			emit.Bytes(script, str)
-		case String:
+		case smartcontract.StringType:
 			str, err := fp.Value.GetString()
 			if err != nil {
 				return err
 			}
 			emit.String(script, str)
-		case Hash160:
+		case smartcontract.Hash160Type:
 			hash, err := fp.Value.GetUint160FromHex()
 			if err != nil {
 				return err
 			}
 			emit.Bytes(script, hash.BytesBE())
-		case Hash256:
+		case smartcontract.Hash256Type:
 			hash, err := fp.Value.GetUint256()
 			if err != nil {
 				return err
 			}
 			emit.Bytes(script, hash.BytesBE())
-		case PublicKey:
+		case smartcontract.PublicKeyType:
 			str, err := fp.Value.GetString()
 			if err != nil {
 				return err
@@ -182,13 +182,13 @@ func expandArrayIntoScript(script *io.BinWriter, slice []Param) error {
 				return err
 			}
 			emit.Bytes(script, key.Bytes())
-		case Integer:
+		case smartcontract.IntegerType:
 			val, err := fp.Value.GetInt()
 			if err != nil {
 				return err
 			}
 			emit.Int(script, int64(val))
-		case Boolean:
+		case smartcontract.BoolType:
 			str, err := fp.Value.GetString()
 			if err != nil {
 				return err

pkg/rpc/request/tx_builder_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"testing"
 
+	"github.com/CityOfZion/neo-go/pkg/smartcontract"
 	"github.com/CityOfZion/neo-go/pkg/util"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -29,31 +30,31 @@ func TestInvocationScriptCreationGood(t *testing.T) {
 		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{}}},
 		script: "00c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: ByteArray, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.ByteArrayType, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
 		script: "1450befd26fdf6e4d957c11e078b24ebce6291456f51c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Signature, Value: Param{Type: StringT, Value: "4edf5005771de04619235d5a4c7a9a11bb78e008541f1da7725f654c33380a3c87e2959a025da706d7255cb3a3fa07ebe9c6559d0d9e6213c68049168eb1056f"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.SignatureType, Value: Param{Type: StringT, Value: "4edf5005771de04619235d5a4c7a9a11bb78e008541f1da7725f654c33380a3c87e2959a025da706d7255cb3a3fa07ebe9c6559d0d9e6213c68049168eb1056f"}}}}}},
 		script: "404edf5005771de04619235d5a4c7a9a11bb78e008541f1da7725f654c33380a3c87e2959a025da706d7255cb3a3fa07ebe9c6559d0d9e6213c68049168eb1056f51c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: String, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.StringType, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
 		script: "283530626566643236666466366534643935376331316530373862323465626365363239313435366651c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Hash160, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.Hash160Type, Value: Param{Type: StringT, Value: "50befd26fdf6e4d957c11e078b24ebce6291456f"}}}}}},
 		script: "146f459162ceeb248b071ec157d9e4f6fd26fdbe5051c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Hash256, Value: Param{Type: StringT, Value: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.Hash256Type, Value: Param{Type: StringT, Value: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7"}}}}}},
 		script: "20e72d286979ee6cb1b7e65dfddfb2e384100b8d148e7758de42e4168b71792c6051c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: PublicKey, Value: Param{Type: StringT, Value: "03c089d7122b840a4935234e82e26ae5efd0c2acb627239dc9f207311337b6f2c1"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.PublicKeyType, Value: Param{Type: StringT, Value: "03c089d7122b840a4935234e82e26ae5efd0c2acb627239dc9f207311337b6f2c1"}}}}}},
 		script: "2103c089d7122b840a4935234e82e26ae5efd0c2acb627239dc9f207311337b6f2c151c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Integer, Value: Param{Type: NumberT, Value: 42}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.IntegerType, Value: Param{Type: NumberT, Value: 42}}}}}},
 		script: "012a51c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Boolean, Value: Param{Type: StringT, Value: "true"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.BoolType, Value: Param{Type: StringT, Value: "true"}}}}}},
 		script: "5151c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}, {
-		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Boolean, Value: Param{Type: StringT, Value: "false"}}}}}},
+		ps:     Params{{Type: StringT, Value: "a"}, {Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.BoolType, Value: Param{Type: StringT, Value: "false"}}}}}},
 		script: "0051c10161676f459162ceeb248b071ec157d9e4f6fd26fdbe50",
 	}}
 	for _, ps := range paramScripts {
@@ -70,17 +71,17 @@ func TestInvocationScriptCreationBad(t *testing.T) {
 		{{Type: NumberT, Value: "qwerty"}},
 		{{Type: ArrayT, Value: 42}},
 		{{Type: ArrayT, Value: []Param{{Type: NumberT, Value: 42}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: ByteArray, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.ByteArrayType, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Signature, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.SignatureType, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: String, Value: Param{Type: NumberT, Value: 42}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.StringType, Value: Param{Type: NumberT, Value: 42}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Hash160, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.Hash160Type, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Hash256, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.Hash256Type, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: PublicKey, Value: Param{Type: NumberT, Value: 42}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.PublicKeyType, Value: Param{Type: NumberT, Value: 42}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: PublicKey, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.PublicKeyType, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Integer, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.IntegerType, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Boolean, Value: Param{Type: NumberT, Value: 42}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.BoolType, Value: Param{Type: NumberT, Value: 42}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Boolean, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.BoolType, Value: Param{Type: StringT, Value: "qwerty"}}}}}},
-		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: Unknown, Value: Param{}}}}}},
+		{{Type: ArrayT, Value: []Param{{Type: FuncParamT, Value: FuncParam{Type: smartcontract.UnknownType, Value: Param{}}}}}},
 	}
 	for _, ps := range testParams {
 		_, err := CreateFunctionInvocationScript(contract, ps)

pkg/rpc/response/types.go

@@ -3,8 +3,8 @@ package response
 import (
 	"encoding/json"
 
-	"github.com/CityOfZion/neo-go/pkg/rpc/request"
 	"github.com/CityOfZion/neo-go/pkg/rpc/response/result"
+	"github.com/CityOfZion/neo-go/pkg/smartcontract"
 	"github.com/CityOfZion/neo-go/pkg/vm"
 )
 
@@ -14,7 +14,7 @@ type InvokeResult struct {
 	State       vm.State `json:"state"`
 	GasConsumed string   `json:"gas_consumed"`
 	Script      string   `json:"script"`
-	Stack       []request.StackParam
+	Stack       []smartcontract.Parameter
 }
 
 // Header is a generic JSON-RPC 2.0 response header (ID and JSON-RPC version).

pkg/smartcontract/param_context.go

@@ -1,33 +1,16 @@
 package smartcontract
 
 import (
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
-	"errors"
+	"math/bits"
 	"strconv"
 	"strings"
 	"unicode/utf8"
 
-	"github.com/CityOfZion/neo-go/pkg/crypto/keys"
-	"github.com/CityOfZion/neo-go/pkg/encoding/address"
-	"github.com/CityOfZion/neo-go/pkg/io"
 	"github.com/CityOfZion/neo-go/pkg/util"
-)
+	"github.com/pkg/errors"
-
-// ParamType represents the Type of the contract parameter.
-type ParamType byte
-
-// A list of supported smart contract parameter types.
-const (
-	SignatureType ParamType = iota
-	BoolType
-	IntegerType
-	Hash160Type
-	Hash256Type
-	ByteArrayType
-	PublicKeyType
-	StringType
-	ArrayType
 )
 
 // PropertyState represents contract properties (flags).
@@ -49,62 +32,6 @@ type Parameter struct {
 	Value interface{} `json:"value"`
 }
 
-func (pt ParamType) String() string {
-	switch pt {
-	case SignatureType:
-		return "Signature"
-	case BoolType:
-		return "Boolean"
-	case IntegerType:
-		return "Integer"
-	case Hash160Type:
-		return "Hash160"
-	case Hash256Type:
-		return "Hash256"
-	case ByteArrayType:
-		return "ByteArray"
-	case PublicKeyType:
-		return "PublicKey"
-	case StringType:
-		return "String"
-	case ArrayType:
-		return "Array"
-	default:
-		return ""
-	}
-}
-
-// MarshalJSON implements the json.Marshaler interface.
-func (pt ParamType) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + pt.String() + `"`), nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler interface.
-func (pt *ParamType) UnmarshalJSON(data []byte) error {
-	var s string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return err
-	}
-
-	p, err := parseParamType(s)
-	if err != nil {
-		return err
-	}
-
-	*pt = p
-	return nil
-}
-
-// EncodeBinary implements io.Serializable interface.
-func (pt ParamType) EncodeBinary(w *io.BinWriter) {
-	w.WriteB(byte(pt))
-}
-
-// DecodeBinary implements io.Serializable interface.
-func (pt *ParamType) DecodeBinary(r *io.BinReader) {
-	*pt = ParamType(r.ReadB())
-}
-
 // NewParameter returns a Parameter with proper initialized Value
 // of the given ParamType.
 func NewParameter(t ParamType) Parameter {
@@ -114,149 +41,188 @@ func NewParameter(t ParamType) Parameter {
 	}
 }
 
-// parseParamType is a user-friendly string to ParamType converter, it's
+type rawParameter struct {
-// case-insensitive and makes the following conversions:
+	Type  ParamType       `json:"type"`
-//     signature -> SignatureType
+	Value json.RawMessage `json:"value"`
-//     bool -> BoolType
-//     int -> IntegerType
-//     hash160 -> Hash160Type
-//     hash256 -> Hash256Type
-//     bytes -> ByteArrayType
-//     key -> PublicKeyType
-//     string -> StringType
-// anything else generates an error.
-func parseParamType(typ string) (ParamType, error) {
-	switch strings.ToLower(typ) {
-	case "signature":
-		return SignatureType, nil
-	case "bool":
-		return BoolType, nil
-	case "int":
-		return IntegerType, nil
-	case "hash160":
-		return Hash160Type, nil
-	case "hash256":
-		return Hash256Type, nil
-	case "bytes", "bytearray":
-		return ByteArrayType, nil
-	case "key":
-		return PublicKeyType, nil
-	case "string":
-		return StringType, nil
-	default:
-		// We deliberately don't support array here.
-		return 0, errors.New("wrong or unsupported parameter type")
-	}
 }
 
-// adjustValToType is a value type-checker and converter.
+// UnmarshalJSON implements Unmarshaler interface.
-func adjustValToType(typ ParamType, val string) (interface{}, error) {
+func (p *Parameter) UnmarshalJSON(data []byte) (err error) {
-	switch typ {
+	var (
-	case SignatureType:
+		r rawParameter
-		b, err := hex.DecodeString(val)
+		i int64
-		if err != nil {
+		s string
-			return nil, err
+		b []byte
+	)
+
+	if err = json.Unmarshal(data, &r); err != nil {
+		return
 	}
-		if len(b) != 64 {
+
-			return nil, errors.New("not a signature")
+	switch p.Type = r.Type; r.Type {
-		}
-		return val, nil
-	case BoolType:
-		switch val {
-		case "true":
-			return true, nil
-		case "false":
-			return false, nil
-		default:
-			return nil, errors.New("invalid boolean value")
-		}
-	case IntegerType:
-		return strconv.Atoi(val)
-	case Hash160Type:
-		u, err := address.StringToUint160(val)
-		if err == nil {
-			return hex.EncodeToString(u.BytesBE()), nil
-		}
-		b, err := hex.DecodeString(val)
-		if err != nil {
-			return nil, err
-		}
-		if len(b) != 20 {
-			return nil, errors.New("not a hash160")
-		}
-		return val, nil
-	case Hash256Type:
-		b, err := hex.DecodeString(val)
-		if err != nil {
-			return nil, err
-		}
-		if len(b) != 32 {
-			return nil, errors.New("not a hash256")
-		}
-		return val, nil
 	case ByteArrayType:
-		_, err := hex.DecodeString(val)
+		if err = json.Unmarshal(r.Value, &s); err != nil {
-		if err != nil {
+			return
-			return nil, err
 		}
-		return val, nil
+		if b, err = hex.DecodeString(s); err != nil {
-	case PublicKeyType:
+			return
-		_, err := keys.NewPublicKeyFromString(val)
-		if err != nil {
-			return nil, err
 		}
-		return val, nil
+		p.Value = b
 	case StringType:
-		return val, nil
+		if err = json.Unmarshal(r.Value, &s); err != nil {
-	default:
+			return
-		return nil, errors.New("unsupported parameter type")
 		}
+		p.Value = s
+	case IntegerType:
+		if err = json.Unmarshal(r.Value, &i); err == nil {
+			p.Value = i
+			return
+		}
+		// sometimes integer comes as string
+		if err = json.Unmarshal(r.Value, &s); err != nil {
+			return
+		}
+		if i, err = strconv.ParseInt(s, 10, 64); err != nil {
+			return
+		}
+		p.Value = i
+	case ArrayType:
+		// https://github.com/neo-project/neo/blob/3d59ecca5a8deb057bdad94b3028a6d5e25ac088/neo/Network/RPC/RpcServer.cs#L67
+		var rs []Parameter
+		if err = json.Unmarshal(r.Value, &rs); err != nil {
+			return
+		}
+		p.Value = rs
+	case Hash160Type:
+		var h util.Uint160
+		if err = json.Unmarshal(r.Value, &h); err != nil {
+			return
+		}
+		p.Value = h
+	case Hash256Type:
+		var h util.Uint256
+		if err = json.Unmarshal(r.Value, &h); err != nil {
+			return
+		}
+		p.Value = h
+	default:
+		return errors.New("not implemented")
+	}
+	return
 }
 
-// inferParamType tries to infer the value type from its contents. It returns
+// Params is an array of Parameter (TODO: drop it?).
-// IntegerType for anything that looks like decimal integer (can be converted
+type Params []Parameter
-// with strconv.Atoi), BoolType for true and false values, Hash160Type for
-// addresses and hex strings encoding 20 bytes long values, PublicKeyType for
-// valid hex-encoded public keys, Hash256Type for hex-encoded 32 bytes values,
-// SignatureType for hex-encoded 64 bytes values, ByteArrayType for any other
-// valid hex-encoded values and StringType for anything else.
-func inferParamType(val string) ParamType {
-	var err error
 
-	_, err = strconv.Atoi(val)
+// TryParseArray converts an array of Parameter into an array of more appropriate things.
-	if err == nil {
+func (p Params) TryParseArray(vals ...interface{}) error {
-		return IntegerType
+	var (
+		err error
+		i   int
+		par Parameter
+	)
+	if len(p) != len(vals) {
+		return errors.New("receiver array doesn't fit the Params length")
+	}
+	for i, par = range p {
+		if err = par.TryParse(vals[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// TryParse converts one Parameter into something more appropriate.
+func (p Parameter) TryParse(dest interface{}) error {
+	var (
+		err  error
+		ok   bool
+		data []byte
+	)
+	switch p.Type {
+	case ByteArrayType:
+		if data, ok = p.Value.([]byte); !ok {
+			return errors.Errorf("failed to cast %s to []byte", p.Value)
+		}
+		switch dest := dest.(type) {
+		case *util.Uint160:
+			if *dest, err = util.Uint160DecodeBytesBE(data); err != nil {
+				return err
+			}
+			return nil
+		case *[]byte:
+			*dest = data
+			return nil
+		case *util.Uint256:
+			if *dest, err = util.Uint256DecodeBytesLE(data); err != nil {
+				return err
+			}
+			return nil
+		case *int64, *int32, *int16, *int8, *int, *uint64, *uint32, *uint16, *uint8, *uint:
+			var size int
+			switch dest.(type) {
+			case *int64, *uint64:
+				size = 64
+			case *int32, *uint32:
+				size = 32
+			case *int16, *uint16:
+				size = 16
+			case *int8, *uint8:
+				size = 8
+			case *int, *uint:
+				size = bits.UintSize
 			}
 
-	if val == "true" || val == "false" {
+			i, err := bytesToUint64(data, size)
-		return BoolType
+			if err != nil {
+				return err
 			}
 
-	_, err = address.StringToUint160(val)
+			switch dest := dest.(type) {
-	if err == nil {
+			case *int64:
-		return Hash160Type
+				*dest = int64(i)
+			case *int32:
+				*dest = int32(i)
+			case *int16:
+				*dest = int16(i)
+			case *int8:
+				*dest = int8(i)
+			case *int:
+				*dest = int(i)
+			case *uint64:
+				*dest = i
+			case *uint32:
+				*dest = uint32(i)
+			case *uint16:
+				*dest = uint16(i)
+			case *uint8:
+				*dest = uint8(i)
+			case *uint:
+				*dest = uint(i)
 			}
-
+		case *string:
-	_, err = keys.NewPublicKeyFromString(val)
+			*dest = string(data)
-	if err == nil {
+			return nil
-		return PublicKeyType
-	}
-
-	unhexed, err := hex.DecodeString(val)
-	if err == nil {
-		switch len(unhexed) {
-		case 20:
-			return Hash160Type
-		case 32:
-			return Hash256Type
-		case 64:
-			return SignatureType
 		default:
-			return ByteArrayType
+			return errors.Errorf("cannot cast param of type %s to type %s", p.Type, dest)
 		}
+	default:
+		return errors.New("cannot define param type")
 	}
-	// Anything can be a string.
+	return nil
-	return StringType
+}
+
+func bytesToUint64(b []byte, size int) (uint64, error) {
+	var length = size / 8
+	if len(b) > length {
+		return 0, errors.Errorf("input doesn't fit into %d bits", size)
+	}
+	if len(b) < length {
+		data := make([]byte, length)
+		copy(data, b)
+		return binary.LittleEndian.Uint64(data), nil
+	}
+	return binary.LittleEndian.Uint64(b), nil
 }
 
 // NewParameterFromString returns a new Parameter initialized from the given
@@ -282,10 +248,14 @@ func NewParameterFromString(in string) (*Parameter, error) {
 		}
 		if char == ':' && !escaped && !hadType {
 			typStr := buf.String()
-			res.Type, err = parseParamType(typStr)
+			res.Type, err = ParseParamType(typStr)
 			if err != nil {
 				return nil, err
 			}
+			// We currently do not support following types:
+			if res.Type == ArrayType || res.Type == MapType || res.Type == InteropInterfaceType || res.Type == VoidType {
+				return nil, errors.Errorf("Unsupported contract parameter type: %s", res.Type)
+			}
 			buf.Reset()
 			hadType = true
 			continue

pkg/smartcontract/param_context_test.go

@@ -1,283 +1,204 @@
 package smartcontract
 
 import (
+	"encoding/json"
+	"reflect"
 	"testing"
 
+	"github.com/CityOfZion/neo-go/pkg/util"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestParseParamType(t *testing.T) {
+var testCases = []struct {
-	var inouts = []struct {
+	input  string
-		in  string
+	result Parameter
-		out ParamType
+}{
-		err bool
+	{
-	}{{
+		input:  `{"type":"Integer","value":12345}`,
-		in:  "signature",
+		result: Parameter{Type: IntegerType, Value: int64(12345)},
-		out: SignatureType,
+	},
-	}, {
+	{
-		in:  "Signature",
+		input:  `{"type":"Integer","value":"12345"}`,
-		out: SignatureType,
+		result: Parameter{Type: IntegerType, Value: int64(12345)},
-	}, {
+	},
-		in:  "SiGnAtUrE",
+	{
-		out: SignatureType,
+		input:  `{"type":"ByteArray","value":"010203"}`,
-	}, {
+		result: Parameter{Type: ByteArrayType, Value: []byte{0x01, 0x02, 0x03}},
-		in:  "bool",
+	},
-		out: BoolType,
+	{
-	}, {
+		input:  `{"type":"String","value":"Some string"}`,
-		in:  "int",
+		result: Parameter{Type: StringType, Value: "Some string"},
-		out: IntegerType,
+	},
-	}, {
+	{
-		in:  "hash160",
+		input: `{"type":"Array","value":[
-		out: Hash160Type,
+				{"type": "String", "value": "str 1"},
-	}, {
+				{"type": "Integer", "value": 2}]}`,
-		in:  "hash256",
+		result: Parameter{
-		out: Hash256Type,
+			Type: ArrayType,
-	}, {
+			Value: []Parameter{
-		in:  "bytes",
+				{Type: StringType, Value: "str 1"},
-		out: ByteArrayType,
+				{Type: IntegerType, Value: int64(2)},
-	}, {
+			},
-		in:  "key",
+		},
-		out: PublicKeyType,
+	},
-	}, {
+	{
-		in:  "string",
+		input: `{"type": "Hash160", "value": "0bcd2978634d961c24f5aea0802297ff128724d6"}`,
-		out: StringType,
+		result: Parameter{
-	}, {
+			Type: Hash160Type,
-		in:  "array",
+			Value: util.Uint160{
-		err: true,
+				0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-	}, {
+				0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-		in:  "qwerty",
+			},
-		err: true,
+		},
-	}}
+	},
-	for _, inout := range inouts {
+	{
-		out, err := parseParamType(inout.in)
+		input: `{"type": "Hash256", "value": "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"}`,
-		if inout.err {
+		result: Parameter{
-			assert.NotNil(t, err, "should error on '%s' input", inout.in)
+			Type: Hash256Type,
-		} else {
+			Value: util.Uint256{
-			assert.Nil(t, err, "shouldn't error on '%s' input", inout.in)
+				0x2d, 0xf3, 0x45, 0xf2, 0x45, 0xc5, 0x98, 0x9e,
-			assert.Equal(t, inout.out, out, "bad output for '%s' input", inout.in)
+				0x69, 0x95, 0x45, 0x06, 0xa5, 0x9e, 0x40, 0x12,
+				0xc1, 0x68, 0x54, 0x48, 0x08, 0xfc, 0xcc, 0x5b,
+				0x15, 0x18, 0xab, 0xa0, 0x8f, 0x30, 0x37, 0xf0,
+			},
+		},
+	},
+}
+
+var errorCases = []string{
+	`{"type": "ByteArray","value":`,        // incorrect JSON
+	`{"type": "ByteArray","value":1}`,      // incorrect Value
+	`{"type": "ByteArray","value":"12zz"}`, // incorrect ByteArray value
+	`{"type": "String","value":`,           // incorrect JSON
+	`{"type": "String","value":1}`,         // incorrect Value
+	`{"type": "Integer","value": "nn"}`,    // incorrect Integer value
+	`{"type": "Integer","value": []}`,      // incorrect Integer value
+	`{"type": "Array","value": 123}`,       // incorrect Array value
+	`{"type": "Hash160","value": "0bcd"}`,  // incorrect Uint160 value
+	`{"type": "Hash256","value": "0bcd"}`,  // incorrect Uint256 value
+	`{"type": "Stringg","value": ""}`,      // incorrect type
+	`{"type": {},"value": ""}`,             // incorrect value
+
+	`{"type": "InteropInterface","value": ""}`, // ununmarshable type
+	`{"type": "Map","value": ""}`,              //unmarshable type
+}
+
+func TestParam_UnmarshalJSON(t *testing.T) {
+	var s Parameter
+	for _, tc := range testCases {
+		assert.NoError(t, json.Unmarshal([]byte(tc.input), &s))
+		assert.Equal(t, s, tc.result)
 	}
+
+	for _, input := range errorCases {
+		assert.Error(t, json.Unmarshal([]byte(input), &s))
 	}
 }
 
-func TestInferParamType(t *testing.T) {
+var tryParseTestCases = []struct {
-	var inouts = []struct {
+	input    interface{}
-		in  string
+	expected interface{}
-		out ParamType
+}{
-	}{{
+	{
-		in:  "42",
+		input: []byte{
-		out: IntegerType,
+			0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-	}, {
+			0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-		in:  "-42",
+		},
-		out: IntegerType,
+		expected: util.Uint160{
-	}, {
+			0x0b, 0xcd, 0x29, 0x78, 0x63, 0x4d, 0x96, 0x1c, 0x24, 0xf5,
-		in:  "0",
+			0xae, 0xa0, 0x80, 0x22, 0x97, 0xff, 0x12, 0x87, 0x24, 0xd6,
-		out: IntegerType,
+		},
-	}, {
+	},
-		in:  "2e10",
+	{
-		out: ByteArrayType,
+		input: []byte{
-	}, {
+			0xf0, 0x37, 0x30, 0x8f, 0xa0, 0xab, 0x18, 0x15,
-		in:  "true",
+			0x5b, 0xcc, 0xfc, 0x08, 0x48, 0x54, 0x68, 0xc1,
-		out: BoolType,
+			0x12, 0x40, 0x9e, 0xa5, 0x06, 0x45, 0x95, 0x69,
-	}, {
+			0x9e, 0x98, 0xc5, 0x45, 0xf2, 0x45, 0xf3, 0x2d,
-		in:  "false",
+		},
-		out: BoolType,
+		expected: util.Uint256{
-	}, {
+			0x2d, 0xf3, 0x45, 0xf2, 0x45, 0xc5, 0x98, 0x9e,
-		in:  "truee",
+			0x69, 0x95, 0x45, 0x06, 0xa5, 0x9e, 0x40, 0x12,
-		out: StringType,
+			0xc1, 0x68, 0x54, 0x48, 0x08, 0xfc, 0xcc, 0x5b,
-	}, {
+			0x15, 0x18, 0xab, 0xa0, 0x8f, 0x30, 0x37, 0xf0,
-		in:  "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		},
-		out: Hash160Type,
+	},
-	}, {
+	{
-		in:  "ZK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		input:    []byte{0, 1, 2, 3, 4, 9, 8, 6},
-		out: StringType,
+		expected: []byte{0, 1, 2, 3, 4, 9, 8, 6},
-	}, {
+	},
-		in:  "50befd26fdf6e4d957c11e078b24ebce6291456f",
+	{
-		out: Hash160Type,
+		input:    []byte{0x63, 0x78, 0x29, 0xcd, 0x0b},
-	}, {
+		expected: int64(50686687331),
-		in:  "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+	},
-		out: PublicKeyType,
+	{
-	}, {
+		input:    []byte("this is a test string"),
-		in:  "30b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+		expected: "this is a test string",
-		out: ByteArrayType,
+	},
-	}, {
-		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
-		out: Hash256Type,
-	}, {
-		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7da",
-		out: ByteArrayType,
-	}, {
-		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
-		out: SignatureType,
-	}, {
-		in:  "qwerty",
-		out: StringType,
-	}, {
-		in:  "ab",
-		out: ByteArrayType,
-	}, {
-		in:  "az",
-		out: StringType,
-	}, {
-		in:  "bad",
-		out: StringType,
-	}, {
-		in:  "фыва",
-		out: StringType,
-	}, {
-		in:  "dead",
-		out: ByteArrayType,
-	}}
-	for _, inout := range inouts {
-		out := inferParamType(inout.in)
-		assert.Equal(t, inout.out, out, "bad output for '%s' input", inout.in)
-	}
 }
 
-func TestAdjustValToType(t *testing.T) {
+func TestParam_TryParse(t *testing.T) {
-	var inouts = []struct {
+	for _, tc := range tryParseTestCases {
-		typ ParamType
+		t.Run(reflect.TypeOf(tc.expected).String(), func(t *testing.T) {
-		val string
+			input := Parameter{
-		out interface{}
+				Type:  ByteArrayType,
-		err bool
+				Value: tc.input,
-	}{{
+			}
-		typ: SignatureType,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
-		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
-	}, {
-		typ: SignatureType,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c",
-		err: true,
-	}, {
-		typ: SignatureType,
-		val: "qwerty",
-		err: true,
-	}, {
-		typ: BoolType,
-		val: "false",
-		out: false,
-	}, {
-		typ: BoolType,
-		val: "true",
-		out: true,
-	}, {
-		typ: BoolType,
-		val: "qwerty",
-		err: true,
-	}, {
-		typ: BoolType,
-		val: "42",
-		err: true,
-	}, {
-		typ: BoolType,
-		val: "0",
-		err: true,
-	}, {
-		typ: IntegerType,
-		val: "0",
-		out: 0,
-	}, {
-		typ: IntegerType,
-		val: "42",
-		out: 42,
-	}, {
-		typ: IntegerType,
-		val: "-42",
-		out: -42,
-	}, {
-		typ: IntegerType,
-		val: "q",
-		err: true,
-	}, {
-		typ: Hash160Type,
-		val: "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
-		out: "23ba2703c53263e8d6e522dc32203339dcd8eee9",
-	}, {
-		typ: Hash160Type,
-		val: "50befd26fdf6e4d957c11e078b24ebce6291456f",
-		out: "50befd26fdf6e4d957c11e078b24ebce6291456f",
-	}, {
-		typ: Hash160Type,
-		val: "befd26fdf6e4d957c11e078b24ebce6291456f",
-		err: true,
-	}, {
-		typ: Hash160Type,
-		val: "q",
-		err: true,
-	}, {
-		typ: Hash256Type,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
-		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
-	}, {
-		typ: Hash256Type,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
-		err: true,
-	}, {
-		typ: Hash256Type,
-		val: "q",
-		err: true,
-	}, {
-		typ: ByteArrayType,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
-		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
-	}, {
-		typ: ByteArrayType,
-		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
-		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
-	}, {
-		typ: ByteArrayType,
-		val: "50befd26fdf6e4d957c11e078b24ebce6291456f",
-		out: "50befd26fdf6e4d957c11e078b24ebce6291456f",
-	}, {
-		typ: ByteArrayType,
-		val: "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
-		err: true,
-	}, {
-		typ: ByteArrayType,
-		val: "q",
-		err: true,
-	}, {
-		typ: ByteArrayType,
-		val: "ab",
-		out: "ab",
-	}, {
-		typ: PublicKeyType,
-		val: "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
-		out: "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
-	}, {
-		typ: PublicKeyType,
-		val: "01b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
-		err: true,
-	}, {
-		typ: PublicKeyType,
-		val: "q",
-		err: true,
-	}, {
-		typ: StringType,
-		val: "q",
-		out: "q",
-	}, {
-		typ: StringType,
-		val: "dead",
-		out: "dead",
-	}, {
-		typ: StringType,
-		val: "йцукен",
-		out: "йцукен",
-	}, {
-		typ: ArrayType,
-		val: "",
-		err: true,
-	}}
 
-	for _, inout := range inouts {
+			val := reflect.New(reflect.TypeOf(tc.expected))
-		out, err := adjustValToType(inout.typ, inout.val)
+			assert.NoError(t, input.TryParse(val.Interface()))
-		if inout.err {
+			assert.Equal(t, tc.expected, val.Elem().Interface())
-			assert.NotNil(t, err, "should error on '%s/%s' input", inout.typ, inout.val)
+		})
-		} else {
-			assert.Nil(t, err, "shouldn't error on '%s/%s' input", inout.typ, inout.val)
-			assert.Equal(t, inout.out, out, "bad output for '%s/%s' input", inout.typ, inout.val)
 	}
+
+	t.Run("[]Uint160", func(t *testing.T) {
+		exp1 := util.Uint160{1, 2, 3, 4, 5}
+		exp2 := util.Uint160{9, 8, 7, 6, 5}
+
+		params := Params{
+			{
+				Type:  ByteArrayType,
+				Value: exp1.BytesBE(),
+			},
+			{
+				Type:  ByteArrayType,
+				Value: exp2.BytesBE(),
+			},
 		}
+
+		var out1, out2 util.Uint160
+
+		assert.NoError(t, params.TryParseArray(&out1, &out2))
+		assert.Equal(t, exp1, out1)
+		assert.Equal(t, exp2, out2)
+	})
+}
+
+func TestParamType_String(t *testing.T) {
+	types := []ParamType{
+		SignatureType,
+		BoolType,
+		IntegerType,
+		Hash160Type,
+		Hash256Type,
+		ByteArrayType,
+		PublicKeyType,
+		StringType,
+		ArrayType,
+		InteropInterfaceType,
+		MapType,
+		VoidType,
+	}
+
+	for _, exp := range types {
+		actual, err := ParseParamType(exp.String())
+		assert.NoError(t, err)
+		assert.Equal(t, exp, actual)
+	}
+
+	actual, err := ParseParamType(UnknownType.String())
+	assert.Error(t, err)
+	assert.Equal(t, UnknownType, actual)
 }
 
 func TestNewParameterFromString(t *testing.T) {
@@ -330,6 +251,12 @@ func TestNewParameterFromString(t *testing.T) {
 	}, {
 		in:  `bool:asdf`,
 		err: true,
+	}, {
+		in:  `InteropInterface:123`,
+		err: true,
+	}, {
+		in:  `Map:[]`,
+		err: true,
 	}}
 	for _, inout := range inouts {
 		out, err := NewParameterFromString(inout.in)

pkg/smartcontract/param_type.go

@@ -0,0 +1,269 @@
+package smartcontract
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"strconv"
+	"strings"
+
+	"github.com/CityOfZion/neo-go/pkg/crypto/keys"
+	"github.com/CityOfZion/neo-go/pkg/encoding/address"
+	"github.com/CityOfZion/neo-go/pkg/io"
+	"github.com/pkg/errors"
+)
+
+// ParamType represents the Type of the smart contract parameter.
+type ParamType int
+
+// A list of supported smart contract parameter types.
+const (
+	UnknownType          ParamType = -1
+	SignatureType        ParamType = 0x00
+	BoolType             ParamType = 0x01
+	IntegerType          ParamType = 0x02
+	Hash160Type          ParamType = 0x03
+	Hash256Type          ParamType = 0x04
+	ByteArrayType        ParamType = 0x05
+	PublicKeyType        ParamType = 0x06
+	StringType           ParamType = 0x07
+	ArrayType            ParamType = 0x10
+	MapType              ParamType = 0x12
+	InteropInterfaceType ParamType = 0xf0
+	VoidType             ParamType = 0xff
+)
+
+// String implements the stringer interface.
+func (pt ParamType) String() string {
+	switch pt {
+	case SignatureType:
+		return "Signature"
+	case BoolType:
+		return "Boolean"
+	case IntegerType:
+		return "Integer"
+	case Hash160Type:
+		return "Hash160"
+	case Hash256Type:
+		return "Hash256"
+	case ByteArrayType:
+		return "ByteArray"
+	case PublicKeyType:
+		return "PublicKey"
+	case StringType:
+		return "String"
+	case ArrayType:
+		return "Array"
+	case MapType:
+		return "Map"
+	case InteropInterfaceType:
+		return "InteropInterface"
+	case VoidType:
+		return "Void"
+	default:
+		return ""
+	}
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (pt ParamType) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + pt.String() + `"`), nil
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface.
+func (pt *ParamType) UnmarshalJSON(data []byte) error {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+
+	p, err := ParseParamType(s)
+	if err != nil {
+		return err
+	}
+
+	*pt = p
+	return nil
+}
+
+// MarshalYAML implements the YAML Marshaler interface.
+func (pt *ParamType) MarshalYAML() (interface{}, error) {
+	return pt.String(), nil
+}
+
+// UnmarshalYAML implements the YAML Unmarshaler interface.
+func (pt *ParamType) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var name string
+
+	err := unmarshal(&name)
+	if err != nil {
+		return err
+	}
+	*pt, err = ParseParamType(name)
+	return err
+}
+
+// EncodeBinary implements io.Serializable interface.
+func (pt ParamType) EncodeBinary(w *io.BinWriter) {
+	w.WriteB(byte(pt))
+}
+
+// DecodeBinary implements io.Serializable interface.
+func (pt *ParamType) DecodeBinary(r *io.BinReader) {
+	*pt = ParamType(r.ReadB())
+}
+
+// ParseParamType is a user-friendly string to ParamType converter, it's
+// case-insensitive and makes the following conversions:
+//     signature -> SignatureType
+//     bool, boolean -> BoolType
+//     int, integer -> IntegerType
+//     hash160 -> Hash160Type
+//     hash256 -> Hash256Type
+//     bytes, bytearray -> ByteArrayType
+//     key, publickey -> PublicKeyType
+//     string -> StringType
+//     array -> ArrayType
+//     map -> MapType
+//     interopinterface -> InteropInterfaceType
+//     void -> VoidType
+// anything else generates an error.
+func ParseParamType(typ string) (ParamType, error) {
+	switch strings.ToLower(typ) {
+	case "signature":
+		return SignatureType, nil
+	case "bool", "boolean":
+		return BoolType, nil
+	case "int", "integer":
+		return IntegerType, nil
+	case "hash160":
+		return Hash160Type, nil
+	case "hash256":
+		return Hash256Type, nil
+	case "bytes", "bytearray":
+		return ByteArrayType, nil
+	case "key", "publickey":
+		return PublicKeyType, nil
+	case "string":
+		return StringType, nil
+	case "array":
+		return ArrayType, nil
+	case "map":
+		return MapType, nil
+	case "interopinterface":
+		return InteropInterfaceType, nil
+	case "void":
+		return VoidType, nil
+	default:
+		return UnknownType, errors.Errorf("Unknown contract parameter type: %s", typ)
+	}
+}
+
+// adjustValToType is a value type-checker and converter.
+func adjustValToType(typ ParamType, val string) (interface{}, error) {
+	switch typ {
+	case SignatureType:
+		b, err := hex.DecodeString(val)
+		if err != nil {
+			return nil, err
+		}
+		if len(b) != 64 {
+			return nil, errors.New("not a signature")
+		}
+		return val, nil
+	case BoolType:
+		switch val {
+		case "true":
+			return true, nil
+		case "false":
+			return false, nil
+		default:
+			return nil, errors.New("invalid boolean value")
+		}
+	case IntegerType:
+		return strconv.Atoi(val)
+	case Hash160Type:
+		u, err := address.StringToUint160(val)
+		if err == nil {
+			return hex.EncodeToString(u.BytesBE()), nil
+		}
+		b, err := hex.DecodeString(val)
+		if err != nil {
+			return nil, err
+		}
+		if len(b) != 20 {
+			return nil, errors.New("not a hash160")
+		}
+		return val, nil
+	case Hash256Type:
+		b, err := hex.DecodeString(val)
+		if err != nil {
+			return nil, err
+		}
+		if len(b) != 32 {
+			return nil, errors.New("not a hash256")
+		}
+		return val, nil
+	case ByteArrayType:
+		_, err := hex.DecodeString(val)
+		if err != nil {
+			return nil, err
+		}
+		return val, nil
+	case PublicKeyType:
+		_, err := keys.NewPublicKeyFromString(val)
+		if err != nil {
+			return nil, err
+		}
+		return val, nil
+	case StringType:
+		return val, nil
+	default:
+		return nil, errors.New("unsupported parameter type")
+	}
+}
+
+// inferParamType tries to infer the value type from its contents. It returns
+// IntegerType for anything that looks like decimal integer (can be converted
+// with strconv.Atoi), BoolType for true and false values, Hash160Type for
+// addresses and hex strings encoding 20 bytes long values, PublicKeyType for
+// valid hex-encoded public keys, Hash256Type for hex-encoded 32 bytes values,
+// SignatureType for hex-encoded 64 bytes values, ByteArrayType for any other
+// valid hex-encoded values and StringType for anything else.
+func inferParamType(val string) ParamType {
+	var err error
+
+	_, err = strconv.Atoi(val)
+	if err == nil {
+		return IntegerType
+	}
+
+	if val == "true" || val == "false" {
+		return BoolType
+	}
+
+	_, err = address.StringToUint160(val)
+	if err == nil {
+		return Hash160Type
+	}
+
+	_, err = keys.NewPublicKeyFromString(val)
+	if err == nil {
+		return PublicKeyType
+	}
+
+	unhexed, err := hex.DecodeString(val)
+	if err == nil {
+		switch len(unhexed) {
+		case 20:
+			return Hash160Type
+		case 32:
+			return Hash256Type
+		case 64:
+			return SignatureType
+		default:
+			return ByteArrayType
+		}
+	}
+	// Anything can be a string.
+	return StringType
+}

pkg/smartcontract/param_type_test.go

@@ -0,0 +1,298 @@
+package smartcontract
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseParamType(t *testing.T) {
+	var inouts = []struct {
+		in  string
+		out ParamType
+		err bool
+	}{{
+		in:  "signature",
+		out: SignatureType,
+	}, {
+		in:  "Signature",
+		out: SignatureType,
+	}, {
+		in:  "SiGnAtUrE",
+		out: SignatureType,
+	}, {
+		in:  "bool",
+		out: BoolType,
+	}, {
+		in:  "int",
+		out: IntegerType,
+	}, {
+		in:  "hash160",
+		out: Hash160Type,
+	}, {
+		in:  "hash256",
+		out: Hash256Type,
+	}, {
+		in:  "bytes",
+		out: ByteArrayType,
+	}, {
+		in:  "key",
+		out: PublicKeyType,
+	}, {
+		in:  "string",
+		out: StringType,
+	}, {
+		in:  "array",
+		out: ArrayType,
+	}, {
+		in:  "map",
+		out: MapType,
+	}, {
+		in:  "interopinterface",
+		out: InteropInterfaceType,
+	}, {
+		in:  "void",
+		out: VoidType,
+	}, {
+		in:  "qwerty",
+		err: true,
+	}}
+	for _, inout := range inouts {
+		out, err := ParseParamType(inout.in)
+		if inout.err {
+			assert.NotNil(t, err, "should error on '%s' input", inout.in)
+		} else {
+			assert.Nil(t, err, "shouldn't error on '%s' input", inout.in)
+			assert.Equal(t, inout.out, out, "bad output for '%s' input", inout.in)
+		}
+	}
+}
+
+func TestInferParamType(t *testing.T) {
+	var inouts = []struct {
+		in  string
+		out ParamType
+	}{{
+		in:  "42",
+		out: IntegerType,
+	}, {
+		in:  "-42",
+		out: IntegerType,
+	}, {
+		in:  "0",
+		out: IntegerType,
+	}, {
+		in:  "2e10",
+		out: ByteArrayType,
+	}, {
+		in:  "true",
+		out: BoolType,
+	}, {
+		in:  "false",
+		out: BoolType,
+	}, {
+		in:  "truee",
+		out: StringType,
+	}, {
+		in:  "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		out: Hash160Type,
+	}, {
+		in:  "ZK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		out: StringType,
+	}, {
+		in:  "50befd26fdf6e4d957c11e078b24ebce6291456f",
+		out: Hash160Type,
+	}, {
+		in:  "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+		out: PublicKeyType,
+	}, {
+		in:  "30b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+		out: ByteArrayType,
+	}, {
+		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+		out: Hash256Type,
+	}, {
+		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7da",
+		out: ByteArrayType,
+	}, {
+		in:  "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
+		out: SignatureType,
+	}, {
+		in:  "qwerty",
+		out: StringType,
+	}, {
+		in:  "ab",
+		out: ByteArrayType,
+	}, {
+		in:  "az",
+		out: StringType,
+	}, {
+		in:  "bad",
+		out: StringType,
+	}, {
+		in:  "фыва",
+		out: StringType,
+	}, {
+		in:  "dead",
+		out: ByteArrayType,
+	}}
+	for _, inout := range inouts {
+		out := inferParamType(inout.in)
+		assert.Equal(t, inout.out, out, "bad output for '%s' input", inout.in)
+	}
+}
+
+func TestAdjustValToType(t *testing.T) {
+	var inouts = []struct {
+		typ ParamType
+		val string
+		out interface{}
+		err bool
+	}{{
+		typ: SignatureType,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
+		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
+	}, {
+		typ: SignatureType,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c",
+		err: true,
+	}, {
+		typ: SignatureType,
+		val: "qwerty",
+		err: true,
+	}, {
+		typ: BoolType,
+		val: "false",
+		out: false,
+	}, {
+		typ: BoolType,
+		val: "true",
+		out: true,
+	}, {
+		typ: BoolType,
+		val: "qwerty",
+		err: true,
+	}, {
+		typ: BoolType,
+		val: "42",
+		err: true,
+	}, {
+		typ: BoolType,
+		val: "0",
+		err: true,
+	}, {
+		typ: IntegerType,
+		val: "0",
+		out: 0,
+	}, {
+		typ: IntegerType,
+		val: "42",
+		out: 42,
+	}, {
+		typ: IntegerType,
+		val: "-42",
+		out: -42,
+	}, {
+		typ: IntegerType,
+		val: "q",
+		err: true,
+	}, {
+		typ: Hash160Type,
+		val: "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		out: "23ba2703c53263e8d6e522dc32203339dcd8eee9",
+	}, {
+		typ: Hash160Type,
+		val: "50befd26fdf6e4d957c11e078b24ebce6291456f",
+		out: "50befd26fdf6e4d957c11e078b24ebce6291456f",
+	}, {
+		typ: Hash160Type,
+		val: "befd26fdf6e4d957c11e078b24ebce6291456f",
+		err: true,
+	}, {
+		typ: Hash160Type,
+		val: "q",
+		err: true,
+	}, {
+		typ: Hash256Type,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+	}, {
+		typ: Hash256Type,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
+		err: true,
+	}, {
+		typ: Hash256Type,
+		val: "q",
+		err: true,
+	}, {
+		typ: ByteArrayType,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
+		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282d",
+	}, {
+		typ: ByteArrayType,
+		val: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+		out: "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+	}, {
+		typ: ByteArrayType,
+		val: "50befd26fdf6e4d957c11e078b24ebce6291456f",
+		out: "50befd26fdf6e4d957c11e078b24ebce6291456f",
+	}, {
+		typ: ByteArrayType,
+		val: "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y",
+		err: true,
+	}, {
+		typ: ByteArrayType,
+		val: "q",
+		err: true,
+	}, {
+		typ: ByteArrayType,
+		val: "ab",
+		out: "ab",
+	}, {
+		typ: PublicKeyType,
+		val: "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+		out: "03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+	}, {
+		typ: PublicKeyType,
+		val: "01b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c",
+		err: true,
+	}, {
+		typ: PublicKeyType,
+		val: "q",
+		err: true,
+	}, {
+		typ: StringType,
+		val: "q",
+		out: "q",
+	}, {
+		typ: StringType,
+		val: "dead",
+		out: "dead",
+	}, {
+		typ: StringType,
+		val: "йцукен",
+		out: "йцукен",
+	}, {
+		typ: ArrayType,
+		val: "",
+		err: true,
+	}, {
+		typ: MapType,
+		val: "[]",
+		err: true,
+	}, {
+		typ: InteropInterfaceType,
+		val: "",
+		err: true,
+	}}
+
+	for _, inout := range inouts {
+		out, err := adjustValToType(inout.typ, inout.val)
+		if inout.err {
+			assert.NotNil(t, err, "should error on '%s/%s' input", inout.typ, inout.val)
+		} else {
+			assert.Nil(t, err, "shouldn't error on '%s/%s' input", inout.typ, inout.val)
+			assert.Equal(t, inout.out, out, "bad output for '%s/%s' input", inout.typ, inout.val)
+		}
+	}
+}