frostfs-contract/frostfsid/client/client.go

package client

import (
	"fmt"

	"git.frostfs.info/TrueCloudLab/frostfs-contract/commonclient"
	"github.com/nspcc-dev/neo-go/pkg/core/state"
	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/notary"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/waiter"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
)

type (
	Client struct {
		act      *actor.Actor
		waiter   waiter.Waiter
		contract util.Uint160
	}

	Options struct {
		ProxyContract util.Uint160
		Waiter        commonclient.WaiterOptions
	}
)

type (
	Subject struct {
		PrimaryKey     *keys.PublicKey
		AdditionalKeys keys.PublicKeys
		Namespace      string
		Name           string
		KV             map[string]string
	}

	SubjectExtended struct {
		PrimaryKey     *keys.PublicKey
		AdditionalKeys keys.PublicKeys
		Namespace      string
		Name           string
		KV             map[string]string
		Groups         []*Group
	}

	Namespace struct {
		Name string
	}

	NamespaceExtended struct {
		Name          string
		GroupsCount   int64
		SubjectsCount int64
	}

	Group struct {
		ID        int64
		Name      string
		Namespace string
		KV        map[string]string
	}

	GroupExtended struct {
		ID            int64
		Name          string
		Namespace     string
		KV            map[string]string
		SubjectsCount int64
	}
)

const (
	IAMPathKey         = "iam-path"
	IAMARNKey          = "iam-arn"
	IAMCreatedTimeKey  = "ctime"
	IAMModifiedTimeKey = "mtime"
)

const iteratorBatchSize = 100

const (
	getAdminMethod   = "getAdmin"
	setAdminMethod   = "setAdmin"
	clearAdminMethod = "clearAdmin"

	versionMethod = "version"

	createSubjectMethod       = "createSubject"
	getSubjectMethod          = "getSubject"
	getSubjectExtendedMethod  = "getSubjectExtended"
	getSubjectKVMethod        = "getSubjectKV"
	listSubjectsMethod        = "listSubjects"
	addSubjectKeyMethod       = "addSubjectKey"
	removeSubjectKeyMethod    = "removeSubjectKey"
	getSubjectByKeyMethod     = "getSubjectByKey"
	getSubjectByNameMethod    = "getSubjectByName"
	getSubjectKeyByNameMethod = "getSubjectKeyByName"
	setSubjectKVMethod        = "setSubjectKV"
	setSubjectNameMethod      = "setSubjectName"
	deleteSubjectKVMethod     = "deleteSubjectKV"
	deleteSubjectMethod       = "deleteSubject"

	createNamespaceMethod       = "createNamespace"
	getNamespaceMethod          = "getNamespace"
	getNamespaceExtendedMethod  = "getNamespaceExtended"
	listNamespacesMethod        = "listNamespaces"
	listNamespaceSubjectsMethod = "listNamespaceSubjects"

	createGroupMethod            = "createGroup"
	getGroupMethod               = "getGroup"
	getGroupExtendedMethod       = "getGroupExtended"
	getGroupIDByNameMethod       = "getGroupIDByName"
	getGroupByNameMethod         = "getGroupByName"
	setGroupNameMethod           = "setGroupName"
	setGroupKVMethod             = "setGroupKV"
	deleteGroupKVMethod          = "deleteGroupKV"
	listGroupsMethod             = "listGroups"
	addSubjectToGroupMethod      = "addSubjectToGroup"
	removeSubjectFromGroupMethod = "removeSubjectFromGroup"
	listGroupSubjectsMethod      = "listGroupSubjects"
	deleteGroupMethod            = "deleteGroup"
)

