package event import ( "testing" "github.com/nspcc-dev/neo-go/pkg/vm" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client" "github.com/nspcc-dev/neo-go/pkg/core/interop/interopnames" "github.com/nspcc-dev/neo-go/pkg/core/transaction" "github.com/nspcc-dev/neo-go/pkg/crypto/hash" "github.com/nspcc-dev/neo-go/pkg/crypto/keys" "github.com/nspcc-dev/neo-go/pkg/io" "github.com/nspcc-dev/neo-go/pkg/network/payload" "github.com/nspcc-dev/neo-go/pkg/smartcontract" "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/stretchr/testify/require" ) var ( alphaKeys keys.PublicKeys wrongAlphaKeys keys.PublicKeys dummyInvocationScript = append([]byte{byte(opcode.PUSHDATA1), 64}, make([]byte, 64)...) wrongDummyInvocationScript = append([]byte{byte(opcode.PUSHDATA1), 64, 1}, make([]byte, 63)...) scriptHash util.Uint160 ) func init() { privat, _ := keys.NewPrivateKey() pub := privat.PublicKey() alphaKeys = keys.PublicKeys{pub} wrongPrivat, _ := keys.NewPrivateKey() wrongPub := wrongPrivat.PublicKey() wrongAlphaKeys = keys.PublicKeys{wrongPub} scriptHash, _ = util.Uint160DecodeStringLE("21fce15191428e9c2f0e8d0329ff6d3dd14882de") } type blockCounter struct { epoch uint32 err error } func (b blockCounter) BlockCount() (res uint32, err error) { return b.epoch, b.err } func TestPrepare_IncorrectScript(t *testing.T) { preparator := notaryPreparator( PreparatorPrm{ alphaKeysSource(), blockCounter{100, nil}, }, ) t.Run("not contract call", func(t *testing.T) { bw := io.NewBufBinWriter() emit.Int(bw.BinWriter, 4) emit.String(bw.BinWriter, "test") emit.Bytes(bw.BinWriter, scriptHash.BytesBE()) emit.Syscall(bw.BinWriter, interopnames.SystemContractCallNative) // any != interopnames.SystemContractCall nr := correctNR(bw.Bytes(), false) _, err := preparator.Prepare(nr) require.EqualError(t, err, errNotContractCall.Error()) }) t.Run("incorrect ", func(t *testing.T) { bw := io.NewBufBinWriter() emit.Int(bw.BinWriter, -1) emit.String(bw.BinWriter, "test") emit.Bytes(bw.BinWriter, scriptHash.BytesBE()) emit.Syscall(bw.BinWriter, interopnames.SystemContractCall) nr := correctNR(bw.Bytes(), false) _, err := preparator.Prepare(nr) require.EqualError(t, err, errIncorrectCallFlag.Error()) }) } func TestPrepare_IncorrectNR(t *testing.T) { type ( mTX struct { sigs []transaction.Signer scripts []transaction.Witness attrs []transaction.Attribute } fbTX struct { attrs []transaction.Attribute } ) setIncorrectFields := func(nr payload.P2PNotaryRequest, m mTX, f fbTX) payload.P2PNotaryRequest { if m.sigs != nil { nr.MainTransaction.Signers = m.sigs } if m.scripts != nil { nr.MainTransaction.Scripts = m.scripts } if m.attrs != nil { nr.MainTransaction.Attributes = m.attrs } if f.attrs != nil { nr.FallbackTransaction.Attributes = f.attrs } return nr } alphaVerificationScript, _ := smartcontract.CreateMultiSigRedeemScript(len(alphaKeys)*2/3+1, alphaKeys) wrongAlphaVerificationScript, _ := smartcontract.CreateMultiSigRedeemScript(len(wrongAlphaKeys)*2/3+1, wrongAlphaKeys) tests := []struct { name string addW bool // additional witness for non alphabet invocations mTX mTX fbTX fbTX expErr error }{ { name: "incorrect witness amount", addW: false, mTX: mTX{ scripts: []transaction.Witness{{}}, }, expErr: errUnexpectedWitnessAmount, }, { name: "not dummy invocation script", addW: false, mTX: mTX{ scripts: []transaction.Witness{ {}, { InvocationScript: wrongDummyInvocationScript, }, {}, }, }, expErr: ErrTXAlreadyHandled, }, { name: "incorrect main TX signers amount", addW: false, mTX: mTX{ sigs: []transaction.Signer{{}}, }, expErr: errUnexpectedCosignersAmount, }, { name: "incorrect main TX Alphabet signer", addW: false, mTX: mTX{ sigs: []transaction.Signer{ {}, { Account: hash.Hash160(wrongAlphaVerificationScript), }, {}, }, }, expErr: errIncorrectAlphabetSigner, }, { name: "incorrect main TX attribute amount", addW: false, mTX: mTX{ attrs: []transaction.Attribute{{}, {}}, }, expErr: errIncorrectAttributesAmount, }, { name: "incorrect main TX attribute", addW: false, mTX: mTX{ attrs: []transaction.Attribute{ { Value: &transaction.NotaryAssisted{ NKeys: uint8(len(alphaKeys) + 1), }, }, }, }, expErr: errIncorrectAttribute, }, { name: "incorrect main TX proxy witness", addW: false, mTX: mTX{ scripts: []transaction.Witness{ { InvocationScript: make([]byte, 1), }, { InvocationScript: dummyInvocationScript, }, {}, }, }, expErr: errIncorrectProxyWitnesses, }, { name: "incorrect main TX Alphabet witness", addW: false, mTX: mTX{ scripts: []transaction.Witness{ {}, { VerificationScript: wrongAlphaVerificationScript, InvocationScript: dummyInvocationScript, }, {}, }, }, expErr: errIncorrectAlphabet, }, { name: "incorrect main TX Notary witness", addW: false, mTX: mTX{ scripts: []transaction.Witness{ {}, { VerificationScript: alphaVerificationScript, InvocationScript: dummyInvocationScript, }, { InvocationScript: wrongDummyInvocationScript, }, }, }, expErr: errIncorrectNotaryPlaceholder, }, { name: "incorrect fb TX attributes amount", addW: false, fbTX: fbTX{ attrs: []transaction.Attribute{{}}, }, expErr: errIncorrectFBAttributesAmount, }, { name: "incorrect fb TX attributes", addW: false, fbTX: fbTX{ attrs: []transaction.Attribute{{}, {}, {}}, }, expErr: errIncorrectFBAttributes, }, { name: "expired fb TX", addW: false, fbTX: fbTX{ []transaction.Attribute{ {}, { Type: transaction.NotValidBeforeT, Value: &transaction.NotValidBefore{ Height: 1, }, }, {}, }, }, expErr: ErrMainTXExpired, }, { name: "incorrect invoker TX Alphabet witness", addW: true, mTX: mTX{ scripts: []transaction.Witness{ {}, { VerificationScript: alphaVerificationScript, InvocationScript: dummyInvocationScript, }, {}, {}, }, }, expErr: errIncorrectInvokerWitnesses, }, { name: "incorrect main TX attribute with invoker", addW: true, mTX: mTX{ attrs: []transaction.Attribute{ { Value: &transaction.NotaryAssisted{ NKeys: uint8(len(alphaKeys) + 2), }, }, }, }, expErr: errIncorrectAttribute, }, } preparator := notaryPreparator( PreparatorPrm{ alphaKeysSource(), blockCounter{100, nil}, }, ) var ( incorrectNR payload.P2PNotaryRequest err error ) for _, test := range tests { t.Run(test.name, func(t *testing.T) { correctNR := correctNR(nil, test.addW) incorrectNR = setIncorrectFields(*correctNR, test.mTX, test.fbTX) _, err = preparator.Prepare(&incorrectNR) require.EqualError(t, err, test.expErr.Error()) }) } } func TestPrepare_CorrectNR(t *testing.T) { tests := []struct { hash util.Uint160 method string args []any }{ { scriptHash, "test1", nil, }, { scriptHash, "test2", []any{ int64(4), "test", []any{ int64(4), false, true, }, }, }, } preparator := notaryPreparator( PreparatorPrm{ alphaKeysSource(), blockCounter{100, nil}, }, ) for _, test := range tests { for i := 0; i < 1; i++ { // run tests against 3 and 4 witness NR additionalWitness := i == 0 nr := correctNR(script(test.hash, test.method, test.args...), additionalWitness) event, err := preparator.Prepare(nr) require.NoError(t, err) require.Equal(t, test.method, event.Type().String()) require.Equal(t, test.hash.StringLE(), event.ScriptHash().StringLE()) // check args parsing bw := io.NewBufBinWriter() emit.Array(bw.BinWriter, test.args...) ctx := vm.NewContext(bw.Bytes()) opCode, param, err := ctx.Next() require.NoError(t, err) for _, opGot := range event.Params() { require.Equal(t, opCode, opGot.code) require.Equal(t, param, opGot.param) opCode, param, err = ctx.Next() require.NoError(t, err) } _, _, err = ctx.Next() // PACK opcode require.NoError(t, err) _, _, err = ctx.Next() // packing len opcode require.NoError(t, err) opCode, _, err = ctx.Next() require.NoError(t, err) require.Equal(t, opcode.RET, opCode) } } } func alphaKeysSource() client.AlphabetKeys { return func() (keys.PublicKeys, error) { return alphaKeys, nil } } func script(hash util.Uint160, method string, args ...any) []byte { bw := io.NewBufBinWriter() if len(args) > 0 { emit.AppCall(bw.BinWriter, hash, method, callflag.All, args) } else { emit.AppCallNoArgs(bw.BinWriter, hash, method, callflag.All) } return bw.Bytes() } func correctNR(script []byte, additionalWitness bool) *payload.P2PNotaryRequest { alphaVerificationScript, _ := smartcontract.CreateMultiSigRedeemScript(len(alphaKeys)*2/3+1, alphaKeys) signers := []transaction.Signer{ {}, { Account: hash.Hash160(alphaVerificationScript), }, {}, } if additionalWitness { // insert on element with index 2 signers = append(signers[:2+1], signers[2:]...) signers[2] = transaction.Signer{Account: hash.Hash160(alphaVerificationScript)} } scripts := []transaction.Witness{ {}, { InvocationScript: dummyInvocationScript, VerificationScript: alphaVerificationScript, }, { InvocationScript: dummyInvocationScript, }, } if additionalWitness { // insert on element with index 2 scripts = append(scripts[:2+1], scripts[2:]...) scripts[2] = transaction.Witness{ InvocationScript: dummyInvocationScript, VerificationScript: alphaVerificationScript, } } nKeys := uint8(len(alphaKeys)) if additionalWitness { nKeys++ } return &payload.P2PNotaryRequest{ MainTransaction: &transaction.Transaction{ Signers: signers, Scripts: scripts, Attributes: []transaction.Attribute{ { Value: &transaction.NotaryAssisted{ NKeys: nKeys, }, }, }, Script: script, }, FallbackTransaction: &transaction.Transaction{ Attributes: []transaction.Attribute{ {}, { Type: transaction.NotValidBeforeT, Value: &transaction.NotValidBefore{ Height: 1000, }, }, {}, }, }, } }