Inside Bitcoin

251        # Before each test, sync the headers chain.
252        test_node.request_headers_and_sync(locator=[tip])
253
254        # Now try a SENDCMPCT message with too-low version
255        test_node.send_and_ping(msg_sendcmpct(announce=True, version=1))
256        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
257
258        # Headers sync before next test.
259        test_node.request_headers_and_sync(locator=[tip])
260
261        # Now try a SENDCMPCT message with too-high version
262        test_node.send_and_ping(msg_sendcmpct(announce=True, version=3))
263        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
264
265        # Headers sync before next test.
266        test_node.request_headers_and_sync(locator=[tip])
267
268        # Now try a SENDCMPCT message with valid version, but announce=False
269        test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
270        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
271
272        # Headers sync before next test.
273        test_node.request_headers_and_sync(locator=[tip])
274
275        # Finally, try a SENDCMPCT message with announce=True
276        test_node.send_and_ping(msg_sendcmpct(announce=True, version=2))
277        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
278
279        # Try one more time (no headers sync should be needed!)
280        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
281
282        # Try one more time, after turning on sendheaders
283        test_node.send_and_ping(msg_sendheaders())
284        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
285
286        # Try one more time, after sending a version=1, announce=false message.
287        test_node.send_and_ping(msg_sendcmpct(announce=False, version=1))
288        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
289
290        # Now turn off announcements
291        test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
292        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message and "headers" in p.last_message)
293
294    # BIP152 mandates that the announce field of a sendcmpct message is a
295    # boolean and MUST have a value of either 1 or 0. Sending any other value
296    # should be treated as misbehavior and lead to a disconnect.
297    def test_invalid_sendcmpct_announce(self):
298        node = self.nodes[0]
299        bad_peer = node.add_p2p_connection(TestP2PConn())
300        msg = msg_sendcmpct(announce=2, version=2)
301        with node.assert_debug_log(['invalid sendcmpct announce field']):
302            bad_peer.send_await_disconnect(msg)
303
304    # This test actually causes bitcoind to (reasonably!) disconnect us, so do this last.
305    # Note, these are not consensus-invalid blocks, but improperly constructed cmpctblock messages.
306    def test_invalid_cmpctblock_message(self):
307        # Make a high-bandwidth peer
308        hb_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
309        self.request_cb_announcements(hb_peer)
310        self.make_peer_hb_to_candidate(self.nodes[0], hb_peer)
311        self.assert_highbandwidth_states(self.nodes[0], idx=-1, hb_to=True, hb_from=True)
312
313        # Make a low-bandwidth peer
314        lb_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
315        self.request_cb_announcements(lb_peer)
316        self.assert_highbandwidth_states(self.nodes[0], idx=-1, hb_to=False, hb_from=True)
317
318        # Construct an invalid cmpctblock message
319        self.generate(self.nodes[0], COINBASE_MATURITY + 1)
320        block = self.build_block_on_tip(self.nodes[0])
321        cmpct_block = P2PHeaderAndShortIDs()
322        cmpct_block.header = CBlockHeader(block)
323        cmpct_block.prefilled_txn_length = 1
324        too_high_prefill_idx = 1
325        prefilled_txn = PrefilledTransaction(too_high_prefill_idx, block.vtx[0])
326        cmpct_block.prefilled_txn = [prefilled_txn]
327
328        # Test an unsolicited invalid cmpctblock from an HB peer.
329        hb_peer.send_await_disconnect(msg_cmpctblock(cmpct_block))
330        assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.hashPrevBlock)
331
332        # Test a solicited invalid cmpctblock from a non-HB peer.
333        lb_peer.send_header_for_blocks([block])
334        lb_peer.wait_for_getdata([block.hash_int], timeout=30)
335        lb_peer.send_await_disconnect(msg_cmpctblock(cmpct_block))
336        assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.hashPrevBlock)
337
338    # Compare the generated shortids to what we expect based on BIP 152, given
339    # bitcoind's choice of nonce.
340    def test_compactblock_construction(self, test_node):
341        node = self.nodes[0]
342        # Generate a bunch of transactions.
343        self.generate(node, COINBASE_MATURITY + 1)
344        num_transactions = 25
345
346        segwit_tx_generated = False
347        for _ in range(num_transactions):
348            hex_tx = self.wallet.send_self_transfer(from_node=self.nodes[0])['hex']
349            tx = tx_from_hex(hex_tx)
350            if not tx.wit.is_null():
351                segwit_tx_generated = True
352
353        assert segwit_tx_generated  # check that our test is not broken
354
355        # Wait until we've seen the block announcement for the resulting tip
356        tip = int(node.getbestblockhash(), 16)
357        test_node.wait_for_block_announcement(tip)
358
359        # Make sure we will receive a fast-announce compact block
360        self.request_cb_announcements(test_node)
361
362        # Now mine a block, and look at the resulting compact block.
363        test_node.clear_block_announcement()
364        block_hash = int(self.generate(node, 1)[0], 16)
365
366        # Store the raw block in our internal format.
367        block = from_hex(CBlock(), node.getblock("%064x" % block_hash, False))
368
369        # Wait until the block was announced (via compact blocks)
370        test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
371
372        # Now fetch and check the compact block
373        header_and_shortids = None
374        with p2p_lock:
375            # Convert the on-the-wire representation to absolute indexes
376            header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
377        self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
378
379        # Now fetch the compact block using a normal non-announce getdata
380        test_node.clear_block_announcement()
381        inv = CInv(MSG_CMPCT_BLOCK, block_hash)
382        test_node.send_without_ping(msg_getdata([inv]))
383
384        test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
385
386        # Now fetch and check the compact block
387        header_and_shortids = None
388        with p2p_lock:
389            # Convert the on-the-wire representation to absolute indexes
390            header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
391        self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
392
393    def check_compactblock_construction_from_block(self, header_and_shortids, block_hash, block):
394        # Check that we got the right block!
395        assert_equal(header_and_shortids.header.hash_int, block_hash)
396
397        # Make sure the prefilled_txn appears to have included the coinbase
398        assert len(header_and_shortids.prefilled_txn) >= 1
399        assert_equal(header_and_shortids.prefilled_txn[0].index, 0)
400
401        # Check that all prefilled_txn entries match what's in the block.
402        for entry in header_and_shortids.prefilled_txn:
403            # This checks the non-witness parts of the tx agree
404            assert_equal(entry.tx.txid_hex, block.vtx[entry.index].txid_hex)
405
406            # And this checks the witness
407            assert_equal(entry.tx.wtxid_hex, block.vtx[entry.index].wtxid_hex)
408
409        # Check that the cmpctblock message announced all the transactions.
410        assert_equal(len(header_and_shortids.prefilled_txn) + len(header_and_shortids.shortids), len(block.vtx))
411
412        # And now check that all the shortids are as expected as well.
413        # Determine the siphash keys to use.
414        [k0, k1] = header_and_shortids.get_siphash_keys()
415
416        index = 0
417        while index < len(block.vtx):
418            if (len(header_and_shortids.prefilled_txn) > 0 and
419                    header_and_shortids.prefilled_txn[0].index == index):
420                # Already checked prefilled transactions above
421                header_and_shortids.prefilled_txn.pop(0)
422            else:
423                tx_hash = block.vtx[index].wtxid_int
424                shortid = calculate_shortid(k0, k1, tx_hash)
425                assert_equal(shortid, header_and_shortids.shortids[0])
426                header_and_shortids.shortids.pop(0)
427            index += 1
428
429    # Test that bitcoind requests compact blocks when we announce new blocks
430    # via header or inv, and that responding to getblocktxn causes the block
431    # to be successfully reconstructed.
432    def test_compactblock_requests(self, test_node):
433        node = self.nodes[0]
434        # Try announcing a block with an inv or header, expect a compactblock
435        # request
436        for announce in ["inv", "header"]:
437            block = self.build_block_on_tip(node)
438
439            if announce == "inv":
440                test_node.send_without_ping(msg_inv([CInv(MSG_BLOCK, block.hash_int)]))
441                test_node.wait_for_getheaders(timeout=30)
442                test_node.send_header_for_blocks([block])
443            else:
444                test_node.send_header_for_blocks([block])
445            test_node.wait_for_getdata([block.hash_int], timeout=30)
446            assert_equal(test_node.last_message["getdata"].inv[0].type, 4)
447
448            # Send back a compactblock message that omits the coinbase
449            comp_block = HeaderAndShortIDs()
450            comp_block.header = CBlockHeader(block)
451            comp_block.nonce = 0
452            [k0, k1] = comp_block.get_siphash_keys()
453            coinbase_hash = block.vtx[0].wtxid_int
454            comp_block.shortids = [calculate_shortid(k0, k1, coinbase_hash)]
455            test_node.clear_getblocktxn()
456            test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
457            assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
458            # Expect a getblocktxn message that requests the coinbase.
459            self.getblocktxn_expected(test_node, block.hash_int, indices=[0])
460
461            # Send the coinbase, and verify that the tip advances.
462            msg = msg_blocktxn()
463            msg.block_transactions.blockhash = block.hash_int
464            msg.block_transactions.transactions = [block.vtx[0]]
465            test_node.send_and_ping(msg)
466            assert_equal(node.getbestblockhash(), block.hash_hex)
467
468    # Create a chain of transactions from given utxo, and add to a new block.
469    def build_block_with_transactions(self, node, utxo, num_transactions):
470        block = self.build_block_on_tip(node)
471
472        for _ in range(num_transactions):
473            tx = CTransaction()
474            tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
475            tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
476            utxo = [tx.txid_int, 0, tx.vout[0].nValue]
477            block.vtx.append(tx)
478
479        block.hashMerkleRoot = block.calc_merkle_root()
480        block.solve()
481        return block
482
483    # Test that we only receive getblocktxn requests for transactions that the
484    # node needs, and that responding to them causes the block to be
485    # reconstructed.
486    def test_getblocktxn_requests(self, test_node):
487        node = self.nodes[0]
488
489        def test_getblocktxn_response(compact_block, peer, expected_result):
490            msg = msg_cmpctblock(compact_block.to_p2p())
491            peer.clear_getblocktxn()
492            peer.send_and_ping(msg)
493            self.getblocktxn_expected(peer, compact_block.header.hash_int, expected_result)
494
495        def test_tip_after_message(node, peer, msg, tip):
496            peer.send_and_ping(msg)
497            assert_equal(int(node.getbestblockhash(), 16), tip)
498
499        # First try announcing compactblocks that won't reconstruct, and verify
500        # that we receive getblocktxn messages back.