frostfs-node/pkg/morph/client/util.go

package client

import (
	"encoding/binary"

	sc "github.com/nspcc-dev/neo-go/pkg/smartcontract"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/pkg/errors"
)

/*
   Use these function to parse stack parameters obtained from `TestInvoke`
   function to native go types. You should know upfront return types of invoked
   method.
*/

// BoolFromStackParameter receives boolean value from the value of a smart contract parameter.
func BoolFromStackParameter(param sc.Parameter) (bool, error) {
	switch param.Type {
	case sc.BoolType:
		val, ok := param.Value.(bool)
		if !ok {
			return false, errors.Errorf("chain/client: can't convert %T to boolean", param.Value)
		}

		return val, nil
	case sc.IntegerType:
		val, ok := param.Value.(int64)
		if !ok {
			return false, errors.Errorf("chain/client: can't convert %T to boolean", param.Value)
		}

		return val > 0, nil
	case sc.ByteArrayType:
		val, ok := param.Value.([]byte)
		if !ok {
			return false, errors.Errorf("chain/client: can't convert %T to boolean", param.Value)
		}

		return len(val) != 0, nil
	default:
		return false, errors.Errorf("chain/client: %s is not a bool type", param.Type)
	}
}

// IntFromStackParameter receives numerical value from the value of a smart contract parameter.
func IntFromStackParameter(param sc.Parameter) (int64, error) {
	switch param.Type {
	case sc.IntegerType:
		val, ok := param.Value.(int64)
		if !ok {
			return 0, errors.Errorf("chain/client: can't convert %T to integer", param.Value)
		}

		return val, nil
	case sc.ByteArrayType:
		val, ok := param.Value.([]byte)
		if !ok || len(val) > 8 {
			return 0, errors.Errorf("chain/client: can't convert %T to integer", param.Value)
		}

		res := make([]byte, 8)
		copy(res[:len(val)], val)

		return int64(binary.LittleEndian.Uint64(res)), nil
	default:
		return 0, errors.Errorf("chain/client: %s is not an integer type", param.Type)
	}
}

// BytesFromStackParameter receives binary value from the value of a smart contract parameter.
func BytesFromStackParameter(param sc.Parameter) ([]byte, error) {
	if param.Type != sc.ByteArrayType {
		if param.Type == sc.AnyType && param.Value == nil {
			return nil, nil
		}

		return nil, errors.Errorf("chain/client: %s is not a byte array type", param.Type)
	}

	val, ok := param.Value.([]byte)
	if !ok {
		return nil, errors.Errorf("chain/client: can't convert %T to byte slice", param.Value)
	}

	return val, nil
}

// ArrayFromStackParameter returns the slice contract parameters from passed parameter.
//
// If passed parameter carries boolean false value, (nil, nil) returns.
func ArrayFromStackParameter(param sc.Parameter) ([]sc.Parameter, error) {
	if param.Type == sc.BoolType && !param.Value.(bool) {
		return nil, nil
	}

	if param.Type != sc.ArrayType {
		if param.Type == sc.AnyType && param.Value == nil {
			return nil, nil
		}

		return nil, errors.Errorf("chain/client: %s is not an array type", param.Type)
	}

	val, ok := param.Value.([]sc.Parameter)
	if !ok {
		return nil, errors.Errorf("chain/client: can't convert %T to parameter slice", param.Value)
	}

	return val, nil
}

// StringFromStackParameter receives string value from the value of a smart contract parameter.
func StringFromStackParameter(param sc.Parameter) (string, error) {
	switch param.Type {
	case sc.StringType:
		val, ok := param.Value.(string)
		if !ok {
			return "", errors.Errorf("chain/client: can't convert %T to string", param.Value)
		}

		return val, nil
	case sc.ByteArrayType:
		val, ok := param.Value.([]byte)
		if !ok {
			return "", errors.Errorf("chain/client: can't convert %T to string", param.Value)
		}

		return string(val), nil
	default:
		return "", errors.Errorf("chain/client: %s is not a string type", param.Type)
	}
}

// BoolFromStackItem receives boolean value from the value of a smart contract parameter.
func BoolFromStackItem(param stackitem.Item) (bool, error) {
	switch param.Type() {
	case stackitem.BooleanT, stackitem.IntegerT, stackitem.ByteArrayT:
		return param.TryBool()
	default:
		return false, errors.Errorf("chain/client: %s is not a bool type", param.Type())
	}
}

// IntFromStackItem receives numerical value from the value of a smart contract parameter.
func IntFromStackItem(param stackitem.Item) (int64, error) {
	switch param.Type() {
	case stackitem.IntegerT, stackitem.ByteArrayT:
		i, err := param.TryInteger()
		if err != nil {
			return 0, err
		}

		return i.Int64(), nil
	default:
		return 0, errors.Errorf("chain/client: %s is not an integer type", param.Type())
	}
}

// BytesFromStackItem receives binary value from the value of a smart contract parameter.
func BytesFromStackItem(param stackitem.Item) ([]byte, error) {
	switch param.Type() {
	case stackitem.BufferT, stackitem.ByteArrayT:
		return param.TryBytes()
	case stackitem.AnyT:
		if param.Value() == nil {
			return nil, nil
		}
		fallthrough
	default:
		return nil, errors.Errorf("chain/client: %s is not a byte array type", param.Type())
	}
}

// ArrayFromStackItem returns the slice contract parameters from passed parameter.
//
// If passed parameter carries boolean false value, (nil, nil) returns.
func ArrayFromStackItem(param stackitem.Item) ([]stackitem.Item, error) {
	switch param.Type() {
	case stackitem.AnyT:
		return nil, nil
	case stackitem.ArrayT:
		items, ok := param.Value().([]stackitem.Item)
		if !ok {
			return nil, errors.Errorf("chain/client: can't convert %T to parameter slice", param.Value())
		}

		return items, nil
	default:
		return nil, errors.Errorf("chain/client: %s is not an array type", param.Type())
	}
}

// StringFromStackItem receives string value from the value of a smart contract parameter.
func StringFromStackItem(param stackitem.Item) (string, error) {
	if param.Type() != stackitem.ByteArrayT {
		return "", errors.Errorf("chain/client: %s is not an integer type", param.Type())
	}

	return stackitem.ToString(param)
}