Inside Bitcoin

501    uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
502    {
503        AssertLockHeld(cs);
504        return totalTxSize;
505    }
506
507    CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
508    {
509        AssertLockHeld(cs);
510        return m_total_fee;
511    }
512
513    bool exists(const Txid& txid) const
514    {
515        LOCK(cs);
516        return (mapTx.count(txid) != 0);
517    }
518
519    bool exists(const Wtxid& wtxid) const
520    {
521        LOCK(cs);
522        return (mapTx.get<index_by_wtxid>().count(wtxid) != 0);
523    }
524
525    const CTxMemPoolEntry* GetEntry(const Txid& txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs);
526
527    /**
528     * Return a mempool transaction with a given hash.
529     *
530     * @param[in] hash      the txid
531     * @returns             the tx if found, otherwise nullptr
532     */
533    CTransactionRef get(const Txid& hash) const;
534
535    /**
536     * Return a mempool transaction with a given witness hash.
537     *
538     * @param[in] hash      the wtxid
539     * @returns             the tx if found, otherwise nullptr
540     */
541    CTransactionRef get(const Wtxid& hash) const;
542
543    template <TxidOrWtxid T>
544    TxMempoolInfo info(const T& id) const
545    {
546        LOCK(cs);
547        auto i{GetIter(id)};
548        return i.has_value() ? GetInfo(*i) : TxMempoolInfo{};
549    }
550
551    /** Returns info for a transaction if its entry_sequence < last_sequence */
552    template <TxidOrWtxid T>
553    TxMempoolInfo info_for_relay(const T& id, uint64_t last_sequence) const
554    {
555        LOCK(cs);
556        auto i{GetIter(id)};
557        return (i.has_value() && i.value()->GetSequence() < last_sequence) ? GetInfo(*i) : TxMempoolInfo{};
558    }
559
560    std::vector<CTxMemPoolEntryRef> entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs);
561    std::vector<TxMempoolInfo> infoAll() const;
562
563    size_t DynamicMemoryUsage() const;
564
565    /** Adds a transaction to the unbroadcast set */
566    void AddUnbroadcastTx(const Txid& txid)
567    {
568        LOCK(cs);
569        // Sanity check the transaction is in the mempool & insert into
570        // unbroadcast set.
571        if (exists(txid)) m_unbroadcast_txids.insert(txid);
572    };
573
574    bool CheckPolicyLimits(const CTransactionRef& tx);
575
576    /** Removes a transaction from the unbroadcast set */
577    void RemoveUnbroadcastTx(const Txid& txid, bool unchecked = false);
578
579    /** Returns transactions in unbroadcast set */
580    std::set<Txid> GetUnbroadcastTxs() const
581    {
582        LOCK(cs);
583        return m_unbroadcast_txids;
584    }
585
586    /** Returns whether a txid is in the unbroadcast set */
587    bool IsUnbroadcastTx(const Txid& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
588    {
589        AssertLockHeld(cs);
590        return m_unbroadcast_txids.contains(txid);
591    }
592
593    /** Guards this internal counter for external reporting */
594    uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
595        return m_sequence_number++;
596    }
597
598    uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs) {
599        return m_sequence_number;
600    }
601
602private:
603    /** Remove a set of transactions from the mempool.
604     *  If a transaction is in this set, then all in-mempool descendants must
605     *  also be in the set, unless this transaction is being removed for being
606     *  in a block.
607     */
608    void RemoveStaged(setEntries& stage, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
609
610    /* Helper for the public removeRecursive() */
611    void removeRecursive(txiter to_remove, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
612
613    /* Removal from the mempool also triggers removal of the entry's Ref from txgraph. */
614    void removeUnchecked(txiter entry, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
615public:
616    /*
617     * CTxMemPool::ChangeSet:
618     *
619     * This class is used for all mempool additions and associated removals (eg
620     * due to rbf). Removals that don't need to be evaluated for acceptance,
621     * such as removing transactions that appear in a block, or due to reorg,
622     * or removals related to mempool limiting or expiry do not need to use
623     * this.
624     *
625     * Callers can interleave calls to StageAddition()/StageRemoval(), and
626     * removals may be invoked in any order, but additions must be done in a
627     * topological order in the case of transaction packages (ie, parents must
628     * be added before children).
629     *
630     * CalculateChunksForRBF() can be used to calculate the feerate diagram of
631     * the proposed set of new transactions and compare with the existing
632     * mempool.
633     *
634     * CalculateMemPoolAncestors() calculates the in-mempool (not including
635     * what is in the change set itself) ancestors of a given transaction.
636     *
637     * Apply() will apply the removals and additions that are staged into the
638     * mempool.
639     *
640     * Only one changeset may exist at a time. While a changeset is
641     * outstanding, no removals or additions may be made directly to the
642     * mempool.
643     */
644    class ChangeSet {
645    public:
646        explicit ChangeSet(CTxMemPool* pool) : m_pool(pool) { m_pool->m_txgraph->StartStaging(); }
647        ~ChangeSet() EXCLUSIVE_LOCKS_REQUIRED(m_pool->cs) {
648            AssertLockHeld(m_pool->cs);
649            if (m_pool->m_txgraph->HaveStaging()) {
650                m_pool->m_txgraph->AbortStaging();
651            }
652            m_pool->m_have_changeset = false;
653        }
654
655        ChangeSet(const ChangeSet&) = delete;
656        ChangeSet& operator=(const ChangeSet&) = delete;
657
658        using TxHandle = CTxMemPool::txiter;
659
660        TxHandle StageAddition(const CTransactionRef& tx, CAmount fee, int64_t time, unsigned int entry_height, uint64_t entry_sequence, bool spends_coinbase, int64_t sigops_cost, LockPoints lp);
661
662        void StageRemoval(CTxMemPool::txiter it);
663
664        const CTxMemPool::setEntries& GetRemovals() const { return m_to_remove; }
665
666        /** Check if any cluster limits are exceeded. Returns true if pass, false if fail. */
667        bool CheckMemPoolPolicyLimits();
668
669        CTxMemPool::setEntries CalculateMemPoolAncestors(TxHandle tx)
670        {
671            // Look up transaction in our cache first
672            auto it = m_ancestors.find(tx);
673            if (it != m_ancestors.end()) return it->second;
674
675            // If not found, try to have the mempool calculate it, and cache
676            // for later.
677            LOCK(m_pool->cs);
678            auto ret = m_pool->CalculateMemPoolAncestors(*tx);
679            m_ancestors.try_emplace(tx, ret);
680            return ret;
681        }
682
683        std::vector<CTransactionRef> GetAddedTxns() const {
684            std::vector<CTransactionRef> ret;
685            ret.reserve(m_entry_vec.size());
686            for (const auto& entry : m_entry_vec) {
687                ret.emplace_back(entry->GetSharedTx());
688            }
689            return ret;
690        }
691
692        /**
693         * Calculate the sorted chunks for the old and new mempool relating to the
694         * clusters that would be affected by a potential replacement transaction.
695         *
696         * @return old and new diagram pair respectively, or an error string if the conflicts don't match a calculable topology
697         */
698        util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CalculateChunksForRBF();
699
700        size_t GetTxCount() const { return m_entry_vec.size(); }
701        const CTransaction& GetAddedTxn(size_t index) const { return m_entry_vec.at(index)->GetTx(); }
702
703        void Apply() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
704
705    private:
706        void ProcessDependencies();
707
708        CTxMemPool* m_pool;
709        CTxMemPool::indexed_transaction_set m_to_add;
710        std::vector<CTxMemPool::txiter> m_entry_vec; // track the added transactions' insertion order
711        // map from the m_to_add index to the ancestors for the transaction
712        std::map<CTxMemPool::txiter, CTxMemPool::setEntries, CompareIteratorByHash> m_ancestors;
713        CTxMemPool::setEntries m_to_remove;
714        bool m_dependencies_processed{false};
715
716        friend class CTxMemPool;
717    };
718
719    std::unique_ptr<ChangeSet> GetChangeSet() EXCLUSIVE_LOCKS_REQUIRED(cs) {
720        Assume(!m_have_changeset);
721        m_have_changeset = true;
722        return std::make_unique<ChangeSet>(this);
723    }
724
725    bool m_have_changeset GUARDED_BY(cs){false};
726
727    friend class CTxMemPool::ChangeSet;
728
729private:
730    // Apply the given changeset to the mempool, by removing transactions in
731    // the to_remove set and adding transactions in the to_add set.
732    void Apply(CTxMemPool::ChangeSet* changeset) EXCLUSIVE_LOCKS_REQUIRED(cs);
733
734    // addNewTransaction must update state for all ancestors of a given transaction,
735    // to track size/count of descendant transactions.  First version of
736    // addNewTransaction can be used to have it call CalculateMemPoolAncestors(), and
737    // then invoke the second version.
738    // Note that addNewTransaction is ONLY called (via Apply()) from ATMP
739    // outside of tests and any other callers may break wallet's in-mempool
740    // tracking (due to lack of CValidationInterface::TransactionAddedToMempool
741    // callbacks).
742    void addNewTransaction(CTxMemPool::txiter it) EXCLUSIVE_LOCKS_REQUIRED(cs);
743public:
744    void StartBlockBuilding() const EXCLUSIVE_LOCKS_REQUIRED(cs) { assert(!m_builder); m_builder = m_txgraph->GetBlockBuilder(); }
745    FeePerWeight GetBlockBuilderChunk(std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& entries) const EXCLUSIVE_LOCKS_REQUIRED(cs)
746    {
747        if (!m_builder) { return {}; }
748
749        auto res = m_builder->GetCurrentChunk();
750        if (!res) { return {}; }