From 70772dd4693ba6b09901a6b812eef21fa240b666 Mon Sep 17 00:00:00 2001 From: glozow Date: Wed, 23 Jul 2025 14:54:52 -0400 Subject: [PATCH] [test] cut the number of transactions involved in 1p1c DoS tests We just need enough transactions to push us above the orphanage limits and trigger trimming. Reducing the number of transactions cuts the runtime of this test significantly. --- test/functional/p2p_opportunistic_1p1c.py | 39 ++++++++++------------- 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/test/functional/p2p_opportunistic_1p1c.py b/test/functional/p2p_opportunistic_1p1c.py index e841cf08061..546d38ca093 100755 --- a/test/functional/p2p_opportunistic_1p1c.py +++ b/test/functional/p2p_opportunistic_1p1c.py @@ -407,9 +407,10 @@ class PackageRelayTest(BitcoinTestFramework): peer_normal = node.add_p2p_connection(P2PInterface()) peer_doser = node.add_p2p_connection(P2PInterface()) + num_individual_dosers = 10 self.log.info("Create very large orphans to be sent by DoSy peers (may take a while)") - large_orphans = [create_large_orphan() for _ in range(100)] + large_orphans = [create_large_orphan() for _ in range(50)] # Check to make sure these are orphans, within max standard size (to be accepted into the orphanage) for large_orphan in large_orphans: assert_greater_than_or_equal(100000, large_orphan.get_vsize()) @@ -419,11 +420,10 @@ class PackageRelayTest(BitcoinTestFramework): assert not testres[0]["allowed"] assert_equal(testres[0]["reject-reason"], "missing-inputs") - num_individual_dosers = 30 self.log.info(f"Connect {num_individual_dosers} peers and send a very large orphan from each one") # This test assumes that unrequested transactions are processed (skipping inv and # getdata steps because they require going through request delays) - # Connect 20 peers and have each of them send a large orphan. + # Connect 10 peers and have each of them send a large orphan. for large_orphan in large_orphans[:num_individual_dosers]: peer_doser_individual = node.add_p2p_connection(P2PInterface()) peer_doser_individual.send_and_ping(msg_tx(large_orphan)) @@ -459,7 +459,7 @@ class PackageRelayTest(BitcoinTestFramework): peer_normal.wait_for_getdata([parent_txid_int]) self.log.info("Send another round of very large orphans from a DoSy peer") - for large_orphan in large_orphans[30:]: + for large_orphan in large_orphans[num_individual_dosers:]: peer_doser.send_and_ping(msg_tx(large_orphan)) # Something was evicted; the orphanage does not contain all large orphans + the 1p1c child @@ -477,12 +477,12 @@ class PackageRelayTest(BitcoinTestFramework): peer_normal = node.add_p2p_connection(P2PInterface()) - # 2 sets of peers: the first set all send the same batch_size orphans. The second set each - # sends batch_size distinct orphans. + # The first set of peers all send the same batch_size orphans. Then a single peer sends + # batch_single_doser distinct orphans. batch_size = 51 num_peers_shared = 60 - num_peers_unique = 40 - + batch_single_doser = 100 + assert_greater_than(num_peers_shared * batch_size + batch_single_doser, 3000) # 60 peers * 51 orphans = 3060 announcements shared_orphans = [self.create_small_orphan() for _ in range(batch_size)] self.log.info(f"Send the same {batch_size} orphans from {num_peers_shared} DoSy peers (may take a while)") @@ -522,22 +522,15 @@ class PackageRelayTest(BitcoinTestFramework): node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY) peer_normal.wait_for_getdata([parent_txid_int]) - # Each of the num_peers_unique peers creates a distinct set of orphans - many_orphans = [self.create_small_orphan() for _ in range(batch_size * num_peers_unique)] + self.log.info(f"Send {batch_single_doser} new orphans from one DoSy peer") + peer_doser_batch = node.add_p2p_connection(P2PInterface()) + this_batch_orphans = [self.create_small_orphan() for _ in range(batch_single_doser)] + for tx in this_batch_orphans: + # Don't wait for responses, because it dramatically increases the runtime of this test. + peer_doser_batch.send_without_ping(msg_tx(tx)) - self.log.info(f"Send sets of {batch_size} orphans from {num_peers_unique} DoSy peers (may take a while)") - for peernum in range(num_peers_unique): - peer_doser_batch = node.add_p2p_connection(P2PInterface()) - this_batch_orphans = many_orphans[batch_size*peernum : batch_size*(peernum+1)] - for tx in this_batch_orphans: - # Don't wait for responses, because it dramatically increases the runtime of this test. - peer_doser_batch.send_without_ping(msg_tx(tx)) - - # Ensure at least one of the peer's orphans shows up in getorphantxs. Since each peer is - # reserved a portion of orphanage space, this must happen as long as the orphans are not - # rejected for some other reason. - peer_doser_batch.sync_with_ping() - self.wait_until(lambda: any([tx.txid_hex in node.getorphantxs() for tx in this_batch_orphans])) + peer_doser_batch.sync_with_ping() + self.wait_until(lambda: any([tx.txid_hex in node.getorphantxs() for tx in this_batch_orphans])) self.log.info("Check that orphan from normal peer still exists in orphanage") assert high_fee_child["txid"] in node.getorphantxs()