feat: interpret block heights as tenure heights in Clarity 2 contracts executing post-3.0

Author: kantai

clarity/src/vm/database/clarity_db.rs

@@ -127,6 +127,11 @@ pub trait HeadersDB {
         id_bhh: &StacksBlockId,
         epoch: &StacksEpochId,
     ) -> Option<u128>;
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32>;
 }
 
 pub trait BurnStateDB {
@@ -285,6 +290,13 @@ impl HeadersDB for NullHeadersDB {
     ) -> Option<u128> {
         None
     }
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        _tip: &StacksBlockId,
+        _tenure_height: u32,
+    ) -> Option<u32> {
+        None
+    }
 }
 
 #[allow(clippy::panic)]
@@ -915,6 +927,25 @@ impl<'a> ClarityDatabase<'a> {
         }
     }
 
+    pub fn get_block_height_for_tenure_height(
+        &mut self,
+        tenure_height: u32,
+    ) -> Result<Option<u32>> {
+        let current_tenure_height = self.get_tenure_height()?;
+        if current_tenure_height < tenure_height {
+            return Ok(None);
+        }
+        if current_tenure_height == tenure_height {
+            return Ok(Some(self.get_current_block_height()));
+        }
+        let current_height = self.get_current_block_height();
+        // query from the parent
+        let query_tip = self.get_index_block_header_hash(current_height.saturating_sub(1))?;
+        Ok(self
+            .headers_db
+            .get_stacks_height_for_tenure_height(&query_tip, tenure_height.into()))
+    }
+
     /// Get the last-known burnchain block height.
     /// Note that this is _not_ the burnchain height in which this block was mined!
     /// This is the burnchain block height of the parent of the Stacks block at the current Stacks

clarity/src/vm/docs/mod.rs

@@ -2863,6 +2863,14 @@ mod test {
         ) -> Option<u128> {
             Some(12000)
         }
+
+        fn get_stacks_height_for_tenure_height(
+            &self,
+            _tip: &StacksBlockId,
+            tenure_height: u32,
+        ) -> Option<u32> {
+            Some(tenure_height)
+        }
     }
 
     struct DocBurnStateDB {}

clarity/src/vm/functions/database.rs

@@ -769,6 +769,24 @@ pub fn special_get_block_info(
         _ => return Ok(Value::none()),
     };
 
+    let height_value = if env.contract_context.get_clarity_version() < &ClarityVersion::Clarity3 {
+        if env.global_context.epoch_id < StacksEpochId::Epoch30 {
+            height_value
+        } else {
+            // interpretting height_value as a tenure height
+            let height_opt = env
+                .global_context
+                .database
+                .get_block_height_for_tenure_height(height_value)?;
+            match height_opt {
+                Some(x) => x,
+                None => return Ok(Value::none()),
+            }
+        }
+    } else {
+        height_value
+    };
+
     let current_block_height = env.global_context.database.get_current_block_height();
     if height_value >= current_block_height {
         return Ok(Value::none());

clarity/src/vm/test_util/mod.rs

@@ -229,6 +229,14 @@ impl HeadersDB for UnitTestHeaderDB {
         // if the block is defined at all, then return a constant
         self.get_burn_block_height_for_block(id_bhh).map(|_| 3000)
     }
+
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        _tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        Some(tenure_height)
+    }
 }
 
 impl BurnStateDB for UnitTestBurnStateDB {

stackslib/src/chainstate/nakamoto/mod.rs

@@ -3886,7 +3886,7 @@ impl NakamotoChainState {
 
     /// Append a Nakamoto Stacks block to the Stacks chain state.
     /// NOTE: This does _not_ set the block as processed!  The caller must do this.
-    fn append_block<'a>(
+    pub(crate) fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
         clarity_instance: &'a mut ClarityInstance,
         burn_dbconn: &mut SortitionHandleConn,

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

@@ -649,6 +649,14 @@ impl HeadersDB for TestSimHeadersDB {
         // if the block is defined at all, then return a constant
         self.get_burn_block_height_for_block(id_bhh).map(|_| 3000)
     }
+
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        _tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        Some(tenure_height)
+    }
 }
 
 #[test]

stackslib/src/clarity_cli.rs

@@ -766,6 +766,14 @@ impl HeadersDB for CLIHeadersDB {
         // if the block is defined at all, then return a constant
         get_cli_block_height(&self.conn(), id_bhh).map(|_| 3000)
     }
+
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        _tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        Some(tenure_height)
+    }
 }
 
 fn get_eval_input(invoked_by: &str, args: &[String]) -> EvalInput {

stackslib/src/clarity_vm/database/mod.rs

@@ -47,7 +47,22 @@ pub trait GetTenureStartId {
         tip: &StacksBlockId,
         tenure_id_consensus_hash: &ConsensusHash,
     ) -> Result<Option<TenureBlockId>, DBError>;
+    fn get_tenure_ch_at_cb_height(
+        &self,
+        tip: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<ConsensusHash>, DBError>;
     fn conn(&self) -> &Connection;
+    fn get_tenure_block_id_at_cb_height(
+        &self,
+        tip: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<TenureBlockId>, DBError> {
+        let Some(tenure_ch) = self.get_tenure_ch_at_cb_height(tip, coinbase_height)? else {
+            return Ok(None);
+        };
+        self.get_tenure_block_id(tip, &tenure_ch)
+    }
 }
 
 impl GetTenureStartId for StacksDBConn<'_> {
@@ -66,6 +81,21 @@ impl GetTenureStartId for StacksDBConn<'_> {
             .map(|block_id| TenureBlockId::from(block_id)))
     }
 
