Inside Bitcoin

501        assert_raises_rpc_error(
502            -8,
503            "Block does not exist at specified height",
504            lambda: self.nodes[0].getnetworkhashps(100, self.nodes[0].getblockcount() + 1),
505        )
506        assert_raises_rpc_error(
507            -8,
508            "Block does not exist at specified height",
509            lambda: self.nodes[0].getnetworkhashps(100, -10),
510        )
511        assert_raises_rpc_error(
512            -8,
513            "Invalid nblocks. Must be a positive number or -1.",
514            lambda: self.nodes[0].getnetworkhashps(-100),
515        )
516        assert_raises_rpc_error(
517            -8,
518            "Invalid nblocks. Must be a positive number or -1.",
519            lambda: self.nodes[0].getnetworkhashps(0),
520        )
521
522        # Genesis block height estimate should return 0
523        hashes_per_second = self.nodes[0].getnetworkhashps(100, 0)
524        assert_equal(hashes_per_second, 0)
525
526        # This should be 2 hashes every 10 minutes or 1/300
527        hashes_per_second = self.nodes[0].getnetworkhashps()
528        assert abs(hashes_per_second * 300 - 1) < 0.0001
529
530        # Test setting the first param of getnetworkhashps to -1 returns the average network
531        # hashes per second from the last difficulty change.
532        current_block_height = self.nodes[0].getmininginfo()['blocks']
533        blocks_since_last_diff_change = current_block_height % DIFFICULTY_ADJUSTMENT_INTERVAL + 1
534        expected_hashes_per_second_since_diff_change = self.nodes[0].getnetworkhashps(blocks_since_last_diff_change)
535
536        assert_equal(self.nodes[0].getnetworkhashps(-1), expected_hashes_per_second_since_diff_change)
537
538        # Ensure long lookups get truncated to chain length
539        hashes_per_second = self.nodes[0].getnetworkhashps(self.nodes[0].getblockcount() + 1000)
540        assert hashes_per_second > 0.003
541
542    def _test_stopatheight(self):
543        self.log.info("Test stopping at height")
544        assert_equal(self.nodes[0].getblockcount(), HEIGHT)
545        self.generate(self.wallet, 6)
546        assert_equal(self.nodes[0].getblockcount(), HEIGHT + 6)
547        self.log.debug('Node should not stop at this height')
548        assert_raises(subprocess.TimeoutExpired, lambda: self.nodes[0].process.wait(timeout=3))
549        try:
550            self.generatetoaddress(self.nodes[0], 1, self.wallet.get_address(), sync_fun=self.no_op)
551        except (ConnectionError, http.client.BadStatusLine):
552            pass  # The node already shut down before response
553        self.log.debug('Node should stop at this height...')
554        self.nodes[0].wait_until_stopped()
555        self.start_node(0)
556        assert_equal(self.nodes[0].getblockcount(), HEIGHT + 7)
557
558    def _test_waitforblock(self):
559        self.log.info("Test waitforblock and waitfornewblock")
560        node = self.nodes[0]
561
562        current_height = node.getblock(node.getbestblockhash())['height']
563        current_hash = node.getblock(node.getbestblockhash())['hash']
564
565        self.log.debug("Roll the chain back a few blocks and then reconsider it")
566        rollback_height = current_height - 100
567        rollback_hash = node.getblockhash(rollback_height)
568        rollback_header = node.getblockheader(rollback_hash)
569
570        node.invalidateblock(rollback_hash)
571        assert_equal(node.getblockcount(), rollback_height - 1)
572
573        self.log.debug("waitforblock should return the same block after its timeout")
574        assert_equal(node.waitforblock(blockhash=current_hash, timeout=1)['hash'], rollback_header['previousblockhash'])
575        assert_raises_rpc_error(-1, "Negative timeout", node.waitforblock, current_hash, -1)
576
577        node.reconsiderblock(rollback_hash)
578        # The chain has probably already been restored by the time reconsiderblock returns,
579        # but poll anyway.
580        self.wait_until(lambda: node.waitforblock(blockhash=current_hash, timeout=100)['hash'] == current_hash)
581
582        # roll back again
583        node.invalidateblock(rollback_hash)
584        assert_equal(node.getblockcount(), rollback_height - 1)
585
586        node.reconsiderblock(rollback_hash)
587        # The chain has probably already been restored by the time reconsiderblock returns,
588        # but poll anyway.
589        self.wait_until(lambda: node.waitfornewblock(current_tip=rollback_header['previousblockhash'])['hash'] == current_hash)
590
591        assert_raises_rpc_error(-1, "Negative timeout", node.waitfornewblock, -1)
592
593    def _test_waitforblockheight(self):
594        self.log.info("Test waitforblockheight")
595        node = self.nodes[0]
596        peer = node.add_p2p_connection(P2PInterface())
597
598        current_height = node.getblock(node.getbestblockhash())['height']
599
600        # Create a fork somewhere below our current height, invalidate the tip
601        # of that fork, and then ensure that waitforblockheight still
602        # works as expected.
603        #
604        # (Previously this was broken based on setting
605        # `rpc/blockchain.cpp:latestblock` incorrectly.)
606        #
607        fork_height = current_height - 100 # choose something vaguely near our tip
608        fork_hash = node.getblockhash(fork_height)
609        fork_block = node.getblock(fork_hash)
610
611        def solve_and_send_block(prevhash, height, time):
612            b = create_block(prevhash, height=height, ntime=time)
613            b.solve()
614            peer.send_and_ping(msg_block(b))
615            return b
616
617        b1 = solve_and_send_block(int(fork_hash, 16), fork_height+1, fork_block['time'] + 1)
618        b2 = solve_and_send_block(b1.hash_int, fork_height+2, b1.nTime + 1)
619
620        node.invalidateblock(b2.hash_hex)
621
622        def assert_waitforheight(height, timeout=2):
623            assert_equal(
624                node.waitforblockheight(height=height, timeout=timeout)['height'],
625                current_height)
626
627        assert_waitforheight(0)
628        assert_waitforheight(current_height - 1)
629        assert_waitforheight(current_height)
630        assert_waitforheight(current_height + 1)
631        assert_raises_rpc_error(-1, "Negative timeout", node.waitforblockheight, current_height, -1)
632
633    def _test_getblock(self):
634        node = self.nodes[0]
635        fee_per_byte = Decimal('0.00000010')
636        fee_per_kb = 1000 * fee_per_byte
637
638        self.wallet.send_self_transfer(fee_rate=fee_per_kb, from_node=node)
639        blockhash = self.generate(node, 1)[0]
640
641        def assert_coinbase_metadata(hash, verbosity):
642            block = node.getblock(hash, verbosity)
643            coinbase_tx = node.getblock(hash, 2)["tx"][0]
644
645            expected_keys = {"version", "locktime", "sequence", "coinbase"}
646            if "txinwitness" in coinbase_tx["vin"][0]:
647                expected_keys.add("witness")
648            assert_equal(set(block["coinbase_tx"].keys()), expected_keys)
649
650            assert_equal(block["coinbase_tx"]["version"], coinbase_tx["version"])
651            assert_equal(block["coinbase_tx"]["locktime"], coinbase_tx["locktime"])
652            assert_equal(block["coinbase_tx"]["sequence"], coinbase_tx["vin"][0]["sequence"])
653            assert_equal(block["coinbase_tx"]["coinbase"], coinbase_tx["vin"][0]["coinbase"])
654
655            witness_stack = coinbase_tx["vin"][0].get("txinwitness")
656            if witness_stack is None:
657                assert "witness" not in block["coinbase_tx"]
658            else:
659                assert_equal(block["coinbase_tx"]["witness"], witness_stack[0])
660
661        def assert_hexblock_hashes(verbosity):
662            block = node.getblock(blockhash, verbosity)
663            assert_equal(blockhash, hash256(bytes.fromhex(block[:160]))[::-1].hex())
664
665        def assert_fee_not_in_block(hash, verbosity):
666            block = node.getblock(hash, verbosity)
667            assert 'fee' not in block['tx'][1]
668
669        def assert_fee_in_block(hash, verbosity):
670            block = node.getblock(hash, verbosity)
671            tx = block['tx'][1]
672            assert 'fee' in tx
673            assert_equal(tx['fee'], tx['vsize'] * fee_per_byte)
674
675        def assert_vin_contains_prevout(verbosity):
676            block = node.getblock(blockhash, verbosity)
677            tx = block["tx"][1]
678            total_vin = Decimal("0.00000000")
679            total_vout = Decimal("0.00000000")
680            for vin in tx["vin"]:
681                assert "prevout" in vin
682                assert_equal(set(vin["prevout"].keys()), set(("value", "height", "generated", "scriptPubKey")))
683                assert_equal(vin["prevout"]["generated"], True)
684                total_vin += vin["prevout"]["value"]
685            for vout in tx["vout"]:
686                total_vout += vout["value"]
687            assert_equal(total_vin, total_vout + tx["fee"])
688
689        def assert_vin_does_not_contain_prevout(hash, verbosity):
690            block = node.getblock(hash, verbosity)
691            tx = block["tx"][1]
692            if isinstance(tx, str):
693                # In verbosity level 1, only the transaction hashes are written
694                pass
695            else:
696                for vin in tx["vin"]:
697                    assert "prevout" not in vin
698
699        self.log.info("Test that getblock with verbosity 0 hashes to expected value")
700        assert_hexblock_hashes(0)
701        assert_hexblock_hashes(False)
702
703        self.log.info("Test that getblock with verbosity 1 doesn't include fee")
704        assert_fee_not_in_block(blockhash, 1)
705        assert_fee_not_in_block(blockhash, True)
706
707        self.log.info("Test getblock coinbase metadata fields")
708        assert_coinbase_metadata(blockhash, 1)
709
710        self.log.info('Test that getblock with verbosity 2 and 3 includes expected fee')
711        assert_fee_in_block(blockhash, 2)
712        assert_fee_in_block(blockhash, 3)
713
714        self.log.info("Test that getblock with verbosity 1 and 2 does not include prevout")
715        assert_vin_does_not_contain_prevout(blockhash, 1)
716        assert_vin_does_not_contain_prevout(blockhash, 2)
717
718        self.log.info("Test that getblock with verbosity 3 includes prevout")
719        assert_vin_contains_prevout(3)
720
721        self.log.info("Test getblock with invalid verbosity type returns proper error message")
722        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", node.getblock, blockhash, "2")
723
724        self.log.info("Test that getblock doesn't work with deleted Undo data")
725
726        def move_block_file(old, new):
727            old_path = self.nodes[0].blocks_path / old
728            new_path = self.nodes[0].blocks_path / new
729            old_path.rename(new_path)
730
731        # Move instead of deleting so we can restore chain state afterwards
732        move_block_file('rev00000.dat', 'rev_wrong')
733
734        assert_raises_rpc_error(-32603, "Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.", lambda: node.getblock(blockhash, 2))
735        assert_raises_rpc_error(-32603, "Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.", lambda: node.getblock(blockhash, 3))
736
737        # Restore chain state
738        move_block_file('rev_wrong', 'rev00000.dat')
739
740        assert 'previousblockhash' not in node.getblock(node.getblockhash(0))
741        assert 'nextblockhash' not in node.getblock(node.getbestblockhash())
742
743        self.log.info("Test getblock when only header is known")
744        current_height = node.getblock(node.getbestblockhash())['height']
745        block_time = node.getblock(node.getbestblockhash())['time'] + 1
746        block = create_block(int(blockhash, 16), create_coinbase(current_height + 1, nValue=100), ntime=block_time)
747        block.solve()
748        node.submitheader(block.serialize().hex())
749        assert_raises_rpc_error(-1, "Block not available (not fully downloaded)", lambda: node.getblock(block.hash_hex))
750