v30.3-roots.1 · Commit 3: [PATCH 03/68] feat(policy): preserve Roots relay and network controls on Core 30.3

src/txmempool.h

Before: src/txmempool.h · After: src/txmempool.h

File metadata

index befaf4e59fd10bfca1cbca0311230aab620096fc..40ae4fcc5218dca5bd377879546012af4d2d0e52 100644

Download original patch · Release notes

Diff rows 1–137 of 137. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. The two line-number columns refer to before and after.

src/txmempool.h CHANGED Viewed

@@ -18,6 +18,7 @@
 #include <policy/packages.h>
 #include <primitives/transaction.h>
 #include <primitives/transaction_identifier.h>
+#include <script/script.h>
 #include <sync.h>
 #include <util/epochguard.h>
 #include <util/feefrac.h>
@@ -42,13 +43,23 @@
 #include <vector>
 class CChain;
+class CScript;
 class ValidationSignals;
 struct bilingual_str;
+static constexpr std::chrono::minutes DYNAMIC_DUST_FEERATE_UPDATE_INTERVAL{15};
 /** Fake height value used in Coin to signify they are only in the memory pool (since 0.8) */
 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
+inline int64_t maxmempoolMinimumBytes(const int64_t descendant_size_vbytes) {
+    return descendant_size_vbytes * 40;
+}
+inline int64_t limitdescendantsizeMaximumVBytes(const int64_t maxmempool) {
+    return maxmempool / 40;
+}
 /**
  * Test whether the LockPoints height and time are still valid on the current chain
  */
@@ -177,12 +188,16 @@ public:
     }
 };
+uint160 ScriptHashkey(const CScript& script);
 // Multi_index tag names
 struct descendant_score {};
 struct entry_time {};
 struct ancestor_score {};
 struct index_by_wtxid {};
+class CBlockPolicyEstimator;
 /**
  * Information about a mempool transaction.
  */
@@ -373,6 +388,9 @@ public:
     using Limits = kernel::MemPoolLimits;
     uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    std::map<uint160, std::pair<const CTransaction *, const CTransaction *>> mapUsedSPK GUARDED_BY(cs);
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
@@ -412,11 +430,11 @@ private:
 public:
     indirectmap<COutPoint, const CTransaction*> mapNextTx GUARDED_BY(cs);
-    std::map<Txid, CAmount> mapDeltas GUARDED_BY(cs);
+    std::map<Txid, std::pair<double, CAmount>> mapDeltas GUARDED_BY(cs);
     using Options = kernel::MemPoolOptions;
-    const Options m_opts;
+    Options m_opts;
     /** Create a new CTxMemPool.
      * Sanity checks will be off by default for performance, because otherwise
@@ -455,10 +473,20 @@ public:
      * the tx is not dependent on other mempool transactions to be included in a block.
      */
     bool HasNoInputsOf(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    /**
+     * Update all transactions in the mempool which depend on tx to recalculate their priority
+     * and adjust the input value that will age to reflect that the inputs from this transaction have
+     * either just been added to the chain or just been removed.
+     */
+    void UpdateDependentPriorities(const CTransaction &tx, unsigned int nBlockHeight, bool addToChain);
+    void UpdateDynamicDustFeerate();
     /** Affect CreateNewBlock prioritisation of transactions */
-    void PrioritiseTransaction(const Txid& hash, const CAmount& nFeeDelta);
-    void ApplyDelta(const Txid& hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void PrioritiseTransaction(const Txid& hash, double dPriorityDelta, const CAmount& nFeeDelta);
+    void PrioritiseTransaction(const Txid& hash, const CAmount& nFeeDelta) { PrioritiseTransaction(hash, 0., nFeeDelta); }
+    void ApplyDeltas(const Txid& hash, double &dPriorityDelta, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void ApplyDelta(const Txid& hash, CAmount& fee_delta) const EXCLUSIVE_LOCKS_REQUIRED(cs) { double priority_delta{0}; ApplyDeltas(hash, priority_delta, fee_delta); }
     void ClearPrioritisation(const Txid& hash) EXCLUSIVE_LOCKS_REQUIRED(cs);
     struct delta_info {
@@ -466,6 +494,7 @@ public:
         const bool in_mempool;
         /** The fee delta added using PrioritiseTransaction(). */
         const CAmount delta;
+        const double priority_delta;
         /** The modified fee (base fee + delta) of this entry. Only present if in_mempool=true. */
         std::optional<CAmount> modified_fee;
         /** The prioritised transaction's txid. */
@@ -661,6 +690,8 @@ public:
     std::vector<CTxMemPoolEntryRef> entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs);
     std::vector<TxMempoolInfo> infoAll() const;
+    void FindScriptPubKey(const std::set<CScript>& needles, std::map<COutPoint, Coin>& out_results);
     size_t DynamicMemoryUsage() const;
     /** Adds a transaction to the unbroadcast set */
@@ -821,7 +852,12 @@ public:
         using TxHandle = CTxMemPool::txiter;
-        TxHandle 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);
+        TxHandle StageAddition(const CTransactionRef& tx, const CAmount fee, int64_t time, unsigned int entry_height, uint64_t entry_sequence, CoinAgeCache coin_age_cache, bool spends_coinbase, int32_t extra_weight, int64_t sigops_cost, LockPoints lp);
+        TxHandle 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)
+        {
+            return StageAddition(tx, fee, time, entry_height, entry_sequence, COIN_AGE_CACHE_ZERO,
+                                 spends_coinbase, /*extra_weight=*/0, sigops_cost, lp);
+        }
         void StageRemoval(CTxMemPool::txiter it) { m_to_remove.insert(it); }
         const CTxMemPool::setEntries& GetRemovals() const { return m_to_remove; }
@@ -862,9 +898,9 @@ public:
         void Apply() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    private:
         CTxMemPool* m_pool;
         CTxMemPool::indexed_transaction_set m_to_add;
+    private:
         std::vector<CTxMemPool::txiter> m_entry_vec; // track the added transactions' insertion order
         // map from the m_to_add index to the ancestors for the transaction
         std::map<CTxMemPool::txiter, CTxMemPool::setEntries, CompareIteratorByHash> m_ancestors;
@@ -912,6 +948,9 @@ private:
  * It also allows you to sign a double-spend directly in
  * signrawtransactionwithkey and signrawtransactionwithwallet,
  * as long as the conflicting transaction is not yet confirmed.
+ *
+ * Its Cursor also doesn't work. In general, it is broken as a CCoinsView
+ * implementation outside of a few use cases.
  */
 class CCoinsViewMemPool : public CCoinsViewBacked
 {