Maintaining pending transactions

1001    }
1002}
1003
1004bool CTxMemPool::GetLoadTried() const
1005{
1006    LOCK(cs);
1007    return m_load_tried;
1008}
1009
1010void CTxMemPool::SetLoadTried(bool load_tried)
1011{
1012    LOCK(cs);
1013    m_load_tried = load_tried;
1014}
1015
1016std::vector<CTxMemPool::txiter> CTxMemPool::GatherClusters(const std::vector<Txid>& txids) const
1017{
1018    AssertLockHeld(cs);
1019
1020    std::vector<CTxMemPool::txiter> ret;
1021    std::set<const CTxMemPoolEntry*> unique_cluster_representatives;
1022    for (auto txid : txids) {
1023        auto it = mapTx.find(txid);
1024        if (it != mapTx.end()) {
1025            // Note that TxGraph::GetCluster will return results in graph
1026            // order, which is deterministic (as long as we are not modifying
1027            // the graph).
1028            auto cluster = m_txgraph->GetCluster(*it, TxGraph::Level::MAIN);
1029            if (unique_cluster_representatives.insert(static_cast<const CTxMemPoolEntry*>(&(**cluster.begin()))).second) {
1030                for (auto tx : cluster) {
1031                    ret.emplace_back(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
1032                }
1033            }
1034        }
1035    }
1036    if (ret.size() > 500) {
1037        return {};
1038    }
1039    return ret;
1040}
1041
1042util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CTxMemPool::ChangeSet::CalculateChunksForRBF()
1043{
1044    LOCK(m_pool->cs);
1045
1046    if (!CheckMemPoolPolicyLimits()) {
1047        return util::Error{Untranslated("cluster size limit exceeded")};
1048    }
1049
1050    return m_pool->m_txgraph->GetMainStagingDiagrams();
1051}
1052
1053CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTransactionRef& tx, const CAmount fee, int64_t time, unsigned int entry_height, uint64_t entry_sequence, bool spends_coinbase, int64_t sigops_cost, LockPoints lp)
1054{
1055    LOCK(m_pool->cs);
1056    Assume(m_to_add.find(tx->GetHash()) == m_to_add.end());
1057    Assume(!m_dependencies_processed);
1058
1059    // We need to process dependencies after adding a new transaction.
1060    m_dependencies_processed = false;
1061
1062    CAmount delta{0};
1063    m_pool->ApplyDelta(tx->GetHash(), delta);
1064
1065    FeePerWeight feerate(fee, GetSigOpsAdjustedWeight(GetTransactionWeight(*tx), sigops_cost, ::nBytesPerSigOp));
1066    auto newit = m_to_add.emplace(tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
1067    m_pool->m_txgraph->AddTransaction(const_cast<CTxMemPoolEntry&>(*newit), feerate);
1068    if (delta) {
1069        newit->UpdateModifiedFee(delta);
1070        m_pool->m_txgraph->SetTransactionFee(*newit, newit->GetModifiedFee());
1071    }
1072
1073    m_entry_vec.push_back(newit);
1074
1075    return newit;
1076}
1077
1078void CTxMemPool::ChangeSet::StageRemoval(CTxMemPool::txiter it)
1079{
1080    LOCK(m_pool->cs);
1081    m_pool->m_txgraph->RemoveTransaction(*it);
1082    m_to_remove.insert(it);
1083}
1084
1085void CTxMemPool::ChangeSet::Apply()
1086{
1087    LOCK(m_pool->cs);
1088    if (!m_dependencies_processed) {
1089        ProcessDependencies();
1090    }
1091    m_pool->Apply(this);
1092    m_to_add.clear();
1093    m_to_remove.clear();
1094    m_entry_vec.clear();
1095    m_ancestors.clear();
1096}
1097
1098void CTxMemPool::ChangeSet::ProcessDependencies()
1099{
1100    LOCK(m_pool->cs);
1101    Assume(!m_dependencies_processed); // should only call this once.
1102    for (const auto& entryptr : m_entry_vec) {
1103        for (const auto &txin : entryptr->GetSharedTx()->vin) {
1104            std::optional<txiter> piter = m_pool->GetIter(txin.prevout.hash);
1105            if (!piter) {
1106                auto it = m_to_add.find(txin.prevout.hash);
1107                if (it != m_to_add.end()) {
1108                    piter = std::make_optional(it);
1109                }
1110            }
1111            if (piter) {
1112                m_pool->m_txgraph->AddDependency(/*parent=*/**piter, /*child=*/*entryptr);
1113            }
1114        }
1115    }
1116    m_dependencies_processed = true;
1117    return;
1118 }
1119
1120bool CTxMemPool::ChangeSet::CheckMemPoolPolicyLimits()
1121{
1122    LOCK(m_pool->cs);
1123    if (!m_dependencies_processed) {
1124        ProcessDependencies();
1125    }
1126
1127    return !m_pool->m_txgraph->IsOversized(TxGraph::Level::TOP);
1128}
1129
1130std::vector<FeePerWeight> CTxMemPool::GetFeerateDiagram() const
1131{
1132    FeePerWeight zero{};
1133    std::vector<FeePerWeight> ret;
1134
1135    ret.emplace_back(zero);
1136
1137    StartBlockBuilding();
1138
1139    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> dummy;
1140
1141    FeePerWeight last_selection = GetBlockBuilderChunk(dummy);
1142    while (last_selection != FeePerWeight{}) {
1143        last_selection += ret.back();
1144        ret.emplace_back(last_selection);
1145        IncludeBuilderChunk();
1146        last_selection = GetBlockBuilderChunk(dummy);
1147    }
1148    StopBlockBuilding();
1149    return ret;
1150}
1151