package notary_test import ( "errors" "fmt" "math/big" "math/rand" "sync" "testing" "time" "github.com/nspcc-dev/neo-go/pkg/config" "github.com/nspcc-dev/neo-go/pkg/config/netmode" "github.com/nspcc-dev/neo-go/pkg/core" "github.com/nspcc-dev/neo-go/pkg/core/block" "github.com/nspcc-dev/neo-go/pkg/core/mempool" "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/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/neotest" "github.com/nspcc-dev/neo-go/pkg/neotest/chain" "github.com/nspcc-dev/neo-go/pkg/network" "github.com/nspcc-dev/neo-go/pkg/network/payload" "github.com/nspcc-dev/neo-go/pkg/services/notary" "github.com/nspcc-dev/neo-go/pkg/smartcontract" "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/wallet" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) func getTestNotary(t *testing.T, bc *core.Blockchain, walletPath, pass string, onTx func(tx *transaction.Transaction) error) (*wallet.Account, *notary.Notary, *mempool.Pool) { mainCfg := config.P2PNotary{ Enabled: true, UnlockWallet: config.Wallet{ Path: walletPath, Password: pass, }, } cfg := notary.Config{ MainCfg: mainCfg, Chain: bc, Log: zaptest.NewLogger(t), } mp := mempool.New(10, 1, true) ntr, err := notary.NewNotary(cfg, netmode.UnitTestNet, mp, onTx) require.NoError(t, err) w, err := wallet.NewWalletFromFile(walletPath) require.NoError(t, err) require.NoError(t, w.Accounts[0].Decrypt(pass, w.Scrypt)) return w.Accounts[0], ntr, mp } // dupNotaryRequest duplicates notary request by serializing/deserializing it. Use // it to avoid data races when reusing the same payload. Normal OnNewRequest handler // never receives the same (as in the same pointer) payload multiple times, even if // the contents is the same it would be a separate buffer. func dupNotaryRequest(t *testing.T, p *payload.P2PNotaryRequest) *payload.P2PNotaryRequest { b, err := p.Bytes() require.NoError(t, err) r, err := payload.NewP2PNotaryRequestFromBytes(b) require.NoError(t, err) return r } func TestNotary(t *testing.T) { bc, validators, committee := chain.NewMultiWithCustomConfig(t, func(c *config.Blockchain) { c.P2PSigExtensions = true }) e := neotest.NewExecutor(t, bc, validators, committee) notaryHash := e.NativeHash(t, nativenames.Notary) designationSuperInvoker := e.NewInvoker(e.NativeHash(t, nativenames.Designation), validators, committee) gasValidatorInvoker := e.ValidatorInvoker(e.NativeHash(t, nativenames.Gas)) var ( nonce uint32 nvbDiffFallback uint32 = 20 ) mtx := sync.RWMutex{} completedTxes := make(map[util.Uint256]*transaction.Transaction) var unluckies []*payload.P2PNotaryRequest var ( finalizeWithError bool choosy bool ) setFinalizeWithError := func(v bool) { mtx.Lock() finalizeWithError = v mtx.Unlock() } setChoosy := func(v bool) { mtx.Lock() choosy = v mtx.Unlock() } onTransaction := func(tx *transaction.Transaction) error { mtx.Lock() defer mtx.Unlock() if !choosy { if completedTxes[tx.Hash()] != nil { panic("transaction was completed twice") } if finalizeWithError { return errors.New("error while finalizing transaction") } completedTxes[tx.Hash()] = tx return nil } for _, unl := range unluckies { if tx.Hash().Equals(unl.FallbackTransaction.Hash()) { return errors.New("error while finalizing transaction") } } completedTxes[tx.Hash()] = tx return nil } getCompletedTx := func(t *testing.T, waitForNonNil bool, h util.Uint256) *transaction.Transaction { if !waitForNonNil { mtx.RLock() defer mtx.RUnlock() return completedTxes[h] } var completedTx *transaction.Transaction require.Eventually(t, func() bool { mtx.RLock() defer mtx.RUnlock() completedTx = completedTxes[h] return completedTx != nil }, time.Second*3, time.Millisecond*50, errors.New("main transaction expected to be completed")) return completedTx } acc1, ntr1, mp1 := getTestNotary(t, bc, "./testdata/notary1.json", "one", onTransaction) acc2, _, _ := getTestNotary(t, bc, "./testdata/notary2.json", "two", onTransaction) randomAcc, err := keys.NewPrivateKey() require.NoError(t, err) bc.SetNotary(ntr1) bc.RegisterPostBlock(func(f func(*transaction.Transaction, *mempool.Pool, bool) bool, pool *mempool.Pool, b *block.Block) { ntr1.PostPersist() }) mp1.RunSubscriptions() ntr1.Start() t.Cleanup(func() { ntr1.Shutdown() mp1.StopSubscriptions() }) notaryNodes := []interface{}{acc1.PublicKey().Bytes(), acc2.PrivateKey().PublicKey().Bytes()} designationSuperInvoker.Invoke(t, stackitem.Null{}, "designateAsRole", int64(noderoles.P2PNotary), notaryNodes) type requester struct { accounts []*wallet.Account m int typ notary.RequestType } createFallbackTx := func(requester *wallet.Account, mainTx *transaction.Transaction, nvbIncrement ...uint32) *transaction.Transaction { fallback := transaction.New([]byte{byte(opcode.RET)}, 2000_0000) fallback.Nonce = nonce nonce++ fallback.SystemFee = 1_0000_0000 fallback.ValidUntilBlock = bc.BlockHeight() + 2*nvbDiffFallback fallback.Signers = []transaction.Signer{ { Account: bc.GetNotaryContractScriptHash(), Scopes: transaction.None, }, { Account: requester.ScriptHash(), Scopes: transaction.None, }, } nvb := bc.BlockHeight() + nvbDiffFallback if len(nvbIncrement) != 0 { nvb += nvbIncrement[0] } fallback.Attributes = []transaction.Attribute{ { Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 0}, }, { Type: transaction.NotValidBeforeT, Value: &transaction.NotValidBefore{Height: nvb}, }, { Type: transaction.ConflictsT, Value: &transaction.Conflicts{Hash: mainTx.Hash()}, }, } fallback.Scripts = []transaction.Witness{ { InvocationScript: append([]byte{byte(opcode.PUSHDATA1), keys.SignatureLen}, make([]byte, keys.SignatureLen)...), VerificationScript: []byte{}, }, } err = requester.SignTx(netmode.UnitTestNet, fallback) require.NoError(t, err) return fallback } createMixedRequest := func(requesters []requester, NVBincrements ...uint32) []*payload.P2PNotaryRequest { mainTx := *transaction.New([]byte{byte(opcode.RET)}, 11000000) mainTx.Nonce = nonce nonce++ mainTx.SystemFee = 100000000 mainTx.ValidUntilBlock = bc.BlockHeight() + 2*nvbDiffFallback signers := make([]transaction.Signer, len(requesters)+1) var ( nKeys uint8 verificationScripts [][]byte ) for i := range requesters { var script []byte switch requesters[i].typ { case notary.Signature: script = requesters[i].accounts[0].PublicKey().GetVerificationScript() nKeys++ case notary.MultiSignature: pubs := make(keys.PublicKeys, len(requesters[i].accounts)) for j, r := range requesters[i].accounts { pubs[j] = r.PublicKey() } script, err = smartcontract.CreateMultiSigRedeemScript(requesters[i].m, pubs) require.NoError(t, err) nKeys += uint8(len(requesters[i].accounts)) } signers[i] = transaction.Signer{ Account: hash.Hash160(script), Scopes: transaction.None, } verificationScripts = append(verificationScripts, script) } signers[len(signers)-1] = transaction.Signer{ Account: bc.GetNotaryContractScriptHash(), Scopes: transaction.None, } mainTx.Signers = signers mainTx.Attributes = []transaction.Attribute{ { Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: nKeys}, }, } payloads := make([]*payload.P2PNotaryRequest, nKeys) plIndex := 0 // we'll collect only m signatures out of n (so only m payloads are needed), but let's create payloads for all requesters (for the next tests) for i, r := range requesters { for _, acc := range r.accounts { cp := mainTx main := &cp main.Scripts = make([]transaction.Witness, len(requesters)) for j := range main.Scripts { main.Scripts[j].VerificationScript = verificationScripts[j] if i == j { main.Scripts[j].InvocationScript = append([]byte{byte(opcode.PUSHDATA1), keys.SignatureLen}, acc.PrivateKey().SignHashable(uint32(netmode.UnitTestNet), main)...) } } main.Scripts = append(main.Scripts, transaction.Witness{}) // empty Notary witness _ = main.Size() // for size update test var fallback *transaction.Transaction if len(NVBincrements) == int(nKeys) { fallback = createFallbackTx(acc, main, NVBincrements[plIndex]) } else { fallback = createFallbackTx(acc, main) } _ = fallback.Size() // for size update test payloads[plIndex] = &payload.P2PNotaryRequest{ MainTransaction: main, FallbackTransaction: fallback, } plIndex++ } } return payloads } checkMainTx := func(t *testing.T, requesters []requester, requests []*payload.P2PNotaryRequest, sentCount int, shouldComplete bool) { nSigs := 0 for _, r := range requesters { switch r.typ { case notary.Signature: nSigs++ case notary.MultiSignature: nSigs += r.m } } nSigners := len(requesters) + 1 if sentCount >= nSigs && shouldComplete { completedTx := getCompletedTx(t, true, requests[0].MainTransaction.Hash()) require.Equal(t, nSigners, len(completedTx.Signers)) require.Equal(t, nSigners, len(completedTx.Scripts)) // check that tx size was updated require.Equal(t, io.GetVarSize(completedTx), completedTx.Size()) for i := 0; i < len(completedTx.Scripts)-1; i++ { _, err := bc.VerifyWitness(completedTx.Signers[i].Account, completedTx, &completedTx.Scripts[i], -1) require.NoError(t, err) } require.Equal(t, transaction.Witness{ InvocationScript: append([]byte{byte(opcode.PUSHDATA1), keys.SignatureLen}, acc1.PrivateKey().SignHashable(uint32(netmode.UnitTestNet), requests[0].MainTransaction)...), VerificationScript: []byte{}, }, completedTx.Scripts[len(completedTx.Scripts)-1]) } else { completedTx := getCompletedTx(t, false, requests[0].MainTransaction.Hash()) require.Nil(t, completedTx, fmt.Errorf("main transaction shouldn't be completed: sent %d out of %d requests", sentCount, nSigs)) } } checkFallbackTxs := func(t *testing.T, requests []*payload.P2PNotaryRequest, shouldComplete bool) { for i, req := range requests { if shouldComplete { completedTx := getCompletedTx(t, true, req.FallbackTransaction.Hash()) require.Equal(t, 2, len(completedTx.Signers)) require.Equal(t, 2, len(completedTx.Scripts)) require.Equal(t, transaction.Witness{ InvocationScript: append([]byte{byte(opcode.PUSHDATA1), keys.SignatureLen}, acc1.PrivateKey().SignHashable(uint32(netmode.UnitTestNet), req.FallbackTransaction)...), VerificationScript: []byte{}, }, completedTx.Scripts[0]) // check that tx size was updated require.Equal(t, io.GetVarSize(completedTx), completedTx.Size()) _, err := bc.VerifyWitness(completedTx.Signers[1].Account, completedTx, &completedTx.Scripts[1], -1) require.NoError(t, err) } else { completedTx := getCompletedTx(t, false, req.FallbackTransaction.Hash()) require.Nil(t, completedTx, fmt.Errorf("fallback transaction for request #%d shouldn't be completed", i)) } } } checkCompleteStandardRequest := func(t *testing.T, nKeys int, shouldComplete bool, nvbIncrements ...uint32) ([]*payload.P2PNotaryRequest, []requester) { requesters := make([]requester, nKeys) for i := range requesters { acc, _ := wallet.NewAccount() requesters[i] = requester{ accounts: []*wallet.Account{acc}, typ: notary.Signature, } } requests := createMixedRequest(requesters, nvbIncrements...) sendOrder := make([]int, nKeys) for i := range sendOrder { sendOrder[i] = i } rand.Shuffle(nKeys, func(i, j int) { sendOrder[j], sendOrder[i] = sendOrder[i], sendOrder[j] }) for i := range requests { ntr1.OnNewRequest(requests[sendOrder[i]]) checkMainTx(t, requesters, requests, i+1, shouldComplete) completedCount := len(completedTxes) // check that the same request won't be processed twice ntr1.OnNewRequest(dupNotaryRequest(t, requests[sendOrder[i]])) checkMainTx(t, requesters, requests, i+1, shouldComplete) require.Equal(t, completedCount, len(completedTxes)) } return requests, requesters } checkCompleteMultisigRequest := func(t *testing.T, nSigs int, nKeys int, shouldComplete bool) ([]*payload.P2PNotaryRequest, []requester) { accounts := make([]*wallet.Account, nKeys) for i := range accounts { accounts[i], _ = wallet.NewAccount() } requesters := []requester{ { accounts: accounts, m: nSigs, typ: notary.MultiSignature, }, } requests := createMixedRequest(requesters) sendOrder := make([]int, nKeys) for i := range sendOrder { sendOrder[i] = i } rand.Shuffle(nKeys, func(i, j int) { sendOrder[j], sendOrder[i] = sendOrder[i], sendOrder[j] }) var submittedRequests []*payload.P2PNotaryRequest // sent only nSigs (m out of n) requests - it should be enough to complete min tx for i := 0; i < nSigs; i++ { submittedRequests = append(submittedRequests, requests[sendOrder[i]]) ntr1.OnNewRequest(requests[sendOrder[i]]) checkMainTx(t, requesters, submittedRequests, i+1, shouldComplete) // check that the same request won't be processed twice ntr1.OnNewRequest(dupNotaryRequest(t, requests[sendOrder[i]])) checkMainTx(t, requesters, submittedRequests, i+1, shouldComplete) } // sent the rest (n-m) out of n requests: main tx is already collected, so only fallbacks should be applied completedCount := len(completedTxes) for i := nSigs; i < nKeys; i++ { submittedRequests = append(submittedRequests, requests[sendOrder[i]]) ntr1.OnNewRequest(requests[sendOrder[i]]) checkMainTx(t, requesters, submittedRequests, i+1, shouldComplete) require.Equal(t, completedCount, len(completedTxes)) } return submittedRequests, requesters } checkCompleteMixedRequest := func(t *testing.T, nSigSigners int, shouldComplete bool) ([]*payload.P2PNotaryRequest, []requester) { requesters := make([]requester, nSigSigners) for i := range requesters { acc, _ := wallet.NewAccount() requesters[i] = requester{ accounts: []*wallet.Account{acc}, typ: notary.Signature, } } multisigAccounts := make([]*wallet.Account, 3) for i := range multisigAccounts { multisigAccounts[i], _ = wallet.NewAccount() } requesters = append(requesters, requester{ accounts: multisigAccounts, m: 2, typ: notary.MultiSignature, }) requests := createMixedRequest(requesters) for i := range requests { ntr1.OnNewRequest(requests[i]) checkMainTx(t, requesters, requests, i+1, shouldComplete) completedCount := len(completedTxes) // check that the same request won't be processed twice ntr1.OnNewRequest(dupNotaryRequest(t, requests[i])) checkMainTx(t, requesters, requests, i+1, shouldComplete) require.Equal(t, completedCount, len(completedTxes)) } return requests, requesters } // OnNewRequest: missing account ntr1.UpdateNotaryNodes(keys.PublicKeys{randomAcc.PublicKey()}) r, _ := checkCompleteStandardRequest(t, 1, false) checkFallbackTxs(t, r, false) // set account back for the next tests ntr1.UpdateNotaryNodes(keys.PublicKeys{acc1.PublicKey()}) // OnNewRequest: signature request for _, i := range []int{1, 2, 3, 10} { r, _ := checkCompleteStandardRequest(t, i, true) checkFallbackTxs(t, r, false) } // OnNewRequest: multisignature request r, _ = checkCompleteMultisigRequest(t, 1, 1, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMultisigRequest(t, 1, 2, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMultisigRequest(t, 1, 3, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMultisigRequest(t, 3, 3, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMultisigRequest(t, 3, 4, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMultisigRequest(t, 3, 10, true) checkFallbackTxs(t, r, false) // OnNewRequest: mixed request r, _ = checkCompleteMixedRequest(t, 1, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMixedRequest(t, 2, true) checkFallbackTxs(t, r, false) r, _ = checkCompleteMixedRequest(t, 3, true) checkFallbackTxs(t, r, false) // PostPersist: missing account setFinalizeWithError(true) r, requesters := checkCompleteStandardRequest(t, 1, false) checkFallbackTxs(t, r, false) ntr1.UpdateNotaryNodes(keys.PublicKeys{randomAcc.PublicKey()}) setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, r, 1, false) checkFallbackTxs(t, r, false) // set account back for the next tests ntr1.UpdateNotaryNodes(keys.PublicKeys{acc1.PublicKey()}) // PostPersist: complete main transaction, signature request setFinalizeWithError(true) requests, requesters := checkCompleteStandardRequest(t, 3, false) // check PostPersist with finalisation error setFinalizeWithError(true) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) // check PostPersist without finalisation error setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), true) // PostPersist: complete main transaction, multisignature account setFinalizeWithError(true) requests, requesters = checkCompleteMultisigRequest(t, 3, 4, false) checkFallbackTxs(t, requests, false) // check PostPersist with finalisation error setFinalizeWithError(true) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // check PostPersist without finalisation error setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), true) checkFallbackTxs(t, requests, false) // PostPersist: complete fallback, signature request setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 3, false) checkFallbackTxs(t, requests, false) // make fallbacks valid e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) // check PostPersist for valid fallbacks with finalisation error e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // check PostPersist for valid fallbacks without finalisation error setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, true) // PostPersist: complete fallback, multisignature request nSigs, nKeys := 3, 5 // check OnNewRequest with finalization error setFinalizeWithError(true) requests, requesters = checkCompleteMultisigRequest(t, nSigs, nKeys, false) checkFallbackTxs(t, requests, false) // make fallbacks valid e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) // check PostPersist for valid fallbacks with finalisation error e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // check PostPersist for valid fallbacks without finalisation error setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests[:nSigs], true) // the rest of fallbacks should also be applied even if the main tx was already constructed by the moment they were sent checkFallbackTxs(t, requests[nSigs:], true) // PostPersist: partial fallbacks completion due to finalisation errors setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 5, false) checkFallbackTxs(t, requests, false) // make fallbacks valid e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) // some of fallbacks should fail finalisation unluckies = []*payload.P2PNotaryRequest{requests[0], requests[4]} lucky := requests[1:4] setChoosy(true) // check PostPersist for lucky fallbacks e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, lucky, true) checkFallbackTxs(t, unluckies, false) // reset finalisation function for unlucky fallbacks to finalise without an error setChoosy(false) setFinalizeWithError(false) // check PostPersist for unlucky fallbacks e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, lucky, true) checkFallbackTxs(t, unluckies, true) // PostPersist: different NVBs // check OnNewRequest with finalization error and different NVBs setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 5, false, 1, 2, 3, 4, 5) checkFallbackTxs(t, requests, false) // generate blocks to reach the most earlier fallback's NVB e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) // check PostPersist for valid fallbacks without finalisation error // Add block before allowing tx to finalize to exclude race condition when // main transaction is finalized between `finalizeWithError` restore and adding new block. e.AddNewBlock(t) mtx.RLock() start := len(completedTxes) mtx.RUnlock() setFinalizeWithError(false) for i := range requests { if i != 0 { e.AddNewBlock(t) } require.Eventually(t, func() bool { mtx.RLock() defer mtx.RUnlock() return len(completedTxes)-start >= i+1 }, time.Second*3, time.Millisecond) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests[:i+1], true) checkFallbackTxs(t, requests[i+1:], false) } // OnRequestRemoval: missing account // check OnNewRequest with finalization error setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 4, false) checkFallbackTxs(t, requests, false) // make fallbacks valid and remove one fallback e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) ntr1.UpdateNotaryNodes(keys.PublicKeys{randomAcc.PublicKey()}) ntr1.OnRequestRemoval(requests[3]) // non of the fallbacks should be completed setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // set account back for the next tests ntr1.UpdateNotaryNodes(keys.PublicKeys{acc1.PublicKey()}) // OnRequestRemoval: signature request, remove one fallback // check OnNewRequest with finalization error setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 4, false) checkFallbackTxs(t, requests, false) // make fallbacks valid and remove one fallback e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) unlucky := requests[3] ntr1.OnRequestRemoval(unlucky) // rest of the fallbacks should be completed setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests[:3], true) require.Nil(t, completedTxes[unlucky.FallbackTransaction.Hash()]) // OnRequestRemoval: signature request, remove all fallbacks setFinalizeWithError(true) requests, requesters = checkCompleteStandardRequest(t, 4, false) // remove all fallbacks e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) for i := range requests { ntr1.OnRequestRemoval(requests[i]) } // then the whole request should be removed, i.e. there are no completed transactions setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // OnRequestRemoval: signature request, remove unexisting fallback ntr1.OnRequestRemoval(requests[0]) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // OnRequestRemoval: multisignature request, remove one fallback nSigs, nKeys = 3, 5 // check OnNewRequest with finalization error setFinalizeWithError(true) requests, requesters = checkCompleteMultisigRequest(t, nSigs, nKeys, false) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // make fallbacks valid and remove the last fallback e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) unlucky = requests[nSigs-1] ntr1.OnRequestRemoval(unlucky) // then (m-1) out of n fallbacks should be completed setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests[:nSigs-1], true) require.Nil(t, completedTxes[unlucky.FallbackTransaction.Hash()]) // the rest (n-(m-1)) out of n fallbacks should also be completed even if main tx has been collected by the moment they were sent checkFallbackTxs(t, requests[nSigs:], true) // OnRequestRemoval: multisignature request, remove all fallbacks setFinalizeWithError(true) requests, requesters = checkCompleteMultisigRequest(t, nSigs, nKeys, false) // make fallbacks valid and then remove all of them e.GenerateNewBlocks(t, int(nvbDiffFallback)) require.NoError(t, err) for i := range requests { ntr1.OnRequestRemoval(requests[i]) } // then the whole request should be removed, i.e. there are no completed transactions setFinalizeWithError(false) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // // OnRequestRemoval: multisignature request, remove unexisting fallbac, i.e. there still shouldn't be any completed transactions after this ntr1.OnRequestRemoval(requests[0]) e.AddNewBlock(t) checkMainTx(t, requesters, requests, len(requests), false) checkFallbackTxs(t, requests, false) // Subscriptions test setFinalizeWithError(false) requester1, _ := wallet.NewAccount() requester2, _ := wallet.NewAccount() amount := int64(100_0000_0000) gasValidatorInvoker.Invoke(t, true, "transfer", e.Validator.ScriptHash(), bc.GetNotaryContractScriptHash(), amount, []interface{}{requester1.ScriptHash(), int64(bc.BlockHeight() + 50)}) e.CheckGASBalance(t, notaryHash, big.NewInt(amount)) gasValidatorInvoker.Invoke(t, true, "transfer", e.Validator.ScriptHash(), bc.GetNotaryContractScriptHash(), amount, []interface{}{requester2.ScriptHash(), int64(bc.BlockHeight() + 50)}) e.CheckGASBalance(t, notaryHash, big.NewInt(2*amount)) // create request for 2 standard signatures => main tx should be completed after the second request is added to the pool requests = createMixedRequest([]requester{ { accounts: []*wallet.Account{requester1}, typ: notary.Signature, }, { accounts: []*wallet.Account{requester2}, typ: notary.Signature, }, }) feer := network.NewNotaryFeer(bc) require.NoError(t, mp1.Add(requests[0].FallbackTransaction, feer, requests[0])) require.NoError(t, mp1.Add(requests[1].FallbackTransaction, feer, requests[1])) require.Eventually(t, func() bool { mtx.RLock() defer mtx.RUnlock() return completedTxes[requests[0].MainTransaction.Hash()] != nil }, 3*time.Second, 100*time.Millisecond) checkFallbackTxs(t, requests, false) }