// New creates a new Client. Options can be empty.
func New(ra actor.RPCActor, acc *wallet.Account, contract util.Uint160, opt Options) (*Client, error) {
	signers := []actor.SignerAccount{{
		Signer: transaction.Signer{
			Account: acc.Contract.ScriptHash(),
			Scopes:  transaction.CalledByEntry,
		},
		Account: acc,
	}}

	if !opt.ProxyContract.Equals(util.Uint160{}) {
		signers = append([]actor.SignerAccount{{
			Signer: transaction.Signer{
				Account:          opt.ProxyContract,
				Scopes:           transaction.CustomContracts,
				AllowedContracts: []util.Uint160{contract},
			},
			Account: notary.FakeContractAccount(opt.ProxyContract),
		}}, signers...)
	}

	act, err := actor.New(ra, signers)
	if err != nil {
		return nil, fmt.Errorf("init actor: %w", err)
	}
	wtr := commonclient.NewWaiter(act, opt.Waiter)

	return &Client{
		act:      act,
		waiter:   wtr,
		contract: contract,
	}, nil
}

// NewSimple creates a new Client using existing actor.Actor and default waiter options.
func NewSimple(act *actor.Actor, contract util.Uint160) *Client {
	wtr := commonclient.NewWaiter(act, commonclient.WaiterOptions{})
	return &Client{
		act:      act,
		waiter:   wtr,
		contract: contract,
	}
}

// StartTx inits transaction.
func (c Client) StartTx() *commonclient.Transaction {
	return commonclient.NewTransaction(c.contract)
}

// SendTx sends provided transaction to blockchain.
func (c Client) SendTx(txn *commonclient.Transaction) (tx util.Uint256, vub uint32, err error) {
	txBytes, err := txn.Bytes()
	if err != nil {
		return util.Uint256{}, 0, err
	}

	return c.act.SendRun(txBytes)
}

// Version returns version of contract.
func (c Client) Version() (int64, error) {
	return unwrap.Int64(c.act.Call(c.contract, versionMethod))
}

// SetAdmin sets address that can perform write operations on contract.
// Must be invoked by committee.
func (c Client) SetAdmin(owner util.Uint160) (tx util.Uint256, vub uint32, err error) {
	method, args := c.SetAdminCall(owner)
	return c.act.SendCall(c.contract, method, args...)
}

// SetAdminCall provides args for SetAdmin to use in commonclient.Transaction.
func (c Client) SetAdminCall(owner util.Uint160) (method string, args []any) {
	return setAdminMethod, []any{owner}
}

// ClearAdmin removes address that can perform write operations on contract.
// Must be invoked by committee.
func (c Client) ClearAdmin() (tx util.Uint256, vub uint32, err error) {
	method, args := c.ClearAdminCall()
	return c.act.SendCall(c.contract, method, args...)
}

// ClearAdminCall provides args for ClearAdmin to use in commonclient.Transaction.
func (c Client) ClearAdminCall() (method string, args []any) {
	return clearAdminMethod, nil
}

// GetAdmin returns address that can perform write operations on contract.
// Second return values is true iff admin is set.
func (c Client) GetAdmin() (util.Uint160, bool, error) {
	item, err := unwrap.Item(c.act.Call(c.contract, getAdminMethod))
	if err != nil {
		return util.Uint160{}, false, err
	}
	if item.Value() == nil {
		return util.Uint160{}, false, nil
	}
	bs, err := item.TryBytes()
	if err != nil {
		return util.Uint160{}, true, err
	}
	u, err := util.Uint160DecodeBytesBE(bs)
	return u, true, err
}

// CreateSubject creates new subject using public key and namespace.
// Must be invoked by contract owner.
func (c Client) CreateSubject(ns string, key *keys.PublicKey) (tx util.Uint256, vub uint32, err error) {
	method, args := c.CreateSubjectCall(ns, key)
	return c.act.SendCall(c.contract, method, args...)
}

// CreateSubjectCall provides args for CreateSubject to use in commonclient.Transaction.
func (c Client) CreateSubjectCall(ns string, key *keys.PublicKey) (method string, args []any) {
	return createSubjectMethod, []any{ns, key.Bytes()}
}

