Feat/tenure change validation

stacks-common/src/types/chainstate.rs

@@ -14,9 +14,7 @@ use crate::codec::{read_next, write_next, Error as CodecError, StacksMessageCode
 use crate::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
-use crate::util::secp256k1::{
-    MessageSignature, SchnorrSignature, Secp256k1PrivateKey, Secp256k1PublicKey,
-};
+use crate::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 use crate::util::uint::Uint256;
 use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE};
 
@@ -338,7 +336,6 @@ impl_byte_array_rusqlite_only!(VRFProof);
 impl_byte_array_rusqlite_only!(TrieHash);
 impl_byte_array_rusqlite_only!(Sha512Trunc256Sum);
 impl_byte_array_rusqlite_only!(MessageSignature);
-impl_byte_array_rusqlite_only!(SchnorrSignature);
 
 impl_byte_array_message_codec!(TrieHash, TRIEHASH_ENCODED_SIZE as u32);
 impl_byte_array_message_codec!(Sha512Trunc256Sum, 32);
@@ -349,7 +346,6 @@ impl_byte_array_message_codec!(BurnchainHeaderHash, 32);
 impl_byte_array_message_codec!(BlockHeaderHash, 32);
 impl_byte_array_message_codec!(StacksBlockId, 32);
 impl_byte_array_message_codec!(MessageSignature, 65);
