Ephemeral MARF

stackslib/src/chainstate/nakamoto/miner.rs

@@ -108,6 +108,7 @@ pub struct MinerTenureInfo<'a> {
     pub cause: Option<TenureChangeCause>,
     pub active_reward_set: boot::RewardSet,
     pub tenure_block_commit_opt: Option<LeaderBlockCommitOp>,
+    pub ephemeral: bool,
 }
 
 /// Structure returned from `NakamotoBlockBuilder::build_nakamoto_block` with
@@ -216,14 +217,27 @@ impl NakamotoBlockBuilder {
     /// This function should be called before `tenure_begin`.
     /// It creates a MinerTenureInfo struct which owns connections to the chainstate and sortition
     /// DBs, so that block-processing is guaranteed to terminate before the lives of these handles
-    /// expire.
+    /// expire.  This is used for normal blocks.
     pub fn load_tenure_info<'a>(
         &self,
         chainstate: &'a mut StacksChainState,
         burn_dbconn: &'a SortitionHandleConn,
         cause: Option<TenureChangeCause>,
     ) -> Result<MinerTenureInfo<'a>, Error> {
-        self.inner_load_tenure_info(chainstate, burn_dbconn, cause, false)
+        self.inner_load_tenure_info(chainstate, burn_dbconn, cause, false, false)
+    }
+
+    /// This function should be called before `tenure_begin`.
+    /// It creates a MinerTenureInfo struct which owns connections to the chainstate and sortition
+    /// DBs, so that block-processing is guaranteed to terminate before the lives of these handles
+    /// expire.  This is used for ephemeral blocks
+    pub fn load_ephemeral_tenure_info<'a>(
+        &self,
+        chainstate: &'a mut StacksChainState,
+        burn_dbconn: &'a SortitionHandleConn,
+        cause: Option<TenureChangeCause>,
+    ) -> Result<MinerTenureInfo<'a>, Error> {
+        self.inner_load_tenure_info(chainstate, burn_dbconn, cause, false, true)
     }
 
     /// This function should be called before `tenure_begin`.
@@ -236,8 +250,9 @@ impl NakamotoBlockBuilder {
         burn_dbconn: &'a SortitionHandleConn,
         cause: Option<TenureChangeCause>,
         shadow_block: bool,
+        ephemeral: bool,
     ) -> Result<MinerTenureInfo<'a>, Error> {
-        debug!("Nakamoto miner tenure begin"; "shadow" => shadow_block, "tenure_change" => ?cause);
+        debug!("Nakamoto miner tenure begin"; "shadow" => shadow_block, "tenure_change" => ?cause, "ephemeral" => ephemeral);
 
         let Some(tenure_election_sn) =
             SortitionDB::get_block_snapshot_consensus(burn_dbconn, &self.header.consensus_hash)?
@@ -372,6 +387,7 @@ impl NakamotoBlockBuilder {
             coinbase_height,
             active_reward_set,
             tenure_block_commit_opt,
+            ephemeral,
         })
     }
 
@@ -395,24 +411,45 @@ impl NakamotoBlockBuilder {
             clarity_tx,
             matured_miner_rewards_opt,
             ..
-        } = NakamotoChainState::setup_block(
-            &mut info.chainstate_tx,
-            info.clarity_instance,
-            burn_dbconn,
-            burn_dbconn.context.first_block_height,
-            &burn_dbconn.context.pox_constants,
-            info.parent_consensus_hash,
-            info.parent_header_hash,
-            info.parent_burn_block_height,
-            info.burn_tip,
-            info.burn_tip_height,
-            info.cause == Some(TenureChangeCause::BlockFound),
-            info.coinbase_height,
-            info.cause == Some(TenureChangeCause::Extended),
-            &self.header.pox_treatment,
-            block_commit,
-            &info.active_reward_set,
-        )?;
+        } = if info.ephemeral {
+            NakamotoChainState::setup_ephemeral_block(
+                &mut info.chainstate_tx,
+                info.clarity_instance,
+                burn_dbconn,
+                burn_dbconn.context.first_block_height,
+                &burn_dbconn.context.pox_constants,
+                info.parent_consensus_hash,
+                info.parent_header_hash,
+                info.parent_burn_block_height,
+                info.burn_tip,
+                info.burn_tip_height,
+                info.cause == Some(TenureChangeCause::BlockFound),
+                info.coinbase_height,
+                info.cause == Some(TenureChangeCause::Extended),
+                &self.header.pox_treatment,
+                block_commit,
+                &info.active_reward_set,
+            )
+        } else {
+            NakamotoChainState::setup_block(
+                &mut info.chainstate_tx,
+                info.clarity_instance,
+                burn_dbconn,
+                burn_dbconn.context.first_block_height,
+                &burn_dbconn.context.pox_constants,
+                info.parent_consensus_hash,
+                info.parent_header_hash,
+                info.parent_burn_block_height,
+                info.burn_tip,
+                info.burn_tip_height,
+                info.cause == Some(TenureChangeCause::BlockFound),
+                info.coinbase_height,
+                info.cause == Some(TenureChangeCause::Extended),
+                &self.header.pox_treatment,
+                block_commit,
+                &info.active_reward_set,
+            )
+        }?;
         self.matured_miner_rewards_opt = matured_miner_rewards_opt;
         Ok(clarity_tx)
     }
