diff --git a/consensus/core/src/config/params.rs b/consensus/core/src/config/params.rs
index f3479b4c2..9c4a500e5 100644
--- a/consensus/core/src/config/params.rs
+++ b/consensus/core/src/config/params.rs
@@ -15,6 +15,33 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ForkActivation(u64);
+
+impl ForkActivation {
+    pub const fn new(daa_score: u64) -> Self {
+        Self(daa_score)
+    }
+
+    pub const fn never() -> Self {
+        Self(u64::MAX)
+    }
+
+    pub const fn always() -> Self {
+        Self(0)
+    }
+
+    pub fn is_active(self, current_daa_score: u64) -> bool {
+        current_daa_score >= self.0
+    }
+
+    /// Checks if the fork was "recently" activated, i.e., in the time frame of the provided range.
+    /// This function returns false for forks that were always active, since they were never activated.
+    pub fn is_within_range_from_activation(self, current_daa_score: u64, range: u64) -> bool {
+        self != Self::always() && self.is_active(current_daa_score) && current_daa_score < self.0 + range
+    }
+}
+
 /// Consensus parameters. Contains settings and configurations which are consensus-sensitive.
 /// Changing one of these on a network node would exclude and prevent it from reaching consensus
 /// with the other unmodified nodes.
@@ -41,7 +68,7 @@ pub struct Params {
     pub target_time_per_block: u64,
 
     /// DAA score from which the window sampling starts for difficulty and past median time calculation
-    pub sampling_activation_daa_score: u64,
+    pub sampling_activation: ForkActivation,
 
     /// Defines the highest allowed proof of work difficulty value for a block as a [`Uint256`]
     pub max_difficulty_target: Uint256,
@@ -81,7 +108,7 @@ pub struct Params {
     pub storage_mass_parameter: u64,
 
     /// DAA score from which storage mass calculation and transaction mass field are activated as a consensus rule
-    pub storage_mass_activation_daa_score: u64,
+    pub storage_mass_activation: ForkActivation,
 
     /// DAA score after which the pre-deflationary period switches to the deflationary period
     pub deflationary_phase_daa_score: u64,
@@ -117,10 +144,10 @@ impl Params {
     #[inline]
     #[must_use]
     pub fn past_median_time_window_size(&self, selected_parent_daa_score: u64) -> usize {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            self.legacy_past_median_time_window_size()
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.sampled_past_median_time_window_size()
+        } else {
+            self.legacy_past_median_time_window_size()
         }
     }
 
@@ -129,10 +156,10 @@ impl Params {
     #[inline]
     #[must_use]
     pub fn timestamp_deviation_tolerance(&self, selected_parent_daa_score: u64) -> u64 {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            self.legacy_timestamp_deviation_tolerance
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.new_timestamp_deviation_tolerance
+        } else {
+            self.legacy_timestamp_deviation_tolerance
         }
     }
 
@@ -141,10 +168,10 @@ impl Params {
     #[inline]
     #[must_use]
     pub fn past_median_time_sample_rate(&self, selected_parent_daa_score: u64) -> u64 {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            1
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.past_median_time_sample_rate
+        } else {
+            1
         }
     }
 
@@ -153,10 +180,10 @@ impl Params {
     #[inline]
     #[must_use]
     pub fn difficulty_window_size(&self, selected_parent_daa_score: u64) -> usize {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            self.legacy_difficulty_window_size
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.sampled_difficulty_window_size
+        } else {
+            self.legacy_difficulty_window_size
         }
     }
 
@@ -165,10 +192,10 @@ impl Params {
     #[inline]
     #[must_use]
     pub fn difficulty_sample_rate(&self, selected_parent_daa_score: u64) -> u64 {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            1
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.difficulty_sample_rate
+        } else {
+            1
         }
     }
 
@@ -188,18 +215,18 @@ impl Params {
     }
 
     pub fn daa_window_duration_in_blocks(&self, selected_parent_daa_score: u64) -> u64 {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            self.legacy_difficulty_window_size as u64
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.difficulty_sample_rate * self.sampled_difficulty_window_size as u64
+        } else {
+            self.legacy_difficulty_window_size as u64
         }
     }
 
     fn expected_daa_window_duration_in_milliseconds(&self, selected_parent_daa_score: u64) -> u64 {
-        if selected_parent_daa_score < self.sampling_activation_daa_score {
-            self.target_time_per_block * self.legacy_difficulty_window_size as u64
-        } else {
+        if self.sampling_activation.is_active(selected_parent_daa_score) {
             self.target_time_per_block * self.difficulty_sample_rate * self.sampled_difficulty_window_size as u64
+        } else {
+            self.target_time_per_block * self.legacy_difficulty_window_size as u64
         }
     }
 
@@ -322,7 +349,7 @@ pub const MAINNET_PARAMS: Params = Params {
     past_median_time_sample_rate: Bps::<1>::past_median_time_sample_rate(),
     past_median_time_sampled_window_size: MEDIAN_TIME_SAMPLED_WINDOW_SIZE,
     target_time_per_block: 1000,
-    sampling_activation_daa_score: u64::MAX,
+    sampling_activation: ForkActivation::never(),
     max_difficulty_target: MAX_DIFFICULTY_TARGET,
     max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
     difficulty_sample_rate: Bps::<1>::difficulty_adjustment_sample_rate(),
@@ -352,7 +379,7 @@ pub const MAINNET_PARAMS: Params = Params {
     max_block_mass: 500_000,
 
     storage_mass_parameter: STORAGE_MASS_PARAMETER,
-    storage_mass_activation_daa_score: u64::MAX,
+    storage_mass_activation: ForkActivation::never(),
 
     // deflationary_phase_daa_score is the DAA score after which the pre-deflationary period
     // switches to the deflationary period. This number is calculated as follows:
@@ -385,7 +412,7 @@ pub const TESTNET_PARAMS: Params = Params {
     past_median_time_sample_rate: Bps::<1>::past_median_time_sample_rate(),
     past_median_time_sampled_window_size: MEDIAN_TIME_SAMPLED_WINDOW_SIZE,
     target_time_per_block: 1000,
-    sampling_activation_daa_score: u64::MAX,
+    sampling_activation: ForkActivation::never(),
     max_difficulty_target: MAX_DIFFICULTY_TARGET,
     max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
     difficulty_sample_rate: Bps::<1>::difficulty_adjustment_sample_rate(),
@@ -415,7 +442,7 @@ pub const TESTNET_PARAMS: Params = Params {
     max_block_mass: 500_000,
 
     storage_mass_parameter: STORAGE_MASS_PARAMETER,
-    storage_mass_activation_daa_score: u64::MAX,
+    storage_mass_activation: ForkActivation::never(),
 
     // deflationary_phase_daa_score is the DAA score after which the pre-deflationary period
     // switches to the deflationary period. This number is calculated as follows:
@@ -447,7 +474,7 @@ pub const TESTNET11_PARAMS: Params = Params {
     legacy_timestamp_deviation_tolerance: LEGACY_TIMESTAMP_DEVIATION_TOLERANCE,
     new_timestamp_deviation_tolerance: NEW_TIMESTAMP_DEVIATION_TOLERANCE,
     past_median_time_sampled_window_size: MEDIAN_TIME_SAMPLED_WINDOW_SIZE,
-    sampling_activation_daa_score: 0, // Sampling is activated from network inception
+    sampling_activation: ForkActivation::always(), // Sampling is activated from network inception
     max_difficulty_target: MAX_DIFFICULTY_TARGET,
     max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
     sampled_difficulty_window_size: DIFFICULTY_SAMPLED_WINDOW_SIZE as usize,
@@ -485,7 +512,7 @@ pub const TESTNET11_PARAMS: Params = Params {
     max_block_mass: 500_000,
 
     storage_mass_parameter: STORAGE_MASS_PARAMETER,
-    storage_mass_activation_daa_score: 0,
+    storage_mass_activation: ForkActivation::always(),
 
     skip_proof_of_work: false,
     max_block_level: 250,
@@ -498,7 +525,7 @@ pub const SIMNET_PARAMS: Params = Params {
     legacy_timestamp_deviation_tolerance: LEGACY_TIMESTAMP_DEVIATION_TOLERANCE,
     new_timestamp_deviation_tolerance: NEW_TIMESTAMP_DEVIATION_TOLERANCE,
     past_median_time_sampled_window_size: MEDIAN_TIME_SAMPLED_WINDOW_SIZE,
-    sampling_activation_daa_score: 0, // Sampling is activated from network inception
+    sampling_activation: ForkActivation::always(), // Sampling is activated from network inception
     max_difficulty_target: MAX_DIFFICULTY_TARGET,
     max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
     sampled_difficulty_window_size: DIFFICULTY_SAMPLED_WINDOW_SIZE as usize,
@@ -538,7 +565,7 @@ pub const SIMNET_PARAMS: Params = Params {
     max_block_mass: 500_000,
 
     storage_mass_parameter: STORAGE_MASS_PARAMETER,
-    storage_mass_activation_daa_score: 0,
+    storage_mass_activation: ForkActivation::always(),
 
     skip_proof_of_work: true, // For simnet only, PoW can be simulated by default
     max_block_level: 250,
@@ -554,7 +581,7 @@ pub const DEVNET_PARAMS: Params = Params {
     past_median_time_sample_rate: Bps::<1>::past_median_time_sample_rate(),
     past_median_time_sampled_window_size: MEDIAN_TIME_SAMPLED_WINDOW_SIZE,
     target_time_per_block: 1000,
-    sampling_activation_daa_score: u64::MAX,
+    sampling_activation: ForkActivation::never(),
     max_difficulty_target: MAX_DIFFICULTY_TARGET,
     max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
     difficulty_sample_rate: Bps::<1>::difficulty_adjustment_sample_rate(),
@@ -584,7 +611,7 @@ pub const DEVNET_PARAMS: Params = Params {
     max_block_mass: 500_000,
 
     storage_mass_parameter: STORAGE_MASS_PARAMETER,
-    storage_mass_activation_daa_score: u64::MAX,
+    storage_mass_activation: ForkActivation::never(),
 
     // deflationary_phase_daa_score is the DAA score after which the pre-deflationary period
     // switches to the deflationary period. This number is calculated as follows:
diff --git a/consensus/src/consensus/mod.rs b/consensus/src/consensus/mod.rs
index 6909562aa..a47b4218f 100644
--- a/consensus/src/consensus/mod.rs
+++ b/consensus/src/consensus/mod.rs
@@ -257,7 +257,7 @@ impl Consensus {
             pruning_lock.clone(),
             notification_root.clone(),
             counters.clone(),
-            params.storage_mass_activation_daa_score,
+            params.storage_mass_activation,
         ));
 
         let virtual_processor = Arc::new(VirtualStateProcessor::new(
@@ -753,7 +753,7 @@ impl ConsensusApi for Consensus {
     }
 
     fn calc_transaction_hash_merkle_root(&self, txs: &[Transaction], pov_daa_score: u64) -> Hash {
-        let storage_mass_activated = pov_daa_score > self.config.storage_mass_activation_daa_score;
+        let storage_mass_activated = self.config.storage_mass_activation.is_active(pov_daa_score);
         calc_hash_merkle_root(txs.iter(), storage_mass_activated)
     }
 
diff --git a/consensus/src/consensus/services.rs b/consensus/src/consensus/services.rs
index 97c6d0b76..608ae61b4 100644
--- a/consensus/src/consensus/services.rs
+++ b/consensus/src/consensus/services.rs
@@ -94,7 +94,7 @@ impl ConsensusServices {
             storage.block_window_cache_for_past_median_time.clone(),
             params.max_difficulty_target,
             params.target_time_per_block,
-            params.sampling_activation_daa_score,
+            params.sampling_activation,
             params.legacy_difficulty_window_size,
             params.sampled_difficulty_window_size,
             params.min_difficulty_window_len,
@@ -146,7 +146,7 @@ impl ConsensusServices {
             params.coinbase_maturity,
             tx_script_cache_counters,
             mass_calculator.clone(),
-            params.storage_mass_activation_daa_score,
+            params.storage_mass_activation,
         );
 
         let pruning_point_manager = PruningPointManager::new(
diff --git a/consensus/src/pipeline/body_processor/body_validation_in_isolation.rs b/consensus/src/pipeline/body_processor/body_validation_in_isolation.rs
index c413552b9..4c6139846 100644
--- a/consensus/src/pipeline/body_processor/body_validation_in_isolation.rs
+++ b/consensus/src/pipeline/body_processor/body_validation_in_isolation.rs
@@ -6,7 +6,7 @@ use kaspa_consensus_core::{block::Block, merkle::calc_hash_merkle_root, tx::Tran
 
 impl BlockBodyProcessor {
     pub fn validate_body_in_isolation(self: &Arc<Self>, block: &Block) -> BlockProcessResult<u64> {
-        let storage_mass_activated = block.header.daa_score > self.storage_mass_activation_daa_score;
+        let storage_mass_activated = self.storage_mass_activation.is_active(block.header.daa_score);
 
         Self::check_has_transactions(block)?;
         Self::check_hash_merkle_root(block, storage_mass_activated)?;
diff --git a/consensus/src/pipeline/body_processor/processor.rs b/consensus/src/pipeline/body_processor/processor.rs
index 4191a01ce..6885c78b5 100644
--- a/consensus/src/pipeline/body_processor/processor.rs
+++ b/consensus/src/pipeline/body_processor/processor.rs
@@ -23,7 +23,7 @@ use crossbeam_channel::{Receiver, Sender};
 use kaspa_consensus_core::{
     block::Block,
     blockstatus::BlockStatus::{self, StatusHeaderOnly, StatusInvalid},
-    config::genesis::GenesisBlock,
+    config::{genesis::GenesisBlock, params::ForkActivation},
     mass::MassCalculator,
     tx::Transaction,
 };
@@ -81,7 +81,7 @@ pub struct BlockBodyProcessor {
     counters: Arc<ProcessingCounters>,
 
     /// Storage mass hardfork DAA score
-    pub(crate) storage_mass_activation_daa_score: u64,
+    pub(crate) storage_mass_activation: ForkActivation,
 }
 
 impl BlockBodyProcessor {
@@ -108,7 +108,7 @@ impl BlockBodyProcessor {
         pruning_lock: SessionLock,
         notification_root: Arc<ConsensusNotificationRoot>,
         counters: Arc<ProcessingCounters>,
-        storage_mass_activation_daa_score: u64,
+        storage_mass_activation: ForkActivation,
     ) -> Self {
         Self {
             receiver,
@@ -131,7 +131,7 @@ impl BlockBodyProcessor {
             task_manager: BlockTaskDependencyManager::new(),
             notification_root,
             counters,
-            storage_mass_activation_daa_score,
+            storage_mass_activation,
         }
     }
 
diff --git a/consensus/src/pipeline/virtual_processor/processor.rs b/consensus/src/pipeline/virtual_processor/processor.rs
index 4b571dddc..c654fef43 100644
--- a/consensus/src/pipeline/virtual_processor/processor.rs
+++ b/consensus/src/pipeline/virtual_processor/processor.rs
@@ -52,7 +52,7 @@ use kaspa_consensus_core::{
     block::{BlockTemplate, MutableBlock, TemplateBuildMode, TemplateTransactionSelector},
     blockstatus::BlockStatus::{StatusDisqualifiedFromChain, StatusUTXOValid},
     coinbase::MinerData,
-    config::genesis::GenesisBlock,
+    config::{genesis::GenesisBlock, params::ForkActivation},
     header::Header,
     merkle::calc_hash_merkle_root,
     pruning::PruningPointsList,
@@ -159,7 +159,7 @@ pub struct VirtualStateProcessor {
     counters: Arc<ProcessingCounters>,
 
     // Storage mass hardfork DAA score
-    pub(crate) storage_mass_activation_daa_score: u64,
+    pub(crate) storage_mass_activation: ForkActivation,
 }
 
 impl VirtualStateProcessor {
@@ -220,7 +220,7 @@ impl VirtualStateProcessor {
             pruning_lock,
             notification_root,
             counters,
-            storage_mass_activation_daa_score: params.storage_mass_activation_daa_score,
+            storage_mass_activation: params.storage_mass_activation,
         }
     }
 
@@ -983,7 +983,7 @@ impl VirtualStateProcessor {
         let parents_by_level = self.parents_manager.calc_block_parents(pruning_info.pruning_point, &virtual_state.parents);
 
         // Hash according to hardfork activation
-        let storage_mass_activated = virtual_state.daa_score > self.storage_mass_activation_daa_score;
+        let storage_mass_activated = self.storage_mass_activation.is_active(virtual_state.daa_score);
         let hash_merkle_root = calc_hash_merkle_root(txs.iter(), storage_mass_activated);
 
         let accepted_id_merkle_root = kaspa_merkle::calc_merkle_root(virtual_state.accepted_tx_ids.iter().copied());
diff --git a/consensus/src/pipeline/virtual_processor/utxo_validation.rs b/consensus/src/pipeline/virtual_processor/utxo_validation.rs
index 6daa3deb8..4a62a4ae8 100644
--- a/consensus/src/pipeline/virtual_processor/utxo_validation.rs
+++ b/consensus/src/pipeline/virtual_processor/utxo_validation.rs
@@ -14,6 +14,7 @@ use kaspa_consensus_core::{
     acceptance_data::{AcceptedTxEntry, MergesetBlockAcceptanceData},
     api::args::TransactionValidationArgs,
     coinbase::*,
+    config::params::ForkActivation,
     hashing,
     header::Header,
     mass::Kip9Version,
@@ -328,7 +329,8 @@ impl VirtualStateProcessor {
 
         // For non-activated nets (mainnet, TN10) we can update mempool rules to KIP9 beta asap. For
         // TN11 we need to hard-fork consensus first (since the new beta rules are more permissive)
-        let kip9_version = if self.storage_mass_activation_daa_score == u64::MAX { Kip9Version::Beta } else { Kip9Version::Alpha };
+        let kip9_version =
+            if self.storage_mass_activation == ForkActivation::never() { Kip9Version::Beta } else { Kip9Version::Alpha };
 
         // Calc the full contextual mass including storage mass
         let contextual_mass = self
diff --git a/consensus/src/processes/transaction_validator/mod.rs b/consensus/src/processes/transaction_validator/mod.rs
index 008b0c4dd..f9d9f79c8 100644
--- a/consensus/src/processes/transaction_validator/mod.rs
+++ b/consensus/src/processes/transaction_validator/mod.rs
@@ -11,7 +11,7 @@ use kaspa_txscript::{
     SigCacheKey,
 };
 
-use kaspa_consensus_core::mass::MassCalculator;
+use kaspa_consensus_core::{config::params::ForkActivation, mass::MassCalculator};
 
 #[derive(Clone)]
 pub struct TransactionValidator {
@@ -27,7 +27,7 @@ pub struct TransactionValidator {
     pub(crate) mass_calculator: MassCalculator,
 
     /// Storage mass hardfork DAA score
-    storage_mass_activation_daa_score: u64,
+    storage_mass_activation: ForkActivation,
 }
 
 impl TransactionValidator {
@@ -41,7 +41,7 @@ impl TransactionValidator {
         coinbase_maturity: u64,
         counters: Arc<TxScriptCacheCounters>,
         mass_calculator: MassCalculator,
-        storage_mass_activation_daa_score: u64,
+        storage_mass_activation: ForkActivation,
     ) -> Self {
         Self {
             max_tx_inputs,
@@ -53,7 +53,7 @@ impl TransactionValidator {
             coinbase_maturity,
             sig_cache: Cache::with_counters(10_000, counters),
             mass_calculator,
-            storage_mass_activation_daa_score,
+            storage_mass_activation,
         }
     }
 
@@ -77,7 +77,7 @@ impl TransactionValidator {
             coinbase_maturity,
             sig_cache: Cache::with_counters(10_000, counters),
             mass_calculator: MassCalculator::new(0, 0, 0, 0),
-            storage_mass_activation_daa_score: u64::MAX,
+            storage_mass_activation: ForkActivation::never(),
         }
     }
 }
diff --git a/consensus/src/processes/transaction_validator/transaction_validator_populated.rs b/consensus/src/processes/transaction_validator/transaction_validator_populated.rs
index dbf1aa37e..bbb74f0ae 100644
--- a/consensus/src/processes/transaction_validator/transaction_validator_populated.rs
+++ b/consensus/src/processes/transaction_validator/transaction_validator_populated.rs
@@ -44,11 +44,11 @@ impl TransactionValidator {
         let total_in = self.check_transaction_input_amounts(tx)?;
         let total_out = Self::check_transaction_output_values(tx, total_in)?;
         let fee = total_in - total_out;
-        if flags != TxValidationFlags::SkipMassCheck && pov_daa_score > self.storage_mass_activation_daa_score {
+        if flags != TxValidationFlags::SkipMassCheck && self.storage_mass_activation.is_active(pov_daa_score) {
             // Storage mass hardfork was activated
             self.check_mass_commitment(tx)?;
 
-            if pov_daa_score < self.storage_mass_activation_daa_score + 10 && self.storage_mass_activation_daa_score > 0 {
+            if self.storage_mass_activation.is_within_range_from_activation(pov_daa_score, 10) {
                 warn!("--------- Storage mass hardfork was activated successfully!!! --------- (DAA score: {})", pov_daa_score);
             }
         }
diff --git a/consensus/src/processes/window.rs b/consensus/src/processes/window.rs
index 9c582af28..ca0f71cf2 100644
--- a/consensus/src/processes/window.rs
+++ b/consensus/src/processes/window.rs
@@ -9,7 +9,7 @@ use crate::{
 };
 use kaspa_consensus_core::{
     blockhash::BlockHashExtensions,
-    config::genesis::GenesisBlock,
+    config::{genesis::GenesisBlock, params::ForkActivation},
     errors::{block::RuleError, difficulty::DifficultyResult},
     BlockHashSet, BlueWorkType,
 };
@@ -249,7 +249,7 @@ pub struct SampledWindowManager<T: GhostdagStoreReader, U: BlockWindowCacheReade
     block_window_cache_for_difficulty: Arc<U>,
     block_window_cache_for_past_median_time: Arc<U>,
     target_time_per_block: u64,
-    sampling_activation_daa_score: u64,
+    sampling_activation: ForkActivation,
     difficulty_window_size: usize,
     difficulty_sample_rate: u64,
     past_median_time_window_size: usize,
@@ -269,7 +269,7 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W:
         block_window_cache_for_past_median_time: Arc<U>,
         max_difficulty_target: Uint256,
         target_time_per_block: u64,
-        sampling_activation_daa_score: u64,
+        sampling_activation: ForkActivation,
         difficulty_window_size: usize,
         min_difficulty_window_len: usize,
         difficulty_sample_rate: u64,
@@ -294,7 +294,7 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W:
             block_window_cache_for_difficulty,
             block_window_cache_for_past_median_time,
             target_time_per_block,
-            sampling_activation_daa_score,
+            sampling_activation,
             difficulty_window_size,
             difficulty_sample_rate,
             past_median_time_window_size,
@@ -525,7 +525,7 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W:
 pub struct DualWindowManager<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W: DaaStoreReader> {
     ghostdag_store: Arc<T>,
     headers_store: Arc<V>,
-    sampling_activation_daa_score: u64,
+    sampling_activation: ForkActivation,
     full_window_manager: FullWindowManager<T, U, V>,
     sampled_window_manager: SampledWindowManager<T, U, V, W>,
 }
@@ -541,7 +541,7 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W:
         block_window_cache_for_past_median_time: Arc<U>,
         max_difficulty_target: Uint256,
         target_time_per_block: u64,
-        sampling_activation_daa_score: u64,
+        sampling_activation: ForkActivation,
         full_difficulty_window_size: usize,
         sampled_difficulty_window_size: usize,
         min_difficulty_window_len: usize,
@@ -571,19 +571,19 @@ impl<T: GhostdagStoreReader, U: BlockWindowCacheReader, V: HeaderStoreReader, W:
             block_window_cache_for_past_median_time,
             max_difficulty_target,
             target_time_per_block,
-            sampling_activation_daa_score,
+            sampling_activation,
             sampled_difficulty_window_size,
             min_difficulty_window_len.min(sampled_difficulty_window_size),
             difficulty_sample_rate,
             sampled_past_median_time_window_size,
             past_median_time_sample_rate,
         );
-        Self { ghostdag_store, headers_store, sampled_window_manager, full_window_manager, sampling_activation_daa_score }
+        Self { ghostdag_store, headers_store, sampled_window_manager, full_window_manager, sampling_activation }
     }
 
     fn sampling(&self, ghostdag_data: &GhostdagData) -> bool {
         let sp_daa_score = self.headers_store.get_daa_score(ghostdag_data.selected_parent).unwrap();
-        sp_daa_score >= self.sampling_activation_daa_score
+        self.sampling_activation.is_active(sp_daa_score)
     }
 }
 
diff --git a/simpa/src/main.rs b/simpa/src/main.rs
index 2994b0a09..a2365e1c9 100644
--- a/simpa/src/main.rs
+++ b/simpa/src/main.rs
@@ -13,7 +13,7 @@ use kaspa_consensus::{
         headers::HeaderStoreReader,
         relations::RelationsStoreReader,
     },
-    params::{Params, Testnet11Bps, DEVNET_PARAMS, NETWORK_DELAY_BOUND, TESTNET11_PARAMS},
+    params::{ForkActivation, Params, Testnet11Bps, DEVNET_PARAMS, NETWORK_DELAY_BOUND, TESTNET11_PARAMS},
 };
 use kaspa_consensus_core::{
     api::ConsensusApi, block::Block, blockstatus::BlockStatus, config::bps::calculate_ghostdag_k, errors::block::BlockProcessResult,
@@ -189,7 +189,7 @@ fn main_impl(mut args: Args) {
     }
     args.bps = if args.testnet11 { Testnet11Bps::bps() as f64 } else { args.bps };
     let mut params = if args.testnet11 { TESTNET11_PARAMS } else { DEVNET_PARAMS };
-    params.storage_mass_activation_daa_score = 400;
+    params.storage_mass_activation = ForkActivation::new(400);
     params.storage_mass_parameter = 10_000;
     let mut builder = ConfigBuilder::new(params)
         .apply_args(|config| apply_args_to_consensus_params(&args, &mut config.params))
@@ -306,12 +306,12 @@ fn apply_args_to_consensus_params(args: &Args, params: &mut Params) {
 
         if args.daa_legacy {
             // Scale DAA and median-time windows linearly with BPS
-            params.sampling_activation_daa_score = u64::MAX;
+            params.sampling_activation = ForkActivation::never();
             params.legacy_timestamp_deviation_tolerance = (params.legacy_timestamp_deviation_tolerance as f64 * args.bps) as u64;
             params.legacy_difficulty_window_size = (params.legacy_difficulty_window_size as f64 * args.bps) as usize;
         } else {
             // Use the new sampling algorithms
-            params.sampling_activation_daa_score = 0;
+            params.sampling_activation = ForkActivation::always();
             params.past_median_time_sample_rate = (10.0 * args.bps) as u64;
             params.new_timestamp_deviation_tolerance = (600.0 * args.bps) as u64;
             params.difficulty_sample_rate = (2.0 * args.bps) as u64;
diff --git a/testing/integration/src/consensus_integration_tests.rs b/testing/integration/src/consensus_integration_tests.rs
index e66baaf69..2256cd3b3 100644
--- a/testing/integration/src/consensus_integration_tests.rs
+++ b/testing/integration/src/consensus_integration_tests.rs
@@ -16,7 +16,9 @@ use kaspa_consensus::model::stores::headers::HeaderStoreReader;
 use kaspa_consensus::model::stores::reachability::DbReachabilityStore;
 use kaspa_consensus::model::stores::relations::DbRelationsStore;
 use kaspa_consensus::model::stores::selected_chain::SelectedChainStoreReader;
-use kaspa_consensus::params::{Params, DEVNET_PARAMS, MAINNET_PARAMS, MAX_DIFFICULTY_TARGET, MAX_DIFFICULTY_TARGET_AS_F64};
+use kaspa_consensus::params::{
+    ForkActivation, Params, DEVNET_PARAMS, MAINNET_PARAMS, MAX_DIFFICULTY_TARGET, MAX_DIFFICULTY_TARGET_AS_F64,
+};
 use kaspa_consensus::pipeline::monitor::ConsensusMonitor;
 use kaspa_consensus::pipeline::ProcessingCounters;
 use kaspa_consensus::processes::reachability::tests::{DagBlock, DagBuilder, StoreValidationExtensions};
@@ -553,7 +555,7 @@ async fn median_time_test() {
             config: ConfigBuilder::new(MAINNET_PARAMS)
                 .skip_proof_of_work()
                 .edit_consensus_params(|p| {
-                    p.sampling_activation_daa_score = u64::MAX;
+                    p.sampling_activation = ForkActivation::never();
                 })
                 .build(),
         },
@@ -562,7 +564,7 @@ async fn median_time_test() {
             config: ConfigBuilder::new(MAINNET_PARAMS)
                 .skip_proof_of_work()
                 .edit_consensus_params(|p| {
-                    p.sampling_activation_daa_score = 0;
+                    p.sampling_activation = ForkActivation::always();
                     p.new_timestamp_deviation_tolerance = 120;
                     p.past_median_time_sample_rate = 3;
                     p.past_median_time_sampled_window_size = (2 * 120 - 1) / 3;
@@ -807,7 +809,7 @@ impl KaspadGoParams {
             past_median_time_sample_rate: 1,
             past_median_time_sampled_window_size: 2 * self.TimestampDeviationTolerance - 1,
             target_time_per_block: self.TargetTimePerBlock / 1_000_000,
-            sampling_activation_daa_score: u64::MAX,
+            sampling_activation: ForkActivation::never(),
             max_block_parents: self.MaxBlockParents,
             max_difficulty_target: MAX_DIFFICULTY_TARGET,
             max_difficulty_target_f64: MAX_DIFFICULTY_TARGET_AS_F64,
@@ -830,7 +832,7 @@ impl KaspadGoParams {
             mass_per_sig_op: self.MassPerSigOp,
             max_block_mass: self.MaxBlockMass,
             storage_mass_parameter: STORAGE_MASS_PARAMETER,
-            storage_mass_activation_daa_score: u64::MAX,
+            storage_mass_activation: ForkActivation::never(),
             deflationary_phase_daa_score: self.DeflationaryPhaseDaaScore,
             pre_deflationary_phase_base_subsidy: self.PreDeflationaryPhaseBaseSubsidy,
             coinbase_maturity: MAINNET_PARAMS.coinbase_maturity,
@@ -1388,7 +1390,7 @@ async fn difficulty_test() {
                 .edit_consensus_params(|p| {
                     p.ghostdag_k = 1;
                     p.legacy_difficulty_window_size = FULL_WINDOW_SIZE;
-                    p.sampling_activation_daa_score = u64::MAX;
+                    p.sampling_activation = ForkActivation::never();
                     // Define past median time so that calls to add_block_with_min_time create blocks
                     // which timestamps fit within the min-max timestamps found in the difficulty window
                     p.legacy_timestamp_deviation_tolerance = 60;
@@ -1404,7 +1406,7 @@ async fn difficulty_test() {
                     p.ghostdag_k = 1;
                     p.sampled_difficulty_window_size = SAMPLED_WINDOW_SIZE;
                     p.difficulty_sample_rate = SAMPLE_RATE;
-                    p.sampling_activation_daa_score = 0;
+                    p.sampling_activation = ForkActivation::always();
                     // Define past median time so that calls to add_block_with_min_time create blocks
                     // which timestamps fit within the min-max timestamps found in the difficulty window
                     p.past_median_time_sample_rate = PMT_SAMPLE_RATE;
@@ -1423,7 +1425,7 @@ async fn difficulty_test() {
                     p.target_time_per_block /= HIGH_BPS;
                     p.sampled_difficulty_window_size = HIGH_BPS_SAMPLED_WINDOW_SIZE;
                     p.difficulty_sample_rate = SAMPLE_RATE * HIGH_BPS;
-                    p.sampling_activation_daa_score = 0;
+                    p.sampling_activation = ForkActivation::always();
                     // Define past median time so that calls to add_block_with_min_time create blocks
                     // which timestamps fit within the min-max timestamps found in the difficulty window
                     p.past_median_time_sample_rate = PMT_SAMPLE_RATE * HIGH_BPS;