Where validation becomes chain state

4001        block.vtx[0] = MakeTransactionRef(std::move(tx));
4002    }
4003}
4004
4005void ChainstateManager::GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev) const
4006{
4007    int commitpos = GetWitnessCommitmentIndex(block);
4008    std::vector<unsigned char> ret(32, 0x00);
4009    if (commitpos == NO_WITNESS_COMMITMENT) {
4010        uint256 witnessroot = BlockWitnessMerkleRoot(block);
4011        CHash256().Write(witnessroot).Write(ret).Finalize(witnessroot);
4012        CTxOut out;
4013        out.nValue = 0;
4014        out.scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT);
4015        out.scriptPubKey[0] = OP_RETURN;
4016        out.scriptPubKey[1] = 0x24;
4017        out.scriptPubKey[2] = 0xaa;
4018        out.scriptPubKey[3] = 0x21;
4019        out.scriptPubKey[4] = 0xa9;
4020        out.scriptPubKey[5] = 0xed;
4021        memcpy(&out.scriptPubKey[6], witnessroot.begin(), 32);
4022        CMutableTransaction tx(*block.vtx[0]);
4023        tx.vout.push_back(out);
4024        block.vtx[0] = MakeTransactionRef(std::move(tx));
4025    }
4026    UpdateUncommittedBlockStructures(block, pindexPrev);
4027}
4028
4029bool HasValidProofOfWork(std::span<const CBlockHeader> headers, const Consensus::Params& consensusParams)
4030{
4031    return std::ranges::all_of(headers,
4032                               [&](const auto& header) { return CheckProofOfWork(header.GetHash(), header.nBits, consensusParams); });
4033}
4034
4035bool IsBlockMutated(const CBlock& block, bool check_witness_root)
4036{
4037    BlockValidationState state;
4038    if (!CheckMerkleRoot(block, state)) {
4039        LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString());
4040        return true;
4041    }
4042
4043    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
4044        // Consider the block mutated if any transaction is 64 bytes in size (see 3.1
4045        // in "Weaknesses in Bitcoin’s Merkle Root Construction":
4046        // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/attachments/20190225/a27d8837/attachment-0001.pdf).
4047        //
4048        // Note: This is not a consensus change as this only applies to blocks that
4049        // don't have a coinbase transaction and would therefore already be invalid.
4050        return std::any_of(block.vtx.begin(), block.vtx.end(),
4051                           [](auto& tx) { return GetSerializeSize(TX_NO_WITNESS(tx)) == 64; });
4052    } else {
4053        // Theoretically it is still possible for a block with a 64 byte
4054        // coinbase transaction to be mutated but we neglect that possibility
4055        // here as it requires at least 224 bits of work.
4056    }
4057
4058    if (!CheckWitnessMalleation(block, check_witness_root, state)) {
4059        LogDebug(BCLog::VALIDATION, "Block mutated: %s\n", state.ToString());
4060        return true;
4061    }
4062
4063    return false;
4064}
4065
4066arith_uint256 CalculateClaimedHeadersWork(std::span<const CBlockHeader> headers)
4067{
4068    arith_uint256 total_work{0};
4069    for (const CBlockHeader& header : headers) {
4070        total_work += GetBlockProof(header);
4071    }
4072    return total_work;
4073}
4074
4075/** Context-dependent validity checks.
4076 *  By "context", we mean only the previous block headers, but not the UTXO
4077 *  set; UTXO-related validity checks are done in ConnectBlock().
4078 *  NOTE: This function is not currently invoked by ConnectBlock(), so we
4079 *  should consider upgrade issues if we change which consensus rules are
4080 *  enforced in this function (eg by adding a new consensus rule). See comment
4081 *  in ConnectBlock().
4082 *  Note that -reindex-chainstate skips the validation that happens here!
4083 *
4084 *  NOTE: failing to check the header's height against the last checkpoint's opened a DoS vector between
4085 *  v0.12 and v0.15 (when no additional protection was in place) whereby an attacker could unboundedly
4086 *  grow our in-memory block index. See https://bitcoincore.org/en/2024/07/03/disclose-header-spam.
4087 */
4088static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
4089{
4090    AssertLockHeld(::cs_main);
4091    assert(pindexPrev != nullptr);
4092    const int nHeight = pindexPrev->nHeight + 1;
4093
4094    // Check proof of work
4095    const Consensus::Params& consensusParams = chainman.GetConsensus();
4096    if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
4097        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work");
4098
4099    // Check timestamp against prev
4100    if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
4101        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-too-old", "block's timestamp is too early");
4102
4103    // Testnet4 and regtest only: Check timestamp against prev for difficulty-adjustment
4104    // blocks to prevent timewarp attacks (see https://github.com/bitcoin/bitcoin/pull/15482).
4105    if (consensusParams.enforce_BIP94) {
4106        // Check timestamp for the first block of each difficulty adjustment
4107        // interval, except the genesis block.
4108        if (nHeight % consensusParams.DifficultyAdjustmentInterval() == 0) {
4109            if (block.GetBlockTime() < pindexPrev->GetBlockTime() - MAX_TIMEWARP) {
4110                return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "time-timewarp-attack", "block's timestamp is too early on diff adjustment block");
4111            }
4112        }
4113    }
4114
4115    // Check timestamp
4116    if (block.Time() > NodeClock::now() + std::chrono::seconds{MAX_FUTURE_BLOCK_TIME}) {
4117        return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future");
4118    }
4119
4120    // Reject blocks with outdated version
4121    if ((block.nVersion < 2 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB)) ||
4122        (block.nVersion < 3 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_DERSIG)) ||
4123        (block.nVersion < 4 && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CLTV))) {
4124            return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
4125                                 strprintf("rejected nVersion=0x%08x block", block.nVersion));
4126    }
4127
4128    return true;
4129}
4130
4131/** NOTE: This function is not currently invoked by ConnectBlock(), so we
4132 *  should consider upgrade issues if we change which consensus rules are
4133 *  enforced in this function (eg by adding a new consensus rule). See comment
4134 *  in ConnectBlock().
4135 *  Note that -reindex-chainstate skips the validation that happens here!
4136 */
4137static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev)
4138{
4139    const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
4140
4141    // Enforce BIP113 (Median Time Past).
4142    bool enforce_locktime_median_time_past{false};
4143    if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_CSV)) {
4144        assert(pindexPrev != nullptr);
4145        enforce_locktime_median_time_past = true;
4146    }
4147
4148    const int64_t nLockTimeCutoff{enforce_locktime_median_time_past ?
4149                                      pindexPrev->GetMedianTimePast() :
4150                                      block.GetBlockTime()};
4151
4152    // Check that all transactions are finalized
4153    for (const auto& tx : block.vtx) {
4154        if (!IsFinalTx(*tx, nHeight, nLockTimeCutoff)) {
4155            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal", "non-final transaction");
4156        }
4157    }
4158
4159    // Enforce rule that the coinbase starts with serialized block height
4160    if (DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_HEIGHTINCB))
4161    {
4162        CScript expect = CScript() << nHeight;
4163        if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
4164            !std::equal(expect.begin(), expect.end(), block.vtx[0]->vin[0].scriptSig.begin())) {
4165            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-height", "block height mismatch in coinbase");
4166        }
4167    }
4168
4169    // Validation for witness commitments.
4170    // * We compute the witness hash (which is the hash including witnesses) of all the block's transactions, except the
4171    //   coinbase (where 0x0000....0000 is used instead).
4172    // * The coinbase scriptWitness is a stack of a single 32-byte vector, containing a witness reserved value (unconstrained).
4173    // * We build a merkle tree with all those witness hashes as leaves (similar to the hashMerkleRoot in the block header).
4174    // * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are
4175    //   {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness reserved value). In case there are
4176    //   multiple, the last one is used.
4177    if (!CheckWitnessMalleation(block, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT), state)) {
4178        return false;
4179    }
4180
4181    // After the coinbase witness reserved value and commitment are verified,
4182    // we can check if the block weight passes (before we've checked the
4183    // coinbase witness, it would be possible for the weight to be too
4184    // large by filling up the coinbase witness, which doesn't change
4185    // the block hash, so we couldn't mark the block as permanently
4186    // failed).
4187    if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) {
4188        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-weight", strprintf("%s : weight limit failed", __func__));
4189    }
4190
4191    return true;
4192}
4193
4194bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValidationState& state, CBlockIndex** ppindex, bool min_pow_checked)
4195{
4196    AssertLockHeld(cs_main);
4197
4198    // Check for duplicate
4199    uint256 hash = block.GetHash();
4200    BlockMap::iterator miSelf{m_blockman.m_block_index.find(hash)};
4201    if (hash != GetConsensus().hashGenesisBlock) {
4202        if (miSelf != m_blockman.m_block_index.end()) {
4203            // Block header is already known.
4204            CBlockIndex* pindex = &(miSelf->second);
4205            if (ppindex)
4206                *ppindex = pindex;
4207            if (pindex->nStatus & BLOCK_FAILED_VALID) {
4208                LogDebug(BCLog::VALIDATION, "%s: block %s is marked invalid\n", __func__, hash.ToString());
4209                return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID, "duplicate-invalid",
4210                                     strprintf("block %s was previously marked invalid", hash.ToString()));
4211            }
4212            return true;
4213        }
4214
4215        if (!CheckBlockHeader(block, state, GetConsensus())) {
4216            LogDebug(BCLog::VALIDATION, "%s: Consensus::CheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
4217            return false;
4218        }
4219
4220        // Get prev block index
4221        CBlockIndex* pindexPrev = nullptr;
4222        BlockMap::iterator mi{m_blockman.m_block_index.find(block.hashPrevBlock)};
4223        if (mi == m_blockman.m_block_index.end()) {
4224            LogDebug(BCLog::VALIDATION, "header %s has prev block not found: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
4225            return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, "prev-blk-not-found");
4226        }
4227        pindexPrev = &((*mi).second);
4228        if (pindexPrev->nStatus & BLOCK_FAILED_VALID) {
4229            LogDebug(BCLog::VALIDATION, "header %s has prev block invalid: %s\n", hash.ToString(), block.hashPrevBlock.ToString());
4230            return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV, "bad-prevblk");
4231        }
4232        if (!ContextualCheckBlockHeader(block, state, *this, pindexPrev)) {
4233            LogDebug(BCLog::VALIDATION, "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
4234            return false;
4235        }
4236    }
4237    if (!min_pow_checked) {
4238        LogDebug(BCLog::VALIDATION, "%s: not adding new block header %s, missing anti-dos proof-of-work validation\n", __func__, hash.ToString());
4239        return state.Invalid(BlockValidationResult::BLOCK_HEADER_LOW_WORK, "too-little-chainwork");
4240    }
4241    CBlockIndex* pindex{m_blockman.AddToBlockIndex(block, m_best_header)};
4242
4243    if (ppindex)
4244        *ppindex = pindex;
4245
4246    return true;
4247}
4248
4249// Exposed wrapper for AcceptBlockHeader
4250bool ChainstateManager::ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex)