Update tests to the new mocktime and RequestObject

Author: Duddino

src/net_processing.cpp

@@ -632,7 +632,7 @@ std::chrono::microseconds CalculateObjectGetDataTime(const CInv& inv, std::chron
     return process_time;
 }
 
-void RequestObject(CNodeState* state, const CInv& inv, std::chrono::microseconds current_time, bool fForce = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+void RequestObject(CNodeState* state, const CInv& inv, std::chrono::microseconds current_time, bool fForce = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     CNodeState::TxDownloadState& peer_download_state = state->m_tx_download;
     if (peer_download_state.m_tx_announced.size() >= MAX_PEER_TX_ANNOUNCEMENTS || peer_download_state.m_tx_announced.count(inv)) {
@@ -660,7 +660,7 @@ void RequestObject(NodeId nodeId, const CInv& inv, std::chrono::microseconds cur
     AssertLockHeld(cs_main);
     auto* state = State(nodeId);
     if (!state) {
-        return;
+      return;
     }
 
     RequestObject(state, inv, current_time, fForce);
@@ -2400,8 +2400,25 @@ bool static ProcessMessage(CNode* pfrom, std::string strCommand, CDataStream& vR
     }
 
     else if (strCommand == NetMsgType::NOTFOUND) {
-        // We do not care about the NOTFOUND message (for now), but logging an Unknown Command
-        // message is undesirable as we transmit it ourselves.
+        // Remove the NOTFOUND transactions from the peer
+        LOCK(cs_main);
+        CNodeState *state = State(pfrom->GetId());
+        std::vector<CInv> vInv;
+        vRecv >> vInv;
+        if (vInv.size() <= MAX_PEER_TX_IN_FLIGHT + MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
+            for (CInv &inv : vInv) {
+                //  If we receive a NOTFOUND message for a txid we requested, erase
+                //  it from our data structures for this peer.
+                auto in_flight_it = state->m_tx_download.m_tx_in_flight.find(inv);
+                if (in_flight_it == state->m_tx_download.m_tx_in_flight.end()) {
+                    // Skip any further work if this is a spurious NOTFOUND
+                    // message.
+                    continue;
+                }
+                    state->m_tx_download.m_tx_in_flight.erase(in_flight_it);
+                    state->m_tx_download.m_tx_announced.erase(inv);
+                }
+        }
         return true;
     }
 

src/net_processing.h

@@ -15,9 +15,9 @@ extern RecursiveMutex cs_main; // !TODO: change mutex to cs_orphans
 /** Default for -maxorphantx, maximum number of orphan transactions kept in memory */
 static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 25;
 /** Expiration time for orphan transactions in seconds */
-static const int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
+static const int64_t ORPHAN_TX_EXPIRE_TIME = 5 * 60;
 /** Minimum time between orphan transactions expire time checks in seconds */
-static const int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
+static const int64_t ORPHAN_TX_EXPIRE_INTERVAL = 1 * 60;
 /** Default for -blockspamfilter, use header spam filter */
 static const bool DEFAULT_BLOCK_SPAM_FILTER = true;
 /** Default for -blockspamfiltermaxsize, maximum size of the list of indexes in the block spam filter */

test/functional/p2p_invalid_messages.py

@@ -8,11 +8,11 @@
 import time
 
 from test_framework import messages
+from test_framework.messages import CTxIn, COutPoint, msg_mnping
 from test_framework.mininode import (
     P2PDataStore,
     P2PInterface,
 )
-from test_framework.messages import CTxIn, COutPoint, msg_mnping
 from test_framework.test_framework import PivxTestFramework
 from test_framework.util import (
     assert_equal,
@@ -212,24 +212,26 @@ def test_large_inv(self):
     def test_fill_askfor(self):
         self.nodes[0].generate(1) # IBD
         conn = self.nodes[0].add_p2p_connection(InvReceiver())
+        self.disable_mocktime()
         invs = []
         blockhash = int(self.nodes[0].getbestblockhash(), 16)
-        for _ in range(50000):
+        total_requests = 100
+        for _ in range(total_requests):
             mnp = msg_mnping(CTxIn(COutPoint(getrandbits(256))), blockhash, int(time.time()))
-            conn.vec_mnp[mnp.get_hash()] = mnp
-            invs.append(messages.CInv(15, mnp.get_hash()))
-        assert_equal(len(conn.vec_mnp), 50000)
-        assert_equal(len(invs), 50000)
+            hash = mnp.get_hash()
+            conn.vec_mnp[hash] = mnp
+            invs.append(messages.CInv(15, hash))
+        assert_equal(len(conn.vec_mnp), total_requests)
+        assert_equal(len(invs), total_requests)
         msg = messages.msg_inv(invs)
         conn.send_message(msg)
-        conn.wait_for_p2p_messages(50000)
-
+        conn.wait_for_p2p_messages(total_requests)
         # Prior #2611 the node was blocking any follow-up request.
         mnp = msg_mnping(CTxIn(COutPoint(getrandbits(256))), getrandbits(256), int(time.time()))
         conn.vec_mnp[mnp.get_hash()] = mnp
         msg = messages.msg_inv([messages.CInv(15, mnp.get_hash())])
         conn.send_and_ping(msg)
-        conn.wait_for_p2p_messages(50001)
+        conn.wait_for_p2p_messages(total_requests + 1)
         self.nodes[0].disconnect_p2ps()
 
     def test_resource_exhaustion(self):

test/functional/test_framework/messages.py

@@ -1246,10 +1246,16 @@ def serialize(self):
         r += ser_string(self.vch_sig)
         r += struct.pack("<I", self.mess_version)
         return r
+    def serialize_for_hash(self):
+        r = b""
+        r += self.vin.serialize()
+        r += ser_uint256(self.blockhash)
+        r += struct.pack("<q", self.sigtime)
+        return r
 
     def get_hash(self):
         if self.cached_hash == b"":
-            self.cached_hash = uint256_from_str(hash256(self.serialize()))
+            self.cached_hash = uint256_from_str(hash256(self.serialize_for_hash()))
         return self.cached_hash
 
     def __repr__(self):

test/functional/test_framework/test_framework.py

@@ -1037,7 +1037,7 @@ def wait_until_mnsync_finished(self):
             raise AssertionError("Unable to complete mnsync: %s" % str(synced))
 
 
-    def wait_until_mn_status(self, status, mnTxHash, _timeout, orEmpty=False, with_ping_mns=None):
+    def wait_until_mn_status(self, status, mnTxHash, _timeout, orEmpty=False, with_ping_mns=None, wait_func = None):
         if with_ping_mns is None:
             with_ping_mns = []
         nodes_status = [None] * self.num_nodes
@@ -1054,6 +1054,8 @@ def all_synced():
         time.sleep(2)
         timeout = time.time() + _timeout
         while not all_synced() and time.time() < timeout:
+            if wait_func is not None:
+                wait_func()
             for i in range(self.num_nodes):
                 if not node_synced(i):
                     nodes_status[i] = self.get_mn_status(self.nodes[i], mnTxHash)
@@ -1066,10 +1068,10 @@ def all_synced():
             raise AssertionError(strErr)
 
 
-    def wait_until_mn_enabled(self, mnTxHash, _timeout, _with_ping_mns=None):
+    def wait_until_mn_enabled(self, mnTxHash, _timeout, _with_ping_mns=None, wait_func = None):
         if _with_ping_mns is None:
             _with_ping_mns = []
-        self.wait_until_mn_status("ENABLED", mnTxHash, _timeout, with_ping_mns=_with_ping_mns)
+        self.wait_until_mn_status("ENABLED", mnTxHash, _timeout, with_ping_mns=_with_ping_mns, wait_func=wait_func)
 
 
     def wait_until_mn_preenabled(self, mnTxHash, _timeout, _with_ping_mns=None):

test/functional/tiertwo_governance_invalid_budget.py

@@ -127,8 +127,8 @@ def setupContext(self):
         self.wait_until_mn_preenabled(self.mnOneCollateral.hash, 40)
         self.wait_until_mn_preenabled(self.mnOneCollateral.hash, 40)
         self.send_3_pings([self.mn1, self.mn2])
-        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [self.mn1, self.mn2])
-        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [self.mn1, self.mn2])
+        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [self.mn1, self.mn2], lambda: self.advance_mocktime(2))
+        self.wait_until_mn_enabled(self.mnTwoCollateral.hash, 120, [self.mn1, self.mn2], lambda: self.advance_mocktime(2))
 
         # activate sporks
         self.log.info("Masternodes enabled. Activating sporks.")

test/functional/tiertwo_governance_reorg.py

@@ -85,8 +85,8 @@ def run_test(self):
         self.wait_until_mn_preenabled(self.mnOneCollateral.hash, 40)
         self.wait_until_mn_preenabled(self.mnOneCollateral.hash, 40)
         self.send_3_pings([mn1, mn2])
-        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [mn1, mn2])
-        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [mn1, mn2])
+        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [mn1, mn2], lambda: self.advance_mocktime(2))
+        self.wait_until_mn_enabled(self.mnOneCollateral.hash, 120, [mn1, mn2], lambda: self.advance_mocktime(2))
 
         # activate sporks
         self.log.info("Masternodes enabled. Activating sporks.")