@@ -458,10 +495,11 @@ impl NakamotoBlockBuilder {
         };
 
         test_debug!(
-            "\n\nMined Nakamoto block {}, {} transactions, state root is {}\n",
+            "\n\nMined Nakamoto block {}, {} transactions, state root is {}\nBlock: {:?}",
             block.header.block_hash(),
             block.txs.len(),
-            state_root_hash
+            state_root_hash,
+            &block
         );
 
         debug!(

stackslib/src/chainstate/nakamoto/mod.rs

@@ -3782,7 +3782,8 @@ impl NakamotoChainState {
     }
 
     /// Begin block-processing for a normal block and return all of the pre-processed state within a
-    /// `SetupBlockResult`.  Used by the Nakamoto miner, and called by Self::setup_normal_block()
+    /// `SetupBlockResult`.  Used by the Nakamoto miner, and called by
+    /// Self::setup_normal_block_processing()
     pub fn setup_block<'a, 'b>(
         chainstate_tx: &'b mut ChainstateTx,
         clarity_instance: &'a mut ClarityInstance,
@@ -3817,6 +3818,47 @@ impl NakamotoChainState {
             new_tenure,
             coinbase_height,
             tenure_extend,
+            false,
+        )
+    }
+
+    /// Begin block-processing for a replay of a normal block and return all of the pre-processed state within a
+    /// `SetupBlockResult`.  Used by the block replay logic, and called by Self::setup_normal_block_processing()
+    pub fn setup_ephemeral_block<'a, 'b>(
+        chainstate_tx: &'b mut ChainstateTx,
+        clarity_instance: &'a mut ClarityInstance,
+        sortition_dbconn: &'b dyn SortitionDBRef,
+        first_block_height: u64,
+        pox_constants: &PoxConstants,
+        parent_consensus_hash: ConsensusHash,
+        parent_header_hash: BlockHeaderHash,
+        parent_burn_height: u32,
+        burn_header_hash: BurnchainHeaderHash,
+        burn_header_height: u32,
+        new_tenure: bool,
+        coinbase_height: u64,
+        tenure_extend: bool,
+        block_bitvec: &BitVec<4000>,
+        tenure_block_commit: &LeaderBlockCommitOp,
+        active_reward_set: &RewardSet,
+    ) -> Result<SetupBlockResult<'a, 'b>, ChainstateError> {
+        // this block's bitvec header must match the miner's block commit punishments
+        Self::check_pox_bitvector(block_bitvec, tenure_block_commit, active_reward_set)?;
+        Self::inner_setup_block(
+            chainstate_tx,
+            clarity_instance,
+            sortition_dbconn,
+            first_block_height,
+            pox_constants,
+            parent_consensus_hash,
+            parent_header_hash,
+            parent_burn_height,
+            burn_header_hash,
+            burn_header_height,
+            new_tenure,
+            coinbase_height,
+            tenure_extend,
+            true,
         )
     }
 
@@ -3942,6 +3984,7 @@ impl NakamotoChainState {
     /// * coinbase_height: the number of tenures that this block confirms (including epoch2 blocks)
     ///   (this is equivalent to the number of coinbases)
     /// * tenure_extend: whether or not to reset the tenure's ongoing execution cost
+    /// * ephemeral: whether or not to begin an ephemeral block (i.e. which won't hit disk)
     ///
     /// Returns clarity_tx, list of receipts, microblock execution cost,
     /// microblock fees, microblock burns, list of microblock tx receipts,
@@ -3961,6 +4004,7 @@ impl NakamotoChainState {
         new_tenure: bool,
         coinbase_height: u64,
         tenure_extend: bool,
+        ephemeral: bool,
     ) -> Result<SetupBlockResult<'a, 'b>, ChainstateError> {
         let parent_index_hash = StacksBlockId::new(&parent_consensus_hash, &parent_header_hash);
         let parent_sortition_id = sortition_dbconn
@@ -4010,15 +4054,27 @@ impl NakamotoChainState {
             parent_cost_total
         };
 
-        let mut clarity_tx = StacksChainState::chainstate_block_begin(
-            chainstate_tx,
-            clarity_instance,
-            sortition_dbconn.as_burn_state_db(),
-            &parent_consensus_hash,
-            &parent_header_hash,
-            &MINER_BLOCK_CONSENSUS_HASH,
-            &MINER_BLOCK_HEADER_HASH,
-        );
+        let mut clarity_tx = if ephemeral {
+            StacksChainState::chainstate_ephemeral_block_begin(
+                chainstate_tx,
+                clarity_instance,
+                sortition_dbconn.as_burn_state_db(),
+                &parent_consensus_hash,
+                &parent_header_hash,
+                &MINER_BLOCK_CONSENSUS_HASH,
+                &MINER_BLOCK_HEADER_HASH,
+            )
+        } else {
+            StacksChainState::chainstate_block_begin(
+                chainstate_tx,
+                clarity_instance,
+                sortition_dbconn.as_burn_state_db(),
+                &parent_consensus_hash,
+                &parent_header_hash,
+                &MINER_BLOCK_CONSENSUS_HASH,
+                &MINER_BLOCK_HEADER_HASH,
+            )
+        };
 
         // now that we have access to the ClarityVM, we can account for reward deductions from
         // PoisonMicroblocks if we have new rewards scheduled

stackslib/src/chainstate/nakamoto/shadow.rs

@@ -414,6 +414,7 @@ impl NakamotoChainState {
             new_tenure,
             coinbase_height,
             tenure_extend,
+            false,
         )
     }
 }
@@ -431,7 +432,7 @@ impl NakamotoBlockBuilder {
         burn_dbconn: &'a SortitionHandleConn,
         cause: Option<TenureChangeCause>,
     ) -> Result<MinerTenureInfo<'a>, Error> {
-        self.inner_load_tenure_info(chainstate, burn_dbconn, cause, true)
+        self.inner_load_tenure_info(chainstate, burn_dbconn, cause, true, false)
     }
 
     /// Begin/resume mining a shadow tenure's transactions.

