Inside Bitcoin

251
252        bad_block.nTime = t + MAX_FUTURE_BLOCK_TIME - MAX_TIMEWARP
253        bad_block.solve()
254        node.submitheader(hexdata=CBlockHeader(bad_block).serialize().hex())
255
256    def test_murch_zawy_mintime(self):
257        self.log.info("Test that GetMinimumTime accounts for the Murch-Zawy rule (BIP54)")
258        node = self.nodes[0]
259
260        self.log.info("Mine the first block of a retarget period two hours in the future")
261        blockchain_info = node.getblockchaininfo()
262        n = DIFFICULTY_ADJUSTMENT_INTERVAL - blockchain_info['blocks'] % DIFFICULTY_ADJUSTMENT_INTERVAL - 1
263        t = blockchain_info['time']
264        for _ in range(n):
265            t += 600
266            node.setmocktime(t)
267            self.generate(self.wallet, 1, sync_fun=self.no_op)
268        node.setmocktime(t + MAX_FUTURE_BLOCK_TIME)
269        self.generate(self.wallet, 1, sync_fun=self.no_op)
270        first_block_time = node.getblock(node.getbestblockhash())['time']
271        assert_equal(first_block_time, t + MAX_FUTURE_BLOCK_TIME)
272
273        self.log.info("Mine to the end of the period with timestamps held back")
274        node.setmocktime(t)
275        self.generate(self.wallet, DIFFICULTY_ADJUSTMENT_INTERVAL - 2, sync_fun=self.no_op)
276        assert_greater_than(first_block_time, node.getblock(node.getbestblockhash())['time'])
277
278        self.log.info("The template for the last block of the period is adjusted to its first block's time")
279        tmpl = node.getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
280        assert_equal(tmpl['mintime'], first_block_time)
281        assert_equal(tmpl['curtime'], first_block_time)
282
283        block = create_block(tmpl=tmpl)
284        block.solve()
285        node.submitheader(hexdata=CBlockHeader(block).serialize().hex())
286
287        self.log.info("The node mines a valid block at the end of the period despite its early wall clock")
288        self.generate(self.wallet, 1, sync_fun=self.no_op)
289        assert_equal(node.getblock(node.getbestblockhash())['time'], first_block_time)
290
291    def test_pruning(self):
292        self.log.info("Test that submitblock stores previously pruned block")
293        prune_node = self.nodes[2]
294        self.generate(prune_node, 400, sync_fun=self.no_op)
295        pruned_block = prune_node.getblock(prune_node.getblockhash(2), verbosity=0)
296        pruned_height = prune_node.pruneblockchain(400)
297        assert_greater_than_or_equal(pruned_height, 2)
298        pruned_blockhash = prune_node.getblockhash(2)
299
300        assert_raises_rpc_error(-1, 'Block not available (pruned data)', prune_node.getblock, pruned_blockhash)
301
302        result = prune_node.submitblock(pruned_block)
303        assert_equal(result, "inconclusive")
304        assert_equal(prune_node.getblock(pruned_blockhash, verbosity=0), pruned_block)
305
306
307    def send_transactions(self, utxos, fee_rate, target_vsize):
308        """
309        Helper to create and send transactions with the specified target virtual size and fee rate.
310        """
311        for utxo in utxos:
312            self.wallet.send_self_transfer(
313                from_node=self.nodes[0],
314                utxo_to_spend=utxo,
315                target_vsize=target_vsize,
316                fee_rate=fee_rate,
317            )
318
319    def verify_block_template(self, expected_tx_count, expected_weight):
320        """
321        Create a block template and check that it satisfies the expected transaction count and total weight.
322        """
323        response = self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
324        self.log.info(f"Testing block template: contains {expected_tx_count} transactions, and total weight <= {expected_weight}")
325        assert_equal(len(response["transactions"]), expected_tx_count)
326        total_weight = sum(transaction["weight"] for transaction in response["transactions"])
327        assert_greater_than_or_equal(expected_weight, total_weight)
328
329    def test_block_max_weight(self):
330        self.log.info("Testing default and custom -blockmaxweight startup options.")
331
332        LARGE_TXS_COUNT = 10
333        LARGE_VSIZE = int(((MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT) / WITNESS_SCALE_FACTOR) / LARGE_TXS_COUNT)
334        HIGH_FEERATE = Decimal("0.0003")
335
336        # Ensure the mempool is empty
337        assert_equal(len(self.nodes[0].getrawmempool()), 0)
338
339        # Generate UTXOs and send 10 large transactions with a high fee rate
340        utxos = [self.wallet.get_utxo(confirmed_only=True) for _ in range(LARGE_TXS_COUNT + 4)] # Add 4 more utxos that will be used in the test later
341        self.send_transactions(utxos[:LARGE_TXS_COUNT], HIGH_FEERATE, LARGE_VSIZE)
342
343        # Send 2 normal transactions with a lower fee rate
344        NORMAL_VSIZE = int(2000 / WITNESS_SCALE_FACTOR)
345        NORMAL_FEERATE = Decimal("0.0001")
346        self.send_transactions(utxos[LARGE_TXS_COUNT:LARGE_TXS_COUNT + 2], NORMAL_FEERATE, NORMAL_VSIZE)
347
348        # Check that the mempool contains all transactions
349        self.log.info(f"Testing that the mempool contains {LARGE_TXS_COUNT + 2} transactions.")
350        assert_equal(len(self.nodes[0].getrawmempool()), LARGE_TXS_COUNT + 2)
351
352        # Verify the block template includes only the 10 high-fee transactions
353        self.log.info("Testing that the block template includes only the 10 large transactions.")
354        self.verify_block_template(
355            expected_tx_count=LARGE_TXS_COUNT,
356            expected_weight=MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT,
357        )
358
359        # Test block template creation with custom -blockmaxweight
360        custom_block_weight = MAX_BLOCK_WEIGHT - 2000
361        # Reducing the weight by 2000 units will prevent 1 large transaction from fitting into the block.
362        self.restart_node(0, extra_args=[f"-blockmaxweight={custom_block_weight}"])
363
364        self.log.info("Testing the block template with custom -blockmaxweight to include 9 large and 2 normal transactions.")
365        self.verify_block_template(
366            expected_tx_count=11,
367            expected_weight=MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT - 2000,
368        )
369
370        # Ensure the block weight does not exceed the maximum
371        self.log.info(f"Testing that the block weight will never exceed {MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT}.")
372        self.restart_node(0, extra_args=[f"-blockmaxweight={MAX_BLOCK_WEIGHT}"])
373        self.log.info("Sending 2 additional normal transactions to fill the mempool to the maximum block weight.")
374        self.send_transactions(utxos[LARGE_TXS_COUNT + 2:], NORMAL_FEERATE, NORMAL_VSIZE)
375        self.log.info(f"Testing that the mempool's weight matches the maximum block weight: {MAX_BLOCK_WEIGHT}.")
376        assert_equal(self.nodes[0].getmempoolinfo()['bytes'] * WITNESS_SCALE_FACTOR, MAX_BLOCK_WEIGHT)
377
378        self.log.info("Testing that the block template includes only 10 transactions and cannot reach full block weight.")
379        self.verify_block_template(
380            expected_tx_count=LARGE_TXS_COUNT,
381            expected_weight=MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT,
382        )
383
384        self.log.info("Test -blockreservedweight startup option.")
385        # Lowering the -blockreservedweight by 4000 will allow for two more transactions.
386        self.restart_node(0, extra_args=["-blockreservedweight=4000"])
387        self.verify_block_template(
388            expected_tx_count=12,
389            expected_weight=MAX_BLOCK_WEIGHT - 4000,
390        )
391
392        self.log.info("Test that node will fail to start when user provide invalid -blockreservedweight")
393        self.stop_node(0)
394        self.nodes[0].assert_start_raises_init_error(
395            extra_args=[f"-blockreservedweight={MAX_BLOCK_WEIGHT + 1}"],
396            expected_msg=f"Error: -blockreservedweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
397        )
398
399        self.log.info(f"Test that node will fail to start when user provide -blockreservedweight below {MINIMUM_BLOCK_RESERVED_WEIGHT}")
400        self.stop_node(0)
401        self.nodes[0].assert_start_raises_init_error(
402            extra_args=[f"-blockreservedweight={MINIMUM_BLOCK_RESERVED_WEIGHT - 1}"],
403            expected_msg=f"Error: -blockreservedweight ({MINIMUM_BLOCK_RESERVED_WEIGHT - 1}) is lower than minimum safety value of ({MINIMUM_BLOCK_RESERVED_WEIGHT})",
404        )
405
406        self.log.info("Test that node will fail to start when user provide invalid -blockmaxweight")
407        self.stop_node(0)
408        self.nodes[0].assert_start_raises_init_error(
409            extra_args=[f"-blockmaxweight={MAX_BLOCK_WEIGHT + 1}"],
410            expected_msg=f"Error: -blockmaxweight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})",
411        )
412
413        self.log.info("Test that node will fail to start when -blockmaxweight is lower than -blockreservedweight")
414        self.stop_node(0)
415        self.nodes[0].assert_start_raises_init_error(
416            extra_args=[f"-blockmaxweight={DEFAULT_BLOCK_RESERVED_WEIGHT - 1}"],
417            expected_msg=f"Error: -blockreservedweight ({DEFAULT_BLOCK_RESERVED_WEIGHT}) exceeds -blockmaxweight ({DEFAULT_BLOCK_RESERVED_WEIGHT - 1})",
418        )
419
420    def test_height_in_locktime(self):
421        self.log.info("Sanity check generated blocks have their coinbase timelocked to their height.")
422        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
423        block = self.nodes[0].getblock(self.nodes[0].getbestblockhash(), 2)
424        assert_equal(block["tx"][0]["locktime"], block["height"] - 1)
425        assert_equal(block["tx"][0]["vin"][0]["sequence"], MAX_SEQUENCE_NONFINAL)
426
427    def run_test(self):
428        node = self.nodes[0]
429        self.wallet = MiniWallet(node)
430        self.mine_chain()
431
432        self.log.info('getmininginfo')
433        mining_info = node.getmininginfo()
434        assert_equal(mining_info['blocks'], 200)
435        assert_equal(mining_info['chain'], self.chain)
436        assert 'currentblocktx' not in mining_info
437        assert 'currentblockweight' not in mining_info
438        assert_equal(mining_info['bits'], nbits_str(REGTEST_N_BITS))
439        assert_equal(mining_info['target'], target_str(REGTEST_TARGET))
440        # We don't care about precision, round to avoid mismatch under Valgrind:
441        assert_equal(round(mining_info['difficulty'], 10), Decimal('0.0000000005'))
442        assert_equal(mining_info['next']['height'], 201)
443        assert_equal(mining_info['next']['target'], target_str(REGTEST_TARGET))
444        assert_equal(mining_info['next']['bits'], nbits_str(REGTEST_N_BITS))
445        assert_equal(round(mining_info['next']['difficulty'], 10), Decimal('0.0000000005'))
446        assert_equal(round(mining_info['networkhashps'], 5), Decimal('0.00333'))
447        assert_equal(mining_info['pooledtx'], 0)
448
449        self.log.info("getblocktemplate: Test default witness commitment")
450        txid = int(self.wallet.send_self_transfer(from_node=node)['wtxid'], 16)
451        tmpl = node.getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
452
453        # Check that default_witness_commitment is present.
454        assert 'default_witness_commitment' in tmpl
455        witness_commitment = tmpl['default_witness_commitment']
456
457        # Check that default_witness_commitment is correct.
458        witness_root = CBlock.get_merkle_root([ser_uint256(0),
459                                               ser_uint256(txid)])
460        script = get_witness_script(witness_root, 0)
461        assert_equal(witness_commitment, script.hex())
462
463        # Mine a block to leave initial block download and clear the mempool
464        self.generatetoaddress(node, 1, node.get_deterministic_priv_key().address)
465        tmpl = node.getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)
466        self.log.info("getblocktemplate: Test capability advertised")
467        assert 'proposal' in tmpl['capabilities']
468        assert 'coinbasetxn' not in tmpl
469
470        next_height = int(tmpl["height"])
471        coinbase_tx = create_coinbase(height=next_height)
472        # sequence numbers must not be max for nLockTime to have effect
473        coinbase_tx.vin[0].nSequence = 2**32 - 2
474
475        block = CBlock()
476        block.nVersion = tmpl["version"]
477        block.hashPrevBlock = int(tmpl["previousblockhash"], 16)
478        block.nTime = tmpl["curtime"]
479        block.nBits = int(tmpl["bits"], 16)
480        block.nNonce = 0
481        block.vtx = [coinbase_tx]
482        block.hashMerkleRoot = block.calc_merkle_root()
483
484        self.log.info("getblocktemplate: segwit rule must be set")
485        assert_raises_rpc_error(-8, "getblocktemplate must be called with the segwit rule set", node.getblocktemplate, {})
486
487        self.log.info("getblocktemplate: result should set the right rules")
488        assert_equal(['csv', '!segwit', 'taproot'], self.nodes[0].getblocktemplate(NORMAL_GBT_REQUEST_PARAMS)['rules'])
489
490        self.log.info("submitblock: Test block decode failure")
491        assert_raises_rpc_error(-22, "Block decode failed", node.submitblock, block.serialize()[:-15].hex())
492
493        self.log.info("submitblock: Test empty block")
494        assert_equal('high-hash', node.submitblock(hexdata=CBlock().serialize().hex()))
495
496        self.log.info('submitheader tests')
497        assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='xx' * BLOCK_HEADER_SIZE))
498        assert_raises_rpc_error(-22, 'Block header decode failed', lambda: node.submitheader(hexdata='ff' * (BLOCK_HEADER_SIZE-2)))
499
500        missing_ancestor_block = copy.deepcopy(block)