multi: avoid calculating next block target ourselves

Fetch directly from Core instead. Calculation has been broken on signets
with shorter block times: https://github.com/LayerTwo-Labs/bip300301_enforcer/blob/a30226f2c1c937bef99744ae8d9ab3761f43c844/lib/wallet/mine.rs#L612-L633

Author: torkelrogstad

app/main.rs

@@ -100,7 +100,6 @@ async fn main() -> anyhow::Result<()> {
         let shutdown_signal = shutdown_rx.map(|_: Result<_, _>| ());
         mempool::init_sync_mempool(
             &mut enforcer,
-            network,
             rpc_client.clone(),
             &cli.node_zmq_addr_sequence,
             shutdown_signal.fuse(),

integration_tests/setup.rs

@@ -4,7 +4,7 @@
 use std::{collections::HashSet, path::PathBuf, sync::Arc, time::Duration};
 
 use anyhow::Context;
-use bitcoin::{Address, BlockHash, Network, Txid};
+use bitcoin::{Address, BlockHash, Txid};
 use cusf_enforcer_mempool::{
     cusf_enforcer::CusfEnforcer,
     mempool::{self, MempoolSync, SyncTaskError},
@@ -194,7 +194,6 @@ where
 {
     let mempool_synced = mempool::init_sync_mempool(
         &mut enforcer,
-        Network::Regtest,
         node.rpc_client.clone(),
         &node.bitcoind.zmq_addr(),
         std::future::pending::<()>().fuse(),

lib/mempool/mod.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use bitcoin::{BlockHash, Network, Target, Transaction, Txid, Weight};
+use bitcoin::{BlockHash, Transaction, Txid, Weight};
 use bitcoin_jsonrpsee::client::{BlockTemplateTransaction, RawMempoolTxFees};
 use hashlink::{LinkedHashMap, LinkedHashSet};
 use imbl::{OrdMap, OrdSet, ordmap};
@@ -482,23 +482,21 @@ fn saturating_sub_weight(lhs: Weight, rhs: Weight) -> Weight {
 pub struct Mempool {
     by_ancestor_fee_rate: ByAncestorFeeRate,
     chain: Chain,
-    network: Network,
     /// Map of txs (which may not be in the mempool) to their direct child txs,
     /// which MUST be in the mempool
     tx_childs: TxChilds,
     txs: MempoolTxs,
 }
 
 impl Mempool {
-    fn new(network: Network, prev_blockhash: BlockHash) -> Self {
+    fn new(prev_blockhash: BlockHash) -> Self {
         let chain = Chain {
             tip: prev_blockhash,
             blocks: imbl::HashMap::new(),
         };
         Self {
             by_ancestor_fee_rate: ByAncestorFeeRate::default(),
             chain,
-            network,
             tx_childs: TxChilds::default(),
             txs: MempoolTxs::default(),
         }
@@ -508,34 +506,6 @@ impl Mempool {
         &self.chain.blocks[&self.chain.tip]
     }
 
-    /// Next target, if known
-    pub fn next_target(&self) -> Option<Target> {
-        let tip = self.tip();
-        let next_height = tip.height + 1;
-        let network_params = self.network.params();
-        if !network_params.no_pow_retargeting
-            && next_height % network_params.miner_confirmation_window == 0
-        {
-            if let Some(first_block_in_period) = self
-                .chain
-                .iter()
-                .nth(network_params.miner_confirmation_window as usize - 1)
-            {
-                let spacing = tip.time - first_block_in_period.time;
-                let res = bitcoin::CompactTarget::from_next_work_required(
-                    tip.compact_target,
-                    spacing as u64,
-                    network_params,
-                );
-                Some(res.into())
-            } else {
-                None
-            }
-        } else {
-            Some(tip.compact_target.into())
-        }
-    }
-
     /// Insert a tx into the mempool,
     /// stating conflicts with other txs due to reasons other than shared
     /// inputs.
@@ -979,7 +949,7 @@ impl Mempool {
 mod tests {
     use super::*;
     use bitcoin::{
-        Amount, Network, OutPoint, ScriptBuf, Sequence, TxIn, TxOut, Witness,
+        Amount, OutPoint, ScriptBuf, Sequence, TxIn, TxOut, Witness,
         absolute::LockTime, hashes::Hash as _, transaction::Version,
     };
 
@@ -1006,7 +976,7 @@ mod tests {
     }
 
     fn test_mempool() -> Mempool {
-        Mempool::new(Network::Regtest, BlockHash::all_zeros())
+        Mempool::new(BlockHash::all_zeros())
     }
 
     /// Reproduces the prod crash: inserting a tx whose `conflicts_with`

lib/mempool/sync/task.rs

@@ -1105,7 +1105,6 @@ pub async fn init_sync_mempool<
     ShutdownSignal,
 >(
     mut enforcer: Enforcer,
-    network: bitcoin::Network,
     rpc_client: RpcClient,
     zmq_addr_sequence: &str,
     // Would it be better to return a Some/None, indicating sync stoppage?
@@ -1137,7 +1136,7 @@ where
     let inner = MempoolSyncInner {
         abandoned_pool: AbandonedPool::default(),
         enforcer,
-        mempool: Mempool::new(network, best_block_hash),
+        mempool: Mempool::new(best_block_hash),
         unfiltered_mempool: UnfilteredMempool {
             tip: best_block_hash,
             txs: HashSet::new(),

lib/server.rs

@@ -565,7 +565,6 @@ async fn block_txs<const COINBASE_TXN: bool, BP>(
 }
 
 struct MempoolQueryOutput {
-    target: Option<bitcoin::Target>,
     prev_blockhash: BlockHash,
     tip_block_mediantime: u32,
     tip_block_height: u32,
@@ -607,7 +606,6 @@ where
         (None, block_txs, None)
     };
     Ok(MempoolQueryOutput {
-        target: mempool.next_target(),
         prev_blockhash: tip_block.hash,
         tip_block_mediantime: tip_block.mediantime,
         tip_block_height: tip_block.height,
@@ -704,7 +702,6 @@ where
                 internal_error(err)
             })?;
         let MempoolQueryOutput {
-            target,
             prev_blockhash,
             tip_block_mediantime,
             tip_block_height,
@@ -722,9 +719,11 @@ where
                 self.known_targets.read().get(&prev_blockhash).copied();
             if let Some(target) = known_target {
                 target
-            } else if let Some(target) = target {
-                target
             } else {
+                // We used to calculate the next block's target here. This didn't
+                // work with signets with custom block times. Instead we always
+                // read directly from Core. This only happens 1 time per chain tip,
+                // so the performance impact is negligible.
                 let mining_info = self
                     .rpc_client
                     .get_mining_info()