Inside Bitcoin

751        comp_block.initialize_from_block(block)
752        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
753
754        tips = node.getchaintips()
755        found = False
756        for x in tips:
757            if x["hash"] == block.hash_hex:
758                assert_equal(x["status"], "headers-only")
759                found = True
760                break
761        assert found
762
763        # Requesting this block via getblocktxn should silently fail
764        # (to avoid fingerprinting attacks).
765        msg = msg_getblocktxn()
766        msg.block_txn_request = BlockTransactionsRequest(block.hash_int, [0])
767        with p2p_lock:
768            test_node.last_message.pop("blocktxn", None)
769        test_node.send_and_ping(msg)
770        with p2p_lock:
771            assert "blocktxn" not in test_node.last_message
772
773    def test_end_to_end_block_relay(self, listeners):
774        node = self.nodes[0]
775        utxo = self.utxos.pop(0)
776
777        block = self.build_block_with_transactions(node, utxo, 10)
778
779        [l.clear_block_announcement() for l in listeners]
780
781        # serialize without witness (this block has no witnesses anyway).
782        # TODO: repeat this test with witness tx's to a segwit node.
783        node.submitblock(block.serialize().hex())
784
785        for l in listeners:
786            l.wait_until(lambda: "cmpctblock" in l.last_message, timeout=30)
787        with p2p_lock:
788            for l in listeners:
789                assert_equal(l.last_message["cmpctblock"].header_and_shortids.header.hash_int, block.hash_int)
790
791    # Test that we don't get disconnected if we relay a compact block with valid header,
792    # but invalid transactions.
793    def test_invalid_tx_in_compactblock(self, test_node):
794        node = self.nodes[0]
795        utxo = self.utxos.pop(0)
796
797        block = self.build_block_with_transactions(node, utxo, 5)
798        block.hashMerkleRoot = block.calc_merkle_root()
799        # Drop the coinbase witness but include the witness commitment.
800        add_witness_commitment(block)
801        block.vtx[0].wit.vtxinwit = []
802        block.solve()
803
804        # Now send the compact block with all transactions prefilled, and
805        # verify that we don't get disconnected.
806        comp_block = HeaderAndShortIDs()
807        comp_block.initialize_from_block(block, prefill_list=list(range(len(block.vtx))), use_witness=True)
808        msg = msg_cmpctblock(comp_block.to_p2p())
809        test_node.send_and_ping(msg)
810
811        # Check that the tip didn't advance
812        assert_not_equal(node.getbestblockhash(), block.hash_hex)
813        test_node.sync_with_ping()
814
815        # Re-establish a proper witness commitment with the coinbase witness, but
816        # invalidate the last tx in the block.
817        block.vtx[4].vin[0].scriptSig = CScript([OP_RETURN])
818        block.hashMerkleRoot = block.calc_merkle_root()
819        add_witness_commitment(block)
820        block.solve()
821
822        # This will lead to a consensus failure for which we also won't be disconnected but which
823        # will be cached.
824        comp_block.initialize_from_block(block, prefill_list=list(range(len(block.vtx))), use_witness=True)
825        msg = msg_cmpctblock(comp_block.to_p2p())
826        test_node.send_and_ping(msg)
827
828        # The tip still didn't advance.
829        assert_not_equal(node.getbestblockhash(), block.hash_hex)
830        test_node.sync_with_ping()
831
832        # The failure above was cached. Submitting the compact block again will return a cached
833        # consensus error (the code path is different) and still not get us disconnected (nor
834        # advance the tip).
835        test_node.send_and_ping(msg)
836        assert_not_equal(node.getbestblockhash(), block.hash_hex)
837        test_node.sync_with_ping()
838
839        # Now, announcing a second block building on top of the invalid one will get us disconnected.
840        block.hashPrevBlock = block.hash_int
841        block.solve()
842        comp_block.initialize_from_block(block, prefill_list=list(range(len(block.vtx))), use_witness=True)
843        msg = msg_cmpctblock(comp_block.to_p2p())
844        test_node.send_await_disconnect(msg)
845
846    def test_empty_getblocktxn_disconnects(self):
847        self.log.info("Testing empty getblocktxn disconnects the peer...")
848        node = self.nodes[0]
849        block_hash = int(node.getbestblockhash(), 16)
850        peer = node.add_p2p_connection(P2PInterface())
851        msg = msg_getblocktxn()
852        msg.block_txn_request = BlockTransactionsRequest(blockhash=block_hash, indexes=[])
853        with node.assert_debug_log(['getblocktxn received with no transaction indexes']):
854            peer.send_without_ping(msg)
855            peer.wait_for_disconnect()
856
857    # peer generates a block and sends it to node, which makes the peer a
858    # candidate for high-bandwidth 'to' (up to 3 peers according to BIP 152)
859    def make_peer_hb_to_candidate(self, node, peer):
860        block = self.build_block_on_tip(node)
861        peer.send_and_ping(msg_block(block))
862
863    # Helper for enabling cb announcements
864    # Send the sendcmpct request and sync headers
865    def request_cb_announcements(self, peer):
866        node = self.nodes[0]
867        tip = node.getbestblockhash()
868        peer.get_headers(locator=[int(tip, 16)], hashstop=0)
869        peer.send_and_ping(msg_sendcmpct(announce=True, version=2))
870
871    def test_compactblock_reconstruction_stalling_peer(self, stalling_peer, delivery_peer):
872        node = self.nodes[0]
873
874        self.make_peer_hb_to_candidate(node, delivery_peer)
875        block, cmpct_block = self.announce_cmpct_block(node, stalling_peer)
876
877        for tx in block.vtx[1:]:
878            delivery_peer.send_without_ping(msg_tx(tx))
879        delivery_peer.sync_with_ping()
880        mempool = node.getrawmempool()
881        for tx in block.vtx[1:]:
882            assert tx.txid_hex in mempool
883
884        delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
885        assert_equal(node.getbestblockhash(), block.hash_hex)
886
887        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
888
889        # Now test that delivering an invalid compact block won't break relay
890
891        block, cmpct_block = self.announce_cmpct_block(node, stalling_peer)
892        for tx in block.vtx[1:]:
893            delivery_peer.send_without_ping(msg_tx(tx))
894        delivery_peer.sync_with_ping()
895
896        cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [CTxInWitness()]
897        cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(0)]
898
899        cmpct_block.use_witness = True
900        delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
901        assert_not_equal(node.getbestblockhash(), block.hash_hex)
902
903        msg = msg_no_witness_blocktxn()
904        msg.block_transactions.blockhash = block.hash_int
905        msg.block_transactions.transactions = block.vtx[1:]
906        stalling_peer.send_and_ping(msg)
907        assert_equal(node.getbestblockhash(), block.hash_hex)
908
909    # assert the RPC getpeerinfo boolean fields `bip152_hb_{to, from}`
910    # match the given parameters for the peer at idx of a given node
911    @staticmethod
912    def assert_highbandwidth_states(node, idx, hb_to, hb_from):
913        peerinfo = node.getpeerinfo()[idx]
914        assert_equal(peerinfo['bip152_hb_to'], hb_to)
915        assert_equal(peerinfo['bip152_hb_from'], hb_from)
916
917    def test_highbandwidth_mode_states_via_getpeerinfo(self):
918        # create new p2p connection for a fresh state w/o any prior sendcmpct messages sent
919        hb_test_node = self.nodes[0].add_p2p_connection(TestP2PConn())
920
921        # Newly created hb_test_node is the last connection.
922        hb_test_node_idx = -1
923
924        # initially, neither node has selected the other peer as high-bandwidth yet
925        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=False, hb_from=False)
926
927        # peer requests high-bandwidth mode by sending sendcmpct(1)
928        hb_test_node.send_and_ping(msg_sendcmpct(announce=True, version=2))
929        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=False, hb_from=True)
930
931        # peer generates a block and sends it to node, which should
932        # select the peer as high-bandwidth (up to 3 peers according to BIP 152)
933        block = self.build_block_on_tip(self.nodes[0])
934        hb_test_node.send_and_ping(msg_block(block))
935        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=True, hb_from=True)
936
937        # peer requests low-bandwidth mode by sending sendcmpct(0)
938        hb_test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
939        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=True, hb_from=False)
940
941    def test_compactblock_reconstruction_parallel_reconstruction(self, stalling_peer, delivery_peer, inbound_peer, outbound_peer):
942        """ All p2p connections are inbound except outbound_peer. We test that ultimate parallel slot
943            can only be taken by an outbound node unless prior attempts were done by an outbound
944        """
945        node = self.nodes[0]
946
947        for name, peer in [("delivery", delivery_peer), ("inbound", inbound_peer), ("outbound", outbound_peer)]:
948            self.log.info(f"Setting {name} as high bandwidth peer")
949            self.make_peer_hb_to_candidate(node, peer)
950            block, cmpct_block = self.announce_cmpct_block(node, peer, 1)
951            msg = msg_blocktxn()
952            msg.block_transactions.blockhash = block.hash_int
953            msg.block_transactions.transactions = block.vtx[1:]
954            peer.send_and_ping(msg)
955            assert_equal(node.getbestblockhash(), block.hash_hex)
956            peer.clear_getblocktxn()
957
958        # Test the simple parallel download case...
959        for num_missing in [1, 5, 20]:
960            delivery_peer.clear_getblocktxn()
961            inbound_peer.clear_getblocktxn()
962            outbound_peer.clear_getblocktxn()
963
964            # Remaining low-bandwidth peer is stalling_peer, who announces first
965            assert_equal([peer['bip152_hb_to'] for peer in node.getpeerinfo()], [False, True, True, True])
966
967            block, cmpct_block = self.announce_cmpct_block(node, stalling_peer, num_missing, solicit=True)
968
969            delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
970            # The second peer to announce should still get a getblocktxn
971            self.getblocktxn_expected(delivery_peer, block.hash_int)
972
973            inbound_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
974            with p2p_lock:
975                # The third inbound peer to announce should *not* get a getblocktxn
976                assert "getblocktxn" not in inbound_peer.last_message
977            assert_not_equal(node.getbestblockhash(), block.hash_hex)
978
979            outbound_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
980            # The third peer to announce should get a getblocktxn if outbound
981            self.getblocktxn_expected(outbound_peer, block.hash_int)
982
983            # Second peer completes the compact block first
984            msg = msg_blocktxn()
985            msg.block_transactions.blockhash = block.hash_int
986            msg.block_transactions.transactions = block.vtx[1:]
987            delivery_peer.send_and_ping(msg)
988            assert_equal(node.getbestblockhash(), block.hash_hex)
989
990            # Nothing bad should happen if we get a late fill from the first peer...
991            stalling_peer.send_and_ping(msg)
992            self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
993
994    def test_compact_blocks_ignored(self):
995        node = self.nodes[0]
996
997        def build_compact_block():
998            # generate a compact block to send that will force a GETBLOCKTXN
999            utxo = self.utxos.pop(0)
1000            block = self.build_block_with_transactions(node, utxo, 10)