forked from TrueCloudLab/frostfs-node
7319ca5a00
Including: - typo fix for `StringFromStackItem` error msg - EigenTrust alpha getter. - renaming local var in reading uin64 values from global cfg function Signed-off-by: Pavel Karpy <carpawell@nspcc.ru>
94 lines
2.7 KiB
Go
94 lines
2.7 KiB
Go
package client
|
|
|
|
import (
|
|
"math/big"
|
|
|
|
"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.
|
|
*/
|
|
|
|
// 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())
|
|
}
|
|
}
|
|
|
|
// BigIntFromStackItem receives numerical value from the value of a smart contract parameter.
|
|
func BigIntFromStackItem(param stackitem.Item) (*big.Int, error) {
|
|
return param.TryInteger()
|
|
}
|
|
|
|
// 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.IntegerT:
|
|
n, err := param.TryInteger()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "can't parse integer bytes")
|
|
}
|
|
|
|
return n.Bytes(), nil
|
|
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, stackitem.StructT:
|
|
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 string type", param.Type())
|
|
}
|
|
|
|
return stackitem.ToString(param)
|
|
}
|