mempool/core: redesign mempool dances on block acceptance

We not only need to remove transactions stored in the block, but also
invalidate some potential double spends caused by these transactions. Usually
new block contains a substantial number of transactions from the pool, so it's
easier to make one pass over it only keeping valid items rather than remove
them one by one and make an additional pass to recheck inputs/witnesses.

pkg/core/blockchain.go

@@ -611,9 +611,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
 	bc.topBlock.Store(block)
 	atomic.StoreUint32(&bc.blockHeight, block.Index)
 	updateBlockHeightMetric(block.Index)
-	for _, tx := range block.Transactions {
-		bc.memPool.Remove(tx.Hash())
-	}
+	bc.memPool.RemoveStale(bc.isTxStillRelevant)
 	return nil
 }
 
@@ -1043,6 +1041,35 @@ func (bc *Blockchain) verifyTx(t *transaction.Transaction, block *block.Block) e
 	return bc.verifyTxWitnesses(t, block)
 }
 
+// isTxStillRelevant is a callback for mempool transaction filtering after the
+// new block addition. It returns false for transactions already present in the
+// chain (added by the new block), transactions using some inputs that are
+// already used (double spends) and does witness reverification for non-standard
+// contracts. It operates under the assumption that full transaction verification
+// was already done so we don't need to check basic things like size, input/output
+// correctness, etc.
+func (bc *Blockchain) isTxStillRelevant(t *transaction.Transaction) bool {
+	var recheckWitness bool
+
+	if bc.dao.HasTransaction(t.Hash()) {
+		return false
+	}
+	if bc.dao.IsDoubleSpend(t) {
+		return false
+	}
+	for i := range t.Scripts {
+		if !vm.IsStandardContract(t.Scripts[i].VerificationScript) {
+			recheckWitness = true
+			break
+		}
+	}
+	if recheckWitness {
+		return bc.verifyTxWitnesses(t, nil) == nil
+	}
+	return true
+
+}
+
 // VerifyTx verifies whether a transaction is bonafide or not. Block parameter
 // is used for easy interop access and can be omitted for transactions that are
 // not yet added into any block.

pkg/core/mempool/mem_pool.go

@@ -207,6 +207,25 @@ func (mp *Pool) Remove(hash util.Uint256) {
 	mp.lock.Unlock()
 }
 
+// RemoveStale filters verified transactions through the given function keeping
+// only the transactions for which it returns a true result. It's used to quickly
+// drop part of the mempool that is now invalid after the block acceptance.
+func (mp *Pool) RemoveStale(isOK func(*transaction.Transaction) bool) {
+	mp.lock.Lock()
+	// We expect a lot of changes, so it's easier to allocate a new slice
+	// rather than move things in an old one.
+	newVerifiedTxes := make([]*item, 0, mp.capacity)
+	for _, itm := range mp.verifiedTxes {
+		if isOK(itm.txn) {
+			newVerifiedTxes = append(newVerifiedTxes, itm)
+		} else {
+			delete(mp.verifiedMap, itm.txn.Hash())
+		}
+	}
+	mp.verifiedTxes = newVerifiedTxes
+	mp.lock.Unlock()
+}
+
 // RemoveOverCapacity removes transactions with lowest fees until the total number of transactions
 // in the Pool is within the capacity of the Pool.
 func (mp *Pool) RemoveOverCapacity() {