CRC: use lazyLock instead of OnceLock for static sync global variable

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stacks-common/src/types/mod.rs

@@ -18,7 +18,7 @@ use std::cell::LazyCell;
 use std::cmp::Ordering;
 use std::fmt;
 use std::ops::{Deref, DerefMut, Index, IndexMut};
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
 #[cfg(feature = "canonical")]
 pub mod sqlite;
@@ -136,75 +136,60 @@ pub struct CoinbaseInterval {
 // The above is for mainnet, which has a burnchain year of 52596 blocks and starts at burnchain height 666050.
 
 /// Mainnet coinbase intervals, as of SIP-029
-// This static value is lazily initialized using `OnceLock` to avoid unnecessary
-// computation at program startup while ensuring thread safety and one-time initialization.
-// The intervals define the emission schedule for mainnet and are validated at runtime.
-pub static COINBASE_INTERVALS_MAINNET: OnceLock<[CoinbaseInterval; 5]> = OnceLock::new();
-
-pub fn get_coinbase_intervals_mainnet() -> &'static [CoinbaseInterval; 5] {
-    COINBASE_INTERVALS_MAINNET.get_or_init(|| {
-        let emissions_schedule = [
-            CoinbaseInterval {
-                coinbase: 1_000 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 0,
-            },
-            CoinbaseInterval {
-                coinbase: 500 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 278_950,
-            },
-            CoinbaseInterval {
-                coinbase: 250 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 383_950,
-            },
-            CoinbaseInterval {
-                coinbase: 125 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 593_950,
-            },
-            CoinbaseInterval {
-                coinbase: (625 * u128::from(MICROSTACKS_PER_STACKS)) / 10,
-                effective_start_height: 803_950,
-            },
-        ];
-        assert!(CoinbaseInterval::check_order(&emissions_schedule));
-        emissions_schedule
-    })
-}
-
-/// Testnet coinbase intervals as defined by SIP-029.
-///
-/// This static value is lazily initialized using `OnceLock` to avoid unnecessary
-/// computation at program startup while ensuring thread safety and one-time initialization.
-/// The intervals define the emission schedule for testnet and are validated at runtime.
-pub static COINBASE_INTERVALS_TESTNET: OnceLock<[CoinbaseInterval; 5]> = OnceLock::new();
-
-pub fn get_coinbase_intervals_testnet() -> &'static [CoinbaseInterval; 5] {
-    COINBASE_INTERVALS_TESTNET.get_or_init(|| {
-        let emissions_schedule = [
-            CoinbaseInterval {
-                coinbase: 1_000 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 0,
-            },
-            CoinbaseInterval {
-                coinbase: 500 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 77_777,
-            },
-            CoinbaseInterval {
-                coinbase: 250 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 77_777 * 7,
-            },
-            CoinbaseInterval {
-                coinbase: 125 * u128::from(MICROSTACKS_PER_STACKS),
-                effective_start_height: 77_777 * 14,
-            },
-            CoinbaseInterval {
-                coinbase: (625 * u128::from(MICROSTACKS_PER_STACKS)) / 10,
-                effective_start_height: 77_777 * 21,
-            },
-        ];
-        assert!(CoinbaseInterval::check_order(&emissions_schedule));
-        emissions_schedule
-    })
-}
+pub static COINBASE_INTERVALS_MAINNET: LazyLock<[CoinbaseInterval; 5]> = LazyLock::new(|| {
+    let emissions_schedule = [
+        CoinbaseInterval {
+            coinbase: 1_000 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 0,
+        },
+        CoinbaseInterval {
+            coinbase: 500 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 278_950,
+        },
+        CoinbaseInterval {
+            coinbase: 250 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 383_950,
+        },
+        CoinbaseInterval {
+            coinbase: 125 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 593_950,
+        },
+        CoinbaseInterval {
+            coinbase: (625 * u128::from(MICROSTACKS_PER_STACKS)) / 10,
+            effective_start_height: 803_950,
+        },
+    ];
+    assert!(CoinbaseInterval::check_order(&emissions_schedule));
+    emissions_schedule
+});
+
+/// Testnet coinbase intervals, as of SIP-029
+pub static COINBASE_INTERVALS_TESTNET: LazyLock<[CoinbaseInterval; 5]> = LazyLock::new(|| {
+    let emissions_schedule = [
+        CoinbaseInterval {
+            coinbase: 1_000 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 0,
+        },
+        CoinbaseInterval {
+            coinbase: 500 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 77_777,
+        },
+        CoinbaseInterval {
+            coinbase: 250 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 77_777 * 7,
+        },
+        CoinbaseInterval {
+            coinbase: 125 * u128::from(MICROSTACKS_PER_STACKS),
+            effective_start_height: 77_777 * 14,
+        },
+        CoinbaseInterval {
+            coinbase: (625 * u128::from(MICROSTACKS_PER_STACKS)) / 10,
+            effective_start_height: 77_777 * 21,
+        },
+    ];
+    assert!(CoinbaseInterval::check_order(&emissions_schedule));
+    emissions_schedule
+});
 
 /// Used for testing to substitute a coinbase schedule
 #[cfg(any(test, feature = "testing"))]
@@ -500,18 +485,18 @@ impl StacksEpochId {
         }
 
         if mainnet {
-            get_coinbase_intervals_mainnet().to_vec()
+            COINBASE_INTERVALS_MAINNET.to_vec()
         } else {
-            get_coinbase_intervals_testnet().to_vec()
+            COINBASE_INTERVALS_TESTNET.to_vec()
         }
     }
 
     #[cfg(not(any(test, feature = "testing")))]
     pub(crate) fn get_coinbase_intervals(mainnet: bool) -> Vec<CoinbaseInterval> {
         if mainnet {
-            get_coinbase_intervals_mainnet().to_vec()
+            COINBASE_INTERVALS_MAINNET.to_vec()
         } else {
-            get_coinbase_intervals_testnet().to_vec()
+            COINBASE_INTERVALS_TESTNET.to_vec()
         }
     }
 

