Inside Bitcoin

251                self.connect_nodes(0, 1)
252                self.sync_all()
253
254                self.log.debug("Create a template")
255                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
256                assert template is not None
257
258                self.log.debug("Test some inspectors of Template")
259                header = (await template.getBlockHeader(ctx)).result
260                assert_equal(len(header), block_header_size)
261                block = await mining_get_block(template, ctx)
262                current_tip = self.nodes[0].getbestblockhash()
263                assert_equal(ser_uint256(block.hashPrevBlock), ser_uint256(int(current_tip, 16)))
264                assert_greater_than_or_equal(len(block.vtx), 1)
265                txfees = await template.getTxFees(ctx)
266                assert_equal(len(txfees.result), 0)
267                txsigops = await template.getTxSigops(ctx)
268                assert_equal(len(txsigops.result), 0)
269
270                self.log.debug("Wait for a new template")
271                waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
272                waitoptions.timeout = self.default_ipc_timeout
273                waitoptions.feeThreshold = 1
274                template2 = await wait_and_do(
275                    mining_wait_next_template(template, stack, ctx, waitoptions),
276                    lambda: self.generate(self.nodes[0], 1))
277                assert template2 is not None
278                block2 = await mining_get_block(template2, ctx)
279                assert_equal(len(block2.vtx), 1)
280
281                self.log.debug("Wait for another, but time out")
282                template3 = await mining_wait_next_template(template2, stack, ctx, waitoptions)
283                assert template3 is None
284
285                self.log.debug("Wait for another, get one after increase in fees in the mempool")
286                template4 = await wait_and_do(
287                    mining_wait_next_template(template2, stack, ctx, waitoptions),
288                    lambda: self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
289                assert template4 is not None
290                block3 = await mining_get_block(template4, ctx)
291                assert_equal(len(block3.vtx), 2)
292
293                self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
294                waitoptions.feeThreshold = 0
295                template5 = await mining_wait_next_template(template4, stack, ctx, waitoptions)
296                assert template5 is not None
297                block4 = await mining_get_block(template5, ctx)
298                assert_equal(len(block4.vtx), 2)
299                waitoptions.feeThreshold = 1
300
301                self.log.debug("Wait for another, get one after increase in fees in the mempool")
302                template6 = await wait_and_do(
303                    mining_wait_next_template(template5, stack, ctx, waitoptions),
304                    lambda: self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
305                assert template6 is not None
306                block4 = await mining_get_block(template6, ctx)
307                assert_equal(len(block4.vtx), 3)
308
309                self.log.debug("Wait for another, but time out, since the fee threshold is set now")
310                template7 = await mining_wait_next_template(template6, stack, ctx, waitoptions)
311                assert template7 is None
312
313                self.log.debug("interruptWait should abort the current wait")
314                async def wait_for_block():
315                    new_waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
316                    new_waitoptions.timeout = max(self.default_ipc_timeout, 60000.0)  # at least 1 minute
317                    new_waitoptions.feeThreshold = 1
318                    template7 = await mining_wait_next_template(template6, stack, ctx, new_waitoptions)
319                    assert template7 is None
320                await wait_and_do(wait_for_block(), template6.interruptWait())
321
322        asyncio.run(capnp.run(async_routine()))
323
324    def run_ipc_option_override_test(self):
325        self.log.info("Running IPC option override test")
326        # Confirm that BlockCreateOptions.blockReservedWeight takes precedence
327        # over -blockreservedweight. Set an absurdly high -blockreservedweight
328        # value that would result in empty blocks to verify this. IPC clients set
329        # blockReservedWeight per template request and are unaffected; later in
330        # the test the IPC template includes a mempool transaction.
331        self.restart_node(0, extra_args=[f"-blockreservedweight={MAX_BLOCK_WEIGHT}"])
332        self.miniwallet.rescan_utxos()
333
334        async def async_routine():
335            ctx, mining = await make_mining_ctx(self)
336            self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
337
338            async with AsyncExitStack() as stack:
339                opts = self.capnp_modules['mining'].BlockCreateOptions()
340                template = await mining_create_block_template(mining, stack, ctx, opts)
341                assert template is not None
342                block = await mining_get_block(template, ctx)
343                assert_equal(len(block.vtx), 2)
344
345                self.log.debug("Use absurdly large reserved weight to force an empty template")
346                opts.blockReservedWeight = MAX_BLOCK_WEIGHT
347                empty_template = await mining_create_block_template(mining, stack, ctx, opts)
348                assert empty_template is not None
349                empty_block = await mining_get_block(empty_template, ctx)
350                assert_equal(len(empty_block.vtx), 1)
351
352            self.log.debug("Enforce minimum reserved weight for IPC clients too")
353            opts.blockReservedWeight = 0
354            await assert_create_new_block_fails(ctx, mining, opts,
355                "block_reserved_weight (0) is lower than minimum safety value of (2000)")
356
357        async def async_routine_check_max_reserved_weight():
358            self.log.debug("Enforce maximum reserved weight for IPC clients too")
359            ctx, mining = await make_mining_ctx(self)
360            opts = self.capnp_modules['mining'].BlockCreateOptions()
361            opts.blockReservedWeight = MAX_BLOCK_WEIGHT + 1
362            await assert_create_new_block_fails(ctx, mining, opts,
363                f"block_reserved_weight ({MAX_BLOCK_WEIGHT + 1}) exceeds consensus maximum block weight ({MAX_BLOCK_WEIGHT})")
364
365        async def async_routine_check_sigops_limit():
366            self.log.debug("Enforce sigops limit for IPC clients too")
367            ctx, mining = await make_mining_ctx(self)
368            opts = self.capnp_modules['mining'].BlockCreateOptions()
369            opts.coinbaseOutputMaxAdditionalSigops = MAX_BLOCK_SIGOPS_COST + 1
370            await assert_create_new_block_fails(ctx, mining, opts,
371                f"coinbase_output_max_additional_sigops ({MAX_BLOCK_SIGOPS_COST + 1}) exceeds consensus maximum block sigops cost ({MAX_BLOCK_SIGOPS_COST})")
372
373        asyncio.run(capnp.run(async_routine()))
374        asyncio.run(capnp.run(async_routine_check_max_reserved_weight()))
375        asyncio.run(capnp.run(async_routine_check_sigops_limit()))
376        self.restart_node(0)
377        self.connect_nodes(0, 1)
378        self.miniwallet.rescan_utxos()
379
380    def run_waitnext_mining_policy_test(self):
381        """Verify that waitNext() preserves the mining policy from -blockmintxfee
382        instead of falling back to defaults."""
383        self.log.info("Running waitNext mining policy test")
384        block_min_tx_fee = Decimal("0.00002000")
385        below_block_min_tx_fee = Decimal("0.00001000")
386        above_block_min_tx_fee = Decimal("0.00003000")
387
388        self.restart_node(0, extra_args=[
389            f"-blockmintxfee={block_min_tx_fee:.8f}",
390            "-minrelaytxfee=0",
391            "-persistmempool=0",
392        ])
393
394        async def async_routine():
395            ctx, mining = await make_mining_ctx(self)
396
397            self.log.debug("Create a below -blockmintxfee transaction")
398            low_fee_tx = self.miniwallet.send_self_transfer(
399                fee_rate=below_block_min_tx_fee,
400                from_node=self.nodes[0],
401                confirmed_only=True,
402            )
403            assert low_fee_tx["txid"] in self.nodes[0].getrawmempool()
404
405            async with AsyncExitStack() as stack:
406                self.log.debug("createNewBlock should respect -blockmintxfee")
407                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
408                assert template is not None
409                block = await mining_get_block(template, ctx)
410                assert low_fee_tx["txid"] not in {tx.txid_hex for tx in block.vtx[1:]}
411
412                self.log.debug("waitNext should preserve the same mining policy")
413                high_fee_tx = self.miniwallet.send_self_transfer(
414                    fee_rate=above_block_min_tx_fee,
415                    from_node=self.nodes[0],
416                    confirmed_only=True,
417                )
418                mempool_txids = self.nodes[0].getrawmempool()
419                assert high_fee_tx["txid"] in mempool_txids
420                assert low_fee_tx["txid"] in mempool_txids
421                template_next = await mining_wait_next_template(template, stack, ctx, self.default_block_wait_options)
422                assert template_next is not None
423
424                block_next = await mining_get_block(template_next, ctx)
425                block_next_txids = {tx.txid_hex for tx in block_next.vtx[1:]}
426                assert high_fee_tx["txid"] in block_next_txids
427                assert low_fee_tx["txid"] not in block_next_txids
428
429        asyncio.run(capnp.run(async_routine()))
430
431    def run_block_max_weight_test(self):
432        """Verify IPC createNewBlock() and waitNext() preserve the -blockmaxweight policy."""
433        self.log.info("Running block_max_weight test")
434
435        # Cap that leaves room for only a handful of mempool transactions
436        # above DEFAULT_BLOCK_RESERVED_WEIGHT (8000). Well below MAX_BLOCK_WEIGHT
437        # (4_000_000), so any truncation observed here is attributable to the
438        # cap, not to consensus limits or wallet chain limits.
439        small_cap = DEFAULT_BLOCK_RESERVED_WEIGHT + 4000
440        NUM_TXS = 20
441
442        self.restart_node(0, extra_args=[
443            f"-blockmaxweight={small_cap}",
444            "-minrelaytxfee=0",
445            "-persistmempool=0",
446        ])
447        # Refresh miniwallet's UTXO view from the chain after restart.
448        self.miniwallet.rescan_utxos()
449
450        # Fill the mempool enough that the configured block weight cap forces
451        # template truncation.
452        for _ in range(NUM_TXS):
453            self.miniwallet.send_self_transfer(from_node=self.nodes[0], confirmed_only=True)
454        assert_equal(self.nodes[0].getmempoolinfo()["size"], NUM_TXS)
455
456        async def async_routine():
457            ctx, mining = await make_mining_ctx(self)
458            async with AsyncExitStack() as stack:
459                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
460                assert template is not None
461                block = await mining_get_block(template, ctx)
462                assert_greater_than_or_equal(small_cap, block.get_weight())
463                # Exclude the coinbase; the cap must have forced truncation.
464                initial_included = len(block.vtx) - 1
465                assert initial_included < NUM_TXS, (
466                    f"Expected -blockmaxweight={small_cap} to truncate; "
467                    f"included {initial_included}/{NUM_TXS} mempool txs"
468                )
469
470                self.log.debug("waitNext should preserve -blockmaxweight")
471                high_fee_tx = self.miniwallet.send_self_transfer(
472                    from_node=self.nodes[0],
473                    confirmed_only=True,
474                    fee_rate=10,
475                )
476                template_next = await mining_wait_next_template(template, stack, ctx, self.default_block_wait_options)
477                assert template_next is not None
478
479                block_next = await mining_get_block(template_next, ctx)
480                assert_greater_than_or_equal(small_cap, block_next.get_weight())
481                assert high_fee_tx["txid"] in {tx.txid_hex for tx in block_next.vtx[1:]}
482                next_included = len(block_next.vtx) - 1
483                assert next_included < NUM_TXS + 1, (
484                    f"Expected -blockmaxweight={small_cap} to remain capped after waitNext; "
485                    f"included {next_included}/{NUM_TXS + 1} mempool txs"
486                )
487
488        asyncio.run(capnp.run(async_routine()))
489
490    def run_coinbase_and_submission_test(self):
491        """Test coinbase construction (getCoinbaseTx) and block submission (submitSolution)."""
492        self.log.info("Running coinbase construction and submission test")
493
494        async def async_routine():
495            ctx, mining = await make_mining_ctx(self)
496            # Node 0 drives the checkBlock() and submitSolution() checks. Node
497            # 2 has a separate IPC interface and starts synced through node 1,
498            # so it can be isolated below to test submitBlock() without
499            # changing node 0's template and chain state first.
500            ctx2, mining2 = await make_mining_ctx(self, node_index=2)