frostfs-node/cmd/frostfs-adm/internal/modules/morph/initialize.go

package morph

import (
	"errors"
	"fmt"
	"os"

	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/config"
	morphUtil "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/util"
	morphClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
	"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/rpcclient/actor"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/management"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

type cache struct {
	nnsCs    *state.Contract
	groupKey *keys.PublicKey
}

type initializeContext struct {
	morphUtil.ClientContext
	cache
	// CommitteeAcc is used for retrieving the committee address and the verification script.
	CommitteeAcc *wallet.Account
	// ConsensusAcc is used for retrieving the committee address and the verification script.
	ConsensusAcc *wallet.Account
	Wallets      []*wallet.Wallet
	// ContractWallet is a wallet for providing the contract group signature.
	ContractWallet *wallet.Wallet
	// Accounts contains simple signature accounts in the same order as in Wallets.
	Accounts     []*wallet.Account
	Contracts    map[string]*contractState
	Command      *cobra.Command
	ContractPath string
	ContractURL  string
}

func initializeSideChainCmd(cmd *cobra.Command, _ []string) error {
	initCtx, err := newInitializeContext(cmd, viper.GetViper())
	if err != nil {
		return fmt.Errorf("initialization error: %w", err)
	}
	defer initCtx.close()

	// 1. Transfer funds to committee accounts.
	cmd.Println("Stage 1: transfer GAS to alphabet nodes.")
	if err := initCtx.transferFunds(); err != nil {
		return err
	}

	cmd.Println("Stage 2: set notary and alphabet nodes in designate contract.")
	if err := initCtx.setNotaryAndAlphabetNodes(); err != nil {
		return err
	}

	// 3. Deploy NNS contract.
	cmd.Println("Stage 3: deploy NNS contract.")
	if err := initCtx.deployNNS(deployMethodName); err != nil {
		return err
	}

	// 4. Deploy NeoFS contracts.
	cmd.Println("Stage 4: deploy NeoFS contracts.")
	if err := initCtx.deployContracts(); err != nil {
		return err
	}

	cmd.Println("Stage 4.1: Transfer GAS to proxy contract.")
	if err := initCtx.transferGASToProxy(); err != nil {
		return err
	}

	cmd.Println("Stage 5: register candidates.")
	if err := initCtx.registerCandidates(); err != nil {
		return err
	}

	cmd.Println("Stage 6: transfer NEO to alphabet contracts.")
	if err := initCtx.transferNEOToAlphabetContracts(); err != nil {
		return err
	}

	cmd.Println("Stage 7: set addresses in NNS.")
	return initCtx.setNNS()
}

func (c *initializeContext) close() {
	if local, ok := c.Client.(*morphUtil.LocalClient); ok {
		err := local.Dump()
		if err != nil {
			c.Command.PrintErrf("Can't write dump: %v\n", err)
			os.Exit(1)
		}
	}
}

func newInitializeContext(cmd *cobra.Command, v *viper.Viper) (*initializeContext, error) {
	walletDir := config.ResolveHomePath(viper.GetString(alphabetWalletsFlag))
	wallets, err := morphUtil.GetAlphabetWallets(v, walletDir)
	if err != nil {
		return nil, err
	}

	needContracts := cmd.Name() == "update-contracts" || cmd.Name() == "init"

	var w *wallet.Wallet
	w, err = getWallet(cmd, v, needContracts, walletDir)
	if err != nil {
		return nil, err
	}

	c, err := createClient(cmd, v, wallets)
	if err != nil {
		return nil, err
	}

	committeeAcc, err := morphUtil.GetWalletAccount(wallets[0], committeeAccountName)
	if err != nil {
		return nil, fmt.Errorf("can't find committee account: %w", err)
	}

	consensusAcc, err := morphUtil.GetWalletAccount(wallets[0], morphUtil.ConsensusAccountName)
	if err != nil {
		return nil, fmt.Errorf("can't find consensus account: %w", err)
	}

	if err := validateInit(cmd); err != nil {
		return nil, err
	}

	ctrPath, err := getContractsPath(cmd, needContracts)
	if err != nil {
		return nil, err
	}

	var ctrURL string
	if needContracts {
		ctrURL, _ = cmd.Flags().GetString(contractsURLFlag)
	}

	if err := checkNotaryEnabled(c); err != nil {
		return nil, err
	}

	accounts, err := createWalletAccounts(wallets)
	if err != nil {
		return nil, err
	}

	cliCtx, err := morphUtil.DefaultClientContext(c, committeeAcc)
	if err != nil {
		return nil, fmt.Errorf("client context: %w", err)
	}

	initCtx := &initializeContext{
		ClientContext:  *cliCtx,
		ConsensusAcc:   consensusAcc,
		CommitteeAcc:   committeeAcc,
		ContractWallet: w,
		Wallets:        wallets,
		Accounts:       accounts,
		Command:        cmd,
		Contracts:      make(map[string]*contractState),
		ContractPath:   ctrPath,
		ContractURL:    ctrURL,
	}

	if needContracts {
		err := initCtx.readContracts(fullContractList)
		if err != nil {
			return nil, err
		}
	}

	return initCtx, nil
}

func validateInit(cmd *cobra.Command) error {
	if cmd.Name() != "init" {
		return nil
	}
	if viper.GetInt64(epochDurationInitFlag) <= 0 {
		return fmt.Errorf("epoch duration must be positive")
	}

	if viper.GetInt64(maxObjectSizeInitFlag) <= 0 {
		return fmt.Errorf("max object size must be positive")
	}

	return nil
}

func createClient(cmd *cobra.Command, v *viper.Viper, wallets []*wallet.Wallet) (morphUtil.Client, error) {
	var c morphUtil.Client
	var err error
	if ldf := cmd.Flags().Lookup(localDumpFlag); ldf != nil && ldf.Changed {
		if cmd.Flags().Changed(morphUtil.EndpointFlag) {
			return nil, fmt.Errorf("`%s` and `%s` flags are mutually exclusive", morphUtil.EndpointFlag, localDumpFlag)
		}
		c, err = morphUtil.NewLocalClient(cmd, v, wallets, ldf.Value.String())
	} else {
		c, err = morphUtil.GetN3Client(v)
	}
	if err != nil {
		return nil, fmt.Errorf("can't create N3 client: %w", err)
	}
	return c, nil
}

func getWallet(cmd *cobra.Command, v *viper.Viper, needContracts bool, walletDir string) (*wallet.Wallet, error) {
	if !needContracts {
		return nil, nil
	}
	return openContractWallet(v, cmd, walletDir)
}

func getContractsPath(cmd *cobra.Command, needContracts bool) (string, error) {
	if !needContracts {
		return "", nil
	}

	ctrPath, err := cmd.Flags().GetString(contractsInitFlag)
	if err != nil {
		return "", fmt.Errorf("invalid contracts path: %w", err)
	}
	return ctrPath, nil
}

func createWalletAccounts(wallets []*wallet.Wallet) ([]*wallet.Account, error) {
	accounts := make([]*wallet.Account, len(wallets))
	for i, w := range wallets {
		acc, err := morphUtil.GetWalletAccount(w, singleAccountName)
		if err != nil {
			return nil, fmt.Errorf("wallet %s is invalid (no single account): %w", w.Path(), err)
		}
		accounts[i] = acc
	}
	return accounts, nil
}

func (c *initializeContext) awaitTx() error {
	return c.ClientContext.AwaitTx(c.Command)
}

func (c *initializeContext) nnsContractState() (*state.Contract, error) {
	if c.nnsCs != nil {
		return c.nnsCs, nil
	}

	r := management.NewReader(c.ReadOnlyInvoker)
	cs, err := r.GetContractByID(1)
	if err != nil {
		return nil, err
	}

	c.nnsCs = cs
	return cs, nil
}

func (c *initializeContext) getSigner(tryGroup bool, acc *wallet.Account) transaction.Signer {
	if tryGroup && c.groupKey != nil {
		return transaction.Signer{
			Account:       acc.Contract.ScriptHash(),
			Scopes:        transaction.CustomGroups,
			AllowedGroups: keys.PublicKeys{c.groupKey},
		}
	}

	signer := transaction.Signer{
		Account: acc.Contract.ScriptHash(),
		Scopes:  transaction.Global, // Scope is important, as we have nested call to container contract.
	}

	if !tryGroup {
		return signer
	}

	nnsCs, err := c.nnsContractState()
	if err != nil {
		return signer
	}

	groupKey, err := nnsResolveKey(c.ReadOnlyInvoker, nnsCs.Hash, morphClient.NNSGroupKeyName)
	if err == nil {
		c.groupKey = groupKey

		signer.Scopes = transaction.CustomGroups
		signer.AllowedGroups = keys.PublicKeys{groupKey}
	}
	return signer
}

// sendCommitteeTx creates transaction from script, signs it by committee nodes and sends it to RPC.
// If tryGroup is false, global scope is used for the signer (useful when
// working with native contracts).
func (c *initializeContext) sendCommitteeTx(script []byte, tryGroup bool) error {
	return c.sendMultiTx(script, tryGroup, false)
}

// sendConsensusTx creates transaction from script, signs it by alphabet nodes and sends it to RPC.
// Not that because this is used only after the contracts were initialized and deployed,
// we always try to have a group scope.
func (c *initializeContext) sendConsensusTx(script []byte) error {
	return c.sendMultiTx(script, true, true)
}

func (c *initializeContext) sendMultiTx(script []byte, tryGroup bool, withConsensus bool) error {
	var act *actor.Actor
	var err error

	withConsensus = withConsensus && !c.ConsensusAcc.Contract.ScriptHash().Equals(c.CommitteeAcc.ScriptHash())
	if tryGroup {
		// Even for consensus signatures we need the committee to pay.
		signers := make([]actor.SignerAccount, 1, 2)
		signers[0] = actor.SignerAccount{
			Signer:  c.getSigner(tryGroup, c.CommitteeAcc),
			Account: c.CommitteeAcc,
		}
		if withConsensus {
			signers = append(signers, actor.SignerAccount{
				Signer:  c.getSigner(tryGroup, c.ConsensusAcc),
				Account: c.ConsensusAcc,
			})
		}
		act, err = actor.New(c.Client, signers)
	} else {
		if withConsensus {
			panic("BUG: should never happen")
		}
		act, err = c.CommitteeAct, nil
	}
	if err != nil {
		return fmt.Errorf("could not create actor: %w", err)
	}

	tx, err := act.MakeUnsignedRun(script, []transaction.Attribute{{Type: transaction.HighPriority}})
	if err != nil {
		return fmt.Errorf("could not perform test invocation: %w", err)
	}

	if err := c.multiSign(tx, committeeAccountName); err != nil {
		return err
	}
	if withConsensus {
		if err := c.multiSign(tx, morphUtil.ConsensusAccountName); err != nil {
			return err
		}
	}

	return c.SendTx(tx, c.Command, false)
}

func checkNotaryEnabled(c morphUtil.Client) error {
	ns, err := c.GetNativeContracts()
	if err != nil {
		return fmt.Errorf("can't get native contract hashes: %w", err)
	}

	notaryEnabled := false
	nativeHashes := make(map[string]util.Uint160, len(ns))
	for i := range ns {
		if ns[i].Manifest.Name == nativenames.Notary {
			notaryEnabled = true
		}
		nativeHashes[ns[i].Manifest.Name] = ns[i].Hash
	}
	if !notaryEnabled {
		return errors.New("notary contract must be enabled")
	}
	return nil
}