package tests import ( "path" "testing" "github.com/nspcc-dev/neo-go/pkg/core/native/nativenames" "github.com/nspcc-dev/neo-go/pkg/core/native/noderoles" "github.com/nspcc-dev/neo-go/pkg/neotest" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/nspcc-dev/neo-go/pkg/vm" "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" "github.com/nspcc-dev/neo-go/pkg/wallet" "github.com/nspcc-dev/neofs-contract/common" "github.com/nspcc-dev/neofs-contract/container" "github.com/stretchr/testify/require" ) const alphabetPath = "../alphabet" func deployAlphabetContract(t *testing.T, e *neotest.Executor, addrNetmap, addrProxy util.Uint160, name string, index, total int64) util.Uint160 { c := neotest.CompileFile(t, e.CommitteeHash, alphabetPath, path.Join(alphabetPath, "config.yml")) args := make([]interface{}, 6) args[0] = false args[1] = addrNetmap args[2] = addrProxy args[3] = name args[4] = index args[5] = total e.DeployContract(t, c, args) return c.Hash } func newAlphabetInvoker(t *testing.T) (*neotest.Executor, *neotest.ContractInvoker) { e := newExecutor(t) ctrNNS := neotest.CompileFile(t, e.CommitteeHash, nnsPath, path.Join(nnsPath, "config.yml")) ctrNetmap := neotest.CompileFile(t, e.CommitteeHash, netmapPath, path.Join(netmapPath, "config.yml")) ctrBalance := neotest.CompileFile(t, e.CommitteeHash, balancePath, path.Join(balancePath, "config.yml")) ctrContainer := neotest.CompileFile(t, e.CommitteeHash, containerPath, path.Join(containerPath, "config.yml")) ctrProxy := neotest.CompileFile(t, e.CommitteeHash, proxyPath, path.Join(proxyPath, "config.yml")) e.DeployContract(t, ctrNNS, nil) deployNetmapContract(t, e, ctrBalance.Hash, ctrContainer.Hash, container.RegistrationFeeKey, int64(containerFee), container.AliasFeeKey, int64(containerAliasFee)) deployBalanceContract(t, e, ctrNetmap.Hash, ctrContainer.Hash) deployContainerContract(t, e, ctrNetmap.Hash, ctrBalance.Hash, ctrNNS.Hash) deployProxyContract(t, e, ctrNetmap.Hash) hash := deployAlphabetContract(t, e, ctrNetmap.Hash, ctrProxy.Hash, "Az", 0, 1) alphabet := getAlphabetAcc(t, e) setAlphabetRole(t, e, alphabet.PrivateKey().PublicKey().Bytes()) return e, e.CommitteeInvoker(hash) } func TestEmit(t *testing.T) { _, c := newAlphabetInvoker(t) const method = "emit" alphabet := getAlphabetAcc(t, c.Executor) cCommittee := c.WithSigners(neotest.NewSingleSigner(alphabet)) cCommittee.InvokeFail(t, "no gas to emit", method) transferNeoToContract(t, c) cCommittee.Invoke(t, stackitem.Null{}, method) notAlphabet := c.NewAccount(t) cNotAlphabet := c.WithSigners(notAlphabet) cNotAlphabet.InvokeFail(t, "invalid invoker", method) } func TestVote(t *testing.T) { e, c := newAlphabetInvoker(t) const method = "vote" newAlphabet := c.NewAccount(t) newAlphabetPub, ok := vm.ParseSignatureContract(newAlphabet.Script()) require.True(t, ok) cNewAlphabet := c.WithSigners(newAlphabet) cNewAlphabet.InvokeFail(t, common.ErrAlphabetWitnessFailed, method, int64(0), []interface{}{newAlphabetPub}) c.InvokeFail(t, "invalid epoch", method, int64(1), []interface{}{newAlphabetPub}) setAlphabetRole(t, e, newAlphabetPub) transferNeoToContract(t, c) neoSH := e.NativeHash(t, nativenames.Neo) neoInvoker := c.CommitteeInvoker(neoSH) gasSH := e.NativeHash(t, nativenames.Gas) gasInvoker := e.CommitteeInvoker(gasSH) res, err := gasInvoker.TestInvoke(t, "balanceOf", gasInvoker.Committee.ScriptHash()) require.NoError(t, err) // transfer some GAS to the new alphabet node gasInvoker.Invoke(t, stackitem.NewBool(true), "transfer", gasInvoker.Committee.ScriptHash(), newAlphabet.ScriptHash(), res.Top().BigInt().Int64()/2, nil) newInvoker := neoInvoker.WithSigners(newAlphabet) newInvoker.Invoke(t, stackitem.NewBool(true), "registerCandidate", newAlphabetPub) c.Invoke(t, stackitem.Null{}, method, int64(0), []interface{}{newAlphabetPub}) // wait one block util // new committee is accepted c.AddNewBlock(t) cNewAlphabet.Invoke(t, stackitem.Null{}, "emit") c.InvokeFail(t, "invalid invoker", "emit") } func transferNeoToContract(t *testing.T, invoker *neotest.ContractInvoker) { neoSH, err := invoker.Chain.GetNativeContractScriptHash(nativenames.Neo) require.NoError(t, err) neoInvoker := invoker.CommitteeInvoker(neoSH) res, err := neoInvoker.TestInvoke(t, "balanceOf", neoInvoker.Committee.ScriptHash()) require.NoError(t, err) // transfer all NEO to alphabet contract neoInvoker.Invoke(t, stackitem.NewBool(true), "transfer", neoInvoker.Committee.ScriptHash(), invoker.Hash, res.Top().BigInt().Int64(), nil) } func setAlphabetRole(t *testing.T, e *neotest.Executor, new []byte) { designSH, err := e.Chain.GetNativeContractScriptHash(nativenames.Designation) require.NoError(t, err) designInvoker := e.CommitteeInvoker(designSH) // set committee as NeoFSAlphabet designInvoker.Invoke(t, stackitem.Null{}, "designateAsRole", int64(noderoles.NeoFSAlphabet), []interface{}{new}) } func getAlphabetAcc(t *testing.T, e *neotest.Executor) *wallet.Account { multi, ok := e.Committee.(neotest.MultiSigner) require.True(t, ok) return multi.Single(0).Account() }