// GetSubject gets subject by address.
func (c Client) GetSubject(addr util.Uint160) (*Subject, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getSubjectMethod, addr))
	if err != nil {
		return nil, err
	}

	return ParseSubject(items)
}

// GetSubjectExtended gets extended subject by address.
func (c Client) GetSubjectExtended(addr util.Uint160) (*SubjectExtended, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getSubjectExtendedMethod, addr))
	if err != nil {
		return nil, err
	}

	return ParseSubjectExtended(items)
}

// GetSubjectKV invokes `getSubjectKV` method of contract.
func (c Client) GetSubjectKV(addr util.Uint160, name string) (string, error) {
	return unwrap.UTF8String(c.act.Call(c.contract, getSubjectKVMethod, addr, name))
}

// ListSubjects gets all subjects.
func (c Client) ListSubjects() ([]util.Uint160, error) {
	return UnwrapArrayOfUint160(commonclient.ReadIteratorItems(c.act, iteratorBatchSize, c.contract, listSubjectsMethod))
}

// ListFullSubjects gets list of subjects.
func (c Client) ListFullSubjects(hashes []util.Uint160) ([]*Subject, error) {
	w := io.NewBufBinWriter()

	for _, hash := range hashes {
		emit.AppCall(w.BinWriter, c.contract, getSubjectMethod, callflag.All, hash)
	}

	invoker, err := c.act.Run(w.Bytes())
	if err != nil {
		return nil, err
	}
	if invoker.State != vmstate.Halt.String() {
		return nil, fmt.Errorf("invocation failed: %s", invoker.FaultException)
	}
	subjects := make([]*Subject, 0, len(invoker.Stack))

	for _, item := range invoker.Stack {
		arr, ok := item.Value().([]stackitem.Item)
		if !ok {
			return nil, fmt.Errorf("invalid subject")
		}

		subject, err := ParseSubject(arr)
		if err != nil {
			return nil, err
		}
		subjects = append(subjects, subject)
	}

	return subjects, nil
}

// AddSubjectKey adds extra public key to subject.
// Must be invoked by contract owner.
func (c Client) AddSubjectKey(addr util.Uint160, key *keys.PublicKey) (tx util.Uint256, vub uint32, err error) {
	method, args := c.AddSubjectKeyCall(addr, key)
	return c.act.SendCall(c.contract, method, args...)
}

// AddSubjectKeyCall provides args for AddSubjectKey to use in commonclient.Transaction.
func (c Client) AddSubjectKeyCall(addr util.Uint160, key *keys.PublicKey) (method string, args []any) {
	return addSubjectKeyMethod, []any{addr, key.Bytes()}
}

// RemoveSubjectKey removes extra public key from subject.
// Must be invoked by contract owner.
func (c Client) RemoveSubjectKey(addr util.Uint160, key *keys.PublicKey) (tx util.Uint256, vub uint32, err error) {
	method, args := c.RemoveSubjectKeyCall(addr, key)
	return c.act.SendCall(c.contract, method, args...)
}

// RemoveSubjectKeyCall provides args for RemoveSubjectKey to use in commonclient.Transaction.
func (c Client) RemoveSubjectKeyCall(addr util.Uint160, key *keys.PublicKey) (method string, args []any) {
	return removeSubjectKeyMethod, []any{addr, key.Bytes()}
}

// SetSubjectKV updates subject kv map.
// Must be invoked by contract owner.
// You can use some predefined key constants: IAMPathKey, IAMARNKey, IAMCreatedTimeKey, IAMModifiedTimeKey.
func (c Client) SetSubjectKV(addr util.Uint160, key, val string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.SetSubjectKVCall(addr, key, val)
	return c.act.SendCall(c.contract, method, args...)
}

// SetSubjectKVCall provides args for SetSubjectKV to use in commonclient.Transaction.
func (c Client) SetSubjectKVCall(addr util.Uint160, key, val string) (method string, args []any) {
	return setSubjectKVMethod, []any{addr, key, val}
}

