Update TxQ lock safety

ximinez · ximinez · commit 255ea43768a9 · 2025-03-25T12:31:35.000-04:00
diff --git a/src/xrpld/app/misc/TxQ.h b/src/xrpld/app/misc/TxQ.h
@@ -745,7 +745,8 @@ class TxQ
     std::optional<TxQAccount::TxMap::iterator>
     removeFromByFee(
         std::optional<TxQAccount::TxMap::iterator> const& replacedTxIter,
-        std::shared_ptr<STTx const> const& tx);
+        std::shared_ptr<STTx const> const& tx,
+        std::lock_guard<std::mutex> const&);
 
     using FeeHook = boost::intrusive::member_hook<
         MaybeTx,
@@ -802,7 +803,7 @@ class TxQ
     /// Is the queue at least `fillPercentage` full?
     template <size_t fillPercentage = 100>
     bool
-    isFull() const;
+    isFull(std::lock_guard<std::mutex> const&) const;
 
     /** Checks if the indicated transaction fits the conditions
         for being stored in the queue.
@@ -815,22 +816,26 @@ class TxQ
         std::shared_ptr<SLE const> const& sleAccount,
         AccountMap::iterator const&,
         std::optional<TxQAccount::TxMap::iterator> const&,
-        std::lock_guard<std::mutex> const& lock);
+        std::lock_guard<std::mutex> const&);
 
     /// Erase and return the next entry in byFee_ (lower fee level)
-    FeeMultiSet::iterator_type erase(FeeMultiSet::const_iterator_type);
+    FeeMultiSet::iterator_type
+    erase(FeeMultiSet::const_iterator_type, std::lock_guard<std::mutex> const&);
     /** Erase and return the next entry for the account (if fee level
         is higher), or next entry in byFee_ (lower fee level).
         Used to get the next "applyable" MaybeTx for accept().
     */
