2251    const Consensus::Params& consensusparams = chainman.GetConsensus();
2252
2253    // BIP16 didn't become active until Apr 1 2012 (on mainnet, and
2254    // retroactively applied to testnet)
2255    // However, only one historical block violated the P2SH rules (on both
2256    // mainnet and testnet).
2257    // Similarly, only one historical block violated the TAPROOT rules on
2258    // mainnet.
2259    // For simplicity, always leave P2SH+WITNESS+TAPROOT on except for the two
2260    // violating blocks.
2261    script_verify_flags flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT};
2262    const auto it{consensusparams.script_flag_exceptions.find(*Assert(block_index.phashBlock))};
2263    if (it != consensusparams.script_flag_exceptions.end()) {
2264        flags = it->second;
2265    }
2266
2267    // Enforce the DERSIG (BIP66) rule
2268    if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_DERSIG)) {
2269        flags |= SCRIPT_VERIFY_DERSIG;
2270    }
2271
2272    // Enforce CHECKLOCKTIMEVERIFY (BIP65)
2273    if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CLTV)) {
2274        flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
2275    }
2276
2277    // Enforce CHECKSEQUENCEVERIFY (BIP112)
2278    if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_CSV)) {
2279        flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
2280    }
2281
2282    // Enforce BIP147 NULLDUMMY (activated simultaneously with segwit)
2283    if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_SEGWIT)) {
2284        flags |= SCRIPT_VERIFY_NULLDUMMY;
2285    }
2286
2287    return flags;
2288}
2289
2290
2291/** Apply the effects of this block (with given index) on the UTXO set represented by coins.
2292 *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
2293 *  can fail if those validity checks fail (among other reasons). */
2294bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
2295                               CCoinsViewCache& view, bool fJustCheck)
2296{
2297    AssertLockHeld(cs_main);
2298    assert(pindex);
2299
2300    uint256 block_hash{block.GetHash()};
2301    assert(*pindex->phashBlock == block_hash);
2302
2303    const auto time_start{SteadyClock::now()};
2304    const CChainParams& params{m_chainman.GetParams()};
2305
2306    // Check it again in case a previous version let a bad block in
2307    // NOTE: We don't currently (re-)invoke ContextualCheckBlock() or
2308    // ContextualCheckBlockHeader() here. This means that if we add a new
2309    // consensus rule that is enforced in one of those two functions, then we
2310    // may have let in a block that violates the rule prior to updating the
2311    // software, and we would NOT be enforcing the rule here. Fully solving
2312    // upgrade from one software version to the next after a consensus rule
2313    // change is potentially tricky and issue-specific (see NeedsRedownload()
2314    // for one approach that was used for BIP 141 deployment).
2315    // Also, currently the rule against blocks more than 2 hours in the future
2316    // is enforced in ContextualCheckBlockHeader(); we wouldn't want to
2317    // re-enforce that rule here (at least until we make it impossible for
2318    // the clock to go backward).
2319    if (!CheckBlock(block, state, params.GetConsensus(), !fJustCheck, !fJustCheck)) {
2320        if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
2321            // We don't write down blocks to disk if they may have been
2322            // corrupted, so this should be impossible unless we're having hardware
2323            // problems.
2324            return FatalError(m_chainman.GetNotifications(), state, _("Corrupt block found indicating potential hardware failure."));
2325        }
2326        LogError("%s: Consensus::CheckBlock: %s\n", __func__, state.ToString());
2327        return false;
2328    }
2329
2330    // verify that the view's current state corresponds to the previous block
2331    uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
2332    assert(hashPrevBlock == view.GetBestBlock());
2333
2334    m_chainman.num_blocks_total++;
2335
2336    // Special case for the genesis block, skipping connection of its transactions
2337    // (its coinbase is unspendable)
2338    if (block_hash == params.GetConsensus().hashGenesisBlock) {
2339        if (!fJustCheck)
2340            view.SetBestBlock(pindex->GetBlockHash());
2341        return true;
2342    }
2343
2344    const char* script_check_reason;
2345    if (m_chainman.AssumedValidBlock().IsNull()) {
2346        script_check_reason = "assumevalid=0 (always verify)";
2347    } else {
2348        constexpr int64_t TWO_WEEKS_IN_SECONDS{60 * 60 * 24 * 7 * 2};
2349        // We've been configured with the hash of a block which has been externally verified to have a valid history.
2350        // A suitable default value is included with the software and updated from time to time.  Because validity
2351        //  relative to a piece of software is an objective fact these defaults can be easily reviewed.
2352        // This setting doesn't force the selection of any particular chain but makes validating some faster by
2353        //  effectively caching the result of part of the verification.
2354        BlockMap::const_iterator it{m_blockman.m_block_index.find(m_chainman.AssumedValidBlock())};
2355        if (it == m_blockman.m_block_index.end()) {
2356            script_check_reason = "assumevalid hash not in headers";
2357        } else if (it->second.GetAncestor(pindex->nHeight) != pindex) {
2358            script_check_reason = (pindex->nHeight > it->second.nHeight) ? "block height above assumevalid height" : "block not in assumevalid chain";
2359        } else if (m_chainman.m_best_header->GetAncestor(pindex->nHeight) != pindex) {
2360            script_check_reason = "block not in best header chain";
2361        } else if (m_chainman.m_best_header->nChainWork < m_chainman.MinimumChainWork()) {
2362            script_check_reason = "best header chainwork below minimumchainwork";
2363        } else if (GetBlockProofEquivalentTime(*m_chainman.m_best_header, *pindex, *m_chainman.m_best_header, params.GetConsensus()) <= TWO_WEEKS_IN_SECONDS) {
2364            script_check_reason = "block too recent relative to best header";
2365        } else {
2366            // This block is a member of the assumed verified chain and an ancestor of the best header.
2367            // Script verification is skipped when connecting blocks under the
2368            //  assumevalid block. Assuming the assumevalid block is valid this
2369            //  is safe because block merkle hashes are still computed and checked,
2370            // Of course, if an assumed valid block is invalid due to false scriptSigs
2371            //  this optimization would allow an invalid chain to be accepted.
2372            // The equivalent time check discourages hash power from extorting the network via DOS attack
2373            //  into accepting an invalid block through telling users they must manually set assumevalid.
2374            //  Requiring a software change or burying the invalid block, regardless of the setting, makes
2375            //  it hard to hide the implication of the demand. This also avoids having release candidates
2376            //  that are hardly doing any signature verification at all in testing without having to
2377            //  artificially set the default assumed verified block further back.
2378            // The test against the minimum chain work prevents the skipping when denied access to any chain at
2379            //  least as good as the expected chain.
2380            script_check_reason = nullptr;
2381        }
2382    }
2383
2384    const auto time_1{SteadyClock::now()};
2385    m_chainman.time_check += time_1 - time_start;
2386    LogDebug(BCLog::BENCH, "    - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n",
2387             Ticks<MillisecondsDouble>(time_1 - time_start),
2388             Ticks<SecondsDouble>(m_chainman.time_check),
2389             Ticks<MillisecondsDouble>(m_chainman.time_check) / m_chainman.num_blocks_total);
2390
2391    // Do not allow blocks that contain transactions which 'overwrite' older transactions,
2392    // unless those are already completely spent.
2393    // If such overwrites are allowed, coinbases and transactions depending upon those
2394    // can be duplicated to remove the ability to spend the first instance -- even after
2395    // being sent to another address.
2396    // See BIP30, CVE-2012-1909, and https://r6.ca/blog/20120206T005236Z.html for more information.
2397    // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
2398    // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
2399    // two in the chain that violate it. This prevents exploiting the issue against nodes during their
2400    // initial block download.
2401    bool fEnforceBIP30 = !IsBIP30Repeat(*pindex);
2402
2403    // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
2404    // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs.  But by the
2405    // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
2406    // before the first had been spent.  Since those coinbases are sufficiently buried it's no longer possible to create further
2407    // duplicate transactions descending from the known pairs either.
2408    // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
2409
2410    // BIP34 requires that a block at height X (block X) has its coinbase
2411    // scriptSig start with a CScriptNum of X (indicated height X).  The above
2412    // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
2413    // case that there is a block X before the BIP34 height of 227,931 which has
2414    // an indicated height Y where Y is greater than X.  The coinbase for block
2415    // X would also be a valid coinbase for block Y, which could be a BIP30
2416    // violation.  An exhaustive search of all mainnet coinbases before the
2417    // BIP34 height which have an indicated height greater than the block height
2418    // reveals many occurrences. The 3 lowest indicated heights found are
2419    // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
2420    // heights would be the first opportunity for BIP30 to be violated.
2421
2422    // The search reveals a great many blocks which have an indicated height
2423    // greater than 1,983,702, so we simply remove the optimization to skip
2424    // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
2425    // that block in another 25 years or so, we should take advantage of a
2426    // future consensus change to do a new and improved version of BIP34 that
2427    // will actually prevent ever creating any duplicate coinbases in the
2428    // future.
2429    static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
2430
2431    // There is no potential to create a duplicate coinbase at block 209,921
2432    // because this is still before the BIP34 height and so explicit BIP30
2433    // checking is still active.
2434
2435    // The final case is block 176,684 which has an indicated height of
2436    // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
2437    // before block 490,897 so there was not much opportunity to address this
2438    // case other than to carefully analyze it and determine it would not be a
2439    // problem. Block 490,897 was, in fact, mined with a different coinbase than
2440    // block 176,684, but it is important to note that even if it hadn't been or
2441    // is remined on an alternate fork with a duplicate coinbase, we would still
2442    // not run into a BIP30 violation.  This is because the coinbase for 176,684
2443    // is spent in block 185,956 in transaction
2444    // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
2445    // spending transaction can't be duplicated because it also spends coinbase
2446    // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
2447    // coinbase has an indicated height of over 4.2 billion, and wouldn't be
2448    // duplicatable until that height, and it's currently impossible to create a
2449    // chain that long. Nevertheless we may wish to consider a future soft fork
2450    // which retroactively prevents block 490,897 from creating a duplicate
2451    // coinbase. The two historical BIP30 violations often provide a confusing
2452    // edge case when manipulating the UTXO and it would be simpler not to have
2453    // another edge case to deal with.
2454
2455    // testnet3 has no blocks before the BIP34 height with indicated heights
2456    // post BIP34 before approximately height 486,000,000. After block
2457    // 1,983,702 testnet3 starts doing unnecessary BIP30 checking again.
2458    assert(pindex->pprev);
2459    CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(params.GetConsensus().BIP34Height);
2460    //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
2461    fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == params.GetConsensus().BIP34Hash));
2462
2463    // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a
2464    // consensus change that ensures coinbases at those heights cannot
2465    // duplicate earlier coinbases.
2466    if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
2467        for (const auto& tx : block.vtx) {
2468            for (size_t o = 0; o < tx->vout.size(); o++) {
2469                if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
2470                    state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-BIP30",
2471                                  "tried to overwrite transaction");
2472                }
2473            }
2474        }
2475    }
2476
2477    // Enforce BIP68 (sequence locks)
2478    int nLockTimeFlags = 0;
2479    if (DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_CSV)) {
2480        nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
2481    }
2482
2483    // Get the script flags for this block
2484    script_verify_flags flags{GetBlockScriptFlags(*pindex, m_chainman)};
2485
2486    const auto time_2{SteadyClock::now()};
2487    m_chainman.time_forks += time_2 - time_1;
2488    LogDebug(BCLog::BENCH, "    - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n",
2489             Ticks<MillisecondsDouble>(time_2 - time_1),
2490             Ticks<SecondsDouble>(m_chainman.time_forks),
2491             Ticks<MillisecondsDouble>(m_chainman.time_forks) / m_chainman.num_blocks_total);
2492
2493    const bool fScriptChecks{!!script_check_reason};
2494    const kernel::ChainstateRole role{GetRole()};
2495    if (script_check_reason != m_last_script_check_reason_logged && role.validated && !role.historical) {
2496        if (fScriptChecks) {
2497            LogInfo("Enabling script verification at block #%d (%s): %s.",
2498                    pindex->nHeight, block_hash.ToString(), script_check_reason);
2499        } else {
2500            LogInfo("Disabling script verification at block #%d (%s).",