// SetSubjectName updates subject name.
// Must be invoked by contract owner.
func (c Client) SetSubjectName(addr util.Uint160, name string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.SetSubjectNameCall(addr, name)
	return c.act.SendCall(c.contract, method, args...)
}

// SetSubjectNameCall provides args for SetSubjectName to use in commonclient.Transaction.
func (c Client) SetSubjectNameCall(addr util.Uint160, name string) (method string, args []any) {
	return setSubjectNameMethod, []any{addr, name}
}

// DeleteSubjectKV removes subject kv map.
// Must be invoked by contract owner.
func (c Client) DeleteSubjectKV(addr util.Uint160, key string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.DeleteSubjectKVCall(addr, key)
	return c.act.SendCall(c.contract, method, args...)
}

// DeleteSubjectKVCall provides args for DeleteSubjectKV to use in commonclient.Transaction.
func (c Client) DeleteSubjectKVCall(addr util.Uint160, key string) (method string, args []any) {
	return deleteSubjectKVMethod, []any{addr, key}
}

// GetSubjectByKey gets subject by its primary or additional keys.
func (c Client) GetSubjectByKey(key *keys.PublicKey) (*Subject, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getSubjectByKeyMethod, key.Bytes()))
	if err != nil {
		return nil, err
	}

	return ParseSubject(items)
}

// GetSubjectByName gets subject by its name (namespace scope).
func (c Client) GetSubjectByName(namespace, subjectName string) (*Subject, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getSubjectByNameMethod, namespace, subjectName))
	if err != nil {
		return nil, err
	}

	return ParseSubject(items)
}

// GetSubjectKeyByName gets subject public key by its name (namespace scope).
func (c Client) GetSubjectKeyByName(namespace, subjectName string) (*keys.PublicKey, error) {
	return unwrap.PublicKey(c.act.Call(c.contract, getSubjectKeyByNameMethod, namespace, subjectName))
}

// DeleteSubject delete subject and removes it from related namespaces and groups.
// Must be invoked by contract owner.
func (c Client) DeleteSubject(addr util.Uint160) (tx util.Uint256, vub uint32, err error) {
	method, args := c.DeleteSubjectCall(addr)
	return c.act.SendCall(c.contract, method, args...)
}

// DeleteSubjectCall provides args for DeleteSubject to use in commonclient.Transaction.
func (c Client) DeleteSubjectCall(addr util.Uint160) (method string, args []any) {
	return deleteSubjectMethod, []any{addr}
}

// CreateNamespace create new namespace.
// Must be invoked by contract owner.
func (c Client) CreateNamespace(namespace string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.CreateNamespaceCall(namespace)
	return c.act.SendCall(c.contract, method, args...)
}

// CreateNamespaceCall provides args for CreateNamespace to use in commonclient.Transaction.
func (c Client) CreateNamespaceCall(namespace string) (method string, args []any) {
	return createNamespaceMethod, []any{namespace}
}

// GetNamespace gets namespace.
func (c Client) GetNamespace(namespace string) (*Namespace, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getNamespaceMethod, namespace))
	if err != nil {
		return nil, err
	}

	return ParseNamespace(items)
}

// GetNamespaceExtended gets extended namespace.
func (c Client) GetNamespaceExtended(namespace string) (*NamespaceExtended, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getNamespaceExtendedMethod, namespace))
	if err != nil {
		return nil, err
	}

	return ParseNamespaceExtended(items)
}

// ListNamespaces gets all namespaces.
func (c Client) ListNamespaces() ([]*Namespace, error) {
	items, err := commonclient.ReadIteratorItems(c.act, iteratorBatchSize, c.contract, listNamespacesMethod)
	if err != nil {
		return nil, err
	}

	return ParseNamespaces(items)
}

