Inside Bitcoin

251        assert_equal(snapshot['blocks'], SNAPSHOT_BASE_HEIGHT)
252
253        # Both states should have the same nBits and target
254        assert_equal(normal['bits'], nbits_str(REGTEST_N_BITS))
255        assert_equal(normal['bits'], snapshot['bits'])
256        assert_equal(normal['target'], target_str(REGTEST_TARGET))
257        assert_equal(normal['target'], snapshot['target'])
258
259        # Now lets sync the nodes and wait for the background validation to finish
260        self.connect_nodes(0, 3)
261        self.sync_blocks(nodes=(n0, n3))
262        self.wait_until(lambda: len(n3.getchainstates()['chainstates']) == 1)
263
264    def test_snapshot_not_on_most_work_chain(self, dump_output_path):
265        self.log.info("Test snapshot is not loaded when the node knows the headers of another chain with more work.")
266        node0 = self.nodes[0]
267        node1 = self.nodes[1]
268        # Create an alternative chain of 2 new blocks, forking off the main chain at the block before the snapshot block.
269        # This simulates a longer chain than the main chain when submitting these two block headers to node 1 because it is only aware of
270        # the main chain headers up to the snapshot height.
271        parent_block_hash = node0.getblockhash(SNAPSHOT_BASE_HEIGHT - 1)
272        block_time = node0.getblock(node0.getbestblockhash())['time'] + 1
273        fork_block1 = create_block(int(parent_block_hash, 16), height=SNAPSHOT_BASE_HEIGHT, ntime=block_time)
274        fork_block1.solve()
275        fork_block2 = create_block(fork_block1.hash_int, height=SNAPSHOT_BASE_HEIGHT + 1, ntime=block_time + 1)
276        fork_block2.solve()
277        node1.submitheader(fork_block1.serialize().hex())
278        node1.submitheader(fork_block2.serialize().hex())
279        msg = "A forked headers-chain with more work than the chain with the snapshot base block header exists. Please proceed to sync without AssumeUtxo."
280        assert_raises_rpc_error(-32603, msg, node1.loadtxoutset, dump_output_path)
281        # Cleanup: submit two more headers of the snapshot chain to node 1, so that it is the most-work chain again and loading
282        # the snapshot in future subtests succeeds
283        main_block1 = node0.getblock(node0.getblockhash(SNAPSHOT_BASE_HEIGHT + 1), 0)
284        main_block2 = node0.getblock(node0.getblockhash(SNAPSHOT_BASE_HEIGHT + 2), 0)
285        node1.submitheader(main_block1)
286        node1.submitheader(main_block2)
287
288    def test_sync_from_assumeutxo_node(self, snapshot):
289        """
290        This test verifies that:
291        1. An IBD node can sync headers from an AssumeUTXO node at any time.
292        2. IBD nodes do not request historical blocks from AssumeUTXO nodes while they are syncing the background-chain.
293        3. The assumeUTXO node dynamically adjusts the network services it offers according to its state.
294        4. IBD nodes can fully sync from AssumeUTXO nodes after they finish the background-chain sync.
295        """
296        self.log.info("Testing IBD-sync from assumeUTXO node")
297        # Node2 starts clean and loads the snapshot.
298        # Node3 starts clean and seeks to sync-up from snapshot_node.
299        miner = self.nodes[0]
300        snapshot_node = self.nodes[2]
301        ibd_node = self.nodes[3]
302
303        # Start test fresh by cleaning up node directories
304        for node in (snapshot_node, ibd_node):
305            self.stop_node(node.index)
306            self.cleanup_folder(node.chain_path)
307            self.start_node(node.index, extra_args=self.extra_args[node.index])
308
309        # Sync-up headers chain on snapshot_node to load snapshot
310        headers_provider_conn = snapshot_node.add_p2p_connection(P2PInterface())
311        headers_provider_conn.wait_for_getheaders()
312        msg = msg_headers()
313        for block_num in range(1, miner.getblockcount()+1):
314            msg.headers.append(from_hex(CBlockHeader(), miner.getblockheader(miner.getblockhash(block_num), verbose=False)))
315        headers_provider_conn.send_without_ping(msg)
316
317        # Ensure headers arrived
318        default_value = {'status': ''}  # No status
319        headers_tip_hash = miner.getbestblockhash()
320        self.wait_until(lambda: next(filter(lambda x: x['hash'] == headers_tip_hash, snapshot_node.getchaintips()), default_value)['status'] == "headers-only")
321        snapshot_node.disconnect_p2ps()
322
323        # Load snapshot
324        snapshot_node.loadtxoutset(snapshot['path'])
325
326        # Connect nodes and verify the ibd_node can sync-up the headers-chain from the snapshot_node
327        self.connect_nodes(ibd_node.index, snapshot_node.index)
328        snapshot_block_hash = snapshot['base_hash']
329        self.wait_until(lambda: next(filter(lambda x: x['hash'] == snapshot_block_hash, ibd_node.getchaintips()), default_value)['status'] == "headers-only")
330
331        # Once the headers-chain is synced, the ibd_node must avoid requesting historical blocks from the snapshot_node.
332        # If it does request such blocks, the snapshot_node will ignore requests it cannot fulfill, causing the ibd_node
333        # to stall. This stall could last for up to 10 min, ultimately resulting in an abrupt disconnection due to the
334        # ibd_node's perceived unresponsiveness.
335        ensure_for(duration=3, f=lambda: len(ibd_node.getpeerinfo()[0]['inflight']) == 0)
336
337        # Now disconnect nodes and finish background chain sync
338        self.disconnect_nodes(ibd_node.index, snapshot_node.index)
339        self.connect_nodes(snapshot_node.index, miner.index)
340        self.sync_blocks(nodes=(miner, snapshot_node))
341        # Check the base snapshot block was stored and ensure node signals full-node service support
342        self.wait_until(lambda: not try_rpc(-1, "Block not available (not fully downloaded)", snapshot_node.getblock, snapshot_block_hash))
343        self.wait_until(lambda: 'NETWORK' in snapshot_node.getnetworkinfo()['localservicesnames'])
344
345        # Now that the snapshot_node is synced, verify the ibd_node can sync from it
346        self.connect_nodes(snapshot_node.index, ibd_node.index)
347        assert 'NETWORK' in ibd_node.getpeerinfo()[0]['servicesnames']
348        self.sync_blocks(nodes=(ibd_node, snapshot_node))
349
350    def test_sync_to_most_work_chain_after_background_validation(self):
351        """
352        After background validation completes, node should be able
353        to download and process blocks from peers without the snapshot block in their chain.
354        """
355        self.log.info("Testing sync to the most-work chain without the snapshot block after background validation")
356
357        forking_node = self.nodes[0]
358        snapshot_node = self.nodes[2]  # Has already completed background validation
359
360        self.log.info("Forking node switches to an alternative chain that forks one block before the snapshot block")
361        fork_point = SNAPSHOT_BASE_HEIGHT - 1
362        forking_node_old_height = forking_node.getblockcount()
363        forking_node_old_chainwork = int(forking_node.getblockchaininfo()['chainwork'], 16)
364        forking_node.invalidateblock(forking_node.getblockhash(fork_point + 1))
365
366        self.log.info("Mine one more block than original chain to make the new chain have most work")
367        self.generate(forking_node, nblocks=(forking_node_old_height - fork_point) + 1, sync_fun=self.no_op)
368        assert int(forking_node.getblockchaininfo()['chainwork'], 16) > forking_node_old_chainwork
369
370        self.log.info("Snapshot node should reorg to the most-work chain without the snapshot block")
371        self.sync_blocks(nodes=(snapshot_node, forking_node))
372
373    def assert_only_network_limited_service(self, node):
374        node_services = node.getnetworkinfo()['localservicesnames']
375        assert 'NETWORK' not in node_services
376        assert 'NETWORK_LIMITED' in node_services
377
378    @contextlib.contextmanager
379    def assert_disk_cleanup(self, node, assumeutxo_used):
380        """
381        Ensure an assumeutxo node is cleaning up the background chainstate
382        """
383        msg = []
384        if assumeutxo_used:
385            # Check that the snapshot actually existed before restart
386            assert (node.datadir_path / node.chain / "chainstate_snapshot").exists()
387            msg = ["cleaning up unneeded background chainstate"]
388
389        with node.assert_debug_log(msg):
390            yield
391
392        assert not (node.datadir_path / node.chain / "chainstate_snapshot").exists()
393
394    def run_test(self):
395        """
396        Bring up two (disconnected) nodes, mine some new blocks on the first,
397        and generate a UTXO snapshot.
398
399        Load the snapshot into the second, ensure it syncs to tip and completes
400        background validation when connected to the first.
401        """
402        n0 = self.nodes[0]
403        n1 = self.nodes[1]
404        n2 = self.nodes[2]
405        n3 = self.nodes[3]
406
407        self.mini_wallet = MiniWallet(n0)
408
409        # Mock time for a deterministic chain
410        for n in self.nodes:
411            n.setmocktime(n.getblockheader(n.getbestblockhash())['time'])
412
413        # Generate a series of blocks that `n0` will have in the snapshot,
414        # but that n1 and n2 don't yet see.
415        assert_equal(n0.getblockcount(), START_HEIGHT)
416        blocks = {START_HEIGHT: Block(n0.getbestblockhash(), 1, START_HEIGHT + 1)}
417        for i in range(100):
418            block_tx = 1
419            if i % 3 == 0:
420                self.mini_wallet.send_self_transfer(from_node=n0)
421                block_tx += 1
422            self.generate(n0, nblocks=1, sync_fun=self.no_op)
423            height = n0.getblockcount()
424            hash = n0.getbestblockhash()
425            blocks[height] = Block(hash, block_tx, blocks[height-1].chain_tx + block_tx)
426            if i == 4:
427                # Create a stale block that forks off the main chain before the snapshot.
428                temp_invalid = n0.getbestblockhash()
429                n0.invalidateblock(temp_invalid)
430                stale_hash = self.generateblock(n0, output="raw(aaaa)", transactions=[], sync_fun=self.no_op)["hash"]
431                n0.invalidateblock(stale_hash)
432                n0.reconsiderblock(temp_invalid)
433                stale_block = n0.getblock(stale_hash, 0)
434
435
436        self.log.info("-- Testing assumeutxo + some indexes + pruning")
437
438        assert_equal(n0.getblockcount(), SNAPSHOT_BASE_HEIGHT)
439        assert_equal(n1.getblockcount(), START_HEIGHT)
440
441        self.log.info(f"Creating a UTXO snapshot at height {SNAPSHOT_BASE_HEIGHT}")
442        dump_output = n0.dumptxoutset('utxos.dat', "latest")
443
444        self.log.info("Test loading snapshot when the node tip is on the same block as the snapshot")
445        assert_equal(n0.getblockcount(), SNAPSHOT_BASE_HEIGHT)
446        assert_equal(n0.getblockchaininfo()["blocks"], SNAPSHOT_BASE_HEIGHT)
447        self.test_snapshot_with_less_work(dump_output['path'])
448
449        self.log.info("Test loading snapshot when headers are not synced")
450        self.test_headers_not_synced(dump_output['path'])
451
452        # In order for the snapshot to activate, we have to ferry over the new
453        # headers to n1 and n2 so that they see the header of the snapshot's
454        # base block while disconnected from n0.
455        for i in range(1, 300):
456            block = n0.getblock(n0.getblockhash(i), 0)
457            # make n1 and n2 aware of the new header, but don't give them the
458            # block.
459            n1.submitheader(block)
460            n2.submitheader(block)
461            n3.submitheader(block)
462
463        # Ensure everyone is seeing the same headers.
464        for n in self.nodes:
465            assert_equal(n.getblockchaininfo()["headers"], SNAPSHOT_BASE_HEIGHT)
466
467        assert_equal(n0.getblockchaininfo()["blocks"], SNAPSHOT_BASE_HEIGHT)
468
469        def check_dump_output(output):
470            assert_equal(
471                output['txoutset_hash'],
472                "106b2c56233e378a824cf0d5ff2be42ed32c72f1605c9be288d00942908a40ac")
473            assert_equal(output["nchaintx"], blocks[SNAPSHOT_BASE_HEIGHT].chain_tx)
474
475        check_dump_output(dump_output)
476
477        # Mine more blocks on top of the snapshot that n1 hasn't yet seen. This
478        # will allow us to test n1's sync-to-tip on top of a snapshot.
479        self.generate(n0, nblocks=100, sync_fun=self.no_op)
480
481        assert_equal(n0.getblockcount(), FINAL_HEIGHT)
482        assert_equal(n1.getblockcount(), START_HEIGHT)
483
484        assert_equal(n0.getblockchaininfo()["blocks"], FINAL_HEIGHT)
485
486        self.log.info("Check that dumptxoutset works for past block heights")
487        # rollback defaults to the snapshot base height
488        dump_output2 = n0.dumptxoutset('utxos2.dat', "rollback")
489        check_dump_output(dump_output2)
490        assert_equal(sha256sum_file(dump_output['path']), sha256sum_file(dump_output2['path']))
491
492        # Rollback with specific height
493        dump_output3 = n0.dumptxoutset('utxos3.dat', rollback=SNAPSHOT_BASE_HEIGHT)
494        check_dump_output(dump_output3)
495        assert_equal(sha256sum_file(dump_output['path']), sha256sum_file(dump_output3['path']))
496
497        # Specified height that is not a snapshot height
498        prev_snap_height = SNAPSHOT_BASE_HEIGHT - 1
499        dump_output4 = n0.dumptxoutset(path='utxos4.dat', rollback=prev_snap_height)
500        assert_equal(