stacks-common/src/types/tests.rs

@@ -18,166 +18,163 @@ use super::{
     set_test_coinbase_schedule, CoinbaseInterval, StacksEpochId, COINBASE_INTERVALS_MAINNET,
     COINBASE_INTERVALS_TESTNET,
 };
-use crate::types::{get_coinbase_intervals_mainnet, get_coinbase_intervals_testnet};
 
 #[test]
 fn test_mainnet_coinbase_emissions() {
-    let coinbase_intervals_mainnet = get_coinbase_intervals_mainnet();
-    assert_eq!(coinbase_intervals_mainnet.len(), 5);
-    assert_eq!(coinbase_intervals_mainnet[0].coinbase, 1_000_000_000);
-    assert_eq!(coinbase_intervals_mainnet[1].coinbase, 500_000_000);
-    assert_eq!(coinbase_intervals_mainnet[2].coinbase, 250_000_000);
-    assert_eq!(coinbase_intervals_mainnet[3].coinbase, 125_000_000);
-    assert_eq!(coinbase_intervals_mainnet[4].coinbase, 62_500_000);
+    assert_eq!(COINBASE_INTERVALS_MAINNET.len(), 5);
+    assert_eq!(COINBASE_INTERVALS_MAINNET[0].coinbase, 1_000_000_000);
+    assert_eq!(COINBASE_INTERVALS_MAINNET[1].coinbase, 500_000_000);
+    assert_eq!(COINBASE_INTERVALS_MAINNET[2].coinbase, 250_000_000);
+    assert_eq!(COINBASE_INTERVALS_MAINNET[3].coinbase, 125_000_000);
+    assert_eq!(COINBASE_INTERVALS_MAINNET[4].coinbase, 62_500_000);
 
     // heights from SIP-029
     assert_eq!(
-        coinbase_intervals_mainnet[0].effective_start_height,
+        COINBASE_INTERVALS_MAINNET[0].effective_start_height,
         666_050 - 666_050
     );
     assert_eq!(
-        coinbase_intervals_mainnet[1].effective_start_height,
+        COINBASE_INTERVALS_MAINNET[1].effective_start_height,
         945_000 - 666_050
     );
     assert_eq!(
-        coinbase_intervals_mainnet[2].effective_start_height,
+        COINBASE_INTERVALS_MAINNET[2].effective_start_height,
         1_050_000 - 666_050
     );
     assert_eq!(
-        coinbase_intervals_mainnet[3].effective_start_height,
+        COINBASE_INTERVALS_MAINNET[3].effective_start_height,
         1_260_000 - 666_050
     );
     assert_eq!(
-        coinbase_intervals_mainnet[4].effective_start_height,
+        COINBASE_INTERVALS_MAINNET[4].effective_start_height,
         1_470_000 - 666_050
     );
 }
 
 #[test]
 fn test_get_coinbase_at_effective_height() {
-    let coinbase_intervals_mainnet = get_coinbase_intervals_mainnet();
-    assert!(CoinbaseInterval::check_order(coinbase_intervals_mainnet));
+    assert!(CoinbaseInterval::check_order(&*COINBASE_INTERVALS_MAINNET));
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             666050 - 666050
         ),
         1_000_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             666051 - 666050
         ),
         1_000_000_000
     );
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             944_999 - 666050
         ),
         1_000_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             945_000 - 666050
         ),
         500_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             945_001 - 666050
         ),
         500_000_000
     );
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_049_999 - 666050
         ),
         500_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_050_000 - 666050
         ),
         250_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_050_001 - 666050
         ),
         250_000_000
     );
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_259_999 - 666050
         ),
         250_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_260_000 - 666050
         ),
         125_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_260_001 - 666050
         ),
         125_000_000
     );
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_469_999 - 666050
         ),
         125_000_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_470_000 - 666050
         ),
         62_500_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             1_470_001 - 666050
         ),
         62_500_000
     );
 
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             2_197_559 - 666050
         ),
         62_500_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             2_197_560 - 666050
         ),
         62_500_000
     );
     assert_eq!(
         CoinbaseInterval::get_coinbase_at_effective_height(
-            coinbase_intervals_mainnet,
+            &*COINBASE_INTERVALS_MAINNET,
             2_197_561 - 666050
         ),
         62_500_000
@@ -330,11 +327,11 @@ fn test_set_coinbase_intervals() {
 
     assert_eq!(
         StacksEpochId::get_coinbase_intervals(true),
-        get_coinbase_intervals_mainnet()
+        *COINBASE_INTERVALS_MAINNET
     );
     assert_eq!(
         StacksEpochId::get_coinbase_intervals(false),
-        get_coinbase_intervals_testnet()
+        *COINBASE_INTERVALS_TESTNET
     );
 
     set_test_coinbase_schedule(Some(new_sched.clone()));
@@ -346,10 +343,10 @@ fn test_set_coinbase_intervals() {
 
     assert_eq!(
         StacksEpochId::get_coinbase_intervals(true),
-        get_coinbase_intervals_mainnet()
+        *COINBASE_INTERVALS_MAINNET
     );
     assert_eq!(
         StacksEpochId::get_coinbase_intervals(false),
-        get_coinbase_intervals_testnet()
+        *COINBASE_INTERVALS_TESTNET
     );
 }