Inside Bitcoin

1// Copyright (c) 2014-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <chainparams.h>
6#include <consensus/amount.h>
7#include <consensus/merkle.h>
8#include <core_io.h>
9#include <hash.h>
10#include <net.h>
11#include <signet.h>
12#include <uint256.h>
13#include <util/chaintype.h>
14#include <validation.h>
15
16#include <string>
17
18#include <test/util/setup_common.h>
19
20#include <boost/test/unit_test.hpp>
21
22BOOST_FIXTURE_TEST_SUITE(validation_tests, BasicTestingSetup)
23
24static void TestBlockSubsidyHalvings(const Consensus::Params& consensusParams)
25{
26    int maxHalvings = 64;
27    CAmount nInitialSubsidy = 50 * COIN;
28
29    CAmount nPreviousSubsidy = nInitialSubsidy * 2; // for height == 0
30    BOOST_CHECK_EQUAL(nPreviousSubsidy, nInitialSubsidy * 2);
31    for (int nHalvings = 0; nHalvings < maxHalvings; nHalvings++) {
32        int nHeight = nHalvings * consensusParams.nSubsidyHalvingInterval;
33        CAmount nSubsidy = GetBlockSubsidy(nHeight, consensusParams);
34        BOOST_CHECK(nSubsidy <= nInitialSubsidy);
35        BOOST_CHECK_EQUAL(nSubsidy, nPreviousSubsidy / 2);
36        nPreviousSubsidy = nSubsidy;
37    }
38    BOOST_CHECK_EQUAL(GetBlockSubsidy(maxHalvings * consensusParams.nSubsidyHalvingInterval, consensusParams), 0);
39}
40
41static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval)
42{
43    Consensus::Params consensusParams;
44    consensusParams.nSubsidyHalvingInterval = nSubsidyHalvingInterval;
45    TestBlockSubsidyHalvings(consensusParams);
46}
47
48BOOST_AUTO_TEST_CASE(block_subsidy_test)
49{
50    const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
51    TestBlockSubsidyHalvings(chainParams->GetConsensus()); // As in main
52    TestBlockSubsidyHalvings(150); // As in regtest
53    TestBlockSubsidyHalvings(1000); // Just another interval
54}
55
56BOOST_AUTO_TEST_CASE(subsidy_limit_test)
57{
58    const auto chainParams = CreateChainParams(*m_node.args, ChainType::MAIN);
59    CAmount nSum = 0;
60    for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {
61        CAmount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());
62        BOOST_CHECK(nSubsidy <= 50 * COIN);
63        nSum += nSubsidy * 1000;
64        BOOST_CHECK(MoneyRange(nSum));
65    }
66    BOOST_CHECK_EQUAL(nSum, CAmount{2099999997690000});
67}
68
69BOOST_AUTO_TEST_CASE(signet_parse_tests)
70{
71    ArgsManager signet_argsman;
72    signet_argsman.ForceSetArg("-signetchallenge", "51"); // set challenge to OP_TRUE
73    const auto signet_params = CreateChainParams(signet_argsman, ChainType::SIGNET);
74    CBlock block;
75    BOOST_CHECK(signet_params->GetConsensus().signet_challenge == std::vector<uint8_t>{OP_TRUE});
76    CScript challenge{OP_TRUE};
77
78    // empty block is invalid
79    BOOST_CHECK(!SignetTxs::Create(block, challenge));
80    BOOST_CHECK(!CheckSignetBlockSolution(block, signet_params->GetConsensus()));
81
82    // no witness commitment
83    CMutableTransaction cb;
84    cb.vout.emplace_back(0, CScript{});
85    block.vtx.push_back(MakeTransactionRef(cb));
86    block.vtx.push_back(MakeTransactionRef(cb)); // Add dummy tx to exercise merkle root code
87    BOOST_CHECK(!SignetTxs::Create(block, challenge));
88    BOOST_CHECK(!CheckSignetBlockSolution(block, signet_params->GetConsensus()));
89
90    // no header is treated valid
91    std::vector<uint8_t> witness_commitment_section_141{0xaa, 0x21, 0xa9, 0xed};
92    for (int i = 0; i < 32; ++i) {
93        witness_commitment_section_141.push_back(0xff);
94    }
95    cb.vout.at(0).scriptPubKey = CScript{} << OP_RETURN << witness_commitment_section_141;
96    block.vtx.at(0) = MakeTransactionRef(cb);
97    BOOST_CHECK(SignetTxs::Create(block, challenge));
98    BOOST_CHECK(CheckSignetBlockSolution(block, signet_params->GetConsensus()));
99
100    // no data after header, valid
101    std::vector<uint8_t> witness_commitment_section_325{0xec, 0xc7, 0xda, 0xa2};
102    cb.vout.at(0).scriptPubKey = CScript{} << OP_RETURN << witness_commitment_section_141 << witness_commitment_section_325;
103    block.vtx.at(0) = MakeTransactionRef(cb);
104    BOOST_CHECK(SignetTxs::Create(block, challenge));
105    BOOST_CHECK(CheckSignetBlockSolution(block, signet_params->GetConsensus()));
106
107    // Premature end of data, invalid
108    witness_commitment_section_325.push_back(0x01);
109    witness_commitment_section_325.push_back(0x51);
110    cb.vout.at(0).scriptPubKey = CScript{} << OP_RETURN << witness_commitment_section_141 << witness_commitment_section_325;
111    block.vtx.at(0) = MakeTransactionRef(cb);
112    BOOST_CHECK(!SignetTxs::Create(block, challenge));
113    BOOST_CHECK(!CheckSignetBlockSolution(block, signet_params->GetConsensus()));
114
115    // has data, valid
116    witness_commitment_section_325.push_back(0x00);
117    cb.vout.at(0).scriptPubKey = CScript{} << OP_RETURN << witness_commitment_section_141 << witness_commitment_section_325;
118    block.vtx.at(0) = MakeTransactionRef(cb);
119    BOOST_CHECK(SignetTxs::Create(block, challenge));
120    BOOST_CHECK(CheckSignetBlockSolution(block, signet_params->GetConsensus()));
121
122    // Extraneous data, invalid
123    witness_commitment_section_325.push_back(0x00);
124    cb.vout.at(0).scriptPubKey = CScript{} << OP_RETURN << witness_commitment_section_141 << witness_commitment_section_325;
125    block.vtx.at(0) = MakeTransactionRef(cb);
126    BOOST_CHECK(!SignetTxs::Create(block, challenge));
127    BOOST_CHECK(!CheckSignetBlockSolution(block, signet_params->GetConsensus()));
128}
129
130//! Test retrieval of valid assumeutxo values.
131BOOST_AUTO_TEST_CASE(test_assumeutxo)
132{
133    const auto params = CreateChainParams(*m_node.args, ChainType::REGTEST);
134
135    // These heights don't have assumeutxo configurations associated, per the contents
136    // of kernel/chainparams.cpp.
137    std::vector<int> bad_heights{0, 100, 111, 115, 209, 211};
138
139    for (auto empty : bad_heights) {
140        const auto out = params->AssumeutxoForHeight(empty);
141        BOOST_CHECK(!out);
142    }
143
144    const auto out110 = *params->AssumeutxoForHeight(110);
145    BOOST_CHECK_EQUAL(out110.hash_serialized.ToString(), "86e9a1205b418b16dde3a18a78c730e30137e28466bda5dbf6b33ab8fc05447c");
146    BOOST_CHECK_EQUAL(out110.m_chain_tx_count, 111U);
147
148    const auto out110_2 = *params->AssumeutxoForBlockhash(uint256{"135eec25a6fb277884e5824e7aa7d052c4868161c99a5122170b5266f86c273d"});
149    BOOST_CHECK_EQUAL(out110_2.hash_serialized.ToString(), "86e9a1205b418b16dde3a18a78c730e30137e28466bda5dbf6b33ab8fc05447c");
150    BOOST_CHECK_EQUAL(out110_2.m_chain_tx_count, 111U);
151}
152
153BOOST_AUTO_TEST_CASE(block_malleation)
154{
155    // Test utilities that calls `IsBlockMutated` and then clears the validity
156    // cache flags on `CBlock`.
157    auto is_mutated = [](CBlock& block, bool check_witness_root) {
158        bool mutated{IsBlockMutated(block, check_witness_root)};
159        block.fChecked = false;
160        block.m_checked_witness_commitment = false;
161        block.m_checked_merkle_root = false;
162        return mutated;
163    };
164    auto is_not_mutated = [&is_mutated](CBlock& block, bool check_witness_root) {
165        return !is_mutated(block, check_witness_root);
166    };
167
168    // Test utilities to create coinbase transactions and insert witness
169    // commitments.
170    //
171    // Note: this will not include the witness stack by default to avoid
172    // triggering the "no witnesses allowed for blocks that don't commit to
173    // witnesses" rule when testing other malleation vectors.
174    auto create_coinbase_tx = [](bool include_witness = false) {
175        CMutableTransaction coinbase;
176        coinbase.vin.resize(1);
177        if (include_witness) {
178            coinbase.vin[0].scriptWitness.stack.resize(1);
179            coinbase.vin[0].scriptWitness.stack[0] = std::vector<unsigned char>(32, 0x00);
180        }
181
182        coinbase.vout.resize(1);
183        coinbase.vout[0].scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT);
184        coinbase.vout[0].scriptPubKey[0] = OP_RETURN;
185        coinbase.vout[0].scriptPubKey[1] = 0x24;
186        coinbase.vout[0].scriptPubKey[2] = 0xaa;
187        coinbase.vout[0].scriptPubKey[3] = 0x21;
188        coinbase.vout[0].scriptPubKey[4] = 0xa9;
189        coinbase.vout[0].scriptPubKey[5] = 0xed;
190
191        auto tx = MakeTransactionRef(coinbase);
192        assert(tx->IsCoinBase());
193        return tx;
194    };
195    auto insert_witness_commitment = [](CBlock& block, uint256 commitment) {
196        assert(!block.vtx.empty() && block.vtx[0]->IsCoinBase() && !block.vtx[0]->vout.empty());
197
198        CMutableTransaction mtx{*block.vtx[0]};
199        CHash256().Write(commitment).Write(std::vector<unsigned char>(32, 0x00)).Finalize(commitment);
200        memcpy(&mtx.vout[0].scriptPubKey[6], commitment.begin(), 32);
201        block.vtx[0] = MakeTransactionRef(mtx);
202    };
203
204    {
205        CBlock block;
206
207        // Empty block is expected to have merkle root of 0x0.
208        BOOST_CHECK(block.vtx.empty());
209        block.hashMerkleRoot = uint256{1};
210        BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
211        block.hashMerkleRoot = uint256{};
212        BOOST_CHECK(is_not_mutated(block, /*check_witness_root=*/false));
213
214        // Block with a single coinbase tx is mutated if the merkle root is not
215        // equal to the coinbase tx's hash.
216        block.vtx.push_back(create_coinbase_tx());
217        BOOST_CHECK(block.vtx[0]->GetHash().ToUint256() != block.hashMerkleRoot);
218        BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
219        block.hashMerkleRoot = block.vtx[0]->GetHash().ToUint256();
220        BOOST_CHECK(is_not_mutated(block, /*check_witness_root=*/false));
221
222        // Block with two transactions is mutated if the merkle root does not
223        // match the double sha256 of the concatenation of the two transaction
224        // hashes.
225        block.vtx.push_back(MakeTransactionRef(CMutableTransaction{}));
226        BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
227        HashWriter hasher;
228        hasher.write(block.vtx[0]->GetHash());
229        hasher.write(block.vtx[1]->GetHash());
230        block.hashMerkleRoot = hasher.GetHash();
231        BOOST_CHECK(is_not_mutated(block, /*check_witness_root=*/false));
232
233        // Block with two transactions is mutated if any node is duplicate.
234        {
235            block.vtx[1] = block.vtx[0];
236            HashWriter hasher;
237            hasher.write(block.vtx[0]->GetHash());
238            hasher.write(block.vtx[1]->GetHash());
239            block.hashMerkleRoot = hasher.GetHash();
240            BOOST_CHECK(is_mutated(block, /*check_witness_root=*/false));
241        }
242
243        // Blocks with 64-byte coinbase transactions are not considered mutated
244        block.vtx.clear();
245        {
246            CMutableTransaction mtx;
247            mtx.vin.resize(1);
248            mtx.vout.resize(1);
249            mtx.vout[0].scriptPubKey.resize(4);
250            block.vtx.push_back(MakeTransactionRef(mtx));