-impl_byte_array_message_codec!(SchnorrSignature, 65);
 
 impl BlockHeaderHash {
     pub fn to_hash160(&self) -> Hash160 {

stacks-common/src/util/macros.rs

@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::cell::RefCell;
-
 // is this machine big-endian?
 pub fn is_big_endian() -> bool {
     u32::from_be(0x1Au32) == 0x1Au32

stacks-common/src/util/secp256k1.rs

@@ -118,45 +118,6 @@ impl Default for Secp256k1PublicKey {
     }
 }
 
-pub struct SchnorrSignature(pub [u8; 65]);
-impl_array_newtype!(SchnorrSignature, u8, 65);
-impl_array_hexstring_fmt!(SchnorrSignature);
-impl_byte_array_newtype!(SchnorrSignature, u8, 65);
-impl_byte_array_serde!(SchnorrSignature);
-pub const SCHNORR_SIGNATURE_ENCODED_SIZE: u32 = 65;
-
-impl Default for SchnorrSignature {
-    /// Creates a default Schnorr Signature. Note this is not a valid signature.
-    fn default() -> Self {
-        Self([0u8; 65])
-    }
-}
-
-impl SchnorrSignature {
-    /// Attempt to convert a Schnorr signature to a WSTS Signature
-    pub fn to_wsts_signature(&self) -> Option<WSTSSignature> {
-        // TODO: update wsts to add a TryFrom for a [u8; 65] and a slice to a Signature
-        let point_bytes: [u8; 33] = self.0[..33].try_into().ok()?;
-        let scalar_bytes: [u8; 32] = self.0[33..].try_into().ok()?;
-        let point = Point::try_from(&Compressed::from(point_bytes)).ok()?;
-        let scalar = Scalar::from(scalar_bytes);
-        Some(WSTSSignature {
-            R: point,
-            z: scalar,
-        })
-    }
-}
-
-/// Convert a WSTS Signature to a SchnorrSignature
-impl From<&WSTSSignature> for SchnorrSignature {
-    fn from(signature: &WSTSSignature) -> Self {
-        let mut buf = [0u8; 65];
-        buf[..33].copy_from_slice(&signature.R.compress().data);
-        buf[33..].copy_from_slice(&signature.z.to_bytes());
-        SchnorrSignature(buf)
-    }
-}
-
 impl Secp256k1PublicKey {
     #[cfg(any(test, feature = "testing"))]
     pub fn new() -> Secp256k1PublicKey {
@@ -744,6 +705,7 @@ mod tests {
         );
     }
 
+    /*
     #[test]
     fn test_schnorr_signature_serde() {
         use wsts::traits::Aggregator;
@@ -820,4 +782,5 @@ mod tests {
             assert!(reverted_signature.verify(&aggregate_public_key, msg));
         }
     }
+    */
 }

stackslib/src/burnchains/tests/mod.rs

@@ -167,6 +167,15 @@ impl TestMiner {
         }
     }
 
+    pub fn block_commit_at(&self, idx: usize) -> Option<LeaderBlockCommitOp> {
+        assert!(idx < self.block_commits.len());
+        self.block_commits.get(idx).cloned()
+    }
+
+    pub fn num_block_commits(&self) -> usize {
+        self.block_commits.len()
+    }
+
     pub fn next_VRF_key(&mut self) -> VRFPrivateKey {
         let pk = if self.vrf_keys.len() == 0 {
             // first key is simply the 32-byte hash of the secret state

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -1664,6 +1664,23 @@ impl<'a> SortitionHandleTx<'a> {
         Ok(())
     }
 
+    /// Update the canonical Stacks tip (testing only)
+    #[cfg(test)]
+    pub fn test_update_canonical_stacks_tip(
+        &mut self,
+        sort_id: &SortitionId,
+        consensus_hash: &ConsensusHash,
+        stacks_block_hash: &BlockHeaderHash,
+        stacks_block_height: u64,
+    ) -> Result<(), db_error> {
+        self.update_canonical_stacks_tip(
+            sort_id,
+            consensus_hash,
+            stacks_block_hash,
+            stacks_block_height,
+        )
+    }
+
     /// Mark an existing snapshot's stacks block as accepted at a particular burn chain tip within a PoX fork (identified by the consensus hash),
     /// and calculate and store its arrival index.
     /// If this Stacks block extends the canonical stacks chain tip, then also update the memoized canonical
@@ -4392,9 +4409,9 @@ impl SortitionDB {
     }
 
     /// Get the canonical Stacks chain tip -- this gets memoized on the canonical burn chain tip.
-    pub fn get_canonical_stacks_chain_tip_hash(
+    pub fn get_canonical_stacks_chain_tip_hash_and_height(
         conn: &Connection,
-    ) -> Result<(ConsensusHash, BlockHeaderHash), db_error> {
+    ) -> Result<(ConsensusHash, BlockHeaderHash, u64), db_error> {
         let sn = SortitionDB::get_canonical_burn_chain_tip(conn)?;
         let cur_epoch = SortitionDB::get_stacks_epoch(conn, sn.block_height)?.expect(&format!(
             "FATAL: no epoch defined for burn height {}",
@@ -4407,9 +4424,9 @@ impl SortitionDB {
             let mut cursor = sn;
             loop {
                 let result_at_tip = conn.query_row_and_then(
-                    "SELECT consensus_hash,block_hash FROM stacks_chain_tips WHERE sortition_id = ?",
+                    "SELECT consensus_hash,block_hash,block_height FROM stacks_chain_tips WHERE sortition_id = ?",
                     &[&cursor.sortition_id],
-                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1))),
+                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1), (u64::try_from(row.get_unwrap::<_, i64>(2)).expect("FATAL: block height too high"))))
                 ).optional()?;
                 if let Some(stacks_tip) = result_at_tip {
                     return Ok(stacks_tip);
@@ -4422,8 +4439,16 @@ impl SortitionDB {
         // epoch 2.x behavior -- look at the snapshot itself
         let stacks_block_hash = sn.canonical_stacks_tip_hash;
         let consensus_hash = sn.canonical_stacks_tip_consensus_hash;
+        let stacks_block_height = sn.canonical_stacks_tip_height;
+        Ok((consensus_hash, stacks_block_hash, stacks_block_height))
+    }
 
-        Ok((consensus_hash, stacks_block_hash))
+    /// Get the canonical Stacks chain tip -- this gets memoized on the canonical burn chain tip.
+    pub fn get_canonical_stacks_chain_tip_hash(
+        conn: &Connection,
+    ) -> Result<(ConsensusHash, BlockHeaderHash), db_error> {
+        Self::get_canonical_stacks_chain_tip_hash_and_height(conn)
+            .map(|(ch, bhh, _height)| (ch, bhh))
     }
 
     /// Get the maximum arrival index for any known snapshot.
@@ -8462,13 +8487,14 @@ pub mod tests {
         }
     }
 
-    fn make_fork_run(
+    pub fn make_fork_run(
         db: &mut SortitionDB,
         start_snapshot: &BlockSnapshot,
         length: u64,
         bit_pattern: u8,
-    ) -> () {
+    ) -> Vec<BlockSnapshot> {
         let mut last_snapshot = start_snapshot.clone();
+        let mut new_snapshots = vec![];
         for i in last_snapshot.block_height..(last_snapshot.block_height + length) {
             let snapshot = BlockSnapshot {
                 accumulated_coinbase_ustx: 0,
@@ -8491,11 +8517,13 @@ pub mod tests {
                 stacks_block_accepted: false,
                 stacks_block_height: 0,
                 arrival_index: 0,
-                canonical_stacks_tip_height: 0,
-                canonical_stacks_tip_hash: BlockHeaderHash([0u8; 32]),
-                canonical_stacks_tip_consensus_hash: ConsensusHash([0u8; 20]),
+                canonical_stacks_tip_height: last_snapshot.canonical_stacks_tip_height,
+                canonical_stacks_tip_hash: last_snapshot.canonical_stacks_tip_hash,
+                canonical_stacks_tip_consensus_hash: last_snapshot
+                    .canonical_stacks_tip_consensus_hash,
                 miner_pk_hash: None,
             };
+            new_snapshots.push(snapshot.clone());
             {
                 let mut tx = SortitionHandleTx::begin(db, &last_snapshot.sortition_id).unwrap();
                 let _index_root = tx
@@ -8515,6 +8543,7 @@ pub mod tests {
                 .unwrap()
                 .unwrap();
         }
+        new_snapshots
     }
 
     #[test]