Inside Bitcoin

501
502            current_block_height = self.nodes[0].getchaintips()[0]["height"]
503            check_opts = self.capnp_modules['mining'].BlockCheckOptions()
504
505            # Send a real transaction so the template includes it.
506            self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
507
508            async with destroying((await mining.createNewBlock(ctx, self.default_block_create_options)).result, ctx) as template:
509                block = await self.build_candidate_block(template, ctx)
510                coinbase = block.vtx[0]
511                self.log.debug("Template should include a mempool transaction")
512                assert len(block.vtx) >= 2, "Block should include at least the coinbase and the mempool tx"
513                balance = self.miniwallet.get_balance()
514                original_version = block.nVersion
515
516                self.log.debug("Disconnect node 2 before block submission tests")
517                # The default topology is 2 -> 1 -> 0. Splitting the 1-2 edge
518                # lets node 2 accept/reject complete blocks independently.
519                self.disconnect_nodes(1, 2)
520
521                self.log.debug("submitSolution should reject an empty coinbase")
522                submitted = (await template.submitSolution(ctx, 0, 0, 0, b"")).result
523                assert_equal(submitted, False)
524
525                self.log.debug("Submit solution that can't be deserialized")
526                try:
527                    await template.submitSolution(ctx, 0, 0, 0, b"\x00")
528                    raise AssertionError("submitSolution unexpectedly succeeded")
529                except capnp.lib.capnp.KjException as e:
530                    assert_capnp_failed(e, "remote exception: std::exception: SpanReader::read(): end of data:")
531
532                self.log.debug("Submit a block with a bad version")
533                block.nVersion = 0
534                block.solve()
535                check = await mining.checkBlock(ctx, block.serialize(), check_opts)
536                assert_equal(check.result, False)
537                assert_equal(check.reason, "bad-version(0x00000000)")
538                assert_equal(check.debug, "rejected nVersion=0x00000000 block")
539                self.log.debug("submitSolution should reject a bad-version block")
540                result = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
541                assert_equal(result.result, False)
542                assert_equal(result.reason, "bad-version(0x00000000)")
543                assert_equal(result.debug, "rejected nVersion=0x00000000 block")
544                self.log.debug("submitBlock should reject a bad-version block")
545                await self.assert_submit_block(
546                    mining2,
547                    ctx2,
548                    block,
549                    result=False,
550                    reason="bad-version(0x00000000)",
551                    debug="rejected nVersion=0x00000000 block",
552                )
553                self.log.debug("Submit a valid block")
554                block.nVersion = original_version
555                block.solve()
556
557                self.log.debug("First call checkBlock()")
558                block_valid = (await mining.checkBlock(ctx, block.serialize(), check_opts)).result
559                assert_equal(block_valid, True)
560
561                # The remote template block will be mutated, capture the original:
562                remote_block_before = await mining_get_block(template, ctx)
563
564                self.log.debug("Submitted coinbase must include witness")
565                assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
566                missing_witness_block = deepcopy(block)
567                missing_witness_block.vtx[0].wit.vtxinwit = []
568                has_witness_commitment = any(
569                    len(o.scriptPubKey) >= 38 and o.scriptPubKey[2:6] == WITNESS_COMMITMENT_HEADER
570                    for o in missing_witness_block.vtx[0].vout
571                )
572                assert has_witness_commitment, "Coinbase should have a witness commitment output"
573                missing_witness_block.hashMerkleRoot = missing_witness_block.calc_merkle_root()
574                missing_witness_block.solve()
575                self.log.debug("submitSolution should reject a coinbase missing witness")
576                result = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())
577                assert_equal(result.result, False)
578                assert_equal(result.reason, "bad-witness-nonce-size")
579                assert_equal(result.debug, "CheckWitnessMalleation : invalid witness reserved value size")
580
581                self.log.debug("Even a rejected submitSolution() mutates the template's block")
582                # Can be used by clients to download and inspect the (rejected)
583                # reconstructed block.
584                remote_block_after = await mining_get_block(template, ctx)
585                assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
586
587                self.log.debug("submitBlock should reject a block missing coinbase witness")
588                await self.assert_submit_block(
589                    mining2,
590                    ctx2,
591                    missing_witness_block,
592                    result=False,
593                    reason="bad-witness-nonce-size",
594                    debug="CheckWitnessMalleation : invalid witness reserved value size",
595                )
596
597                self.log.debug("Submit again, with the witness")
598                result = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
599                assert_equal(result.result, True)
600                assert_equal(result.reason, "")
601                assert_equal(result.debug, "")
602
603                self.log.debug("Submit a valid complete block through the disconnected node")
604                await self.assert_submit_block(mining2, ctx2, block, result=True)
605                assert_equal(self.nodes[2].getchaintips()[0]["height"], current_block_height + 1)
606                self.log.debug("submitBlock should reject the duplicate complete block")
607                await self.assert_submit_block(mining2, ctx2, block, result=False, reason="duplicate")
608
609            self.log.debug("Block should propagate")
610            # Check that the IPC node actually updates its own chain
611            assert_equal(self.nodes[0].getchaintips()[0]["height"], current_block_height + 1)
612            # Stalls if a regression causes submitSolution() to accept an invalid block:
613            self.sync_blocks(self.nodes[:2])
614            # Rejoin node 2 and verify the submitBlock result converges with
615            # the submitSolution result from node 0.
616            self.connect_nodes(1, 2)
617            self.sync_all()
618            # Check that the other node accepts the block
619            assert_equal(self.nodes[0].getchaintips()[0], self.nodes[1].getchaintips()[0])
620
621            self.miniwallet.rescan_utxos()
622            assert_equal(self.miniwallet.get_balance(), balance + 1)
623            self.log.debug("Check block should fail now, since it is a duplicate")
624            check = await mining.checkBlock(ctx, block.serialize(), check_opts)
625            assert_equal(check.result, False)
626            assert_equal(check.reason, "inconclusive-not-best-prevblk")
627            self.log.debug("submitBlock on the same node should fail with duplicate after submitSolution succeeds")
628            await self.assert_submit_block(mining, ctx, block, result=False, reason="duplicate")
629
630            self.log.debug("submitSolution should return duplicate after submitBlock succeeds")
631            async with destroying((await mining2.createNewBlock(ctx2, self.default_block_create_options)).result, ctx2) as template2:
632                duplicate_block = await self.build_candidate_block(template2, ctx2)
633                duplicate_coinbase = duplicate_block.vtx[0]
634                duplicate_block.solve()
635                self.log.debug("Submit a valid complete block before duplicate submitSolution")
636                await self.assert_submit_block(mining2, ctx2, duplicate_block, result=True)
637                self.nodes[2].waitforblockheight(current_block_height + 2)
638                self.log.debug("submitSolution should reject the duplicate block")
639                result = await template2.submitSolution(ctx2, duplicate_block.nVersion, duplicate_block.nTime, duplicate_block.nNonce, duplicate_coinbase.serialize())
640                assert_equal(result.result, False)
641                assert_equal(result.reason, "duplicate")
642                assert_equal(result.debug, "")
643            self.sync_all()
644
645            self.log.debug(
646                "submitSolution and submitBlock should report inconclusive for valid stale blocks")
647            async with AsyncExitStack() as stack:
648                active_template = await mining_create_block_template(
649                    mining2, stack, ctx2, self.default_block_create_options)
650                solution_template = await mining_create_block_template(
651                    mining2, stack, ctx2, self.default_block_create_options)
652                submit_block_template = await mining_create_block_template(
653                    mining2, stack, ctx2, self.default_block_create_options)
654                assert active_template is not None
655                assert solution_template is not None
656                assert submit_block_template is not None
657
658                active_block = await self.build_candidate_block(
659                    active_template, ctx2, extra_nonce=b"\x01")
660                solution_block = await self.build_candidate_block(
661                    solution_template, ctx2, extra_nonce=b"\x02")
662                submit_block = await self.build_candidate_block(
663                    submit_block_template, ctx2, extra_nonce=b"\x03")
664                active_block.solve()
665                solution_block.solve()
666                submit_block.solve()
667
668                # All three templates share a parent. The first block becomes
669                # active, so the remaining valid blocks are accepted as stale.
670                await self.assert_submit_block(
671                    mining2, ctx2, active_block, result=True)
672
673                solution_coinbase = solution_block.vtx[0]
674                result = await solution_template.submitSolution(
675                    ctx2,
676                    solution_block.nVersion,
677                    solution_block.nTime,
678                    solution_block.nNonce,
679                    solution_coinbase.serialize(),
680                )
681                assert_equal(result.result, False)
682                assert_equal(result.reason, "inconclusive")
683                assert_equal(result.debug, "")
684
685                await self.assert_submit_block(
686                    mining2, ctx2, submit_block, result=False, reason="inconclusive")
687            self.sync_all()
688
689            self.log.debug("Submit the same invalid block twice")
690            async with destroying((await mining2.createNewBlock(ctx2, self.default_block_create_options)).result, ctx2) as template2:
691                invalid_block = await self.build_candidate_block(template2, ctx2)
692                invalid_block.vtx[0].nLockTime = 2**32 - 1
693                invalid_block.hashMerkleRoot = invalid_block.calc_merkle_root()
694                invalid_block.solve()
695                self.log.debug("submitBlock should reject the non-final block")
696                await self.assert_submit_block(
697                    mining2,
698                    ctx2,
699                    invalid_block,
700                    result=False,
701                    reason="bad-txns-nonfinal",
702                    debug="non-final transaction",
703                )
704                self.log.debug("submitBlock should report duplicate-invalid for the same block")
705                await self.assert_submit_block(
706                    mining2,
707                    ctx2,
708                    invalid_block,
709                    result=False,
710                    reason="duplicate-invalid",
711                    debug=f"block {invalid_block.hash_hex} was previously marked invalid",
712                )
713
714            self.log.debug("Submit a malformed complete block")
715            try:
716                await mining2.submitBlock(ctx2, block.serialize()[:-15])
717                raise AssertionError("submitBlock unexpectedly succeeded")
718            except capnp.lib.capnp.KjException as e:
719                assert_capnp_failed(e, "remote exception: std::exception: SpanReader::read(): end of data:")
720
721            self.log.debug("Submit empty block data")
722            try:
723                await mining2.submitBlock(ctx2, b"")
724                raise AssertionError("submitBlock unexpectedly succeeded")
725            except capnp.lib.capnp.KjException as e:
726                assert_capnp_failed(e, "remote exception: std::exception: SpanReader::read(): end of data:")
727            assert_equal(self.nodes[2].is_node_stopped(), False)
728
729        asyncio.run(capnp.run(async_routine()))
730
731    def run_transaction_lookup_test(self):
732        """Test getTransactionsByTxID() and getTransactionsByWitnessID()."""
733        self.log.info("Running transaction lookup test")
734
735        async def async_routine():
736            ctx, mining = await make_mining_ctx(self)
737            tx1 = self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
738            tx2 = self.miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0], utxo_to_spend=tx1["new_utxo"])
739
740            self.log.debug("getTransactionsByTxID() returns mempool txs and nulls")
741            raw_txs_txid = await mining.getTransactionsByTxID(ctx, [tx1["tx"].txid, tx2["tx"].txid, bytes(32)])
742            assert_equal(len(raw_txs_txid.result), 3)
743            assert_equal(raw_txs_txid.result[0].hex(), tx1["hex"])
744            assert_equal(raw_txs_txid.result[1].hex(), tx2["hex"])
745            assert_equal(raw_txs_txid.result[2], b'')
746
747            self.log.debug("getTransactionsByWitnessID() returns mempool txs and nulls")
748            raw_txs_wtxid = await mining.getTransactionsByWitnessID(ctx, [tx1["tx"].wtxid, tx2["tx"].wtxid, bytes(32)])
749            assert_equal(len(raw_txs_wtxid.result), 3)
750            assert_equal(raw_txs_wtxid.result[0].hex(), tx1["hex"])