Inside Bitcoin

251        # Note: continues past -stopatheight height, so must be invoked
252        # after _test_stopatheight
253
254        self.log.info("Test getdeploymentinfo")
255        self.stop_node(0)
256        self.start_node(0, extra_args=[
257            '-testactivationheight=bip34@2',
258            '-testactivationheight=dersig@3',
259            '-testactivationheight=cltv@4',
260            '-testactivationheight=csv@5',
261            '-testactivationheight=segwit@6',
262        ])
263
264        gbci207 = self.nodes[0].getblockchaininfo()
265        self.check_signalling_deploymentinfo_result(self.nodes[0].getdeploymentinfo(), gbci207["blocks"], gbci207["bestblockhash"], "started")
266
267        # block just prior to lock in
268        self.generate(self.wallet, 287 - gbci207["blocks"])
269        gbci287 = self.nodes[0].getblockchaininfo()
270        self.check_signalling_deploymentinfo_result(self.nodes[0].getdeploymentinfo(), gbci287["blocks"], gbci287["bestblockhash"], "locked_in")
271
272        # calling with an explicit hash works
273        self.check_signalling_deploymentinfo_result(self.nodes[0].getdeploymentinfo(gbci207["bestblockhash"]), gbci207["blocks"], gbci207["bestblockhash"], "started")
274
275    def _test_verificationprogress(self):
276        self.log.info("Check that verificationprogress is less than 1 when the block tip is old")
277        future = 2 * 60 * 60
278        self.nodes[0].setmocktime(self.nodes[0].getblockchaininfo()["time"] + future + 1)
279        assert_greater_than(1, self.nodes[0].getblockchaininfo()["verificationprogress"])
280
281        self.log.info("Check that verificationprogress is exactly 1 for a recent block tip")
282        self.nodes[0].setmocktime(self.nodes[0].getblockchaininfo()["time"] + future)
283        assert_equal(1, self.nodes[0].getblockchaininfo()["verificationprogress"])
284
285        self.log.info("Check that verificationprogress is less than 1 as soon as a new header comes in")
286        self.nodes[0].submitheader(self.generateblock(self.nodes[0], output="raw(55)", transactions=[], submit=False, sync_fun=self.no_op)["hex"])
287        assert_greater_than(1, self.nodes[0].getblockchaininfo()["verificationprogress"])
288
289    def _test_y2106(self):
290        self.log.info("Check that block timestamps work until year 2106")
291        self.generate(self.nodes[0], 8)[-1]
292        time_2106 = 2**32 - 1
293        assert_raises_rpc_error(-8, f"Mocktime must be in the range [0, {time_2106}], not -1.", self.nodes[0].setmocktime, -1)
294        assert_raises_rpc_error(-8, f"Mocktime must be in the range [0, {time_2106}], not {time_2106 + 1}.", self.nodes[0].setmocktime, time_2106 + 1)
295        self.nodes[0].setmocktime(time_2106)
296        last = self.generate(self.nodes[0], 6)[-1]
297        assert_equal(self.nodes[0].getblockheader(last)["mediantime"], time_2106)
298
299    def _test_getchaintxstats(self):
300        self.log.info("Test getchaintxstats")
301
302        # Test `getchaintxstats` invalid extra parameters
303        assert_raises_rpc_error(-1, 'getchaintxstats', self.nodes[0].getchaintxstats, 0, '', 0)
304
305        # Test `getchaintxstats` invalid `nblocks`
306        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type number", self.nodes[0].getchaintxstats, '')
307        assert_raises_rpc_error(-8, "Invalid block count: should be between 0 and the block's height - 1", self.nodes[0].getchaintxstats, -1)
308        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())
309
310        # Test `getchaintxstats` invalid `blockhash`
311        assert_raises_rpc_error(-3, "JSON value of type number is not of expected type string", self.nodes[0].getchaintxstats, blockhash=0)
312        assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 1, for '0')", self.nodes[0].getchaintxstats, blockhash='0')
313        assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].getchaintxstats, blockhash='ZZZ0000000000000000000000000000000000000000000000000000000000000')
314        assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getchaintxstats, blockhash='0000000000000000000000000000000000000000000000000000000000000000')
315        blockhash = self.nodes[0].getblockhash(HEIGHT)
316        self.nodes[0].invalidateblock(blockhash)
317        assert_raises_rpc_error(-8, "Block is not in main chain", self.nodes[0].getchaintxstats, blockhash=blockhash)
318        self.nodes[0].reconsiderblock(blockhash)
319
320        chaintxstats = self.nodes[0].getchaintxstats(nblocks=1)
321        # 200 txs plus genesis tx
322        assert_equal(chaintxstats['txcount'], HEIGHT + 1)
323        # tx rate should be 1 per 10 minutes, or 1/600
324        # we have to round because of binary math
325        assert_equal(round(chaintxstats['txrate'] * TIME_RANGE_STEP, 10), Decimal(1))
326
327        b1_hash = self.nodes[0].getblockhash(1)
328        b1 = self.nodes[0].getblock(b1_hash)
329        b200_hash = self.nodes[0].getblockhash(HEIGHT)
330        b200 = self.nodes[0].getblock(b200_hash)
331        time_diff = b200['mediantime'] - b1['mediantime']
332
333        chaintxstats = self.nodes[0].getchaintxstats()
334        assert_equal(chaintxstats['time'], b200['time'])
335        assert_equal(chaintxstats['txcount'], HEIGHT + 1)
336        assert_equal(chaintxstats['window_final_block_hash'], b200_hash)
337        assert_equal(chaintxstats['window_final_block_height'], HEIGHT )
338        assert_equal(chaintxstats['window_block_count'], HEIGHT - 1)
339        assert_equal(chaintxstats['window_tx_count'], HEIGHT - 1)
340        assert_equal(chaintxstats['window_interval'], time_diff)
341        assert_equal(round(chaintxstats['txrate'] * time_diff, 10), Decimal(HEIGHT - 1))
342
343        chaintxstats = self.nodes[0].getchaintxstats(blockhash=b1_hash)
344        assert_equal(chaintxstats['time'], b1['time'])
345        assert_equal(chaintxstats['txcount'], 2)
346        assert_equal(chaintxstats['window_final_block_hash'], b1_hash)
347        assert_equal(chaintxstats['window_final_block_height'], 1)
348        assert_equal(chaintxstats['window_block_count'], 0)
349        assert 'window_tx_count' not in chaintxstats
350        assert 'window_interval' not in chaintxstats
351        assert 'txrate' not in chaintxstats
352
353    def _test_gettxoutsetinfo(self):
354        node = self.nodes[0]
355        res = node.gettxoutsetinfo()
356
357        assert_equal(res['total_amount'], Decimal('8725.00000000'))
358        assert_equal(res['transactions'], HEIGHT)
359        assert_equal(res['height'], HEIGHT)
360        assert_equal(res['txouts'], HEIGHT)
361        assert_equal(res['bogosize'], 16800),
362        assert_equal(res['bestblock'], node.getblockhash(HEIGHT))
363        size = res['disk_size']
364        assert size > 6400
365        assert size < 64000
366        assert_equal(len(res['bestblock']), 64)
367        assert_equal(len(res['hash_serialized_3']), 64)
368
369        self.log.info("Test gettxoutsetinfo works for blockchain with just the genesis block")
370        b1hash = node.getblockhash(1)
371        node.invalidateblock(b1hash)
372
373        res2 = node.gettxoutsetinfo()
374        assert_equal(res2['transactions'], 0)
375        assert_equal(res2['total_amount'], Decimal('0'))
376        assert_equal(res2['height'], 0)
377        assert_equal(res2['txouts'], 0)
378        assert_equal(res2['bogosize'], 0),
379        assert_equal(res2['bestblock'], node.getblockhash(0))
380        assert_equal(len(res2['hash_serialized_3']), 64)
381
382        self.log.info("Test gettxoutsetinfo returns the same result after invalidate/reconsider block")
383        node.reconsiderblock(b1hash)
384
385        res3 = node.gettxoutsetinfo()
386        # The field 'disk_size' is non-deterministic and can thus not be
387        # compared between res and res3.  Everything else should be the same.
388        del res['disk_size'], res3['disk_size']
389        assert_equal(res, res3)
390
391        self.log.info("Test gettxoutsetinfo hash_type option")
392        # Adding hash_type 'hash_serialized_3', which is the default, should
393        # not change the result.
394        res4 = node.gettxoutsetinfo(hash_type='hash_serialized_3')
395        del res4['disk_size']
396        assert_equal(res, res4)
397
398        # hash_type none should not return a UTXO set hash.
399        res5 = node.gettxoutsetinfo(hash_type='none')
400        assert 'hash_serialized_3' not in res5
401
402        # hash_type muhash should return a different UTXO set hash.
403        res6 = node.gettxoutsetinfo(hash_type='muhash')
404        assert 'muhash' in res6
405        assert_not_equal(res['hash_serialized_3'], res6['muhash'])
406
407        # muhash should not be returned unless requested.
408        for r in [res, res2, res3, res4, res5]:
409            assert 'muhash' not in r
410
411        # Unknown hash_type raises an error
412        assert_raises_rpc_error(-8, "'foo hash' is not a valid hash_type", node.gettxoutsetinfo, "foo hash")
413
414    def _test_gettxout(self):
415        self.log.info("Validating gettxout RPC response")
416        node = self.nodes[0]
417
418        # Get the best block hash and the block, which
419        # should only include the coinbase transaction.
420        best_block_hash = node.getbestblockhash()
421        block = node.getblock(best_block_hash)
422        assert_equal(block['nTx'], 1)
423
424        # Get the transaction ID of the coinbase tx and
425        # the transaction output.
426        txid = block['tx'][0]
427        txout = node.gettxout(txid, 0)
428
429        # Validate the gettxout response
430        assert_equal(txout['bestblock'], best_block_hash)
431        assert_equal(txout['confirmations'], 1)
432        assert_equal(txout['value'], 25)
433        assert_equal(txout['scriptPubKey']['address'], self.wallet.get_address())
434        assert_equal(txout['scriptPubKey']['hex'], self.wallet.get_output_script().hex())
435        decoded_script = node.decodescript(self.wallet.get_output_script().hex())
436        assert_equal(txout['scriptPubKey']['asm'], decoded_script['asm'])
437        assert_equal(txout['scriptPubKey']['desc'], decoded_script['desc'])
438        assert_equal(txout['scriptPubKey']['type'], decoded_script['type'])
439        assert_equal(txout['coinbase'], True)
440
441    def _test_getblockheader(self):
442        self.log.info("Test getblockheader")
443        node = self.nodes[0]
444
445        assert_raises_rpc_error(-8, "hash must be of length 64 (not 8, for 'nonsense')", node.getblockheader, "nonsense")
446        assert_raises_rpc_error(-8, "hash must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')", node.getblockheader, "ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
447        assert_raises_rpc_error(-5, "Block not found", node.getblockheader, "0cf7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
448
449        besthash = node.getbestblockhash()
450        secondbesthash = node.getblockhash(HEIGHT - 1)
451        header = node.getblockheader(blockhash=besthash)
452
453        assert_equal(header['hash'], besthash)
454        assert_equal(header['height'], HEIGHT)
455        assert_equal(header['confirmations'], 1)
456        assert_equal(header['previousblockhash'], secondbesthash)
457        assert_is_hex_string(header['chainwork'])
458        assert_equal(header['nTx'], 1)
459        assert_is_hash_string(header['hash'])
460        assert_is_hash_string(header['previousblockhash'])
461        assert_is_hash_string(header['merkleroot'])
462        assert_equal(header['bits'], nbits_str(REGTEST_N_BITS))
463        assert_equal(header['target'], target_str(REGTEST_TARGET))
464        assert isinstance(header['time'], int)
465        assert_equal(header['mediantime'], TIME_RANGE_MTP)
466        assert isinstance(header['nonce'], int)
467        assert isinstance(header['version'], int)
468        assert isinstance(int(header['versionHex'], 16), int)
469        assert isinstance(header['difficulty'], Decimal)
470
471        # Test with verbose=False, which should return the header as hex.
472        header_hex = node.getblockheader(blockhash=besthash, verbose=False)
473        assert_is_hex_string(header_hex)
474
475        header = from_hex(CBlockHeader(), header_hex)
476        assert_equal(header.hash_hex, besthash)
477
478        assert 'previousblockhash' not in node.getblockheader(node.getblockhash(0))
479        assert 'nextblockhash' not in node.getblockheader(node.getbestblockhash())
480
481    def _test_getdifficulty(self):
482        self.log.info("Test getdifficulty")
483        difficulty = self.nodes[0].getdifficulty()
484        # 1 hash in 2 should be valid, so difficulty should be 1/2**31
485        # binary => decimal => binary math is why we do this check
486        assert abs(difficulty * 2**31 - 1) < 0.0001
487
488    def _test_getnetworkhashps(self):
489        self.log.info("Test getnetworkhashps")
490        assert_raises_rpc_error(
491            -3,
492            textwrap.dedent("""
493            Wrong type passed:
494            {
495                "Position 1 (nblocks)": "JSON value of type string is not of expected type number",
496                "Position 2 (height)": "JSON value of type array is not of expected type number"
497            }
498            """).strip(),
499            lambda: self.nodes[0].getnetworkhashps("a", []),
500        )