Inside Bitcoin

251        self.log.info("Verify getheaders with null locator and invalid hashstop does not return headers.")
252        block = create_block(int(tip["hash"], 16), height=tip["height"] + 1, ntime=tip["mediantime"] + 1)
253        block.solve()
254        test_node.send_header_for_blocks([block])
255        test_node.clear_block_announcements()
256        test_node.send_get_headers(locator=[], hashstop=block.hash_int)
257        test_node.sync_with_ping()
258        assert_equal(test_node.block_announced, False)
259        inv_node.clear_block_announcements()
260        test_node.send_without_ping(msg_block(block))
261        inv_node.check_last_inv_announcement(inv=[block.hash_int])
262
263    def test_nonnull_locators(self, test_node, inv_node):
264        tip = int(self.nodes[0].getbestblockhash(), 16)
265
266        # PART 1
267        # 1. Mine a block; expect inv announcements each time
268        self.log.info("Part 1: headers don't start before sendheaders message...")
269        for i in range(4):
270            self.log.debug("Part 1.{}: starting...".format(i))
271            old_tip = tip
272            tip = self.mine_blocks(1)
273            inv_node.check_last_inv_announcement(inv=[tip])
274            test_node.check_last_inv_announcement(inv=[tip])
275            # Try a few different responses; none should affect next announcement
276            if i == 0:
277                # first request the block
278                test_node.send_get_data([tip])
279                test_node.wait_for_block(tip)
280            elif i == 1:
281                # next try requesting header and block
282                test_node.send_get_headers(locator=[old_tip], hashstop=tip)
283                test_node.send_get_data([tip])
284                test_node.wait_for_block(tip)
285                test_node.clear_block_announcements()  # since we requested headers...
286            elif i == 2:
287                # this time announce own block via headers
288                inv_node.clear_block_announcements()
289                height = self.nodes[0].getblockcount()
290                last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time']
291                block_time = last_time + 1
292                new_block = create_block(tip, height=height + 1, ntime=block_time)
293                new_block.solve()
294                test_node.send_header_for_blocks([new_block])
295                test_node.wait_for_getdata([new_block.hash_int])
296                test_node.send_and_ping(msg_block(new_block))  # make sure this block is processed
297                inv_node.wait_until(lambda: inv_node.block_announced)
298                inv_node.clear_block_announcements()
299                test_node.clear_block_announcements()
300
301        self.log.info("Part 1: success!")
302        self.log.info("Part 2: announce blocks with headers after sendheaders message...")
303        # PART 2
304        # 2. Send a sendheaders message and test that headers announcements
305        # commence and keep working.
306        test_node.send_without_ping(msg_sendheaders())
307        prev_tip = int(self.nodes[0].getbestblockhash(), 16)
308        test_node.send_get_headers(locator=[prev_tip], hashstop=0)
309        test_node.sync_with_ping()
310
311        # Now that we've synced headers, headers announcements should work
312        tip = self.mine_blocks(1)
313        expected_hash = tip
314        inv_node.check_last_inv_announcement(inv=[tip])
315        test_node.check_last_headers_announcement(headers=[tip])
316
317        height = self.nodes[0].getblockcount() + 1
318        block_time += 10  # Advance far enough ahead
319        for i in range(10):
320            self.log.debug("Part 2.{}: starting...".format(i))
321            # Mine i blocks, and alternate announcing either via
322            # inv (of tip) or via headers. After each, new blocks
323            # mined by the node should successfully be announced
324            # with block header, even though the blocks are never requested
325            for j in range(2):
326                self.log.debug("Part 2.{}.{}: starting...".format(i, j))
327                blocks = []
328                for _ in range(i + 1):
329                    blocks.append(create_block(tip, height=height, ntime=block_time))
330                    blocks[-1].solve()
331                    tip = blocks[-1].hash_int
332                    block_time += 1
333                    height += 1
334                if j == 0:
335                    # Announce via inv
336                    test_node.send_block_inv(tip)
337                    if i == 0:
338                        test_node.wait_for_getheaders(block_hash=expected_hash)
339                    else:
340                        assert "getheaders" not in test_node.last_message
341                    # Should have received a getheaders now
342                    test_node.send_header_for_blocks(blocks)
343                    # Test that duplicate inv's won't result in duplicate
344                    # getdata requests, or duplicate headers announcements
345                    [inv_node.send_block_inv(x.hash_int) for x in blocks]
346                    test_node.wait_for_getdata([x.hash_int for x in blocks])
347                    inv_node.sync_with_ping()
348                else:
349                    # Announce via headers
350                    test_node.send_header_for_blocks(blocks)
351                    test_node.wait_for_getdata([x.hash_int for x in blocks])
352                    # Test that duplicate headers won't result in duplicate
353                    # getdata requests (the check is further down)
354                    inv_node.send_header_for_blocks(blocks)
355                    inv_node.sync_with_ping()
356                [test_node.send_without_ping(msg_block(x)) for x in blocks]
357                test_node.sync_with_ping()
358                inv_node.sync_with_ping()
359                # This block should not be announced to the inv node (since it also
360                # broadcast it)
361                assert "inv" not in inv_node.last_message
362                assert "headers" not in inv_node.last_message
363                tip = self.mine_blocks(1)
364                inv_node.check_last_inv_announcement(inv=[tip])
365                test_node.check_last_headers_announcement(headers=[tip])
366                height += 1
367                block_time += 1
368
369        self.log.info("Part 2: success!")
370
371        self.log.info("Part 3: headers announcements can stop after large reorg, and resume after headers/inv from peer...")
372
373        # PART 3.  Headers announcements can stop after large reorg, and resume after
374        # getheaders or inv from peer.
375        for j in range(2):
376            self.log.debug("Part 3.{}: starting...".format(j))
377            # First try mining a reorg that can propagate with header announcement
378            new_block_hashes = self.mine_reorg(length=7)
379            tip = new_block_hashes[-1]
380            inv_node.check_last_inv_announcement(inv=[tip])
381            test_node.check_last_headers_announcement(headers=new_block_hashes)
382
383            block_time += 8
384
385            # Mine a too-large reorg, which should be announced with a single inv
386            new_block_hashes = self.mine_reorg(length=8)
387            tip = new_block_hashes[-1]
388            inv_node.check_last_inv_announcement(inv=[tip])
389            test_node.check_last_inv_announcement(inv=[tip])
390
391            block_time += 9
392
393            fork_point = self.nodes[0].getblock("%064x" % new_block_hashes[0])["previousblockhash"]
394            fork_point = int(fork_point, 16)
395
396            # Use getblocks/getdata
397            test_node.send_getblocks(locator=[fork_point])
398            test_node.check_last_inv_announcement(inv=new_block_hashes)
399            test_node.send_get_data(new_block_hashes)
400            test_node.wait_for_block(new_block_hashes[-1])
401
402            for i in range(3):
403                self.log.debug("Part 3.{}.{}: starting...".format(j, i))
404
405                # Mine another block, still should get only an inv
406                tip = self.mine_blocks(1)
407                inv_node.check_last_inv_announcement(inv=[tip])
408                test_node.check_last_inv_announcement(inv=[tip])
409                if i == 0:
410                    # Just get the data -- shouldn't cause headers announcements to resume
411                    test_node.send_get_data([tip])
412                    test_node.wait_for_block(tip)
413                elif i == 1:
414                    # Send a getheaders message that shouldn't trigger headers announcements
415                    # to resume (best header sent will be too old)
416                    test_node.send_get_headers(locator=[fork_point], hashstop=new_block_hashes[1])
417                    test_node.send_get_data([tip])
418                    test_node.wait_for_block(tip)
419                elif i == 2:
420                    # This time, try sending either a getheaders to trigger resumption
421                    # of headers announcements, or mine a new block and inv it, also
422                    # triggering resumption of headers announcements.
423                    test_node.send_get_data([tip])
424                    test_node.wait_for_block(tip)
425                    if j == 0:
426                        test_node.send_get_headers(locator=[tip], hashstop=0)
427                        test_node.sync_with_ping()
428                    else:
429                        test_node.send_block_inv(tip)
430                        test_node.sync_with_ping()
431            # New blocks should now be announced with header
432            tip = self.mine_blocks(1)
433            inv_node.check_last_inv_announcement(inv=[tip])
434            test_node.check_last_headers_announcement(headers=[tip])
435
436        self.log.info("Part 3: success!")
437
438        self.log.info("Part 4: Testing direct fetch behavior...")
439        tip = self.mine_blocks(1)
440        height = self.nodes[0].getblockcount() + 1
441        last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time']
442        block_time = last_time + 1
443
444        # Create 2 blocks.  Send the blocks, then send the headers.
445        blocks = []
446        for _ in range(2):
447            blocks.append(create_block(tip, height=height, ntime=block_time))
448            blocks[-1].solve()
449            tip = blocks[-1].hash_int
450            block_time += 1
451            height += 1
452            inv_node.send_without_ping(msg_block(blocks[-1]))
453
454        inv_node.sync_with_ping()  # Make sure blocks are processed
455        test_node.last_message.pop("getdata", None)
456        test_node.send_header_for_blocks(blocks)
457        test_node.sync_with_ping()
458        # should not have received any getdata messages
459        with p2p_lock:
460            assert "getdata" not in test_node.last_message
461
462        # This time, direct fetch should work
463        blocks = []
464        for _ in range(3):
465            blocks.append(create_block(tip, height=height, ntime=block_time))
466            blocks[-1].solve()
467            tip = blocks[-1].hash_int
468            block_time += 1
469            height += 1
470
471        test_node.send_header_for_blocks(blocks)
472        test_node.sync_with_ping()
473        test_node.wait_for_getdata([x.hash_int for x in blocks], timeout=DIRECT_FETCH_RESPONSE_TIME)
474
475        [test_node.send_without_ping(msg_block(x)) for x in blocks]
476
477        test_node.sync_with_ping()
478
479        # Now announce a header that forks the last two blocks
480        tip = blocks[0].hash_int
481        height -= 2
482        blocks = []
483
484        # Create extra blocks for later
485        for _ in range(20):
486            blocks.append(create_block(tip, height=height, ntime=block_time))
487            blocks[-1].solve()
488            tip = blocks[-1].hash_int
489            block_time += 1
490            height += 1
491
492        # Announcing one block on fork should not trigger direct fetch
493        # (less work than tip)
494        test_node.last_message.pop("getdata", None)
495        test_node.send_header_for_blocks(blocks[0:1])
496        test_node.sync_with_ping()
497        with p2p_lock:
498            assert "getdata" not in test_node.last_message
499
500        # Announcing one more block on fork should trigger direct fetch for