forked from TrueCloudLab/frostfs-node
Evgenii Stratonikov
4239f1e817
We do not use `nep17` wrapper, because transfers of different tokens are possible in a single transaction. Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>
203 lines
5.5 KiB
Go
203 lines
5.5 KiB
Go
package morph
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"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 (c *initializeContext) transferFunds() error {
|
|
ok, err := c.transferFundsFinished()
|
|
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, consensusAccountName); err != nil {
|
|
return fmt.Errorf("can't send transfer transaction: %w", err)
|
|
}
|
|
|
|
return c.awaitTx()
|
|
}
|
|
|
|
func (c *initializeContext) transferFundsFinished() (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 == consensusAccountName {
|
|
h = c.ConsensusAcc.Contract.ScriptHash()
|
|
}
|
|
for _, w := range c.Wallets {
|
|
acc, err := 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 (c *initializeContext) transferGASToProxy() error {
|
|
proxyCs := c.getContract(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, committeeAccountName); err != nil {
|
|
return err
|
|
}
|
|
|
|
return c.awaitTx()
|
|
}
|
|
|
|
type transferTarget struct {
|
|
Token util.Uint160
|
|
Address util.Uint160
|
|
Amount int64
|
|
Data any
|
|
}
|
|
|
|
func createNEP17MultiTransferTx(c 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())
|
|
}
|