package morph import ( "fmt" "math/big" morphUtil "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/util" "github.com/nspcc-dev/neo-go/pkg/core/native" "github.com/nspcc-dev/neo-go/pkg/core/transaction" "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/gas" "github.com/nspcc-dev/neo-go/pkg/rpcclient/neo" "github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17" "github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag" scContext "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/emit" "github.com/nspcc-dev/neo-go/pkg/vm/opcode" "github.com/nspcc-dev/neo-go/pkg/wallet" ) const ( gasInitialTotalSupply = 30000000 * native.GASFactor // initialAlphabetGASAmount represents the amount of GAS given to each alphabet node. initialAlphabetGASAmount = 10_000 * native.GASFactor // initialProxyGASAmount represents the amount of GAS given to a proxy contract. initialProxyGASAmount = 50_000 * native.GASFactor ) func transferFunds(c *InitializeContext) error { ok, err := transferFundsFinished(c) if ok || err != nil { if err == nil { c.Command.Println("Stage 1: already performed.") } return err } var transfers []transferTarget for _, acc := range c.Accounts { to := acc.Contract.ScriptHash() transfers = append(transfers, transferTarget{ Token: gas.Hash, Address: to, Amount: initialAlphabetGASAmount, }, ) } // It is convenient to have all funds at the committee account. transfers = append(transfers, transferTarget{ Token: gas.Hash, Address: c.CommitteeAcc.Contract.ScriptHash(), Amount: (gasInitialTotalSupply - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2, }, transferTarget{ Token: neo.Hash, Address: c.CommitteeAcc.Contract.ScriptHash(), Amount: native.NEOTotalSupply, }, ) tx, err := createNEP17MultiTransferTx(c.Client, c.ConsensusAcc, transfers) if err != nil { return fmt.Errorf("can't create transfer transaction: %w", err) } if err := c.MultiSignAndSend(tx, morphUtil.ConsensusAccountName); err != nil { return fmt.Errorf("can't send transfer transaction: %w", err) } return c.AwaitTx() } func transferFundsFinished(c *InitializeContext) (bool, error) { acc := c.Accounts[0] r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash) res, err := r.BalanceOf(acc.Contract.ScriptHash()) return res.Cmp(big.NewInt(initialAlphabetGASAmount/2)) == 1, err } func (c *InitializeContext) MultiSignAndSend(tx *transaction.Transaction, accType string) error { if err := c.MultiSign(tx, accType); err != nil { return err } return c.SendTx(tx, c.Command, false) } func (c *InitializeContext) MultiSign(tx *transaction.Transaction, accType string) error { version, err := c.Client.GetVersion() if err != nil { // error appears only if client // has not been initialized panic(err) } network := version.Protocol.Network // Use parameter context to avoid dealing with signature order. pc := scContext.NewParameterContext("", network, tx) h := c.CommitteeAcc.Contract.ScriptHash() if accType == morphUtil.ConsensusAccountName { h = c.ConsensusAcc.Contract.ScriptHash() } for _, w := range c.Wallets { acc, err := morphUtil.GetWalletAccount(w, accType) if err != nil { return fmt.Errorf("can't find %s wallet account: %w", accType, err) } 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) } for i := range tx.Signers { if tx.Signers[i].Account == h { if i < len(tx.Scripts) { tx.Scripts[i] = *w } else if i == len(tx.Scripts) { tx.Scripts = append(tx.Scripts, *w) } else { panic("BUG: invalid signing order") } return nil } } return fmt.Errorf("%s account was not found among transaction signers", accType) } func transferGASToProxy(c *InitializeContext) error { proxyCs := c.GetContract(morphUtil.ProxyContract) r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash) bal, err := r.BalanceOf(proxyCs.Hash) if err != nil || bal.Sign() > 0 { return err } tx, err := createNEP17MultiTransferTx(c.Client, c.CommitteeAcc, []transferTarget{{ Token: gas.Hash, Address: proxyCs.Hash, Amount: initialProxyGASAmount, }}) if err != nil { return err } if err := c.MultiSignAndSend(tx, morphUtil.CommitteeAccountName); err != nil { return err } return c.AwaitTx() } type transferTarget struct { Token util.Uint160 Address util.Uint160 Amount int64 Data any } func createNEP17MultiTransferTx(c morphUtil.Client, acc *wallet.Account, recipients []transferTarget) (*transaction.Transaction, error) { from := acc.Contract.ScriptHash() w := io.NewBufBinWriter() for i := range recipients { emit.AppCall(w.BinWriter, recipients[i].Token, "transfer", callflag.All, from, recipients[i].Address, recipients[i].Amount, recipients[i].Data) emit.Opcodes(w.BinWriter, opcode.ASSERT) } if w.Err != nil { return nil, fmt.Errorf("failed to create transfer script: %w", w.Err) } signers := []actor.SignerAccount{{ Signer: transaction.Signer{ Account: acc.Contract.ScriptHash(), Scopes: transaction.CalledByEntry, }, Account: acc, }} act, err := actor.New(c, signers) if err != nil { return nil, fmt.Errorf("can't create actor: %w", err) } return act.MakeRun(w.Bytes()) }