Testnet-11 final adjustments (#214)

* just a minor unavoidable refactor

* lim rothschild rates

* finalize merge depth bound constant

* mildly reduce cache sizes

* finalize pruning depth

* finalize daa constants

Author: michaelsutton

consensus/core/src/config/bps.rs

@@ -68,9 +68,7 @@ impl<const BPS: u64> Bps<BPS> {
     }
 
     pub const fn merge_depth_bound() -> u64 {
-        // Merge depth bound needs to be upper-bounded by DAA window *block duration* in order to prevent merging
-        // low-difficulty side-chains. TODO: finalize and decide if to make it lower
-        BPS * NEW_DIFFICULTY_WINDOW_DURATION
+        BPS * MERGE_DEPTH_DURATION
     }
 
     pub const fn finality_depth() -> u64 {
@@ -79,9 +77,13 @@ impl<const BPS: u64> Bps<BPS> {
 
     pub const fn pruning_depth() -> u64 {
         // Based on the analysis at https://github.com/kaspanet/docs/blob/main/Reference/prunality/Prunality.pdf
-        // TODO: note that `Self::merge_depth_bound()` can replace one `Self::finality_depth()` unit, but for now we keep
-        // this calculation identical to the legacy calculation
-        Self::finality_depth() * 2 + 4 * Self::mergeset_size_limit() * Self::ghostdag_k() as u64 + 2 * Self::ghostdag_k() as u64 + 2
+        // and on the decomposition of merge depth (rule R-I therein) from finality depth (φ)
+        // We add an additional merge depth unit as a safety margin for anticone finalization
+        Self::finality_depth()
+            + Self::merge_depth_bound() * 2
+            + 4 * Self::mergeset_size_limit() * Self::ghostdag_k() as u64
+            + 2 * Self::ghostdag_k() as u64
+            + 2
     }
 
     pub const fn pruning_proof_m() -> u64 {

consensus/core/src/config/constants.rs

@@ -57,21 +57,22 @@ pub mod consensus {
     //
 
     /// Minimal size of the difficulty window. Affects the DA algorithm only at the starting period of a new net
-    pub const MIN_DIFFICULTY_WINDOW_LEN: usize = 2;
+    pub const MIN_DIFFICULTY_WINDOW_LEN: usize = 10;
 
     /// **Legacy** difficulty adjustment window size corresponding to ~46 minutes with 1 BPS
     pub const LEGACY_DIFFICULTY_WINDOW_SIZE: usize = 2641;
 
     /// **New** difficulty window duration expressed in time units (seconds).
     /// TODO: KIP-0004: 30,000 (500 minutes)
-    pub const NEW_DIFFICULTY_WINDOW_DURATION: u64 = 2000;
+    pub const NEW_DIFFICULTY_WINDOW_DURATION: u64 = 2641;
 
     /// The desired interval between samples of the difficulty window (seconds).
     /// TODO: KIP-0004: 30 seconds
-    pub const DIFFICULTY_WINDOW_SAMPLE_INTERVAL: u64 = 2;
+    pub const DIFFICULTY_WINDOW_SAMPLE_INTERVAL: u64 = 4;
 
     /// Size of the **sampled** difficulty window (independent of BPS)
-    pub const DIFFICULTY_SAMPLED_WINDOW_SIZE: u64 = NEW_DIFFICULTY_WINDOW_DURATION / DIFFICULTY_WINDOW_SAMPLE_INTERVAL;
+    pub const DIFFICULTY_SAMPLED_WINDOW_SIZE: u64 =
+        (NEW_DIFFICULTY_WINDOW_DURATION + DIFFICULTY_WINDOW_SAMPLE_INTERVAL - 1) / DIFFICULTY_WINDOW_SAMPLE_INTERVAL;
 
     //
     // ~~~~~~~~~~~~~~~~~~~ Finality & Pruning ~~~~~~~~~~~~~~~~~~~
@@ -84,6 +85,14 @@ pub mod consensus {
     /// TODO: finalize this value (consider 6-24 hours)
     pub const NEW_FINALITY_DURATION: u64 = 43_200; // 12 hours
 
+    /// Merge depth bound duration (in seconds). For 1 BPS networks this equals the legacy depth
+    /// bound in block units. For higher BPS networks this should be scaled up.
+    ///
+    /// This number should be roughly equal to DAA window duration in order to prevent merging
+    /// low-difficulty side-chains (up to ~2x over DAA duration is still reasonable since creating
+    /// a mergeable low-difficulty side-chain within this bound requires a significant hashrate fraction)
+    pub const MERGE_DEPTH_DURATION: u64 = 3600;
+
     /// The value of the pruning proof `M` parameter
     pub const PRUNING_PROOF_M: u64 = 1000;
 
@@ -105,6 +114,8 @@ pub mod perf {
     use kaspa_hashes::Hash;
     use std::mem::size_of;
 
+    use super::consensus::NETWORK_DELAY_BOUND;
+
     /// The default target depth for reachability reindexes.
     pub const DEFAULT_REINDEX_DEPTH: u64 = 100;
 
@@ -188,17 +199,15 @@ pub mod perf {
     }
 
     pub fn approx_direct_header_parents(consensus_params: &Params) -> usize {
-        let avg_delay = 2;
-        consensus_params.bps() as usize * avg_delay
+        consensus_params.bps() as usize * NETWORK_DELAY_BOUND as usize
     }
 
     pub fn approx_header_parents(consensus_params: &Params) -> usize {
-        approx_direct_header_parents(consensus_params) * 2 // 2x for multi-levels
+        approx_direct_header_parents(consensus_params) * 4 // 4x for multi-levels
     }
 
     pub fn approx_mergeset_size(consensus_params: &Params) -> usize {
-        let avg_delay = 2;
-        consensus_params.bps() as usize * avg_delay
+        consensus_params.bps() as usize * NETWORK_DELAY_BOUND as usize
     }
 }
 

mining/src/manager_tests.rs

@@ -865,15 +865,11 @@ mod tests {
         count: usize,
     ) -> (Vec<Transaction>, Vec<Transaction>) {
         // Make the funding amounts always different so that funding txs have different ids
-        let parent_child_pairs = (0..count)
+        (0..count)
             .map(|i| {
                 create_parent_and_children_transactions(consensus, vec![500 * SOMPI_PER_KASPA, 3_000 * SOMPI_PER_KASPA + i as u64])
             })
-            .collect::<Vec<(_, _)>>();
-        let parent_txs = parent_child_pairs.iter().map(|(p, _)| p.clone()).collect::<Vec<_>>();
-        let child_txs = parent_child_pairs.iter().map(|(_, c)| c.clone()).collect::<Vec<_>>();
-
-        (parent_txs, child_txs)
+            .unzip()
     }
 
     fn create_parent_and_children_transactions(

rothschild/src/main.rs

@@ -128,7 +128,7 @@ async fn main() {
     );
 
     let mut utxos = refresh_utxos(&rpc_client, kaspa_addr.clone(), &mut pending, coinbase_maturity).await;
-    let mut ticker = interval(Duration::from_secs_f64(1.0 / (args.tps as f64)));
+    let mut ticker = interval(Duration::from_secs_f64(1.0 / (args.tps.min(100) as f64)));
     ticker.set_missed_tick_behavior(MissedTickBehavior::Burst);
 
     let mut maximize_inputs = false;
@@ -173,7 +173,7 @@ fn should_maximize_inputs(
 async fn pause_if_mempool_is_full(rpc_client: &GrpcClient) {
     loop {
         let mempool_size = rpc_client.get_info().await.unwrap().mempool_size;
-        if mempool_size < 100_000 {
+        if mempool_size < 10_000 {
             break;
         }