Inside Bitcoin

501
502        tx_grandparent = self.wallet.create_self_transfer()
503
504        # Create middle tx (both parent and child) which will be in orphanage.
505        tx_middle = self.wallet.create_self_transfer(utxo_to_spend=tx_grandparent["new_utxo"])
506
507        # Create a fake version of the middle tx
508        tx_orphan_bad_wit = malleate_tx_to_invalid_witness(tx_middle)
509
510        # Create grandchild spending from tx_middle (and spending from tx_orphan_bad_wit since they
511        # have the same txid).
512        tx_grandchild = self.wallet.create_self_transfer(utxo_to_spend=tx_middle["new_utxo"])
513
514        bad_peer = node.add_p2p_connection(P2PInterface())
515        honest_peer = node.add_p2p_connection(P2PInterface())
516
517        # 1. Fake orphan is received first. It is missing an input.
518        bad_peer.send_and_ping(msg_tx(tx_orphan_bad_wit))
519        assert tx_in_orphanage(node, tx_orphan_bad_wit)
520
521        # 2. Node requests missing tx_grandparent by txid.
522        grandparent_txid_int = int(tx_grandparent["txid"], 16)
523        node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
524        bad_peer.wait_for_getdata([grandparent_txid_int])
525
526        # 3. Honest peer relays the grandchild, which is missing a parent. The parent by txid already
527        # exists in orphanage, but should be re-requested because the node shouldn't assume that the
528        # witness data is the same. In this case, a same-txid-different-witness transaction exists!
529        honest_peer.send_and_ping(msg_tx(tx_grandchild["tx"]))
530        assert tx_in_orphanage(node, tx_grandchild["tx"])
531        middle_txid_int = int(tx_middle["txid"], 16)
532        node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
533        honest_peer.wait_for_getdata([middle_txid_int])
534
535        # 4. Honest peer relays the real child, which is also missing parents and should be placed
536        # in the orphanage.
537        honest_peer.send_and_ping(msg_tx(tx_middle["tx"]))
538        assert tx_in_orphanage(node, tx_middle["tx"])
539        assert_equal(len(node.getrawmempool()), 0)
540
541        # 5. Honest peer sends tx_grandparent
542        honest_peer.send_and_ping(msg_tx(tx_grandparent["tx"]))
543
544        # 6. After parent is accepted, orphans should be reconsidered.
545        # The real child should be accepted and the fake one rejected.
546        node_mempool = node.getrawmempool()
547        assert tx_grandparent["txid"] in node_mempool
548        assert tx_middle["txid"] in node_mempool
549        assert tx_grandchild["txid"] in node_mempool
550        assert_equal(node.getmempoolentry(tx_middle["txid"])["wtxid"], tx_middle["wtxid"])
551        self.wait_until(lambda: len(node.getorphantxs()) == 0)
552
553    @cleanup
554    def test_orphan_txid_inv(self):
555        self.log.info("Check node does not ignore announcement with same txid as tx in orphanage")
556        node = self.nodes[0]
557
558        tx_parent = self.wallet.create_self_transfer()
559
560        # Create the real child and fake version
561        tx_child = self.wallet.create_self_transfer(utxo_to_spend=tx_parent["new_utxo"])
562        tx_orphan_bad_wit = malleate_tx_to_invalid_witness(tx_child)
563
564        bad_peer = node.add_p2p_connection(PeerTxRelayer())
565        # Must not send wtxidrelay because otherwise the inv(TX) will be ignored later
566        honest_peer = node.add_p2p_connection(P2PInterface(wtxidrelay=False))
567
568        # 1. Fake orphan is received first. It is missing an input.
569        bad_peer.send_and_ping(msg_tx(tx_orphan_bad_wit))
570        assert tx_in_orphanage(node, tx_orphan_bad_wit)
571
572        # 2. Node requests the missing parent by txid.
573        parent_txid_int = int(tx_parent["txid"], 16)
574        node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
575        bad_peer.wait_for_getdata([parent_txid_int])
576
577        # 3. Honest peer announces the real child, by txid (this isn't common but the node should
578        # still keep track of it).
579        child_txid_int = int(tx_child["txid"], 16)
580        honest_peer.send_and_ping(msg_inv([CInv(t=MSG_TX, h=child_txid_int)]))
581
582        # 4. The child is requested. Honest peer sends it.
583        node.bumpmocktime(TXREQUEST_TIME_SKIP)
584        honest_peer.wait_for_getdata([child_txid_int])
585        honest_peer.send_and_ping(msg_tx(tx_child["tx"]))
586        assert tx_in_orphanage(node, tx_child["tx"])
587
588        # 5. After first parent request times out, the node sends another one for the missing parent
589        # of the real orphan child.
590        node.bumpmocktime(GETDATA_TX_INTERVAL)
591        honest_peer.wait_for_getdata([parent_txid_int])
592        honest_peer.send_and_ping(msg_tx(tx_parent["tx"]))
593
594        # 6. After parent is accepted, orphans should be reconsidered.
595        # The real child should be accepted and the fake one rejected. This may happen in either
596        # order since the message-processing is randomized. If tx_orphan_bad_wit is validated first,
597        # its consensus error leads to disconnection of bad_peer. If tx_child is validated first,
598        # tx_orphan_bad_wit is rejected for txn-same-nonwitness-data-in-mempool (no punishment).
599        node_mempool = node.getrawmempool()
600        assert tx_parent["txid"] in node_mempool
601        assert tx_child["txid"] in node_mempool
602        assert_equal(node.getmempoolentry(tx_child["txid"])["wtxid"], tx_child["wtxid"])
603        self.wait_until(lambda: len(node.getorphantxs()) == 0)
604
605
606    @cleanup
607    def test_orphan_handling_prefer_outbound(self):
608        self.log.info("Test that the node prefers requesting from outbound peers")
609        node = self.nodes[0]
610        orphan_wtxid, orphan_tx, parent_tx = self.create_parent_and_child()
611        orphan_inv = CInv(t=MSG_WTX, h=int(orphan_wtxid, 16))
612
613        peer_inbound = node.add_p2p_connection(PeerTxRelayer())
614        peer_outbound = node.add_outbound_p2p_connection(PeerTxRelayer(), p2p_idx=1)
615
616        # Inbound peer relays the transaction.
617        peer_inbound.send_and_ping(msg_inv([orphan_inv]))
618        self.nodes[0].bumpmocktime(TXREQUEST_TIME_SKIP)
619        peer_inbound.wait_for_getdata([int(orphan_wtxid, 16)])
620
621        # Both peers send invs for the orphan, so the node can expect both to know its ancestors.
622        peer_outbound.send_and_ping(msg_inv([orphan_inv]))
623
624        peer_inbound.send_and_ping(msg_tx(orphan_tx))
625
626        # There should be 1 orphan with 2 announcers (we don't know what their peer IDs are)
627        orphanage = node.getorphantxs(verbosity=2)
628        assert_equal(orphanage[0]["wtxid"], orphan_wtxid)
629        assert_equal(len(orphanage[0]["from"]), 2)
630
631        # The outbound peer should be preferred for getting orphan parents
632        self.nodes[0].bumpmocktime(TXID_RELAY_DELAY)
633        peer_outbound.wait_for_parent_requests([parent_tx.txid_int])
634
635        # There should be no request to the inbound peer
636        peer_inbound.assert_never_requested(parent_tx.txid_int)
637
638        self.log.info("Test that, if the preferred peer doesn't respond, the node sends another request")
639        self.nodes[0].bumpmocktime(GETDATA_TX_INTERVAL)
640        peer_inbound.sync_with_ping()
641        peer_inbound.wait_for_parent_requests([parent_tx.txid_int])
642
643    @cleanup
644    def test_maximal_package_protected(self):
645        self.log.info("Test that a node only announcing a maximally sized ancestor package is protected in orphanage")
646        self.nodes[0].setmocktime(int(time.time()))
647        node = self.nodes[0]
648
649        peer_normal = node.add_p2p_connection(P2PInterface())
650        peer_doser = node.add_p2p_connection(P2PInterface())
651
652        # Each of the num_peers peers creates a distinct set of orphans
653        large_orphans = [create_large_orphan() for _ in range(60)]
654
655        # Check to make sure these are orphans, within max standard size (to be accepted into the orphanage)
656        for large_orphan in large_orphans:
657            testres = node.testmempoolaccept([large_orphan.serialize().hex()])
658            assert not testres[0]["allowed"]
659            assert_equal(testres[0]["reject-reason"], "missing-inputs")
660
661        num_individual_dosers = 20
662        self.log.info(f"Connect {num_individual_dosers} peers and send a very large orphan from each one")
663        # This test assumes that unrequested transactions are processed (skipping inv and
664        # getdata steps because they require going through request delays)
665        # Connect 20 peers and have each of them send a large orphan.
666        for large_orphan in large_orphans[:num_individual_dosers]:
667            peer_doser_individual = node.add_p2p_connection(P2PInterface())
668            peer_doser_individual.send_and_ping(msg_tx(large_orphan))
669            node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY + 1)
670            peer_doser_individual.wait_for_getdata([large_orphan.vin[0].prevout.hash])
671
672        # Make sure that these transactions are going through the orphan handling codepaths.
673        # Subsequent rounds will not wait for getdata because the time mocking will cause the
674        # normal package request to time out.
675        self.wait_until(lambda: len(node.getorphantxs()) == num_individual_dosers)
676
677        # Now honest peer will send a maximally sized ancestor package of 24 orphans chaining
678        # off of a single missing transaction, with a total vsize 404,000Wu
679        ancestor_package = self.wallet.create_self_transfer_chain(chain_length=DEFAULT_ANCESTOR_LIMIT - 1)
680        sum_ancestor_package_vsize = sum([tx["tx"].get_vsize() for tx in ancestor_package])
681        final_tx = self.wallet.create_self_transfer(utxo_to_spend=ancestor_package[-1]["new_utxo"], target_vsize=101000 - sum_ancestor_package_vsize)
682        ancestor_package.append(final_tx)
683
684        # Peer sends all but first tx to fill up orphange with their orphans
685        for orphan in ancestor_package[1:]:
686            peer_normal.send_and_ping(msg_tx(orphan["tx"]))
687
688        orphan_set = node.getorphantxs()
689        for orphan in ancestor_package[1:]:
690            assert orphan["txid"] in orphan_set
691
692        # Wait for ultimate parent request (the root ancestor transaction)
693        parent_txid_int = ancestor_package[0]["tx"].txid_int
694        node.bumpmocktime(NONPREF_PEER_TX_DELAY + TXID_RELAY_DELAY)
695
696        self.wait_until(lambda: "getdata" in peer_normal.last_message and parent_txid_int in [inv.hash for inv in peer_normal.last_message.get("getdata").inv])
697
698        self.log.info("Send another round of very large orphans from a DoSy peer")
699        for large_orphan in large_orphans[num_individual_dosers:]:
700            peer_doser.send_and_ping(msg_tx(large_orphan))
701
702        self.log.info("Provide the top ancestor. The whole package should be re-evaluated after enough time.")
703        peer_normal.send_and_ping(msg_tx(ancestor_package[0]["tx"]))
704
705        # Wait until all transactions have been processed. When the last tx is accepted, it's
706        # guaranteed to have all ancestors.
707        self.wait_until(lambda: node.getmempoolentry(final_tx["txid"])["ancestorcount"] == DEFAULT_ANCESTOR_LIMIT)
708
709    @cleanup
710    def test_announcers_before_and_after(self):
711        self.log.info("Test that the node uses all peers who announced the tx prior to realizing it's an orphan")
712        node = self.nodes[0]
713        orphan_wtxid, orphan_tx, parent_tx = self.create_parent_and_child()
714        orphan_inv = CInv(t=MSG_WTX, h=int(orphan_wtxid, 16))
715
716        # Announces before tx is sent, disconnects while node is requesting parents
717        peer_early_disconnected = node.add_outbound_p2p_connection(PeerTxRelayer(), p2p_idx=3)
718        # Announces before tx is sent, doesn't respond to parent request
719        peer_early_unresponsive = node.add_p2p_connection(PeerTxRelayer())
720
721        # Announces after tx is sent
722        peer_late_announcer = node.add_p2p_connection(PeerTxRelayer())
723
724        # Both peers send invs for the orphan, so the node can expect both to know its ancestors.
725        peer_early_disconnected.send_and_ping(msg_inv([orphan_inv]))
726        self.nodes[0].bumpmocktime(TXREQUEST_TIME_SKIP)
727        peer_early_disconnected.wait_for_getdata([int(orphan_wtxid, 16)])
728        peer_early_unresponsive.send_and_ping(msg_inv([orphan_inv]))
729        peer_early_disconnected.send_and_ping(msg_tx(orphan_tx))
730
731        # There should be 1 orphan with 2 announcers (we don't know what their peer IDs are)
732        orphanage = node.getorphantxs(verbosity=2)
733        assert_equal(len(orphanage), 1)
734        assert_equal(orphanage[0]["wtxid"], orphan_wtxid)
735        assert_equal(len(orphanage[0]["from"]), 2)
736
737        # Peer disconnects before responding to request
738        self.nodes[0].bumpmocktime(TXID_RELAY_DELAY)
739        peer_early_disconnected.wait_for_parent_requests([parent_tx.txid_int])
740        peer_early_disconnected.peer_disconnect()
741
742        # The orphan should have 1 announcer left after the node finishes disconnecting peer_early_disconnected.
743        self.wait_until(lambda: len(node.getorphantxs(verbosity=2)[0]["from"]) == 1)
744
745        # The node should retry with the other peer that announced the orphan earlier.
746        # This node's request was additionally delayed because it's an inbound peer.
747        self.nodes[0].bumpmocktime(NONPREF_PEER_TX_DELAY)
748        peer_early_unresponsive.wait_for_parent_requests([parent_tx.txid_int])
749
750        self.log.info("Test that the node uses peers who announce the tx after realizing it's an orphan")