forked from TrueCloudLab/frostfs-node
144 lines
4 KiB
Go
144 lines
4 KiB
Go
package initialize
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
|
|
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"
|
|
"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 *morphUtil.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, constants.ConsensusAccountName); err != nil {
|
|
return fmt.Errorf("can't send transfer transaction: %w", err)
|
|
}
|
|
|
|
return c.AwaitTx()
|
|
}
|
|
|
|
func transferFundsFinished(c *morphUtil.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 transferGASToProxy(c *morphUtil.InitializeContext) error {
|
|
proxyCs := c.GetContract(constants.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, constants.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())
|
|
}
|