Introduce waitFeesChanged() mining interface

Sjors · Sjors · commit a87589abfde4 · 2024-09-30T20:12:16.000+02:00
diff --git a/src/interfaces/mining.h b/src/interfaces/mining.h
@@ -71,6 +71,18 @@ class Mining
      */
     virtual BlockRef waitTipChanged(uint256 current_tip, MillisecondsDouble timeout = MillisecondsDouble::max()) = 0;
 
+    /**
+     * Waits for fees in the next block to rise, a new tip or the timeout.
+     *
+     * @param[in] current_tip   block hash that the most recent template builds on
+     * @param[in] fee_threshold how far total fees for the next block should rise (currently ignored)
+     * @param[in] options       options for creating the block, should match those
+     *                          passed to createNewBlock (currently ignored)
+     *
+     * @returns true if fees increased, false if a new tip arrives or the timeout occurs
+     */
+    virtual bool waitFeesChanged(uint256 current_tip, CAmount fee_threshold, const node::BlockCreateOptions& options = {}, MillisecondsDouble timeout = MillisecondsDouble::max()) = 0;
+
    /**
      * Construct a new block template
      *
diff --git a/src/ipc/capnp/mining.capnp b/src/ipc/capnp/mining.capnp
@@ -17,10 +17,11 @@ interface Mining $Proxy.wrap("interfaces::Mining") {
     isInitialBlockDownload @1 (context :Proxy.Context) -> (result: Bool);
     getTip @2 (context :Proxy.Context) -> (result: Common.BlockRef, hasResult: Bool);
     waitTipChanged @3 (context :Proxy.Context, currentTip: Data, timeout: Float64) -> (result: Common.BlockRef);
-    createNewBlock @4 (scriptPubKey: Data, options: BlockCreateOptions) -> (result: BlockTemplate);
-    processNewBlock @5 (context :Proxy.Context, block: Data) -> (newBlock: Bool, result: Bool);
-    getTransactionsUpdated @6 (context :Proxy.Context) -> (result: UInt32);
-    testBlockValidity @7 (context :Proxy.Context, block: Data, checkMerkleRoot: Bool) -> (state: BlockValidationState, result: Bool);
+    waitFeesChanged @4 (context :Proxy.Context, currentTip: Data, feeThreshold: Int64, options: BlockCreateOptions, timeout: Float64) -> (result: Bool);
+    createNewBlock @5 (scriptPubKey: Data, options: BlockCreateOptions) -> (result: BlockTemplate);
+    processNewBlock @6 (context :Proxy.Context, block: Data) -> (newBlock: Bool, result: Bool);
+    getTransactionsUpdated @7 (context :Proxy.Context) -> (result: UInt32);
+    testBlockValidity @8 (context :Proxy.Context, block: Data, checkMerkleRoot: Bool) -> (state: BlockValidationState, result: Bool);
 }
 
 interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
@@ -957,6 +957,35 @@ class MinerImpl : public Mining
         return BlockRef{chainman().ActiveChain().Tip()->GetBlockHash(), chainman().ActiveChain().Tip()->nHeight};
     }
 
+    bool waitFeesChanged(uint256 current_tip, CAmount fee_threshold, const BlockCreateOptions& options, MillisecondsDouble timeout) override
+    {
+        if (timeout > std::chrono::years{100}) timeout = std::chrono::years{100}; // Upper bound to avoid UB in std::chrono
+        auto now{std::chrono::steady_clock::now()};
+        const auto deadline = now + timeout;
+        const MillisecondsDouble tick{1000};
+
+        unsigned int last_mempool_update{context()->mempool->GetTransactionsUpdated()};
+
+        BlockAssembler::Options assemble_options{options};
+        ApplyArgsManOptions(*Assert(m_node.args), assemble_options);
+
+        while (!chainman().m_interrupt) {
+            now = std::chrono::steady_clock::now();
+            if (now >= deadline) break;
+
+            if (getTip().value().hash != current_tip) {
+                return false;
+            }
+
+            // TODO: when cluster mempool is available, actually calculate
+            // fees for the next block. This is currently too expensive.
+            if (context()->mempool->GetTransactionsUpdated() > last_mempool_update) return true;
+
+            std::this_thread::sleep_until(std::min(deadline, now + tick));
+        }
+        return false;
+    }
+
     bool processNewBlock(const std::shared_ptr<const CBlock>& block, bool* new_block) override
     {
         return chainman().ProcessNewBlock(block, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/new_block);
