Inside Bitcoin

501        utxo = self.utxos.pop(0)
502
503        block = self.build_block_with_transactions(node, utxo, 5)
504        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
505        comp_block = HeaderAndShortIDs()
506        comp_block.initialize_from_block(block, use_witness=True)
507
508        test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])
509
510        msg_bt = msg_no_witness_blocktxn()
511        msg_bt = msg_blocktxn()  # serialize with witnesses
512        msg_bt.block_transactions = BlockTransactions(block.hash_int, block.vtx[1:])
513        test_tip_after_message(node, test_node, msg_bt, block.hash_int)
514
515        utxo = self.utxos.pop(0)
516        block = self.build_block_with_transactions(node, utxo, 5)
517        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
518
519        # Now try interspersing the prefilled transactions
520        comp_block.initialize_from_block(block, prefill_list=[0, 1, 5], use_witness=True)
521        test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
522        msg_bt.block_transactions = BlockTransactions(block.hash_int, block.vtx[2:5])
523        test_tip_after_message(node, test_node, msg_bt, block.hash_int)
524
525        # Now try giving one transaction ahead of time.
526        utxo = self.utxos.pop(0)
527        block = self.build_block_with_transactions(node, utxo, 5)
528        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
529        test_node.send_and_ping(msg_tx(block.vtx[1]))
530        assert block.vtx[1].txid_hex in node.getrawmempool()
531
532        # Prefill 4 out of the 6 transactions, and verify that only the one
533        # that was not in the mempool is requested.
534        comp_block.initialize_from_block(block, prefill_list=[0, 2, 3, 4], use_witness=True)
535        test_getblocktxn_response(comp_block, test_node, [5])
536
537        msg_bt.block_transactions = BlockTransactions(block.hash_int, [block.vtx[5]])
538        test_tip_after_message(node, test_node, msg_bt, block.hash_int)
539
540        # Now provide all transactions to the node before the block is
541        # announced and verify reconstruction happens immediately.
542        utxo = self.utxos.pop(0)
543        block = self.build_block_with_transactions(node, utxo, 10)
544        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
545        for tx in block.vtx[1:]:
546            test_node.send_without_ping(msg_tx(tx))
547        test_node.sync_with_ping()
548        # Make sure all transactions were accepted.
549        mempool = node.getrawmempool()
550        for tx in block.vtx[1:]:
551            assert tx.txid_hex in mempool
552
553        # Clear out last request.
554        test_node.clear_getblocktxn()
555
556        # Send compact block
557        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
558        test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.hash_int)
559        with p2p_lock:
560            # Shouldn't have gotten a request for any transaction
561            assert "getblocktxn" not in test_node.last_message
562
563    # Incorrectly responding to a getblocktxn shouldn't cause the block to be
564    # permanently failed.
565    def test_incorrect_blocktxn_response(self, test_node):
566        node = self.nodes[0]
567        utxo = self.utxos.pop(0)
568
569        block = self.build_block_with_transactions(node, utxo, 10)
570        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
571        # Relay the first 5 transactions from the block in advance
572        for tx in block.vtx[1:6]:
573            test_node.send_without_ping(msg_tx(tx))
574        test_node.sync_with_ping()
575        # Make sure all transactions were accepted.
576        mempool = node.getrawmempool()
577        for tx in block.vtx[1:6]:
578            assert tx.txid_hex in mempool
579
580        # Send compact block
581        comp_block = HeaderAndShortIDs()
582        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
583        test_node.clear_getblocktxn()
584        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
585        expected_indices = [6, 7, 8, 9, 10]
586        self.getblocktxn_expected(test_node, block.hash_int, expected_indices)
587
588        # Now give an incorrect response.
589        # Note that it's possible for bitcoind to be smart enough to know we're
590        # lying, since it could check to see if the shortid matches what we're
591        # sending, and eg disconnect us for misbehavior.  If that behavior
592        # change was made, we could just modify this test by having a
593        # different peer provide the block further down, so that we're still
594        # verifying that the block isn't marked bad permanently. This is good
595        # enough for now.
596        msg = msg_blocktxn()
597        msg.block_transactions = BlockTransactions(block.hash_int, [block.vtx[5]] + block.vtx[7:])
598        test_node.send_and_ping(msg)
599
600        # Tip should not have updated
601        assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
602
603        # We should receive a getdata request
604        test_node.wait_for_getdata([block.hash_int], timeout=10)
605        assert test_node.last_message["getdata"].inv[0].type in (MSG_BLOCK, MSG_BLOCK | MSG_WITNESS_FLAG)
606
607        # Deliver the block
608        test_node.send_and_ping(msg_block(block))
609        assert_equal(node.getbestblockhash(), block.hash_hex)
610
611    # Multiple blocktxn responses will cause a node to get disconnected.
612    def test_multiple_blocktxn_response(self, test_node):
613        node = self.nodes[0]
614        utxo = self.utxos.pop(0)
615
616        block = self.build_block_with_transactions(node, utxo, 2)
617
618        # The attacker sends the block header so that we request it.
619        test_node.send_without_ping(msg_headers([block]))
620        test_node.wait_for_getdata([block.hash_int], timeout=30)
621
622        # Send compact block
623        comp_block = HeaderAndShortIDs()
624        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
625        test_node.clear_getblocktxn()
626        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
627        self.getblocktxn_expected(test_node, block.hash_int, indices=[1,2])
628
629        # Send a blocktxn that does not succeed in reconstruction, triggering
630        # getdata fallback.
631        msg = msg_blocktxn()
632        msg.block_transactions = BlockTransactions(block.hash_int, [block.vtx[2]] + [block.vtx[1]])
633        test_node.send_and_ping(msg)
634
635        # Tip should not have updated
636        assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
637
638        # We should receive a getdata request
639        test_node.wait_for_getdata([block.hash_int], timeout=10)
640        assert test_node.last_message["getdata"].inv[0].type in (MSG_BLOCK, MSG_BLOCK | MSG_WITNESS_FLAG)
641
642        # Send the same blocktxn and assert the sender gets disconnected.
643        with node.assert_debug_log(['previous compact block reconstruction attempt failed']):
644            test_node.send_without_ping(msg)
645            test_node.wait_for_disconnect()
646
647    def test_getblocktxn_handler(self, test_node):
648        node = self.nodes[0]
649        # bitcoind will not send blocktxn responses for blocks whose height is
650        # more than 10 blocks deep.
651        MAX_GETBLOCKTXN_DEPTH = 10
652        chain_height = node.getblockcount()
653        current_height = chain_height
654        while (current_height >= chain_height - MAX_GETBLOCKTXN_DEPTH):
655            block_hash = node.getblockhash(current_height)
656            block = from_hex(CBlock(), node.getblock(block_hash, False))
657
658            msg = msg_getblocktxn()
659            msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [])
660            num_to_request = random.randint(1, len(block.vtx))
661            msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request)))
662            test_node.send_without_ping(msg)
663            test_node.wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10)
664
665            with p2p_lock:
666                assert_equal(test_node.last_message["blocktxn"].block_transactions.blockhash, int(block_hash, 16))
667                all_indices = msg.block_txn_request.to_absolute()
668                for index in all_indices:
669                    tx = test_node.last_message["blocktxn"].block_transactions.transactions.pop(0)
670                    assert_equal(tx.txid_hex, block.vtx[index].txid_hex)
671                    # Check that the witness matches
672                    assert_equal(tx.wtxid_hex, block.vtx[index].wtxid_hex)
673                test_node.last_message.pop("blocktxn", None)
674            current_height -= 1
675
676        # Next request should send a full block response, as we're past the
677        # allowed depth for a blocktxn response.
678        block_hash = node.getblockhash(current_height)
679        msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [0])
680        with p2p_lock:
681            test_node.last_message.pop("block", None)
682            test_node.last_message.pop("blocktxn", None)
683        test_node.send_and_ping(msg)
684        with p2p_lock:
685            assert_equal(test_node.last_message["block"].block.hash_hex, block_hash)
686            assert "blocktxn" not in test_node.last_message
687
688        # Request with out-of-bounds tx index results in disconnect
689        bad_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
690        block_hash = node.getblockhash(chain_height)
691        block = from_hex(CBlock(), node.getblock(block_hash, False))
692        msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [len(block.vtx)])
693        with node.assert_debug_log(['getblocktxn with out-of-bounds tx indices']):
694            bad_peer.send_without_ping(msg)
695            bad_peer.wait_for_disconnect()
696
697    def test_low_work_compactblocks(self, test_node):
698        # A compactblock with insufficient work won't get its header included
699        node = self.nodes[0]
700        hashPrevBlock = int(node.getblockhash(node.getblockcount() - 150), 16)
701        block = self.build_block_on_tip(node)
702        block.hashPrevBlock = hashPrevBlock
703        block.solve()
704
705        comp_block = HeaderAndShortIDs()
706        comp_block.initialize_from_block(block)
707        with self.nodes[0].assert_debug_log(['[net] Ignoring low-work compact block from peer 0']):
708            test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
709
710        tips = node.getchaintips()
711        found = False
712        for x in tips:
713            if x["hash"] == block.hash_hex:
714                found = True
715                break
716        assert not found
717
718    def test_compactblocks_not_at_tip(self, test_node):
719        node = self.nodes[0]
720        # Test that requesting old compactblocks doesn't work.
721        MAX_CMPCTBLOCK_DEPTH = 5
722        new_blocks = []
723        for _ in range(MAX_CMPCTBLOCK_DEPTH + 1):
724            test_node.clear_block_announcement()
725            new_blocks.append(self.generate(node, 1)[0])
726            test_node.wait_until(test_node.received_block_announcement, timeout=30)
727
728        test_node.clear_block_announcement()
729        test_node.send_without_ping(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
730        test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
731
732        test_node.clear_block_announcement()
733        self.generate(node, 1)
734        test_node.wait_until(test_node.received_block_announcement, timeout=30)
735        test_node.clear_block_announcement()
736        with p2p_lock:
737            test_node.last_message.pop("block", None)
738        test_node.send_without_ping(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
739        test_node.wait_until(lambda: "block" in test_node.last_message, timeout=30)
740        with p2p_lock:
741            assert_equal(test_node.last_message["block"].block.hash_hex, new_blocks[0])
742
743        # Generate an old compactblock, and verify that it's not accepted.
744        cur_height = node.getblockcount()
745        hashPrevBlock = int(node.getblockhash(cur_height - 5), 16)
746        block = self.build_block_on_tip(node)
747        block.hashPrevBlock = hashPrevBlock
748        block.solve()
749
750        comp_block = HeaderAndShortIDs()