Method Updated

src/txgraph.cpp:1072–1146

}

void GenericClusterImpl::Updated(TxGraphImpl& graph, int level, bool rename) noexcept
{
    // Update all the Locators for this Cluster's Entry objects.
    for (DepGraphIndex idx : m_linearization) {
        auto& entry = graph.m_entries[m_mapping[idx]];
        // Discard any potential ChunkData prior to modifying the Cluster (as that could
        // invalidate its ordering).
        if (level == 0 && !rename) graph.ClearChunkData(entry);
        entry.m_locator[level].SetPresent(this, idx);
    }
    // If this is for the main graph (level = 0), and the Cluster's quality is ACCEPTABLE or
    // OPTIMAL, compute its chunking and store its information in the Entry's m_main_lin_index
    // and m_main_chunk_feerate. These fields are only accessed after making the entire graph
    // ACCEPTABLE, so it is pointless to compute these if we haven't reached that quality level
    // yet.
    // When rename=true, this is always performed for level 0, to make sure the values inside the
    // entries remain consistent with the chunk index (otherwise unrelated chunk index operations
    // could cause the index to become corrupted, by inserting elements in the wrong place).
    if (level == 0 && (rename || IsAcceptable())) {
        auto chunking = ChunkLinearizationInfo(m_depgraph, m_linearization);
        LinearizationIndex lin_idx{0};
        /** The sum of all chunk feerate FeeFracs with the same feerate as the current chunk,
         *  up to and including the current chunk. */
        FeeFrac equal_feerate_chunk_feerate;
        // Iterate over the chunks.
        for (unsigned chunk_idx = 0; chunk_idx < chunking.size(); ++chunk_idx) {
            auto& chunk = chunking[chunk_idx];
            auto chunk_count = chunk.transactions.Count();
            Assume(chunk_count > 0);
            // Update equal_feerate_chunk_feerate to include this chunk, starting over when the
            // feerate changed.
            if (ByRatio{chunk.feerate} < ByRatio{equal_feerate_chunk_feerate}) {
                equal_feerate_chunk_feerate = chunk.feerate;
            } else {
                // Note that this is adding fees to fees, and sizes to sizes, so the overall
                // ratio remains the same; it's just accounting for the size of the added chunk.
                equal_feerate_chunk_feerate += chunk.feerate;
            }
            // Determine the m_fallback_order maximum transaction in the chunk.
            auto it = chunk.transactions.begin();
            GraphIndex max_element = m_mapping[*it];
            ++it;
            while (it != chunk.transactions.end()) {
                GraphIndex this_element = m_mapping[*it];
                if (graph.m_fallback_order(*graph.m_entries[this_element].m_ref, *graph.m_entries[max_element].m_ref) > 0) {
                    max_element = this_element;
                }
                ++it;
            }
            // Iterate over the transactions in the linearization, which must match those in chunk.
            while (true) {
                DepGraphIndex idx = m_linearization[lin_idx];
                GraphIndex graph_idx = m_mapping[idx];
                auto& entry = graph.m_entries[graph_idx];
                entry.m_main_lin_index = lin_idx++;
                entry.m_main_chunk_feerate = FeePerWeight::FromFeeFrac(chunk.feerate);
                entry.m_main_equal_feerate_chunk_prefix_size = equal_feerate_chunk_feerate.size;
                entry.m_main_max_chunk_fallback = max_element;