frostfs-contract/frostfsid/client/utils.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
}