// ListNamespaceSubjects gets all subjects from namespace.
func (c Client) ListNamespaceSubjects(namespace string) ([]util.Uint160, error) {
	return UnwrapArrayOfUint160(commonclient.ReadIteratorItems(c.act, iteratorBatchSize, c.contract, listNamespaceSubjectsMethod, namespace))
}

// CreateGroup creates a new group in specific namespace.
// Must be invoked by contract owner.
func (c Client) CreateGroup(namespace, group string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.CreateGroupCall(namespace, group)
	return c.act.SendCall(c.contract, method, args...)
}

// CreateGroupCall provides args for CreateGroup to use in commonclient.Transaction.
func (c Client) CreateGroupCall(namespace, group string) (method string, args []any) {
	return createGroupMethod, []any{namespace, group}
}

// GetGroup gets group.
func (c Client) GetGroup(namespace string, groupID int64) (*Group, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getGroupMethod, namespace, groupID))
	if err != nil {
		return nil, err
	}

	return ParseGroup(items)
}

// GetGroupExtended gets extended group.
func (c Client) GetGroupExtended(namespace string, groupID int64) (*GroupExtended, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getGroupExtendedMethod, namespace, groupID))
	if err != nil {
		return nil, err
	}

	return ParseGroupExtended(items)
}

// SetGroupName updates subject name.
// Must be invoked by contract owner.
func (c Client) SetGroupName(namespace string, groupID int64, name string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.SetGroupNameCall(namespace, groupID, name)
	return c.act.SendCall(c.contract, method, args...)
}

// SetGroupNameCall provides args for SetGroupName to use in commonclient.Transaction.
func (c Client) SetGroupNameCall(namespace string, groupID int64, name string) (method string, args []any) {
	return setGroupNameMethod, []any{namespace, groupID, name}
}

// SetGroupKV updates group kv map.
// Must be invoked by contract owner.
// You can use some predefined key constants: IAMPathKey, IAMARNKey, IAMCreatedTimeKey, IAMModifiedTimeKey.
func (c Client) SetGroupKV(namespace string, groupID int64, key, val string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.SetGroupKVCall(namespace, groupID, key, val)
	return c.act.SendCall(c.contract, method, args...)
}

// SetGroupKVCall provides args for SetGroupKV to use in commonclient.Transaction.
func (c Client) SetGroupKVCall(namespace string, groupID int64, key, val string) (method string, args []any) {
	return setGroupKVMethod, []any{namespace, groupID, key, val}
}

// DeleteGroupKV removes group kv map.
// Must be invoked by contract owner.
func (c Client) DeleteGroupKV(namespace string, groupID int64, key string) (tx util.Uint256, vub uint32, err error) {
	method, args := c.DeleteGroupKVCall(namespace, groupID, key)
	return c.act.SendCall(c.contract, method, args...)
}

// DeleteGroupKVCall provides args for DeleteGroupKV to use in commonclient.Transaction.
func (c Client) DeleteGroupKVCall(namespace string, groupID int64, key string) (method string, args []any) {
	return deleteGroupKVMethod, []any{namespace, groupID, key}
}

// GetGroupIDByName gets group id its name (namespace scope).
func (c Client) GetGroupIDByName(namespace, groupName string) (int64, error) {
	return unwrap.Int64(c.act.Call(c.contract, getGroupIDByNameMethod, namespace, groupName))
}

// GetGroupByName gets group by its name (namespace scope).
func (c Client) GetGroupByName(namespace, groupName string) (*Group, error) {
	items, err := unwrap.Array(c.act.Call(c.contract, getGroupByNameMethod, namespace, groupName))
	if err != nil {
		return nil, err
	}

	return ParseGroup(items)
}

// ListGroups gets all groups in specific namespace.
func (c Client) ListGroups(namespace string) ([]*Group, error) {
	items, err := commonclient.ReadIteratorItems(c.act, iteratorBatchSize, c.contract, listGroupsMethod, namespace)
	if err != nil {
		return nil, err
	}

	return ParseGroups(items)
}

