312 lines
6.3 KiB
Go
312 lines
6.3 KiB
Go
package client
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/state"
|
|
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
|
|
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
|
|
)
|
|
|
|
func UnwrapArrayOfUint160(items []stackitem.Item, err error) ([]util.Uint160, error) {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return unwrap.ArrayOfUint160(makeValidRes(stackitem.NewArray(items)))
|
|
}
|
|
|
|
func ParseSubject(structArr []stackitem.Item) (*Subject, error) {
|
|
if len(structArr) < 5 {
|
|
return nil, errors.New("invalid response subject struct")
|
|
}
|
|
|
|
var (
|
|
err error
|
|
subj Subject
|
|
)
|
|
|
|
subj.PrimaryKey, err = unwrap.PublicKey(makeValidRes(structArr[0]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !structArr[1].Equals(stackitem.Null{}) {
|
|
subj.AdditionalKeys, err = unwrap.ArrayOfPublicKeys(makeValidRes(structArr[1]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if !structArr[2].Equals(stackitem.Null{}) {
|
|
subj.Namespace, err = unwrap.UTF8String(makeValidRes(structArr[2]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if !structArr[2].Equals(stackitem.Null{}) {
|
|
subj.Name, err = unwrap.UTF8String(makeValidRes(structArr[3]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
subj.KV, err = ParseMap(structArr[4])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &subj, nil
|
|
}
|
|
|
|
func ParseSubjectExtended(structArr []stackitem.Item) (*SubjectExtended, error) {
|
|
if len(structArr) < 6 {
|
|
return nil, errors.New("invalid response subject extended struct")
|
|
}
|
|
|
|
var (
|
|
err error
|
|
subj SubjectExtended
|
|
)
|
|
|
|
subj.PrimaryKey, err = unwrap.PublicKey(makeValidRes(structArr[0]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !structArr[1].Equals(stackitem.Null{}) {
|
|
subj.AdditionalKeys, err = unwrap.ArrayOfPublicKeys(makeValidRes(structArr[1]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
nsBytes, err := structArr[2].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
subj.Namespace = string(nsBytes)
|
|
|
|
nameBytes, err := structArr[3].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
subj.Name = string(nameBytes)
|
|
|
|
subj.KV, err = ParseMap(structArr[4])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !structArr[5].Equals(stackitem.Null{}) {
|
|
groupItems, ok := structArr[5].Value().([]stackitem.Item)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid groups field")
|
|
}
|
|
|
|
subj.Groups, err = ParseGroups(groupItems)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return &subj, nil
|
|
}
|
|
|
|
func ParseMap(item stackitem.Item) (map[string]string, error) {
|
|
if item.Equals(stackitem.Null{}) {
|
|
return nil, nil
|
|
}
|
|
|
|
metaMap, err := unwrap.Map(makeValidRes(item))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
meta, ok := metaMap.Value().([]stackitem.MapElement)
|
|
if !ok {
|
|
return nil, errors.New("invalid map type")
|
|
}
|
|
|
|
res := make(map[string]string, len(meta))
|
|
for _, element := range meta {
|
|
key, err := element.Key.TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
val, err := element.Value.TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res[string(key)] = string(val)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func ParseNamespace(structArr []stackitem.Item) (*Namespace, error) {
|
|
if len(structArr) < 1 {
|
|
return nil, errors.New("invalid response namespace struct")
|
|
}
|
|
|
|
name, err := structArr[0].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Namespace{Name: string(name)}, nil
|
|
}
|
|
|
|
func ParseNamespaceExtended(structArr []stackitem.Item) (*NamespaceExtended, error) {
|
|
if len(structArr) < 3 {
|
|
return nil, errors.New("invalid response namespace extended struct")
|
|
}
|
|
|
|
name, err := structArr[0].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
groupCount, err := structArr[1].TryInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
subjectCount, err := structArr[2].TryInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &NamespaceExtended{
|
|
Name: string(name),
|
|
GroupsCount: groupCount.Int64(),
|
|
SubjectsCount: subjectCount.Int64(),
|
|
}, nil
|
|
}
|
|
|
|
func ParseNamespaces(items []stackitem.Item) ([]*Namespace, error) {
|
|
var err error
|
|
res := make([]*Namespace, len(items))
|
|
|
|
for i := 0; i < len(items); i++ {
|
|
arr, ok := items[i].Value().([]stackitem.Item)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid namespace type")
|
|
}
|
|
res[i], err = ParseNamespace(arr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func ParseGroup(structArr []stackitem.Item) (*Group, error) {
|
|
if len(structArr) < 4 {
|
|
return nil, errors.New("invalid response group struct")
|
|
}
|
|
|
|
groupID, err := structArr[0].TryInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
name, err := structArr[1].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
namespace, err := structArr[2].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
kvs, err := ParseMap(structArr[3])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Group{
|
|
ID: groupID.Int64(),
|
|
Name: string(name),
|
|
Namespace: string(namespace),
|
|
KV: kvs,
|
|
}, nil
|
|
}
|
|
|
|
func ParseGroupExtended(structArr []stackitem.Item) (*GroupExtended, error) {
|
|
if len(structArr) < 5 {
|
|
return nil, errors.New("invalid response group extended struct")
|
|
}
|
|
|
|
groupID, err := structArr[0].TryInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
name, err := structArr[1].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
namespace, err := structArr[2].TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
kvs, err := ParseMap(structArr[3])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
subjectCount, err := structArr[4].TryInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &GroupExtended{
|
|
ID: groupID.Int64(),
|
|
Name: string(name),
|
|
Namespace: string(namespace),
|
|
KV: kvs,
|
|
SubjectsCount: subjectCount.Int64(),
|
|
}, nil
|
|
}
|
|
|
|
func ParseGroups(items []stackitem.Item) ([]*Group, error) {
|
|
var err error
|
|
res := make([]*Group, len(items))
|
|
|
|
for i := 0; i < len(items); i++ {
|
|
arr, ok := items[i].Value().([]stackitem.Item)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid group type")
|
|
}
|
|
res[i], err = ParseGroup(arr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func makeValidRes(item stackitem.Item) (*result.Invoke, error) {
|
|
return &result.Invoke{
|
|
Stack: []stackitem.Item{item},
|
|
State: vmstate.Halt.String(),
|
|
}, nil
|
|
}
|
|
|
|
func makeResFromAppExec(res *state.AppExecResult) (*result.Invoke, error) {
|
|
return &result.Invoke{
|
|
Stack: res.Stack,
|
|
State: res.VMState.String(),
|
|
}, nil
|
|
}
|