-    FeeMultiSet::iterator_type eraseAndAdvance(
-        FeeMultiSet::const_iterator_type);
+    FeeMultiSet::iterator_type
+    eraseAndAdvance(
+        FeeMultiSet::const_iterator_type,
+        std::lock_guard<std::mutex> const&);
     /// Erase a range of items, based on TxQAccount::TxMap iterators
     TxQAccount::TxMap::iterator
     erase(
         TxQAccount& txQAccount,
         TxQAccount::TxMap::const_iterator begin,
-        TxQAccount::TxMap::const_iterator end);
+        TxQAccount::TxMap::const_iterator end,
+        std::lock_guard<std::mutex> const&);
 
     /**
         All-or-nothing attempt to try to apply the queued txs for
@@ -849,6 +854,7 @@ class TxQ
         std::size_t const txExtraCount,
         ApplyFlags flags,
         FeeMetrics::Snapshot const& metricsSnapshot,
+        std::lock_guard<std::mutex> const&,
         beast::Journal j);
 };
 
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -373,7 +373,7 @@ TxQ::~TxQ()
 
 template <size_t fillPercentage>
 bool
-TxQ::isFull() const
+TxQ::isFull(std::lock_guard<std::mutex> const&) const
 {
     static_assert(
         fillPercentage > 0 && fillPercentage <= 100, "Invalid fill percentage");
@@ -447,8 +447,9 @@ TxQ::canBeHeld(
 }
 
 auto
-TxQ::erase(TxQ::FeeMultiSet::const_iterator_type candidateIter)
-    -> FeeMultiSet::iterator_type
+TxQ::erase(
+    TxQ::FeeMultiSet::const_iterator_type candidateIter,
+    std::lock_guard<std::mutex> const&) -> FeeMultiSet::iterator_type
 {
     auto& txQAccount = byAccount_.at(candidateIter->account);
     auto const seqProx = candidateIter->seqProxy;
@@ -463,8 +464,9 @@ TxQ::erase(TxQ::FeeMultiSet::const_iterator_type candidateIter)
 }
 
 auto
-TxQ::eraseAndAdvance(TxQ::FeeMultiSet::const_iterator_type candidateIter)
-    -> FeeMultiSet::iterator_type
+TxQ::eraseAndAdvance(
+    TxQ::FeeMultiSet::const_iterator_type candidateIter,
+    std::lock_guard<std::mutex> const&) -> FeeMultiSet::iterator_type
 {
     auto& txQAccount = byAccount_.at(candidateIter->account);
     auto const accountIter =
@@ -505,7 +507,8 @@ auto
 TxQ::erase(
     TxQ::TxQAccount& txQAccount,
     TxQ::TxQAccount::TxMap::const_iterator begin,
-    TxQ::TxQAccount::TxMap::const_iterator end) -> TxQAccount::TxMap::iterator
+    TxQ::TxQAccount::TxMap::const_iterator end,
+    std::lock_guard<std::mutex> const&) -> TxQAccount::TxMap::iterator
 {
     for (auto it = begin; it != end; ++it)
     {
@@ -526,6 +529,7 @@ TxQ::tryClearAccountQueueUpThruTx(
     std::size_t const txExtraCount,
     ApplyFlags flags,
     FeeMetrics::Snapshot const& metricsSnapshot,
+    std::lock_guard<std::mutex> const& lock,
     beast::Journal j)
 {
     SeqProxy const tSeqProx{tx.getSeqProxy()};
@@ -603,11 +607,11 @@ TxQ::tryClearAccountQueueUpThruTx(
     {
         // All of the queued transactions applied, so remove them from the
         // queue.
-        endTxIter = erase(accountIter->second, beginTxIter, endTxIter);
+        endTxIter = erase(accountIter->second, beginTxIter, endTxIter, lock);
         // If `tx` is replacing a queued tx, delete that one, too.
         if (endTxIter != accountIter->second.transactions.end() &&
             endTxIter->first == tSeqProx)
-            erase(accountIter->second, endTxIter, std::next(endTxIter));
+            erase(accountIter->second, endTxIter, std::next(endTxIter), lock);
     }
 
     return txResult;
@@ -1212,6 +1216,7 @@ TxQ::apply(
             view.txCount(),
             flags,
             metricsSnapshot,
+            lock,
             j);
         if (result.applied)
         {
@@ -1240,7 +1245,7 @@ TxQ::apply(
     // If the queue is full, decide whether to drop the current
     // transaction or the last transaction for the account with
     // the lowest fee.
-    if (!replacedTxIter && isFull())
+    if (!replacedTxIter && isFull(lock))
     {
         auto lastRIter = byFee_.rbegin();
         while (lastRIter != byFee_.rend() && lastRIter->account == account)
@@ -1303,7 +1308,7 @@ TxQ::apply(
                 << " from queue with average fee of " << endEffectiveFeeLevel
                 << " in favor of " << transactionID << " with fee of "
                 << feeLevelPaid;
-            erase(byFee_.iterator_to(dropRIter->second));
+            erase(byFee_.iterator_to(dropRIter->second), lock);
         }
         else
         {
@@ -1317,7 +1322,7 @@ TxQ::apply(
     // Hold the transaction in the queue.
     if (replacedTxIter)
     {
-        replacedTxIter = removeFromByFee(replacedTxIter, tx);
+        replacedTxIter = removeFromByFee(replacedTxIter, tx, lock);
     }
 
     if (!accountIsInQueue)
@@ -1382,7 +1387,7 @@ TxQ::processClosedLedger(Application& app, ReadView const& view, bool timeLeap)
         if (candidateIter->lastValid && *candidateIter->lastValid <= ledgerSeq)
         {
             byAccount_.at(candidateIter->account).dropPenalty = true;
-            candidateIter = erase(candidateIter);
+            candidateIter = erase(candidateIter, lock);
         }
         else
         {
@@ -1486,7 +1491,7 @@ TxQ::accept(Application& app, OpenView& view)
                     << " applied successfully with " << transToken(txnResult)
                     << ". Remove from queue.";
 
-                candidateIter = eraseAndAdvance(candidateIter);
+                candidateIter = eraseAndAdvance(candidateIter, lock);
                 ledgerChanged = true;
             }
             else if (
@@ -1500,7 +1505,7 @@ TxQ::accept(Application& app, OpenView& view)
                 JLOG(j_.debug()) << "Queued transaction " << candidateIter->txID
                                  << " failed with " << transToken(txnResult)
                                  << ". Remove from queue.";
-                candidateIter = eraseAndAdvance(candidateIter);
+                candidateIter = eraseAndAdvance(candidateIter, lock);
             }
             else
             {
@@ -1515,7 +1520,7 @@ TxQ::accept(Application& app, OpenView& view)
                     --candidateIter->retriesRemaining;
                 candidateIter->lastResult = txnResult;
                 if (account.dropPenalty && account.transactions.size() > 1 &&
-                    isFull<95>())
+                    isFull<95>(lock))
                 {
                     // The queue is close to full, this account has multiple
                     // txs queued, and this account has had a transaction
@@ -1530,7 +1535,7 @@ TxQ::accept(Application& app, OpenView& view)
                             << transToken(txnResult)
                             << ". Removing ticketed tx from account "
                             << account.account;
-                        candidateIter = eraseAndAdvance(candidateIter);
+                        candidateIter = eraseAndAdvance(candidateIter, lock);
                     }
                     else
                     {
@@ -1551,7 +1556,7 @@ TxQ::accept(Application& app, OpenView& view)
                             << account.account;
                         auto endIter = byFee_.iterator_to(dropRIter->second);
                         if (endIter != candidateIter)
-                            erase(endIter);
+                            erase(endIter, lock);
                         ++candidateIter;
                     }
                 }
@@ -1698,8 +1703,8 @@ TxQ::tryDirectApply(
     if (txSeqProx.isSeq() && txSeqProx != acctSeqProx)
         return {};
 
-    FeeLevel64 const requiredFeeLevel = [this, &view, flags]() {
-        std::lock_guard lock(mutex_);
+    std::lock_guard lock(mutex_);
+    FeeLevel64 const requiredFeeLevel = [this, &view, flags, &lock]() {
         return getRequiredFeeLevel(
             view, flags, feeMetrics_.getSnapshot(), lock);
     }();
@@ -1727,7 +1732,6 @@ TxQ::tryDirectApply(
         {
             // If the applied transaction replaced a transaction in the
             // queue then remove the replaced transaction.
-            std::lock_guard lock(mutex_);
 
             AccountMap::iterator accountIter = byAccount_.find(account);
             if (accountIter != byAccount_.end())
@@ -1737,7 +1741,7 @@ TxQ::tryDirectApply(
                         txQAcct.transactions.find(txSeqProx);
                     existingIter != txQAcct.transactions.end())
                 {
-                    removeFromByFee(existingIter, tx);
+                    removeFromByFee(existingIter, tx, lock);
                 }
             }
         }
@@ -1749,7 +1753,8 @@ TxQ::tryDirectApply(
 std::optional<TxQ::TxQAccount::TxMap::iterator>
 TxQ::removeFromByFee(
     std::optional<TxQAccount::TxMap::iterator> const& replacedTxIter,
-    std::shared_ptr<STTx const> const& tx)
+    std::shared_ptr<STTx const> const& tx,
+    std::lock_guard<std::mutex> const& lock)
 {
     if (replacedTxIter && tx)
     {
@@ -1769,7 +1774,7 @@ TxQ::removeFromByFee(
             deleteIter->account == (*tx)[sfAccount],
             "ripple::TxQ::removeFromByFee : matching account");
 
-        erase(deleteIter);
+        erase(deleteIter, lock);
     }
     return std::nullopt;
 }
@@ -1789,7 +1794,7 @@ TxQ::getMetrics(OpenView const& view) const
     result.txPerLedger = snapshot.txnsExpected;
     result.referenceFeeLevel = baseLevel;
     result.minProcessingFeeLevel =
-        isFull() ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : baseLevel;
+        isFull(lock) ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : baseLevel;
     result.medFeeLevel = snapshot.escalationMultiplier;
     result.openLedgerFeeLevel = FeeMetrics::scaleFeeLevel(snapshot, view);
 

Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ TxQ::~TxQ()`
`373`	`373`
`374`	`374`	`template <size_t fillPercentage>`
`375`	`375`	`bool`
`376`		`-TxQ::isFull() const`
	`376`	`+TxQ::isFull(std::lock_guard<std::mutex> const&) const`
`377`	`377`	`{`
`378`	`378`	`static_assert(`
`379`	`379`	`fillPercentage > 0 && fillPercentage <= 100, "Invalid fill percentage");`
`@@ -447,8 +447,9 @@ TxQ::canBeHeld(`
`447`	`447`	`}`
`448`	`448`
`449`	`449`	`auto`
`450`		`-TxQ::erase(TxQ::FeeMultiSet::const_iterator_type candidateIter)`
`451`		`- -> FeeMultiSet::iterator_type`
	`450`	`+TxQ::erase(`
	`451`	`+ TxQ::FeeMultiSet::const_iterator_type candidateIter,`
	`452`	`+ std::lock_guard<std::mutex> const&) -> FeeMultiSet::iterator_type`
`452`	`453`	`{`
`453`	`454`	`auto& txQAccount = byAccount_.at(candidateIter->account);`
`454`	`455`	`auto const seqProx = candidateIter->seqProxy;`
`@@ -463,8 +464,9 @@ TxQ::erase(TxQ::FeeMultiSet::const_iterator_type candidateIter)`
`463`	`464`	`}`
`464`	`465`
`465`	`466`	`auto`
`466`		`-TxQ::eraseAndAdvance(TxQ::FeeMultiSet::const_iterator_type candidateIter)`
`467`		`- -> FeeMultiSet::iterator_type`
	`467`	`+TxQ::eraseAndAdvance(`
	`468`	`+ TxQ::FeeMultiSet::const_iterator_type candidateIter,`
	`469`	`+ std::lock_guard<std::mutex> const&) -> FeeMultiSet::iterator_type`
`468`	`470`	`{`
`469`	`471`	`auto& txQAccount = byAccount_.at(candidateIter->account);`
`470`	`472`	`auto const accountIter =`
`@@ -505,7 +507,8 @@ auto`
`505`	`507`	`TxQ::erase(`
`506`	`508`	`TxQ::TxQAccount& txQAccount,`
`507`	`509`	`TxQ::TxQAccount::TxMap::const_iterator begin,`
`508`		`- TxQ::TxQAccount::TxMap::const_iterator end) -> TxQAccount::TxMap::iterator`
	`510`	`+ TxQ::TxQAccount::TxMap::const_iterator end,`
	`511`	`+ std::lock_guard<std::mutex> const&) -> TxQAccount::TxMap::iterator`
`509`	`512`	`{`
`510`	`513`	`for (auto it = begin; it != end; ++it)`
`511`	`514`	`{`
`@@ -526,6 +529,7 @@ TxQ::tryClearAccountQueueUpThruTx(`
`526`	`529`	`std::size_t const txExtraCount,`
`527`	`530`	`ApplyFlags flags,`
`528`	`531`	`FeeMetrics::Snapshot const& metricsSnapshot,`
	`532`	`+ std::lock_guard<std::mutex> const& lock,`
`529`	`533`	`beast::Journal j)`
`530`	`534`	`{`
`531`	`535`	`SeqProxy const tSeqProx{tx.getSeqProxy()};`
`@@ -603,11 +607,11 @@ TxQ::tryClearAccountQueueUpThruTx(`
`603`	`607`	`{`
`604`	`608`	`// All of the queued transactions applied, so remove them from the`
`605`	`609`	`// queue.`
`606`		`- endTxIter = erase(accountIter->second, beginTxIter, endTxIter);`
	`610`	`+ endTxIter = erase(accountIter->second, beginTxIter, endTxIter, lock);`
`607`	`611`	// If `tx` is replacing a queued tx, delete that one, too.
`608`	`612`	`if (endTxIter != accountIter->second.transactions.end() &&`
`609`	`613`	`endTxIter->first == tSeqProx)`
`610`		`- erase(accountIter->second, endTxIter, std::next(endTxIter));`
	`614`	`+ erase(accountIter->second, endTxIter, std::next(endTxIter), lock);`
`611`	`615`	`}`
`612`	`616`
`613`	`617`	`return txResult;`
`@@ -1212,6 +1216,7 @@ TxQ::apply(`
`1212`	`1216`	`view.txCount(),`
`1213`	`1217`	`flags,`
`1214`	`1218`	`metricsSnapshot,`
	`1219`	`+ lock,`
`1215`	`1220`	`j);`
`1216`	`1221`	`if (result.applied)`
`1217`	`1222`	`{`
`@@ -1240,7 +1245,7 @@ TxQ::apply(`
`1240`	`1245`	`// If the queue is full, decide whether to drop the current`
`1241`	`1246`	`// transaction or the last transaction for the account with`
`1242`	`1247`	`// the lowest fee.`
`1243`		`- if (!replacedTxIter && isFull())`
	`1248`	`+ if (!replacedTxIter && isFull(lock))`
`1244`	`1249`	`{`
`1245`	`1250`	`auto lastRIter = byFee_.rbegin();`
`1246`	`1251`	`while (lastRIter != byFee_.rend() && lastRIter->account == account)`
`@@ -1303,7 +1308,7 @@ TxQ::apply(`
`1303`	`1308`	`<< " from queue with average fee of " << endEffectiveFeeLevel`
`1304`	`1309`	`<< " in favor of " << transactionID << " with fee of "`
`1305`	`1310`	`<< feeLevelPaid;`
`1306`		`- erase(byFee_.iterator_to(dropRIter->second));`
	`1311`	`+ erase(byFee_.iterator_to(dropRIter->second), lock);`
`1307`	`1312`	`}`
`1308`	`1313`	`else`
`1309`	`1314`	`{`
`@@ -1317,7 +1322,7 @@ TxQ::apply(`
`1317`	`1322`	`// Hold the transaction in the queue.`
`1318`	`1323`	`if (replacedTxIter)`
`1319`	`1324`	`{`
`1320`		`- replacedTxIter = removeFromByFee(replacedTxIter, tx);`
	`1325`	`+ replacedTxIter = removeFromByFee(replacedTxIter, tx, lock);`
`1321`	`1326`	`}`
`1322`	`1327`
`1323`	`1328`	`if (!accountIsInQueue)`
`@@ -1382,7 +1387,7 @@ TxQ::processClosedLedger(Application& app, ReadView const& view, bool timeLeap)`
`1382`	`1387`	`if (candidateIter->lastValid && *candidateIter->lastValid <= ledgerSeq)`
`1383`	`1388`	`{`
`1384`	`1389`	`byAccount_.at(candidateIter->account).dropPenalty = true;`
`1385`		`- candidateIter = erase(candidateIter);`
	`1390`	`+ candidateIter = erase(candidateIter, lock);`
`1386`	`1391`	`}`
`1387`	`1392`	`else`
`1388`	`1393`	`{`
`@@ -1486,7 +1491,7 @@ TxQ::accept(Application& app, OpenView& view)`
`1486`	`1491`	`<< " applied successfully with " << transToken(txnResult)`
`1487`	`1492`	`<< ". Remove from queue.";`
`1488`	`1493`
`1489`		`- candidateIter = eraseAndAdvance(candidateIter);`
	`1494`	`+ candidateIter = eraseAndAdvance(candidateIter, lock);`
`1490`	`1495`	`ledgerChanged = true;`
`1491`	`1496`	`}`
`1492`	`1497`	`else if (`
`@@ -1500,7 +1505,7 @@ TxQ::accept(Application& app, OpenView& view)`
`1500`	`1505`	`JLOG(j_.debug()) << "Queued transaction " << candidateIter->txID`
`1501`	`1506`	`<< " failed with " << transToken(txnResult)`
`1502`	`1507`	`<< ". Remove from queue.";`
`1503`		`- candidateIter = eraseAndAdvance(candidateIter);`
	`1508`	`+ candidateIter = eraseAndAdvance(candidateIter, lock);`
`1504`	`1509`	`}`
`1505`	`1510`	`else`
`1506`	`1511`	`{`
`@@ -1515,7 +1520,7 @@ TxQ::accept(Application& app, OpenView& view)`
`1515`	`1520`	`--candidateIter->retriesRemaining;`
`1516`	`1521`	`candidateIter->lastResult = txnResult;`
`1517`	`1522`	`if (account.dropPenalty && account.transactions.size() > 1 &&`
`1518`		`- isFull<95>())`
	`1523`	`+ isFull<95>(lock))`
`1519`	`1524`	`{`
`1520`	`1525`	`// The queue is close to full, this account has multiple`
`1521`	`1526`	`// txs queued, and this account has had a transaction`
`@@ -1530,7 +1535,7 @@ TxQ::accept(Application& app, OpenView& view)`
`1530`	`1535`	`<< transToken(txnResult)`
`1531`	`1536`	`<< ". Removing ticketed tx from account "`
`1532`	`1537`	`<< account.account;`
`1533`		`- candidateIter = eraseAndAdvance(candidateIter);`
	`1538`	`+ candidateIter = eraseAndAdvance(candidateIter, lock);`
`1534`	`1539`	`}`
`1535`	`1540`	`else`
`1536`	`1541`	`{`
`@@ -1551,7 +1556,7 @@ TxQ::accept(Application& app, OpenView& view)`
`1551`	`1556`	`<< account.account;`
`1552`	`1557`	`auto endIter = byFee_.iterator_to(dropRIter->second);`
`1553`	`1558`	`if (endIter != candidateIter)`
`1554`		`- erase(endIter);`
	`1559`	`+ erase(endIter, lock);`
`1555`	`1560`	`++candidateIter;`
`1556`	`1561`	`}`
`1557`	`1562`	`}`
`@@ -1698,8 +1703,8 @@ TxQ::tryDirectApply(`
`1698`	`1703`	`if (txSeqProx.isSeq() && txSeqProx != acctSeqProx)`
`1699`	`1704`	`return {};`
`1700`	`1705`
`1701`		`- FeeLevel64 const requiredFeeLevel = [this, &view, flags]() {`
`1702`		`- std::lock_guard lock(mutex_);`
	`1706`	`+ std::lock_guard lock(mutex_);`
	`1707`	`+ FeeLevel64 const requiredFeeLevel = [this, &view, flags, &lock]() {`
`1703`	`1708`	`return getRequiredFeeLevel(`
`1704`	`1709`	`view, flags, feeMetrics_.getSnapshot(), lock);`
`1705`	`1710`	`}();`
`@@ -1727,7 +1732,6 @@ TxQ::tryDirectApply(`
`1727`	`1732`	`{`
`1728`	`1733`	`// If the applied transaction replaced a transaction in the`
`1729`	`1734`	`// queue then remove the replaced transaction.`
`1730`		`- std::lock_guard lock(mutex_);`
`1731`	`1735`
`1732`	`1736`	`AccountMap::iterator accountIter = byAccount_.find(account);`
`1733`	`1737`	`if (accountIter != byAccount_.end())`
`@@ -1737,7 +1741,7 @@ TxQ::tryDirectApply(`
`1737`	`1741`	`txQAcct.transactions.find(txSeqProx);`
`1738`	`1742`	`existingIter != txQAcct.transactions.end())`
`1739`	`1743`	`{`
`1740`		`- removeFromByFee(existingIter, tx);`
	`1744`	`+ removeFromByFee(existingIter, tx, lock);`
`1741`	`1745`	`}`
`1742`	`1746`	`}`
`1743`	`1747`	`}`
`@@ -1749,7 +1753,8 @@ TxQ::tryDirectApply(`
`1749`	`1753`	`std::optional<TxQ::TxQAccount::TxMap::iterator>`
`1750`	`1754`	`TxQ::removeFromByFee(`
`1751`	`1755`	`std::optional<TxQAccount::TxMap::iterator> const& replacedTxIter,`
`1752`		`- std::shared_ptr<STTx const> const& tx)`
	`1756`	`+ std::shared_ptr<STTx const> const& tx,`
	`1757`	`+ std::lock_guard<std::mutex> const& lock)`
`1753`	`1758`	`{`
`1754`	`1759`	`if (replacedTxIter && tx)`
`1755`	`1760`	`{`
`@@ -1769,7 +1774,7 @@ TxQ::removeFromByFee(`
`1769`	`1774`	`deleteIter->account == (*tx)[sfAccount],`
`1770`	`1775`	`"ripple::TxQ::removeFromByFee : matching account");`
`1771`	`1776`
`1772`		`- erase(deleteIter);`
	`1777`	`+ erase(deleteIter, lock);`
`1773`	`1778`	`}`
`1774`	`1779`	`return std::nullopt;`
`1775`	`1780`	`}`
`@@ -1789,7 +1794,7 @@ TxQ::getMetrics(OpenView const& view) const`
`1789`	`1794`	`result.txPerLedger = snapshot.txnsExpected;`
`1790`	`1795`	`result.referenceFeeLevel = baseLevel;`
`1791`	`1796`	`result.minProcessingFeeLevel =`
`1792`		`- isFull() ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : baseLevel;`
	`1797`	`+ isFull(lock) ? byFee_.rbegin()->feeLevel + FeeLevel64{1} : baseLevel;`
`1793`	`1798`	`result.medFeeLevel = snapshot.escalationMultiplier;`
`1794`	`1799`	`result.openLedgerFeeLevel = FeeMetrics::scaleFeeLevel(snapshot, view);`
`1795`	`1800`