Inside Bitcoin

251        self.restart_node(0)
252        self.nodes[0].setmocktime(int(time.time()))
253
254        # Peer that is immediately asked, but never responds.
255        # This will set us up to have two ready requests, one
256        # of which is preferred and one which is not
257        unresponsive_peer = self.nodes[0].add_outbound_p2p_connection(
258           TestP2PConn(), wait_for_verack=True, p2p_idx=0, connection_type="outbound-full-relay")
259        unresponsive_peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=0xff00ff00)]))
260        unresponsive_peer.wait_until(lambda: unresponsive_peer.tx_getdata_count >= 1, timeout=1)
261
262        # A bunch of incoming (non-preferred) connections that advertise the same tx
263        non_pref_peers = []
264        NUM_INBOUND = 10
265        for _ in range(NUM_INBOUND):
266            non_pref_peers.append(self.nodes[0].add_p2p_connection(TestP2PConn()))
267            non_pref_peers[-1].send_and_ping(msg_inv([CInv(t=MSG_WTX, h=0xff00ff00)]))
268
269        # Check that no request made due to in-flight
270        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY)
271        with p2p_lock:
272            for peer in non_pref_peers:
273                assert_equal(peer.tx_getdata_count, 0)
274
275        # Now add another outbound (preferred) which is immediately ready for consideration
276        # upon advertisement
277        pref_peer = self.nodes[0].add_outbound_p2p_connection(
278           TestP2PConn(), wait_for_verack=True, p2p_idx=1, connection_type="outbound-full-relay")
279        pref_peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=0xff00ff00)]))
280
281        assert_equal(len(self.nodes[0].getpeerinfo()), NUM_INBOUND + 2)
282
283        # Still have to wait for in-flight to timeout
284        with p2p_lock:
285            assert_equal(pref_peer.tx_getdata_count, 0)
286
287        # Timeout in-flight
288        self.nodes[0].bumpmocktime(GETDATA_TX_INTERVAL - NONPREF_PEER_TX_DELAY)
289
290        # Preferred peers are *always* selected next if ready
291        pref_peer.wait_until(lambda: pref_peer.tx_getdata_count >= 1, timeout=10)
292
293        # And none for non-preferred
294        for non_pref_peer in non_pref_peers:
295            with p2p_lock:
296                assert_equal(non_pref_peer.tx_getdata_count, 0)
297
298    def test_txid_inv_delay(self, glob_wtxid=False):
299        self.log.info('Check that inv from a txid-relay peers are delayed by {} s, with a wtxid peer {}'.format(TXID_RELAY_DELAY, glob_wtxid))
300        self.restart_node(0, extra_args=['[email protected]'])
301        mock_time = int(time.time() + 1)
302        self.nodes[0].setmocktime(mock_time)
303        peer = self.nodes[0].add_p2p_connection(TestP2PConn(wtxidrelay=False))
304        if glob_wtxid:
305            # Add a second wtxid-relay connection otherwise TXID_RELAY_DELAY is waived in
306            # lack of wtxid-relay peers
307            self.nodes[0].add_p2p_connection(TestP2PConn(wtxidrelay=True))
308        peer.send_and_ping(msg_inv([CInv(t=MSG_TX, h=0xff11ff11)]))
309        with p2p_lock:
310            assert_equal(peer.tx_getdata_count, 0 if glob_wtxid else 1)
311        self.nodes[0].setmocktime(mock_time + TXID_RELAY_DELAY)
312        peer.wait_until(lambda: peer.tx_getdata_count >= 1, timeout=1)
313
314    def test_large_inv_batch(self):
315        self.log.info('Test how large inv batches are handled with relay permission')
316        self.restart_node(0, extra_args=['[email protected]'])
317        peer = self.nodes[0].add_p2p_connection(TestP2PConn())
318        peer.send_without_ping(msg_inv([CInv(t=MSG_WTX, h=wtxid) for wtxid in range(MAX_PEER_TX_ANNOUNCEMENTS + 1)]))
319        peer.wait_until(lambda: peer.tx_getdata_count == MAX_PEER_TX_ANNOUNCEMENTS + 1)
320
321        self.log.info('Test how large inv batches are handled without relay permission')
322        self.restart_node(0)
323        peer = self.nodes[0].add_p2p_connection(TestP2PConn())
324        peer.send_without_ping(msg_inv([CInv(t=MSG_WTX, h=wtxid) for wtxid in range(MAX_PEER_TX_ANNOUNCEMENTS + 1)]))
325        peer.wait_until(lambda: peer.tx_getdata_count == MAX_PEER_TX_ANNOUNCEMENTS)
326        peer.sync_with_ping()
327
328    def test_duplicate_tx_inv(self):
329        self.log.info('Check that duplicate transaction identifiers in one inv message are processed once')
330        node = self.nodes[0]
331        node.logging(include=['net'])
332
333        def send_invs_and_read_log(peer, invs):
334            log_start = node.debug_log_size(encoding='utf-8')
335            peer.send_and_ping(msg_inv(invs))
336            with open(node.debug_log_path, encoding='utf-8', errors='replace') as debug_log:
337                debug_log.seek(log_start)
338                return debug_log.read()
339
340        for wtxidrelay, inv_type, inv_name, mismatched_type, mismatched_name, hash_a, hash_b in [
341            (False, MSG_TX, 'tx', MSG_WTX, 'wtx', 0xaabbcc, 0xddeeff),
342            (True, MSG_WTX, 'wtx', MSG_TX, 'tx', 0x112233, 0x445566),
343        ]:
344            peer = node.add_p2p_connection(TestP2PConn(wtxidrelay=wtxidrelay))
345            inv_a_log = f"got inv: {inv_name} {hash_a:064x}"
346            inv_b_log = f"got inv: {inv_name} {hash_b:064x}"
347            mismatched_inv_log = f"got inv: {mismatched_name} {hash_a:064x}"
348
349            log = send_invs_and_read_log(peer, [
350                CInv(t=mismatched_type, h=hash_a),
351                CInv(t=inv_type, h=hash_a),
352                CInv(t=inv_type, h=hash_b),
353                CInv(t=inv_type, h=hash_a),
354                CInv(t=inv_type, h=hash_b),
355            ])
356            assert_equal(log.count(inv_a_log), 1)
357            assert_equal(log.count(inv_b_log), 1)
358            assert_equal(log.count(mismatched_inv_log), 0)
359
360            # The duplicate filter is scoped to a single INV message.
361            log = send_invs_and_read_log(peer, [
362                CInv(t=inv_type, h=hash_a),
363                CInv(t=inv_type, h=hash_a),
364            ])
365            assert_equal(log.count(inv_a_log), 1)
366            assert_equal(log.count(inv_b_log), 0)
367
368        self.log.info('Check that MSG_TX and MSG_WITNESS_TX are deduplicated as txids')
369        peer = node.add_p2p_connection(TestP2PConn(wtxidrelay=False))
370        for first_type, first_name, second_type, second_name, hash_a in [
371            (MSG_TX, 'tx', MSG_WITNESS_TX, 'witness-tx', 0x667788),
372            (MSG_WITNESS_TX, 'witness-tx', MSG_TX, 'tx', 0x778899),
373        ]:
374            log = send_invs_and_read_log(peer, [
375                CInv(t=first_type, h=hash_a),
376                CInv(t=second_type, h=hash_a),
377            ])
378            assert_equal(log.count(f"got inv: {first_name} {hash_a:064x}"), 1)
379            assert_equal(log.count(f"got inv: {second_name} {hash_a:064x}"), 0)
380
381        self.log.info('Check that txids and wtxids are deduplicated separately')
382        peer = node.add_p2p_connection(TestP2PConn(wtxidrelay=True))
383        for first_type, second_type, hash_a in [
384            (MSG_WITNESS_TX, MSG_WTX, 0x8899aa),
385            (MSG_WTX, MSG_WITNESS_TX, 0x99aabb),
386        ]:
387            log = send_invs_and_read_log(peer, [
388                CInv(t=first_type, h=hash_a),
389                CInv(t=second_type, h=hash_a),
390            ])
391            assert_equal(log.count(f"got inv: witness-tx {hash_a:064x}"), 1)
392            assert_equal(log.count(f"got inv: wtx {hash_a:064x}"), 1)
393
394    def test_spurious_notfound(self):
395        self.log.info('Check that spurious notfound is ignored')
396        self.nodes[0].p2ps[0].send_without_ping(msg_notfound(vec=[CInv(MSG_TX, 1)]))
397
398    def test_rejects_filter_reset(self):
399        self.log.info('Check that rejected tx is not requested again')
400        node = self.nodes[0]
401        fill_mempool(self, node, tx_sync_fun=self.no_op)
402        self.wallet.rescan_utxos()
403        mempoolminfee = node.getmempoolinfo()['mempoolminfee']
404        peer = node.add_p2p_connection(TestP2PConn())
405        low_fee_tx = self.wallet.create_self_transfer(fee_rate=Decimal("0.9")*mempoolminfee)
406        assert_equal(node.testmempoolaccept([low_fee_tx['hex']])[0]["reject-reason"], "mempool min fee not met")
407        peer.send_and_ping(msg_tx(low_fee_tx['tx']))
408        peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=int(low_fee_tx['wtxid'], 16))]))
409        node.setmocktime(int(time.time()))
410        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
411        peer.sync_with_ping()
412        assert_equal(peer.tx_getdata_count, 0)
413
414        self.log.info('Check that rejection filter is cleared after new block comes in')
415        self.generate(self.wallet, 1, sync_fun=self.no_op)
416        peer.sync_with_ping()
417        peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=int(low_fee_tx['wtxid'], 16))]))
418        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
419        peer.wait_for_getdata([int(low_fee_tx['wtxid'], 16)])
420
421    def test_inv_wtxidrelay_mismatch(self):
422        self.log.info("Check that INV messages that don't match the wtxidrelay setting are ignored")
423        node = self.nodes[0]
424        wtxidrelay_on_peer = node.add_p2p_connection(TestP2PConn(wtxidrelay=True))
425        wtxidrelay_off_peer = node.add_p2p_connection(TestP2PConn(wtxidrelay=False))
426        random_tx = self.wallet.create_self_transfer()
427
428        # MSG_TX INV from wtxidrelay=True peer -> mismatch, ignored
429        wtxidrelay_on_peer.send_and_ping(msg_inv([CInv(t=MSG_TX, h=int(random_tx['txid'], 16))]))
430        node.setmocktime(int(time.time()))
431        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
432        wtxidrelay_on_peer.sync_with_ping()
433        assert_equal(wtxidrelay_on_peer.tx_getdata_count, 0)
434
435        # MSG_WTX INV from wtxidrelay=False peer -> mismatch, ignored
436        wtxidrelay_off_peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=int(random_tx['wtxid'], 16))]))
437        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
438        wtxidrelay_off_peer.sync_with_ping()
439        assert_equal(wtxidrelay_off_peer.tx_getdata_count, 0)
440
441        # MSG_TX INV from wtxidrelay=False peer works
442        wtxidrelay_off_peer.send_and_ping(msg_inv([CInv(t=MSG_TX, h=int(random_tx['txid'], 16))]))
443        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
444        wtxidrelay_off_peer.wait_for_getdata([int(random_tx['txid'], 16)])
445
446        # MSG_WTX INV from wtxidrelay=True peer works
447        wtxidrelay_on_peer.send_and_ping(msg_inv([CInv(t=MSG_WTX, h=int(random_tx['wtxid'], 16))]))
448        node.bumpmocktime(MAX_GETDATA_INBOUND_WAIT)
449        wtxidrelay_on_peer.wait_for_getdata([int(random_tx['wtxid'], 16)])
450
451    def run_test(self):
452        self.wallet = MiniWallet(self.nodes[0])
453
454        # Run tests without mocktime that only need one peer-connection first, to avoid restarting the nodes
455        self.test_expiry_fallback()
456        self.test_disconnect_fallback()
457        self.test_notfound_fallback()
458        self.test_preferred_tiebreaker_inv()
459        self.test_preferred_inv(ConnectionType.INBOUND)
460        self.test_preferred_inv(ConnectionType.OUTBOUND)
461        self.test_preferred_inv(ConnectionType.WHITELIST)
462        self.test_txid_inv_delay()
463        self.test_txid_inv_delay(True)
464        self.test_large_inv_batch()
465        self.test_duplicate_tx_inv()
466        self.test_spurious_notfound()
467
468        # Run each test against new bitcoind instances, as setting mocktimes has long-term effects on when
469        # the next trickle relay event happens.
470        for test, with_inbounds in [
471            (self.test_in_flight_max, True),
472            (self.test_inv_block, True),
473            (self.test_tx_requests, True),
474            (self.test_rejects_filter_reset, False),
475            (self.test_inv_wtxidrelay_mismatch, False),
476        ]:
477            self.stop_nodes()
478            self.start_nodes()
479            self.connect_nodes(1, 0)
480            # Setup the p2p connections
481            self.peers = []
482            if with_inbounds:
483                for node in self.nodes:
484                    for _ in range(NUM_INBOUND):
485                        self.peers.append(node.add_p2p_connection(TestP2PConn()))
486                self.log.info("Nodes are setup with {} incoming connections each".format(NUM_INBOUND))
487            test()
488
489if __name__ == '__main__':
490    TxDownloadTest(__file__).main()
491