frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper/actor.go

package helper

import (
	"fmt"

	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/config"
	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
	"github.com/google/uuid"
	"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/neorpc/result"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/context"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

// LocalActor is a kludge, do not use it outside of the morph commands.
type LocalActor struct {
	neoActor   *actor.Actor
	accounts   []*wallet.Account
	Invoker    *invoker.Invoker
	rpcInvoker invoker.RPCInvoke
}

// NewLocalActor create LocalActor with accounts form provided wallets.
// In case of empty wallets provided created actor with dummy account only for read operation.
//
// If wallets are provided, the contract client will use accounts with accName name from these wallets.
// To determine which account name should be used in a contract client, refer to how the contract
// verifies the transaction signature.
func NewLocalActor(cmd *cobra.Command, c actor.RPCActor, accName string) (*LocalActor, error) {
	walletDir := config.ResolveHomePath(viper.GetString(commonflags.AlphabetWalletsFlag))
	var act *actor.Actor
	var accounts []*wallet.Account

	wallets, err := GetAlphabetWallets(viper.GetViper(), walletDir)
	commonCmd.ExitOnErr(cmd, "unable to get alphabet wallets: %w", err)

	for _, w := range wallets {
		acc, err := GetWalletAccount(w, accName)
		commonCmd.ExitOnErr(cmd, fmt.Sprintf("can't find %s account: %%w", accName), err)
		accounts = append(accounts, acc)
	}
	act, err = actor.New(c, []actor.SignerAccount{{
		Signer: transaction.Signer{
			Account: accounts[0].Contract.ScriptHash(),
			Scopes:  transaction.Global,
		},
		Account: accounts[0],
	}})
	if err != nil {
		return nil, err
	}
	return &LocalActor{
		neoActor:   act,
		accounts:   accounts,
		Invoker:    &act.Invoker,
		rpcInvoker: c,
	}, nil
}

func (a *LocalActor) SendCall(contract util.Uint160, method string, params ...any) (util.Uint256, uint32, error) {
	tx, err := a.neoActor.MakeCall(contract, method, params...)
	if err != nil {
		return util.Uint256{}, 0, err
	}
	err = a.resign(tx)
	if err != nil {
		return util.Uint256{}, 0, err
	}
	return a.neoActor.Send(tx)
}

func (a *LocalActor) SendRun(script []byte) (util.Uint256, uint32, error) {
	tx, err := a.neoActor.MakeRun(script)
	if err != nil {
		return util.Uint256{}, 0, err
	}
	err = a.resign(tx)
	if err != nil {
		return util.Uint256{}, 0, err
	}
	return a.neoActor.Send(tx)
}

// resign is used to sign tx with committee accounts.
// Inside the methods `MakeCall` and `SendRun` of the NeoGO's actor transaction is signing by committee account,
// because actor uses committee wallet.
// But it is not enough, need to sign with another committee accounts.
func (a *LocalActor) resign(tx *transaction.Transaction) error {
	if len(a.accounts[0].Contract.Parameters) > 1 {
		// Use parameter context to avoid dealing with signature order.
		network := a.neoActor.GetNetwork()
		pc := context.NewParameterContext("", network, tx)
		h := a.accounts[0].Contract.ScriptHash()
		for _, acc := range a.accounts {
			priv := acc.PrivateKey()
			sign := priv.SignHashable(uint32(network), tx)
			if err := pc.AddSignature(h, acc.Contract, priv.PublicKey(), sign); err != nil {
				return fmt.Errorf("can't add signature: %w", err)
			}
			if len(pc.Items[h].Signatures) == len(acc.Contract.Parameters) {
				break
			}
		}

		w, err := pc.GetWitness(h)
		if err != nil {
			return fmt.Errorf("incomplete signature: %w", err)
		}
		tx.Scripts[0] = *w
	}
	return nil
}

func (a *LocalActor) Wait(h util.Uint256, vub uint32, err error) (*state.AppExecResult, error) {
	return a.neoActor.Wait(h, vub, err)
}

func (a *LocalActor) Sender() util.Uint160 {
	return a.neoActor.Sender()
}

func (a *LocalActor) Call(contract util.Uint160, operation string, params ...any) (*result.Invoke, error) {
	return a.neoActor.Call(contract, operation, params...)
}

func (a *LocalActor) CallAndExpandIterator(_ util.Uint160, _ string, _ int, _ ...any) (*result.Invoke, error) {
	panic("unimplemented")
}

func (a *LocalActor) TerminateSession(_ uuid.UUID) error {
	panic("unimplemented")
}

func (a *LocalActor) TraverseIterator(sessionID uuid.UUID, iterator *result.Iterator, num int) ([]stackitem.Item, error) {
	return a.neoActor.TraverseIterator(sessionID, iterator, num)
}

func (a *LocalActor) MakeRun(_ []byte) (*transaction.Transaction, error) {
	panic("unimplemented")
}

func (a *LocalActor) MakeUnsignedCall(_ util.Uint160, _ string, _ []transaction.Attribute, _ ...any) (*transaction.Transaction, error) {
	panic("unimplemented")
}

func (a *LocalActor) MakeUnsignedRun(_ []byte, _ []transaction.Attribute) (*transaction.Transaction, error) {
	panic("unimplemented")
}

func (a *LocalActor) MakeCall(_ util.Uint160, _ string, _ ...any) (*transaction.Transaction, error) {
	panic("unimplemented")
}

func (a *LocalActor) GetRPCInvoker() invoker.RPCInvoke {
	return a.rpcInvoker
}