neoneo-go/pkg/rpcclient/notary/actor_test.go
Anna Shaleva 7c9b1d05d2 rpcclient: refactor waiter package naming
Adjust names of all used structures, no need to duplicate `Waiter` everywhere,
we already in the `waiter` package. Also, adjust comments to Actor so that links
to Waiter are properly described in docs.

Ref. #3265.

Signed-off-by: Anna Shaleva <shaleva.ann@nspcc.ru>
2023-12-29 15:22:50 +03:00

587 lines
16 KiB
Go

package notary
import (
"context"
"errors"
"testing"
"github.com/google/uuid"
"github.com/nspcc-dev/neo-go/pkg/config/netmode"
"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/encoding/address"
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/network/payload"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
"github.com/nspcc-dev/neo-go/pkg/rpcclient/waiter"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/stretchr/testify/require"
)
type RPCClient struct {
err error
invRes *result.Invoke
netFee int64
bCount uint32
version *result.Version
hash util.Uint256
nhash util.Uint256
mirror bool
applog *result.ApplicationLog
}
func (r *RPCClient) InvokeContractVerify(contract util.Uint160, params []smartcontract.Parameter, signers []transaction.Signer, witnesses ...transaction.Witness) (*result.Invoke, error) {
return r.invRes, r.err
}
func (r *RPCClient) InvokeFunction(contract util.Uint160, operation string, params []smartcontract.Parameter, signers []transaction.Signer) (*result.Invoke, error) {
return r.invRes, r.err
}
func (r *RPCClient) InvokeScript(script []byte, signers []transaction.Signer) (*result.Invoke, error) {
return r.invRes, r.err
}
func (r *RPCClient) CalculateNetworkFee(tx *transaction.Transaction) (int64, error) {
return r.netFee, r.err
}
func (r *RPCClient) GetBlockCount() (uint32, error) {
return r.bCount, r.err
}
func (r *RPCClient) GetVersion() (*result.Version, error) {
verCopy := *r.version
return &verCopy, r.err
}
func (r *RPCClient) SendRawTransaction(tx *transaction.Transaction) (util.Uint256, error) {
return r.hash, r.err
}
func (r *RPCClient) SubmitP2PNotaryRequest(req *payload.P2PNotaryRequest) (util.Uint256, error) {
if r.mirror {
return req.FallbackTransaction.Hash(), nil
}
return r.nhash, r.err
}
func (r *RPCClient) TerminateSession(sessionID uuid.UUID) (bool, error) {
return false, nil // Just a stub, unused by actor.
}
func (r *RPCClient) TraverseIterator(sessionID, iteratorID uuid.UUID, maxItemsCount int) ([]stackitem.Item, error) {
return nil, nil // Just a stub, unused by actor.
}
func (r *RPCClient) Context() context.Context {
return context.Background()
}
func (r *RPCClient) GetApplicationLog(hash util.Uint256, trig *trigger.Type) (*result.ApplicationLog, error) {
return r.applog, nil
}
var _ = waiter.RPCPollingBased(&RPCClient{})
func TestNewActor(t *testing.T) {
rc := &RPCClient{
version: &result.Version{
Protocol: result.Protocol{
Network: netmode.UnitTestNet,
MillisecondsPerBlock: 1000,
ValidatorsCount: 7,
},
},
}
_, err := NewActor(rc, nil, nil)
require.Error(t, err)
var (
keyz [4]*keys.PrivateKey
accs [4]*wallet.Account
faccs [4]*wallet.Account
pkeys [4]*keys.PublicKey
)
for i := range accs {
keyz[i], err = keys.NewPrivateKey()
require.NoError(t, err)
accs[i] = wallet.NewAccountFromPrivateKey(keyz[i])
pkeys[i] = keyz[i].PublicKey()
faccs[i] = FakeSimpleAccount(pkeys[i])
}
var multiAccs [4]*wallet.Account
for i := range accs {
multiAccs[i] = &wallet.Account{}
*multiAccs[i] = *accs[i]
require.NoError(t, multiAccs[i].ConvertMultisig(smartcontract.GetDefaultHonestNodeCount(len(pkeys)), pkeys[:]))
}
// nil Contract
badMultiAcc0 := &wallet.Account{}
*badMultiAcc0 = *multiAccs[0]
badMultiAcc0.Contract = nil
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: badMultiAcc0,
}}, accs[0])
require.Error(t, err)
// Non-standard script.
badMultiAcc0.Contract = &wallet.Contract{}
*badMultiAcc0.Contract = *multiAccs[0].Contract
badMultiAcc0.Contract.Script = append(badMultiAcc0.Contract.Script, byte(opcode.NOP))
badMultiAcc0.Address = address.Uint160ToString(badMultiAcc0.Contract.ScriptHash())
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: badMultiAcc0.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: badMultiAcc0,
}}, accs[0])
require.Error(t, err)
// Too many keys
var (
manyKeys [256]*keys.PrivateKey
manyPkeys [256]*keys.PublicKey
)
for i := range manyKeys {
manyKeys[i], err = keys.NewPrivateKey()
require.NoError(t, err)
manyPkeys[i] = manyKeys[i].PublicKey()
}
bigMultiAcc := &wallet.Account{}
*bigMultiAcc = *wallet.NewAccountFromPrivateKey(manyKeys[0])
require.NoError(t, bigMultiAcc.ConvertMultisig(129, manyPkeys[:]))
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: bigMultiAcc.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: bigMultiAcc,
}}, wallet.NewAccountFromPrivateKey(manyKeys[0]))
require.Error(t, err)
// No contract in the simple account.
badSimple0 := &wallet.Account{}
*badSimple0 = *accs[0]
badSimple0.Contract = nil
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, badSimple0)
require.Error(t, err)
// Simple account that can't sign.
badSimple0 = FakeSimpleAccount(pkeys[0])
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, badSimple0)
require.Error(t, err)
// Multisig account instead of simple one.
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, multiAccs[0])
require.Error(t, err)
// Main actor freaking out on hash mismatch.
_, err = NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: accs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, accs[0])
require.Error(t, err)
// FB actor freaking out on hash mismatch.
opts := NewDefaultActorOptions(NewReader(invoker.New(rc, nil)), accs[0])
opts.FbSigner.Signer.Account = multiAccs[0].Contract.ScriptHash()
_, err = NewTunedActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, opts)
require.Error(t, err)
// Good, one multisig.
multi0, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: multiAccs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: multiAccs[0],
}}, accs[0])
require.NoError(t, err)
script := []byte{byte(opcode.RET)}
rc.invRes = &result.Invoke{
State: "HALT",
GasConsumed: 3,
Script: script,
Stack: []stackitem.Item{stackitem.Make(42)},
}
tx, err := multi0.MakeRun(script)
require.NoError(t, err)
require.Equal(t, 1, len(tx.Attributes))
require.Equal(t, transaction.NotaryAssistedT, tx.Attributes[0].Type)
require.Equal(t, &transaction.NotaryAssisted{NKeys: 4}, tx.Attributes[0].Value)
// Good, 4 single sigs with one that can sign and one contract.
single4, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: accs[0].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: accs[0],
}, {
Signer: transaction.Signer{
Account: faccs[1].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: faccs[1],
}, {
Signer: transaction.Signer{
Account: faccs[2].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: faccs[2],
}, {
Signer: transaction.Signer{
Account: accs[3].Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: faccs[3],
}, {
Signer: transaction.Signer{
Account: util.Uint160{1, 2, 3},
Scopes: transaction.CalledByEntry,
},
Account: FakeContractAccount(util.Uint160{1, 2, 3}),
}}, accs[0])
require.NoError(t, err)
tx, err = single4.MakeRun(script)
require.NoError(t, err)
require.Equal(t, 1, len(tx.Attributes))
require.Equal(t, transaction.NotaryAssistedT, tx.Attributes[0].Type)
require.Equal(t, &transaction.NotaryAssisted{NKeys: 4}, tx.Attributes[0].Value) // One account can sign, three need to collect additional sigs.
}
func TestSendRequestExactly(t *testing.T) {
rc := &RPCClient{
version: &result.Version{
Protocol: result.Protocol{
Network: netmode.UnitTestNet,
MillisecondsPerBlock: 1000,
ValidatorsCount: 7,
},
},
}
key0, err := keys.NewPrivateKey()
require.NoError(t, err)
key1, err := keys.NewPrivateKey()
require.NoError(t, err)
acc0 := wallet.NewAccountFromPrivateKey(key0)
facc1 := FakeSimpleAccount(key1.PublicKey())
act, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: acc0.Contract.ScriptHash(),
Scopes: transaction.None,
},
Account: acc0,
}, {
Signer: transaction.Signer{
Account: facc1.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: facc1,
}}, acc0)
require.NoError(t, err)
script := []byte{byte(opcode.RET)}
mainTx := transaction.New(script, 1)
fbTx := transaction.New(script, 1)
// Hashes mismatch
_, _, _, err = act.SendRequestExactly(mainTx, fbTx)
require.Error(t, err)
// Error returned
rc.err = errors.New("")
_, _, _, err = act.SendRequestExactly(mainTx, fbTx)
require.Error(t, err)
// OK returned
rc.err = nil
rc.nhash = fbTx.Hash()
mHash, fbHash, vub, err := act.SendRequestExactly(mainTx, fbTx)
require.NoError(t, err)
require.Equal(t, mainTx.Hash(), mHash)
require.Equal(t, fbTx.Hash(), fbHash)
require.Equal(t, mainTx.ValidUntilBlock, vub)
}
func TestSendRequest(t *testing.T) {
rc := &RPCClient{
version: &result.Version{
Protocol: result.Protocol{
Network: netmode.UnitTestNet,
MillisecondsPerBlock: 1000,
ValidatorsCount: 7,
},
},
bCount: 42,
}
key0, err := keys.NewPrivateKey()
require.NoError(t, err)
key1, err := keys.NewPrivateKey()
require.NoError(t, err)
acc0 := wallet.NewAccountFromPrivateKey(key0)
facc0 := FakeSimpleAccount(key0.PublicKey())
facc1 := FakeSimpleAccount(key1.PublicKey())
act, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: acc0.Contract.ScriptHash(),
Scopes: transaction.None,
},
Account: acc0,
}, {
Signer: transaction.Signer{
Account: facc1.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: facc1,
}}, acc0)
require.NoError(t, err)
script := []byte{byte(opcode.RET)}
rc.invRes = &result.Invoke{
State: "HALT",
GasConsumed: 3,
Script: script,
Stack: []stackitem.Item{stackitem.Make(42)},
}
mainTx, err := act.MakeRun(script)
require.NoError(t, err)
// No attributes.
fbTx, err := act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
fbTx.Attributes = nil
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
// Bad NVB.
fbTx, err = act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
fbTx.Attributes[1].Type = transaction.HighPriority
fbTx.Attributes[1].Value = nil
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
// Bad Conflicts.
fbTx, err = act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
fbTx.Attributes[2].Type = transaction.HighPriority
fbTx.Attributes[2].Value = nil
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
// GetBlockCount error.
fbTx, err = act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
rc.err = errors.New("")
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
// Can't sign suddenly.
rc.err = nil
acc0Backup := &wallet.Account{}
*acc0Backup = *acc0
*acc0 = *facc0
fbTx, err = act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
// Good.
*acc0 = *acc0Backup
fbTx, err = act.FbActor.MakeUnsignedRun(script, nil)
require.NoError(t, err)
_, _, _, err = act.SendRequest(mainTx, fbTx)
require.Error(t, err)
}
func TestNotarize(t *testing.T) {
rc := &RPCClient{
version: &result.Version{
Protocol: result.Protocol{
Network: netmode.UnitTestNet,
MillisecondsPerBlock: 1000,
ValidatorsCount: 7,
},
},
bCount: 42,
}
key0, err := keys.NewPrivateKey()
require.NoError(t, err)
key1, err := keys.NewPrivateKey()
require.NoError(t, err)
acc0 := wallet.NewAccountFromPrivateKey(key0)
facc1 := FakeSimpleAccount(key1.PublicKey())
act, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: acc0.Contract.ScriptHash(),
Scopes: transaction.None,
},
Account: acc0,
}, {
Signer: transaction.Signer{
Account: facc1.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: facc1,
}}, acc0)
require.NoError(t, err)
script := []byte{byte(opcode.RET)}
// Immediate error from MakeRun.
rc.invRes = &result.Invoke{
State: "FAULT",
GasConsumed: 3,
Script: script,
Stack: []stackitem.Item{stackitem.Make(42)},
}
_, _, _, err = act.Notarize(act.MakeRun(script))
require.Error(t, err)
// Explicitly good transaction. but failure to create a fallback.
rc.invRes.State = "HALT"
tx, err := act.MakeRun(script)
require.NoError(t, err)
rc.invRes.State = "FAULT"
_, _, _, err = act.Notarize(tx, nil)
require.Error(t, err)
// FB hash mismatch from SendRequestExactly.
rc.invRes.State = "HALT"
_, _, _, err = act.Notarize(act.MakeRun(script))
require.Error(t, err)
// Good.
rc.mirror = true
mHash, fbHash, vub, err := act.Notarize(act.MakeRun(script))
require.NoError(t, err)
require.NotEqual(t, util.Uint256{}, mHash)
require.NotEqual(t, util.Uint256{}, fbHash)
require.Equal(t, uint32(92), vub)
}
func TestDefaultActorOptions(t *testing.T) {
rc := &RPCClient{
version: &result.Version{
Protocol: result.Protocol{
Network: netmode.UnitTestNet,
MillisecondsPerBlock: 1000,
ValidatorsCount: 7,
},
},
}
acc, err := wallet.NewAccount()
require.NoError(t, err)
opts := NewDefaultActorOptions(NewReader(invoker.New(rc, nil)), acc)
rc.invRes = &result.Invoke{
State: "HALT",
GasConsumed: 3,
Script: opts.FbScript,
Stack: []stackitem.Item{stackitem.Make(42)},
}
tx := transaction.New(opts.FbScript, 1)
require.Error(t, opts.MainCheckerModifier(&result.Invoke{State: "FAULT"}, tx))
rc.invRes.State = "FAULT"
require.Error(t, opts.MainCheckerModifier(&result.Invoke{State: "HALT"}, tx))
rc.invRes.State = "HALT"
require.NoError(t, opts.MainCheckerModifier(&result.Invoke{State: "HALT"}, tx))
require.Equal(t, uint32(42), tx.ValidUntilBlock)
}
func TestWait(t *testing.T) {
rc := &RPCClient{version: &result.Version{Protocol: result.Protocol{MillisecondsPerBlock: 1}}}
key0, err := keys.NewPrivateKey()
require.NoError(t, err)
key1, err := keys.NewPrivateKey()
require.NoError(t, err)
acc0 := wallet.NewAccountFromPrivateKey(key0)
facc1 := FakeSimpleAccount(key1.PublicKey())
act, err := NewActor(rc, []actor.SignerAccount{{
Signer: transaction.Signer{
Account: acc0.Contract.ScriptHash(),
Scopes: transaction.None,
},
Account: acc0,
}, {
Signer: transaction.Signer{
Account: facc1.Contract.ScriptHash(),
Scopes: transaction.CalledByEntry,
},
Account: facc1,
}}, acc0)
require.NoError(t, err)
someErr := errors.New("someErr")
_, err = act.Wait(util.Uint256{}, util.Uint256{}, 0, someErr)
require.ErrorIs(t, err, someErr)
cont := util.Uint256{1, 2, 3}
ex := state.Execution{
Trigger: trigger.Application,
VMState: vmstate.Halt,
GasConsumed: 123,
Stack: []stackitem.Item{stackitem.Null{}},
}
applog := &result.ApplicationLog{
Container: cont,
IsTransaction: true,
Executions: []state.Execution{ex},
}
rc.applog = applog
res, err := act.Wait(util.Uint256{}, util.Uint256{}, 0, nil)
require.NoError(t, err)
require.Equal(t, &state.AppExecResult{
Container: cont,
Execution: ex,
}, res)
}