// AddSubjectToGroup adds a new subject to group.
// Must be invoked by contract owner.
func (c Client) AddSubjectToGroup(addr util.Uint160, groupID int64) (tx util.Uint256, vub uint32, err error) {
	method, args := c.AddSubjectToGroupCall(addr, groupID)
	return c.act.SendCall(c.contract, method, args...)
}

// AddSubjectToGroupCall provides args for AddSubjectToGroup to use in commonclient.Transaction.
func (c Client) AddSubjectToGroupCall(addr util.Uint160, groupID int64) (method string, args []any) {
	return addSubjectToGroupMethod, []any{addr, groupID}
}

// RemoveSubjectFromGroup removes subject from group.
// Must be invoked by contract owner.
func (c Client) RemoveSubjectFromGroup(addr util.Uint160, groupID int64) (tx util.Uint256, vub uint32, err error) {
	method, args := c.RemoveSubjectFromGroupCall(addr, groupID)
	return c.act.SendCall(c.contract, method, args...)
}

// RemoveSubjectFromGroupCall provides args for RemoveSubjectFromGroup to use in commonclient.Transaction.
func (c Client) RemoveSubjectFromGroupCall(addr util.Uint160, groupID int64) (method string, args []any) {
	return removeSubjectFromGroupMethod, []any{addr, groupID}
}

// ListGroupSubjects gets all subjects in specific group.
func (c Client) ListGroupSubjects(namespace string, groupID int64) ([]util.Uint160, error) {
	return UnwrapArrayOfUint160(commonclient.ReadIteratorItems(c.act, iteratorBatchSize, c.contract, listGroupSubjectsMethod, namespace, groupID))
}

// DeleteGroup deletes group.
// Must be invoked by contract owner.
func (c Client) DeleteGroup(namespace string, groupID int64) (tx util.Uint256, vub uint32, err error) {
	method, args := c.DeleteGroupCall(namespace, groupID)
	return c.act.SendCall(c.contract, method, args...)
}

// DeleteGroupCall provides args for DeleteGroup to use in commonclient.Transaction.
func (c Client) DeleteGroupCall(namespace string, groupID int64) (method string, args []any) {
	return deleteGroupMethod, []any{namespace, groupID}
}

// ListNonEmptyNamespaces gets namespaces that contain at least one subject.
func (c Client) ListNonEmptyNamespaces() ([]string, error) {
	namespaces, err := c.ListNamespaces()
	if err != nil {
		return nil, err
	}

	var res []string

	for _, namespace := range namespaces {
		nsExt, err := c.GetNamespaceExtended(namespace.Name)
		if err != nil {
			return nil, err
		}

		if nsExt.SubjectsCount > 0 {
			res = append(res, nsExt.Name)
		}
	}

	return res, nil
}

// Wait waits until the specified transaction is accepted to the chain.
func (c Client) Wait(tx util.Uint256, vub uint32, err error) (*state.AppExecResult, error) {
	return c.Waiter().Wait(tx, vub, err)
}

// Waiter returns underlying waiter.Waiter.
func (c Client) Waiter() waiter.Waiter {
	return c.waiter
}

// ParseGroupID fetch groupID from stack after creating group method invocation.
func (c Client) ParseGroupID(res *state.AppExecResult, err error) (int64, error) {
	if err != nil {
		return 0, err
	}

	return unwrap.Int64(makeResFromAppExec(res))
}

// ListNonEmptyGroups gets groups that contain at least one subject.
func (c Client) ListNonEmptyGroups(namespace string) ([]string, error) {
	groups, err := c.ListGroups(namespace)
	if err != nil {
		return nil, err
	}

	var res []string

	for _, group := range groups {
		groupExt, err := c.GetGroupExtended(namespace, group.ID)
		if err != nil {
			return nil, err
		}

		if groupExt.SubjectsCount > 0 {
			res = append(res, groupExt.Name)
		}
	}

	return res, nil
}