2016-05-06 11:23:48 +02:00
#!/usr/bin/env python3
2023-08-16 19:27:31 +02:00
# Copyright (c) 2014-2020 The Bitcoin Core developers
2015-10-08 10:22:50 +02:00
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
2019-01-07 10:55:35 +01:00
""" Test RPCs related to blockchainstate.
2015-10-08 10:22:50 +02:00
2019-01-07 10:55:35 +01:00
Test the following RPCs :
2017-11-10 21:48:00 +01:00
- getblockchaininfo
2021-07-30 11:44:20 +02:00
- getchaintxstats
2019-01-07 10:55:35 +01:00
- gettxoutsetinfo
2017-04-21 17:12:12 +02:00
- getblockheader
2021-07-30 11:44:20 +02:00
- getdifficulty
2017-05-14 12:43:33 +02:00
- getnetworkhashps
2021-07-30 11:44:20 +02:00
- waitforblockheight
- getblock
- getblockhash
- getbestblockhash
2019-01-07 10:55:35 +01:00
- verifychain
Tests correspond to code in rpc / blockchain . cpp .
"""
2015-10-08 10:22:50 +02:00
2015-12-02 18:12:23 +01:00
from decimal import Decimal
2019-07-11 23:22:52 +02:00
import http . client
2020-12-24 15:32:02 +01:00
import os
2017-06-22 10:50:24 +02:00
import subprocess
2015-10-08 10:22:50 +02:00
2021-02-25 09:48:28 +01:00
from test_framework . address import ADDRESS_BCRT1_P2SH_OP_TRUE
2018-03-15 16:55:50 +01:00
from test_framework . blocktools import (
2021-08-27 01:35:02 +02:00
CLTV_HEIGHT ,
2021-08-10 15:41:16 +02:00
DERSIG_HEIGHT ,
2018-03-15 16:55:50 +01:00
create_block ,
create_coinbase ,
2019-02-25 17:44:18 +01:00
TIME_GENESIS_BLOCK ,
2018-03-15 16:55:50 +01:00
)
from test_framework . messages import (
2020-08-21 14:33:41 +02:00
CBlockHeader ,
2021-06-24 12:47:04 +02:00
from_hex ,
2018-03-15 16:55:50 +01:00
msg_block ,
)
2024-01-15 20:35:29 +01:00
from test_framework . p2p import P2PInterface
from test_framework . test_framework import BitcoinTestFramework
from test_framework . util import (
assert_equal ,
assert_greater_than ,
assert_greater_than_or_equal ,
assert_raises ,
assert_raises_rpc_error ,
assert_is_hex_string ,
assert_is_hash_string ,
2020-12-24 15:32:02 +01:00
get_datadir_path ,
2024-01-15 20:35:29 +01:00
set_node_times ,
2018-03-15 16:55:50 +01:00
)
2020-12-24 15:32:02 +01:00
from test_framework . wallet import MiniWallet
2018-03-15 16:55:50 +01:00
2015-10-08 10:22:50 +02:00
2021-07-30 11:44:20 +02:00
HEIGHT = 200 # blocks mined
TIME_RANGE_STEP = 156 # ten-minute steps
TIME_RANGE_MTP = TIME_GENESIS_BLOCK + ( HEIGHT - 6 ) * TIME_RANGE_STEP
TIME_RANGE_END = TIME_GENESIS_BLOCK + HEIGHT * TIME_RANGE_STEP
2015-10-08 10:22:50 +02:00
class BlockchainTest ( BitcoinTestFramework ) :
2017-09-01 18:47:13 +02:00
def set_test_params ( self ) :
2019-02-25 17:44:18 +01:00
self . setup_clean_chain = True
2016-05-20 15:16:51 +02:00
self . num_nodes = 1
2019-12-09 19:52:38 +01:00
self . supports_cli = False
2015-10-08 10:22:50 +02:00
2018-09-13 12:33:15 +02:00
def run_test ( self ) :
2019-02-25 17:44:18 +01:00
self . mine_chain ( )
2018-09-10 22:58:15 +02:00
self . restart_node ( 0 , extra_args = [ ' -stopatheight=207 ' , ' -prune=1 ' , ' -txindex=0 ' ] ) # Set extra args with pruning after rescan is complete
2020-01-12 23:50:32 +01:00
# Actual tests
2017-09-25 13:16:08 +02:00
self . _test_getblockchaininfo ( )
2017-06-05 16:25:12 +02:00
self . _test_getchaintxstats ( )
2015-12-09 18:01:34 +01:00
self . _test_gettxoutsetinfo ( )
self . _test_getblockheader ( )
2017-04-21 17:12:12 +02:00
self . _test_getdifficulty ( )
2017-05-14 12:43:33 +02:00
self . _test_getnetworkhashps ( )
2017-06-22 10:50:24 +02:00
self . _test_stopatheight ( )
2018-03-15 16:55:50 +01:00
self . _test_waitforblockheight ( )
2020-12-24 15:32:02 +01:00
self . _test_getblock ( )
2017-06-22 10:50:24 +02:00
assert self . nodes [ 0 ] . verifychain ( 4 , 0 )
2015-12-09 18:01:34 +01:00
2019-02-25 17:44:18 +01:00
def mine_chain ( self ) :
2021-07-30 11:44:20 +02:00
self . log . info ( f " Generate { HEIGHT } blocks after the genesis block in 156 sec " )
for t in range ( TIME_GENESIS_BLOCK , TIME_RANGE_END , TIME_RANGE_STEP ) :
2019-02-25 17:44:18 +01:00
# 156 sec steps from genesis block time
set_node_times ( self . nodes , t )
2021-02-25 09:48:28 +01:00
self . nodes [ 0 ] . generatetoaddress ( 1 , ADDRESS_BCRT1_P2SH_OP_TRUE )
2019-02-25 17:44:18 +01:00
assert_equal ( self . nodes [ 0 ] . getblockchaininfo ( ) [ ' blocks ' ] , 200 )
2017-09-25 13:16:08 +02:00
def _test_getblockchaininfo ( self ) :
self . log . info ( " Test getblockchaininfo " )
keys = [
' bestblockhash ' ,
' blocks ' ,
' chain ' ,
' chainwork ' ,
' difficulty ' ,
' headers ' ,
2017-11-10 21:48:00 +01:00
' initialblockdownload ' ,
2017-09-25 13:16:08 +02:00
' mediantime ' ,
' pruned ' ,
2017-10-09 16:53:12 +02:00
' size_on_disk ' ,
2017-09-25 13:16:08 +02:00
' softforks ' ,
2021-07-21 09:47:31 +02:00
' time ' ,
2017-09-25 13:16:08 +02:00
' verificationprogress ' ,
2017-09-28 13:46:00 +02:00
' warnings ' ,
2017-09-25 13:16:08 +02:00
]
res = self . nodes [ 0 ] . getblockchaininfo ( )
2017-10-09 16:53:12 +02:00
2021-07-30 11:44:20 +02:00
assert_equal ( res [ ' time ' ] , TIME_RANGE_END - TIME_RANGE_STEP )
assert_equal ( res [ ' mediantime ' ] , TIME_RANGE_MTP )
2021-07-21 09:47:31 +02:00
2017-10-09 16:53:12 +02:00
# result should have these additional pruning keys if manual pruning is enabled
assert_equal ( sorted ( res . keys ( ) ) , sorted ( [ ' pruneheight ' , ' automatic_pruning ' ] + keys ) )
# size_on_disk should be > 0
assert_greater_than ( res [ ' size_on_disk ' ] , 0 )
2017-09-25 13:16:08 +02:00
# pruneheight should be greater or equal to 0
2017-10-09 16:53:12 +02:00
assert_greater_than_or_equal ( res [ ' pruneheight ' ] , 0 )
# check other pruning fields given that prune=1
assert res [ ' pruned ' ]
assert not res [ ' automatic_pruning ' ]
2017-09-25 13:16:08 +02:00
2021-06-17 20:26:27 +02:00
self . restart_node ( 0 , [ ' -stopatheight=207 ' , ' -txindex=0 ' ] , expected_stderr = ' Warning: You are starting with governance validation disabled. This is expected because you are running a pruned node. ' )
2017-09-25 13:16:08 +02:00
res = self . nodes [ 0 ] . getblockchaininfo ( )
# should have exact keys
assert_equal ( sorted ( res . keys ( ) ) , keys )
2020-04-17 07:52:06 +02:00
self . restart_node ( 0 , [ ' -stopatheight=207 ' , ' -prune=550 ' , ' -txindex=0 ' ] )
2017-10-09 16:53:12 +02:00
res = self . nodes [ 0 ] . getblockchaininfo ( )
# result should have these additional pruning keys if prune=550
assert_equal ( sorted ( res . keys ( ) ) , sorted ( [ ' pruneheight ' , ' automatic_pruning ' , ' prune_target_size ' ] + keys ) )
# check related fields
assert res [ ' pruned ' ]
assert_equal ( res [ ' pruneheight ' ] , 0 )
assert res [ ' automatic_pruning ' ]
assert_equal ( res [ ' prune_target_size ' ] , 576716800 )
assert_greater_than ( res [ ' size_on_disk ' ] , 0 )
2019-08-15 22:02:02 +02:00
assert_equal ( res [ ' softforks ' ] , {
2021-08-03 10:09:42 +02:00
' bip34 ' : { ' type ' : ' buried ' , ' active ' : True , ' height ' : 2 } ,
2021-08-10 15:41:16 +02:00
' bip66 ' : { ' type ' : ' buried ' , ' active ' : True , ' height ' : DERSIG_HEIGHT } ,
2021-08-27 01:35:02 +02:00
' bip65 ' : { ' type ' : ' buried ' , ' active ' : True , ' height ' : CLTV_HEIGHT } ,
2023-05-18 19:15:08 +02:00
' bip147 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 432 } ,
2019-08-15 22:02:02 +02:00
' csv ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 432 } ,
2023-03-28 11:07:38 +02:00
' dip0001 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 2000 } ,
2023-05-18 19:15:08 +02:00
' dip0003 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 432 } ,
2023-03-28 11:25:39 +02:00
' dip0008 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 432 } ,
2023-05-18 19:15:08 +02:00
' dip0020 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 300 } ,
' dip0024 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 900 } ,
2024-08-07 05:15:26 +02:00
' realloc ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 1000 } ,
2023-07-23 22:19:38 +02:00
' v19 ' : { ' type ' : ' buried ' , ' active ' : False , ' height ' : 900 } ,
2019-08-15 22:02:02 +02:00
' v20 ' : {
' type ' : ' bip9 ' ,
' bip9 ' : {
' status ' : ' defined ' ,
' start_time ' : 0 ,
2023-08-26 23:45:22 +02:00
' timeout ' : 9223372036854775807 ,
2023-10-18 05:31:40 +02:00
' since ' : 0 ,
2021-04-15 03:33:47 +02:00
' min_activation_height ' : 0 ,
2023-11-10 15:31:12 +01:00
' ehf ' : False ,
2019-08-15 22:02:02 +02:00
} , ' active ' : False } ,
2023-08-01 06:52:48 +02:00
' mn_rr ' : {
' type ' : ' bip9 ' ,
' bip9 ' : {
' status ' : ' defined ' ,
' start_time ' : 0 ,
2023-08-26 23:45:22 +02:00
' timeout ' : 9223372036854775807 ,
2023-10-18 05:31:40 +02:00
' since ' : 0 ,
2021-04-15 03:33:47 +02:00
' min_activation_height ' : 0 ,
2023-11-10 15:31:12 +01:00
' ehf ' : True ,
2023-08-01 06:52:48 +02:00
} ,
' active ' : False } ,
2019-08-15 22:02:02 +02:00
' testdummy ' : {
' type ' : ' bip9 ' ,
' bip9 ' : {
' status ' : ' started ' ,
' bit ' : 28 ,
' start_time ' : 0 ,
2023-08-26 23:45:22 +02:00
' timeout ' : 9223372036854775807 , # testdummy does not have a timeout so is set to the max int64 value
2019-08-15 22:02:02 +02:00
' since ' : 144 ,
' statistics ' : {
' period ' : 144 ,
' threshold ' : 108 ,
2021-07-30 11:44:20 +02:00
' elapsed ' : HEIGHT - 143 ,
' count ' : HEIGHT - 143 ,
2019-08-15 22:02:02 +02:00
' possible ' : True ,
} ,
2021-04-15 03:33:47 +02:00
' min_activation_height ' : 0 ,
2023-11-10 15:31:12 +01:00
' ehf ' : False ,
2019-08-15 22:02:02 +02:00
} ,
' active ' : False } ,
} )
2017-10-09 16:53:12 +02:00
2017-06-05 16:25:12 +02:00
def _test_getchaintxstats ( self ) :
2018-02-02 17:57:01 +01:00
self . log . info ( " Test getchaintxstats " )
2018-02-26 16:35:56 +01:00
# Test `getchaintxstats` invalid extra parameters
assert_raises_rpc_error ( - 1 , ' getchaintxstats ' , self . nodes [ 0 ] . getchaintxstats , 0 , ' ' , 0 )
# Test `getchaintxstats` invalid `nblocks`
assert_raises_rpc_error ( - 1 , " JSON value is not an integer as expected " , self . nodes [ 0 ] . getchaintxstats , ' ' )
assert_raises_rpc_error ( - 8 , " Invalid block count: should be between 0 and the block ' s height - 1 " , self . nodes [ 0 ] . getchaintxstats , - 1 )
assert_raises_rpc_error ( - 8 , " Invalid block count: should be between 0 and the block ' s height - 1 " , self . nodes [ 0 ] . getchaintxstats , self . nodes [ 0 ] . getblockcount ( ) )
# Test `getchaintxstats` invalid `blockhash`
assert_raises_rpc_error ( - 1 , " JSON value is not a string as expected " , self . nodes [ 0 ] . getchaintxstats , blockhash = 0 )
2018-09-24 20:54:10 +02:00
assert_raises_rpc_error ( - 8 , " blockhash must be of length 64 (not 1, for ' 0 ' ) " , self . nodes [ 0 ] . getchaintxstats , blockhash = ' 0 ' )
assert_raises_rpc_error ( - 8 , " blockhash must be hexadecimal string (not ' ZZZ0000000000000000000000000000000000000000000000000000000000000 ' ) " , self . nodes [ 0 ] . getchaintxstats , blockhash = ' ZZZ0000000000000000000000000000000000000000000000000000000000000 ' )
assert_raises_rpc_error ( - 5 , " Block not found " , self . nodes [ 0 ] . getchaintxstats , blockhash = ' 0000000000000000000000000000000000000000000000000000000000000000 ' )
2021-07-30 11:44:20 +02:00
blockhash = self . nodes [ 0 ] . getblockhash ( HEIGHT )
2018-02-26 16:35:56 +01:00
self . nodes [ 0 ] . invalidateblock ( blockhash )
assert_raises_rpc_error ( - 8 , " Block is not in main chain " , self . nodes [ 0 ] . getchaintxstats , blockhash = blockhash )
self . nodes [ 0 ] . reconsiderblock ( blockhash )
2018-11-13 22:49:17 +01:00
chaintxstats = self . nodes [ 0 ] . getchaintxstats ( nblocks = 1 )
2017-06-05 16:25:12 +02:00
# 200 txs plus genesis tx
2021-07-30 11:44:20 +02:00
assert_equal ( chaintxstats [ ' txcount ' ] , HEIGHT + 1 )
2019-07-04 17:15:52 +02:00
# tx rate should be 1 per ~2.6 minutes (156 seconds), or 1/156
2017-06-05 16:25:12 +02:00
# we have to round because of binary math
2021-07-30 11:44:20 +02:00
assert_equal ( round ( chaintxstats [ ' txrate ' ] * TIME_RANGE_STEP , 10 ) , Decimal ( 1 ) )
2017-06-05 16:25:12 +02:00
2018-02-02 17:57:01 +01:00
b1_hash = self . nodes [ 0 ] . getblockhash ( 1 )
b1 = self . nodes [ 0 ] . getblock ( b1_hash )
2021-07-30 11:44:20 +02:00
b200_hash = self . nodes [ 0 ] . getblockhash ( HEIGHT )
2018-02-02 17:57:01 +01:00
b200 = self . nodes [ 0 ] . getblock ( b200_hash )
2017-10-02 15:21:26 +02:00
time_diff = b200 [ ' mediantime ' ] - b1 [ ' mediantime ' ]
chaintxstats = self . nodes [ 0 ] . getchaintxstats ( )
assert_equal ( chaintxstats [ ' time ' ] , b200 [ ' time ' ] )
2021-07-30 11:44:20 +02:00
assert_equal ( chaintxstats [ ' txcount ' ] , HEIGHT + 1 )
2018-02-02 17:57:01 +01:00
assert_equal ( chaintxstats [ ' window_final_block_hash ' ] , b200_hash )
2021-07-30 11:44:20 +02:00
assert_equal ( chaintxstats [ ' window_final_block_height ' ] , HEIGHT )
assert_equal ( chaintxstats [ ' window_block_count ' ] , HEIGHT - 1 )
assert_equal ( chaintxstats [ ' window_tx_count ' ] , HEIGHT - 1 )
2017-10-02 15:21:26 +02:00
assert_equal ( chaintxstats [ ' window_interval ' ] , time_diff )
2021-07-30 11:44:20 +02:00
assert_equal ( round ( chaintxstats [ ' txrate ' ] * time_diff , 10 ) , Decimal ( HEIGHT - 1 ) )
2017-10-02 15:21:26 +02:00
2018-02-02 17:57:01 +01:00
chaintxstats = self . nodes [ 0 ] . getchaintxstats ( blockhash = b1_hash )
2017-10-02 15:21:26 +02:00
assert_equal ( chaintxstats [ ' time ' ] , b1 [ ' time ' ] )
assert_equal ( chaintxstats [ ' txcount ' ] , 2 )
2018-02-02 17:57:01 +01:00
assert_equal ( chaintxstats [ ' window_final_block_hash ' ] , b1_hash )
2019-08-29 16:41:29 +02:00
assert_equal ( chaintxstats [ ' window_final_block_height ' ] , 1 )
2017-10-02 15:21:26 +02:00
assert_equal ( chaintxstats [ ' window_block_count ' ] , 0 )
2021-08-27 21:03:02 +02:00
assert ' window_tx_count ' not in chaintxstats
assert ' window_interval ' not in chaintxstats
assert ' txrate ' not in chaintxstats
2017-10-02 15:21:26 +02:00
2015-12-09 18:01:34 +01:00
def _test_gettxoutsetinfo ( self ) :
2015-10-08 10:22:50 +02:00
node = self . nodes [ 0 ]
res = node . gettxoutsetinfo ( )
2016-05-06 11:23:48 +02:00
assert_equal ( res [ ' total_amount ' ] , Decimal ( ' 98214.28571450 ' ) )
2021-07-30 11:44:20 +02:00
assert_equal ( res [ ' transactions ' ] , HEIGHT )
assert_equal ( res [ ' height ' ] , HEIGHT )
assert_equal ( res [ ' txouts ' ] , HEIGHT )
2021-02-25 09:48:28 +01:00
assert_equal ( res [ ' bogosize ' ] , 14600 ) ,
2017-06-02 00:47:58 +02:00
size = res [ ' disk_size ' ]
assert size > 6400
assert size < 64000
2016-05-06 11:23:48 +02:00
assert_equal ( len ( res [ ' bestblock ' ] ) , 64 )
assert_equal ( len ( res [ ' hash_serialized_2 ' ] ) , 64 )
2015-10-08 10:22:50 +02:00
2021-07-30 11:44:20 +02:00
self . log . info ( " Test gettxoutsetinfo works for blockchain with just the genesis block " )
2017-05-26 20:56:52 +02:00
b1hash = node . getblockhash ( 1 )
node . invalidateblock ( b1hash )
res2 = node . gettxoutsetinfo ( )
assert_equal ( res2 [ ' transactions ' ] , 0 )
assert_equal ( res2 [ ' total_amount ' ] , Decimal ( ' 0 ' ) )
assert_equal ( res2 [ ' height ' ] , 0 )
assert_equal ( res2 [ ' txouts ' ] , 0 )
2017-06-06 11:26:28 +02:00
assert_equal ( res2 [ ' bogosize ' ] , 0 ) ,
2017-05-26 20:56:52 +02:00
assert_equal ( res2 [ ' bestblock ' ] , node . getblockhash ( 0 ) )
2017-06-02 00:47:58 +02:00
assert_equal ( len ( res2 [ ' hash_serialized_2 ' ] ) , 64 )
2017-05-26 20:56:52 +02:00
2021-07-30 11:44:20 +02:00
self . log . info ( " Test gettxoutsetinfo returns the same result after invalidate/reconsider block " )
2017-05-26 20:56:52 +02:00
node . reconsiderblock ( b1hash )
res3 = node . gettxoutsetinfo ( )
2018-08-11 03:31:06 +02:00
# The field 'disk_size' is non-deterministic and can thus not be
# compared between res and res3. Everything else should be the same.
del res [ ' disk_size ' ] , res3 [ ' disk_size ' ]
assert_equal ( res , res3 )
2017-05-26 20:56:52 +02:00
2021-07-30 11:44:20 +02:00
self . log . info ( " Test gettxoutsetinfo hash_type option " )
2022-02-26 11:54:04 +01:00
# Adding hash_type 'hash_serialized_2', which is the default, should
# not change the result.
res4 = node . gettxoutsetinfo ( hash_type = ' hash_serialized_2 ' )
del res4 [ ' disk_size ' ]
assert_equal ( res , res4 )
# hash_type none should not return a UTXO set hash.
res5 = node . gettxoutsetinfo ( hash_type = ' none ' )
assert ' hash_serialized_2 ' not in res5
2022-02-26 11:54:28 +01:00
# hash_type muhash should return a different UTXO set hash.
res6 = node . gettxoutsetinfo ( hash_type = ' muhash ' )
assert ' muhash ' in res6
assert ( res [ ' hash_serialized_2 ' ] != res6 [ ' muhash ' ] )
2021-05-02 07:50:08 +02:00
# muhash should not be returned unless requested.
2022-02-26 11:54:28 +01:00
for r in [ res , res2 , res3 , res4 , res5 ] :
assert ' muhash ' not in r
# Unknown hash_type raises an error
assert_raises_rpc_error ( - 8 , " foohash is not a valid hash_type " , node . gettxoutsetinfo , " foohash " )
2015-12-09 18:01:34 +01:00
def _test_getblockheader ( self ) :
2021-07-30 11:44:20 +02:00
self . log . info ( " Test getblockheader " )
2015-12-09 18:01:34 +01:00
node = self . nodes [ 0 ]
2018-09-24 20:54:10 +02:00
assert_raises_rpc_error ( - 8 , " hash must be of length 64 (not 8, for ' nonsense ' ) " , node . getblockheader , " nonsense " )
assert_raises_rpc_error ( - 8 , " hash must be hexadecimal string (not ' ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844 ' ) " , node . getblockheader , " ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844 " )
assert_raises_rpc_error ( - 5 , " Block not found " , node . getblockheader , " 0cf7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844 " )
2015-12-09 18:01:34 +01:00
besthash = node . getbestblockhash ( )
2021-07-30 11:44:20 +02:00
secondbesthash = node . getblockhash ( HEIGHT - 1 )
2018-11-13 22:49:17 +01:00
header = node . getblockheader ( blockhash = besthash )
2015-12-09 18:01:34 +01:00
assert_equal ( header [ ' hash ' ] , besthash )
2021-07-30 11:44:20 +02:00
assert_equal ( header [ ' height ' ] , HEIGHT )
2015-12-09 18:01:34 +01:00
assert_equal ( header [ ' confirmations ' ] , 1 )
assert_equal ( header [ ' previousblockhash ' ] , secondbesthash )
assert_is_hex_string ( header [ ' chainwork ' ] )
2018-06-14 19:38:19 +02:00
assert_equal ( header [ ' nTx ' ] , 1 )
2015-12-09 18:01:34 +01:00
assert_is_hash_string ( header [ ' hash ' ] )
assert_is_hash_string ( header [ ' previousblockhash ' ] )
assert_is_hash_string ( header [ ' merkleroot ' ] )
assert_is_hash_string ( header [ ' bits ' ] , length = None )
assert isinstance ( header [ ' time ' ] , int )
2021-07-30 11:44:20 +02:00
assert_equal ( header [ ' mediantime ' ] , TIME_RANGE_MTP )
2015-12-09 18:01:34 +01:00
assert isinstance ( header [ ' nonce ' ] , int )
assert isinstance ( header [ ' version ' ] , int )
2016-04-05 15:48:49 +02:00
assert isinstance ( int ( header [ ' versionHex ' ] , 16 ) , int )
2016-01-18 15:17:48 +01:00
assert isinstance ( header [ ' difficulty ' ] , Decimal )
2015-10-08 10:22:50 +02:00
2020-08-21 14:33:41 +02:00
# Test with verbose=False, which should return the header as hex.
header_hex = node . getblockheader ( blockhash = besthash , verbose = False )
assert_is_hex_string ( header_hex )
2021-06-24 12:47:04 +02:00
header = from_hex ( CBlockHeader ( ) , header_hex )
2020-08-21 14:33:41 +02:00
header . calc_sha256 ( )
assert_equal ( header . hash , besthash )
2021-02-23 18:28:19 +01:00
assert ' previousblockhash ' not in node . getblockheader ( node . getblockhash ( 0 ) )
assert ' nextblockhash ' not in node . getblockheader ( node . getbestblockhash ( ) )
2017-04-21 17:12:12 +02:00
def _test_getdifficulty ( self ) :
2021-07-30 11:44:20 +02:00
self . log . info ( " Test getdifficulty " )
2017-04-21 17:12:12 +02:00
difficulty = self . nodes [ 0 ] . getdifficulty ( )
# 1 hash in 2 should be valid, so difficulty should be 1/2**31
# binary => decimal => binary math is why we do this check
assert abs ( difficulty * 2 * * 31 - 1 ) < 0.0001
2017-05-14 12:43:33 +02:00
def _test_getnetworkhashps ( self ) :
2021-07-30 11:44:20 +02:00
self . log . info ( " Test getnetworkhashps " )
2017-05-14 12:43:33 +02:00
hashes_per_second = self . nodes [ 0 ] . getnetworkhashps ( )
2019-06-19 20:05:39 +02:00
# This should be 2 hashes every 2.6 minutes (156 seconds) or 1/78
assert abs ( hashes_per_second * 78 - 1 ) < 0.0001
2017-05-14 12:43:33 +02:00
2017-06-22 10:50:24 +02:00
def _test_stopatheight ( self ) :
2021-07-30 11:44:20 +02:00
assert_equal ( self . nodes [ 0 ] . getblockcount ( ) , HEIGHT )
2021-02-25 09:48:28 +01:00
self . nodes [ 0 ] . generatetoaddress ( 6 , ADDRESS_BCRT1_P2SH_OP_TRUE )
2021-07-30 11:44:20 +02:00
assert_equal ( self . nodes [ 0 ] . getblockcount ( ) , HEIGHT + 6 )
2017-06-22 10:50:24 +02:00
self . log . debug ( ' Node should not stop at this height ' )
2017-08-15 23:34:07 +02:00
assert_raises ( subprocess . TimeoutExpired , lambda : self . nodes [ 0 ] . process . wait ( timeout = 3 ) )
2019-07-11 23:22:52 +02:00
try :
2021-02-25 09:48:28 +01:00
self . nodes [ 0 ] . generatetoaddress ( 1 , ADDRESS_BCRT1_P2SH_OP_TRUE )
2019-07-11 23:22:52 +02:00
except ( ConnectionError , http . client . BadStatusLine ) :
pass # The node already shut down before response
2017-06-22 10:50:24 +02:00
self . log . debug ( ' Node should stop at this height... ' )
2017-09-06 20:02:08 +02:00
self . nodes [ 0 ] . wait_until_stopped ( )
2020-04-17 07:52:06 +02:00
self . start_node ( 0 , [ ' -txindex=0 ' ] )
2021-07-30 11:44:20 +02:00
assert_equal ( self . nodes [ 0 ] . getblockcount ( ) , HEIGHT + 7 )
2017-06-22 10:50:24 +02:00
2018-03-15 16:55:50 +01:00
def _test_waitforblockheight ( self ) :
self . log . info ( " Test waitforblockheight " )
node = self . nodes [ 0 ]
2020-09-25 14:18:21 +02:00
peer = node . add_p2p_connection ( P2PInterface ( ) )
2018-03-15 16:55:50 +01:00
current_height = node . getblock ( node . getbestblockhash ( ) ) [ ' height ' ]
# Create a fork somewhere below our current height, invalidate the tip
# of that fork, and then ensure that waitforblockheight still
# works as expected.
#
# (Previously this was broken based on setting
# `rpc/blockchain.cpp:latestblock` incorrectly.)
#
b20hash = node . getblockhash ( 20 )
b20 = node . getblock ( b20hash )
def solve_and_send_block ( prevhash , height , time ) :
b = create_block ( prevhash , create_coinbase ( height ) , time )
b . solve ( )
2020-09-25 14:18:21 +02:00
peer . send_and_ping ( msg_block ( b ) )
2018-03-15 16:55:50 +01:00
return b
b21f = solve_and_send_block ( int ( b20hash , 16 ) , 21 , b20 [ ' time ' ] + 1 )
b22f = solve_and_send_block ( b21f . sha256 , 22 , b21f . nTime + 1 )
node . invalidateblock ( b22f . hash )
def assert_waitforheight ( height , timeout = 2 ) :
assert_equal (
2018-11-13 22:49:17 +01:00
node . waitforblockheight ( height = height , timeout = timeout ) [ ' height ' ] ,
2018-03-15 16:55:50 +01:00
current_height )
assert_waitforheight ( 0 )
assert_waitforheight ( current_height - 1 )
assert_waitforheight ( current_height )
assert_waitforheight ( current_height + 1 )
2020-12-24 15:32:02 +01:00
def _test_getblock ( self ) :
node = self . nodes [ 0 ]
miniwallet = MiniWallet ( node )
2021-02-25 09:48:28 +01:00
miniwallet . scan_blocks ( num = 5 )
2020-12-24 15:32:02 +01:00
fee_per_byte = Decimal ( ' 0.00000010 ' )
fee_per_kb = 1000 * fee_per_byte
miniwallet . send_self_transfer ( fee_rate = fee_per_kb , from_node = node )
blockhash = node . generate ( 1 ) [ 0 ]
2021-07-30 11:44:20 +02:00
self . log . info ( " Test getblock with verbosity 1 doesn ' t include fee " )
2020-12-24 15:32:02 +01:00
block = node . getblock ( blockhash , 1 )
assert ' fee ' not in block [ ' tx ' ] [ 1 ]
2021-07-30 11:44:20 +02:00
self . log . info ( ' Test getblock with verbosity 2 includes expected fee ' )
2020-12-24 15:32:02 +01:00
block = node . getblock ( blockhash , 2 )
tx = block [ ' tx ' ] [ 1 ]
assert ' fee ' in tx
assert_equal ( tx [ ' fee ' ] , tx [ ' size ' ] * fee_per_byte )
2021-07-30 11:44:20 +02:00
self . log . info ( " Test getblock with verbosity 2 still works with pruned Undo data " )
2020-12-24 15:32:02 +01:00
datadir = get_datadir_path ( self . options . tmpdir , 0 )
2021-04-19 08:15:30 +02:00
self . log . info ( " Test that getblock with invalid verbosity type returns proper error message " )
assert_raises_rpc_error ( - 1 , " JSON value is not an integer as expected " , node . getblock , blockhash , " 2 " )
2020-12-24 15:32:02 +01:00
def move_block_file ( old , new ) :
old_path = os . path . join ( datadir , self . chain , ' blocks ' , old )
new_path = os . path . join ( datadir , self . chain , ' blocks ' , new )
os . rename ( old_path , new_path )
# Move instead of deleting so we can restore chain state afterwards
move_block_file ( ' rev00000.dat ' , ' rev_wrong ' )
block = node . getblock ( blockhash , 2 )
assert ' fee ' not in block [ ' tx ' ] [ 1 ]
# Restore chain state
move_block_file ( ' rev_wrong ' , ' rev00000.dat ' )
2021-02-23 18:28:19 +01:00
assert ' previousblockhash ' not in node . getblock ( node . getblockhash ( 0 ) )
assert ' nextblockhash ' not in node . getblock ( node . getbestblockhash ( ) )
2017-06-22 10:50:24 +02:00
2015-10-08 10:22:50 +02:00
if __name__ == ' __main__ ' :
BlockchainTest ( ) . main ( )