stackslib/src/chainstate/stacks/boot/contract_tests.rs

@@ -31,7 +31,9 @@ use crate::chainstate::stacks::boot::{
 use crate::chainstate::stacks::index::ClarityMarfTrieId;
 use crate::chainstate::stacks::{C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *};
 use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
-use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
+use crate::clarity_vm::database::marf::{
+    ClarityMarfStore, ClarityMarfStoreTransaction, MarfedKV, WritableMarfStore,
+};
 use crate::core::{
     StacksEpoch, StacksEpochId, BITCOIN_REGTEST_FIRST_BLOCK_HASH,
     BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT, BITCOIN_REGTEST_FIRST_BLOCK_TIMESTAMP,
@@ -141,10 +143,10 @@ impl ClarityTestSim {
         F: FnOnce(&mut ClarityBlockConnection) -> R,
     {
         let r = {
-            let mut store = self.marf.begin(
+            let mut store: Box<dyn WritableMarfStore> = Box::new(self.marf.begin(
                 &StacksBlockId(test_sim_height_to_hash(self.block_height, self.fork)),
                 &StacksBlockId(test_sim_height_to_hash(self.block_height + 1, self.fork)),
-            );
+            ));
 
             self.block_height += 1;
             if new_tenure {
@@ -193,10 +195,10 @@ impl ClarityTestSim {
     where
         F: FnOnce(&mut OwnedEnvironment) -> R,
     {
-        let mut store = self.marf.begin(
+        let mut store: Box<dyn WritableMarfStore> = Box::new(self.marf.begin(
             &StacksBlockId(test_sim_height_to_hash(self.block_height, self.fork)),
             &StacksBlockId(test_sim_height_to_hash(self.block_height + 1, self.fork)),
-        );
+        ));
 
         self.block_height += 1;
         if new_tenure {
@@ -240,8 +242,8 @@ impl ClarityTestSim {
         self.execute_next_block_with_tenure(true, f)
     }
 
-    fn check_and_bump_epoch(
-        store: &mut WritableMarfStore,
+    fn check_and_bump_epoch<'a>(
+        store: &mut Box<dyn WritableMarfStore + 'a>,
         headers_db: &TestSimHeadersDB,
         burn_db: &dyn BurnStateDB,
     ) -> StacksEpochId {
@@ -268,10 +270,10 @@ impl ClarityTestSim {
     where
         F: FnOnce(&mut OwnedEnvironment) -> R,
     {
-        let mut store = self.marf.begin(
+        let mut store: Box<dyn WritableMarfStore> = Box::new(self.marf.begin(
             &StacksBlockId(test_sim_height_to_hash(parent_height, self.fork)),
             &StacksBlockId(test_sim_height_to_hash(parent_height + 1, self.fork + 1)),
-        );
+        ));
 
         let r = {
             let headers_db = TestSimHeadersDB {