+    fn get_tenure_ch_at_cb_height(
+        &self,
+        tip: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<ConsensusHash>, DBError> {
+        let opt_out = self
+            .get_indexed(
+                tip,
+                &nakamoto_keys::ongoing_tenure_coinbase_height(coinbase_height),
+            )?
+            .map(|hex_inp| nakamoto_keys::parse_consensus_hash(&hex_inp))
+            .flatten();
+        Ok(opt_out)
+    }
+
     fn conn(&self) -> &Connection {
         self.sqlite()
     }
@@ -87,6 +117,21 @@ impl GetTenureStartId for StacksDBTx<'_> {
             .map(|block_id| TenureBlockId::from(block_id)))
     }
 
+    fn get_tenure_ch_at_cb_height(
+        &self,
+        tip: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<ConsensusHash>, DBError> {
+        let opt_out = self
+            .get_indexed_ref(
+                tip,
+                &nakamoto_keys::ongoing_tenure_coinbase_height(coinbase_height),
+            )?
+            .map(|hex_inp| nakamoto_keys::parse_consensus_hash(&hex_inp))
+            .flatten();
+        Ok(opt_out)
+    }
+
     fn conn(&self) -> &Connection {
         self.sqlite()
     }
@@ -105,6 +150,15 @@ impl GetTenureStartId for MARF<StacksBlockId> {
     fn conn(&self) -> &Connection {
         self.sqlite_conn()
     }
+
+    fn get_tenure_ch_at_cb_height(
+        &self,
+        tip: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<ConsensusHash>, DBError> {
+        let dbconn = StacksDBConn::new(self, ());
+        dbconn.get_tenure_ch_at_cb_height(tip, coinbase_height)
+    }
 }
 
 pub struct HeadersDBConn<'a>(pub StacksDBConn<'a>);
@@ -188,6 +242,22 @@ impl<'a> HeadersDB for HeadersDBConn<'a> {
         })
     }
 
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        let tenure_block_id =
+            GetTenureStartId::get_tenure_block_id_at_cb_height(&self.0, tip, tenure_height.into())
+                .expect("FATAL: bad DB data for tenure height lookups")?;
+        get_stacks_header_column(self.0.conn(), &tenure_block_id.0, "block_height", |r| {
+            u64::from_row(r)
+                .expect("FATAL: malformed block_height")
+                .try_into()
+                .expect("FATAL: blockchain too long")
+        })
+    }
+
     fn get_vrf_seed_for_block(
         &self,
         id_bhh: &StacksBlockId,
@@ -417,6 +487,25 @@ impl<'a> HeadersDB for ChainstateTx<'a> {
         let tenure_id_bhh = get_first_block_in_tenure(self.deref(), id_bhh, Some(epoch));
         get_matured_reward(self.deref(), &tenure_id_bhh, epoch).map(|x| x.total().into())
     }
+
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        let tenure_block_id = GetTenureStartId::get_tenure_block_id_at_cb_height(
+            self.deref(),
+            tip,
+            tenure_height.into(),
+        )
+        .expect("FATAL: bad DB data for tenure height lookups")?;
+        get_stacks_header_column(self.deref(), &tenure_block_id.0, "block_height", |r| {
+            u64::from_row(r)
+                .expect("FATAL: malformed block_height")
+                .try_into()
+                .expect("FATAL: blockchain too long")
+        })
+    }
 }
 
 impl HeadersDB for MARF<StacksBlockId> {
@@ -572,6 +661,27 @@ impl HeadersDB for MARF<StacksBlockId> {
         let tenure_id_bhh = get_first_block_in_tenure(self, id_bhh, Some(epoch));
         get_matured_reward(self, &tenure_id_bhh, epoch).map(|x| x.total().into())
     }
+
+    fn get_stacks_height_for_tenure_height(
+        &self,
+        tip: &StacksBlockId,
+        tenure_height: u32,
+    ) -> Option<u32> {
+        let tenure_block_id =
+            GetTenureStartId::get_tenure_block_id_at_cb_height(self, tip, tenure_height.into())
+                .expect("FATAL: bad DB data for tenure height lookups")?;
+        get_stacks_header_column(
+            self.sqlite_conn(),
+            &tenure_block_id.0,
+            "block_height",
+            |r| {
+                u64::from_row(r)
+                    .expect("FATAL: malformed block_height")
+                    .try_into()
+                    .expect("FATAL: blockchain too long")
+            },
+        )
+    }
 }
 
 /// Select a specific column from the headers table, specifying whether to use