251}
252
253bool BlockAssembler::TestChunkBlockLimits(int64_t chunk_weight, int64_t chunk_sigops_cost) const
254{
255    // block_max_weight has been flattened before block assembly limit checks.
256    Assert(m_options.block_max_weight);
257    if (nBlockWeight + chunk_weight >= m_options.block_max_weight) {
258        return false;
259    }
260    if (nBlockSigOpsCost + chunk_sigops_cost >= MAX_BLOCK_SIGOPS_COST) {
261        return false;
262    }
263    return true;
264}
265
266// Perform transaction-level checks before adding to block:
267// - transaction finality (locktime)
268bool BlockAssembler::TestChunkTransactions(const std::vector<CTxMemPoolEntryRef>& txs) const
269{
270    for (const auto tx : txs) {
271        if (!IsFinalTx(tx.get().GetTx(), nHeight, m_lock_time_cutoff)) {
272            return false;
273        }
274    }
275    return true;
276}
277
278void BlockAssembler::AddToBlock(const CTxMemPoolEntry& entry)
279{
280    pblocktemplate->block.vtx.emplace_back(entry.GetSharedTx());
281    pblocktemplate->vTxFees.push_back(entry.GetFee());
282    pblocktemplate->vTxSigOpsCost.push_back(entry.GetSigOpCost());
283    nBlockWeight += entry.GetTxWeight();
284    ++nBlockTx;
285    nBlockSigOpsCost += entry.GetSigOpCost();
286    nFees += entry.GetFee();
287
288    if (*m_options.print_modified_fee) {
289        LogInfo("fee rate %s txid %s\n",
290                  CFeeRate(entry.GetModifiedFee(), entry.GetTxSize()).ToString(),
291                  entry.GetTx().GetHash().ToString());
292    }
293}
294
295void BlockAssembler::addChunks()
296{
297    // Limit the number of attempts to add transactions to the block when it is
298    // close to full; this is just a simple heuristic to finish quickly if the
299    // mempool has a lot of entries.
300    const int64_t MAX_CONSECUTIVE_FAILURES = 1000;
301    constexpr int32_t BLOCK_FULL_ENOUGH_WEIGHT_DELTA = 4000;
302    int64_t nConsecutiveFailed = 0;
303
304    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> selected_transactions;
305    selected_transactions.reserve(MAX_CLUSTER_COUNT_LIMIT);
306    FeePerWeight chunk_feerate;
307
308    // This fills selected_transactions
309    chunk_feerate = m_mempool->GetBlockBuilderChunk(selected_transactions);
310    FeePerVSize chunk_feerate_vsize = ToFeePerVSize(chunk_feerate);
311
312    while (selected_transactions.size() > 0) {
313        // Check to see if min fee rate is still respected.
314        if (ByRatio{chunk_feerate_vsize} < ByRatio{m_options.block_min_fee_rate->GetFeePerVSize()}) {
315            // Everything else we might consider has a lower feerate
316            return;
317        }
318
319        int64_t chunk_sig_ops = 0;
320        int64_t chunk_weight = 0;
321        for (const auto& tx : selected_transactions) {
322            chunk_sig_ops += tx.get().GetSigOpCost();
323            chunk_weight += tx.get().GetTxWeight();
324        }
325
326        // Check to see if this chunk will fit.
327        if (!TestChunkBlockLimits(chunk_weight, chunk_sig_ops) || !TestChunkTransactions(selected_transactions)) {
328            // This chunk won't fit, so we skip it and will try the next best one.
329            m_mempool->SkipBuilderChunk();
330            ++nConsecutiveFailed;
331
332            // block_max_weight has been flattened before block assembly limit checks.
333            Assert(m_options.block_max_weight);
334            if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockWeight +
335                    BLOCK_FULL_ENOUGH_WEIGHT_DELTA > *m_options.block_max_weight) {
336                // Give up if we're close to full and haven't succeeded in a while
337                return;
338            }
339        } else {
340            m_mempool->IncludeBuilderChunk();
341
342            // This chunk will fit, so add it to the block.
343            nConsecutiveFailed = 0;
344            for (const auto& tx : selected_transactions) {
345                AddToBlock(tx);
346            }
347            pblocktemplate->m_package_feerates.emplace_back(chunk_feerate_vsize);
348        }
349
350        selected_transactions.clear();
351        chunk_feerate = m_mempool->GetBlockBuilderChunk(selected_transactions);
352        chunk_feerate_vsize = ToFeePerVSize(chunk_feerate);
353    }
354}
355
356void AddMerkleRootAndCoinbase(CBlock& block, CTransactionRef coinbase, uint32_t version, uint32_t timestamp, uint32_t nonce)
357{
358    if (block.vtx.size() == 0) {
359        block.vtx.emplace_back(coinbase);
360    } else {
361        block.vtx[0] = coinbase;
362    }
363    block.nVersion = version;
364    block.nTime = timestamp;
365    block.nNonce = nonce;
366    block.hashMerkleRoot = BlockMerkleRoot(block);
367
368    // Reset cached checks
369    block.m_checked_witness_commitment = false;
370    block.m_checked_merkle_root = false;
371    block.fChecked = false;
372}
373
374namespace {
375class SubmitBlockStateCatcher final : public CValidationInterface
376{
377public:
378    uint256 m_hash;
379    bool m_found{false};
380    BlockValidationState m_state;
381
382    explicit SubmitBlockStateCatcher(const uint256& hash) : m_hash{hash} {}
383
384protected:
385    void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& state) override
386    {
387        if (block->GetHash() != m_hash) return;
388        // ProcessNewBlock emits BlockChecked synchronously while holding cs_main,
389        // so SubmitBlock can read these fields after ProcessNewBlock returns
390        // without extra synchronization.
391        m_found = true;
392        m_state = state;
393    }
394};
395} // namespace
396
397bool SubmitBlock(ChainstateManager& chainman, const std::shared_ptr<const CBlock>& block, std::string& reason, std::string& debug)
398{
399    reason.clear();
400    debug.clear();
401
402    // This follows the submitblock RPC's validation-state capture pattern, but
403    // is intentionally kept separate from the RPC implementation. The RPC entry
404    // point decodes hex, formats BIP22/JSONRPC results, and calls
405    // UpdateUncommittedBlockStructures() for legacy witness handling. IPC
406    // callers submit already-formed blocks and need bool + reason/debug
407    // results.
408    auto sc = std::make_shared<SubmitBlockStateCatcher>(block->GetHash());
409    CHECK_NONFATAL(chainman.m_options.signals)->RegisterSharedValidationInterface(sc);
410    bool new_block;
411    bool accepted = chainman.ProcessNewBlock(block, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
412    // No queue drain is needed. The BlockChecked notification used above is
413    // emitted synchronously by ProcessNewBlock, unlike most validation signals.
414    CHECK_NONFATAL(chainman.m_options.signals)->UnregisterSharedValidationInterface(sc);
415
416    if (!new_block && accepted) {
417        reason = "duplicate";
418    } else if (!accepted && (!sc->m_found || sc->m_state.IsValid())) {
419        // ProcessNewBlock can fail without a validation result, for example
420        // from an activation or system error. It can also fail after a valid
421        // BlockChecked result. In these cases the validation result is
422        // inconclusive.
423        reason = "inconclusive";
424    } else if (!sc->m_found) {
425        // The block was accepted but not connected, for example if it does not
426        // have more work than the current tip.
427        reason = "inconclusive";
428    } else if (!sc->m_state.IsValid()) {
429        reason = sc->m_state.GetRejectReason();
430        debug = sc->m_state.GetDebugMessage();
431    }
432    const bool result{accepted && new_block && reason.empty()};
433    CHECK_NONFATAL(result == reason.empty());
434    return result;
435}
436
437void InterruptWait(KernelNotifications& kernel_notifications, bool& interrupt_wait)
438{
439    LOCK(kernel_notifications.m_tip_block_mutex);
440    interrupt_wait = true;
441    kernel_notifications.m_tip_block_cv.notify_all();
442}
443
444std::unique_ptr<CBlockTemplate> WaitAndCreateNewBlock(ChainstateManager& chainman,
445                                                      KernelNotifications& kernel_notifications,
446                                                      CTxMemPool* mempool,
447                                                      const std::unique_ptr<CBlockTemplate>& block_template,
448                                                      const BlockWaitOptions& wait_options,
449                                                      const BlockCreateOptions& create_options,
450                                                      bool& interrupt_wait)
451{
452    // Delay calculating the current template fees, just in case a new block
453    // comes in before the next tick.
454    CAmount current_fees = -1;
455
456    // Alternate waiting for a new tip and checking if fees have risen.
457    // The latter check is expensive so we only run it once per second.
458    auto now{NodeClock::now()};
459    const auto deadline = now + wait_options.timeout;
460    const MillisecondsDouble tick{1000};
461    const bool allow_min_difficulty{chainman.GetParams().GetConsensus().fPowAllowMinDifficultyBlocks};
462
463    do {
464        bool tip_changed{false};
465        {
466            WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
467            // Note that wait_until() checks the predicate before waiting
468            kernel_notifications.m_tip_block_cv.wait_until(lock, std::min(now + tick, deadline), [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
469                AssertLockHeld(kernel_notifications.m_tip_block_mutex);
470                const auto tip_block{kernel_notifications.TipBlock()};
471                // We assume tip_block is set, because this is an instance
472                // method on BlockTemplate and no template could have been
473                // generated before a tip exists.
474                tip_changed = Assume(tip_block) && tip_block != block_template->block.hashPrevBlock;
475                return tip_changed || chainman.m_interrupt || interrupt_wait;
476            });
477            if (interrupt_wait) {
478                interrupt_wait = false;
479                return nullptr;
480            }
481        }
482
483        if (chainman.m_interrupt) return nullptr;
484        // At this point the tip changed, a full tick went by or we reached
485        // the deadline.
486
487        // Must release m_tip_block_mutex before locking cs_main, to avoid deadlocks.
488        LOCK(::cs_main);
489
490        // On test networks return a minimum difficulty block after 20 minutes
491        if (!tip_changed && allow_min_difficulty) {
492            const NodeClock::time_point tip_time{std::chrono::seconds{chainman.ActiveChain().Tip()->GetBlockTime()}};
493            if (now > tip_time + 20min) {
494                tip_changed = true;
495            }
496        }
497
498        /**
499         * We determine if fees increased compared to the previous template by generating
500         * a fresh template. There may be more efficient ways to determine how much