chore: revert to nightly 2024-11-01 (#31)

storopoli · web-flow · commit 49557e836782 · 2025-02-27T10:47:21.000-03:00
* chore: revert to nightly 2024-11-01

* chore: revert generics because nightly 2024-11-01 does not like
diff --git a/crates/p2p/src/lib.rs b/crates/p2p/src/lib.rs
@@ -1,6 +1,4 @@
 //! Strata P2P implementation.
-#![expect(incomplete_features)] // the generic_const_exprs feature is incomplete
-#![feature(generic_const_exprs)] // but necessary for using const generic bounds in
 
 pub mod commands;
 pub mod events;
diff --git a/crates/types/src/lib.rs b/crates/types/src/lib.rs
@@ -2,6 +2,7 @@
 #![expect(incomplete_features)] // the generic_const_exprs feature is incomplete
 #![feature(generic_const_exprs)] // but necessary for using const generic bounds in
 #![feature(strict_overflow_ops)] // necessary for const wots computations
+#![feature(const_strict_overflow_ops)] // necessary for const wots computations
 
 mod deposit_data;
 mod operator;
diff --git a/crates/types/src/stake_data.rs b/crates/types/src/stake_data.rs
@@ -6,7 +6,7 @@ use bitcoin::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{wots::wots_total_digits, Wots256PublicKey, WOTS_SINGLE};
+use crate::{Wots256PublicKey, WOTS_SINGLE};
 
 /// Size of a [`sha256::Hash`] in bytes.
 pub const HASH_SIZE: usize = 32;
@@ -18,7 +18,7 @@ pub const TXID_SIZE: usize = 32;
 pub const VOUT_SIZE: usize = 4;
 
 /// Size of Wots256PublicKey in arrays (2 * 32 + 4 = 68)
-const WOTS256_ARRAYS: usize = wots_total_digits(32);
+const WOTS256_ARRAYS: usize = 68;
 
 /// Stake data for a single stake transaction.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
@@ -54,11 +54,11 @@ impl StakeData {
     ///
     /// The byte array is structured as follows:
     ///
-    /// - 5,120 (20 * 256) bytes for the withdrawal fulfillment public key.
+    /// - 1,360 (20 * 68) bytes for the withdrawal fulfillment public key.
     /// - 32 bytes for the hash.
     /// - 36 (32 + 4) bytes for the operator funds
     ///
-    /// Total is 5,188 bytes.
+    /// Total is 1,428 bytes.
     ///
     /// # Implementation Details
     ///
@@ -67,18 +67,16 @@ impl StakeData {
     pub fn to_flattened_bytes(
         &self,
     ) -> [u8; WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE + TXID_SIZE + VOUT_SIZE] {
-        let mut bytes =
-            [0u8; WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE + TXID_SIZE + VOUT_SIZE];
-        bytes[0..WOTS_SINGLE * Wots256PublicKey::SIZE]
+        let mut bytes = [0u8; WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE + TXID_SIZE + VOUT_SIZE];
+        bytes[0..WOTS_SINGLE * WOTS256_ARRAYS]
             .copy_from_slice(&self.withdrawal_fulfillment_pk.to_flattened_bytes());
-        bytes[WOTS_SINGLE * Wots256PublicKey::SIZE
-            ..WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE]
+        bytes[WOTS_SINGLE * WOTS256_ARRAYS..WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE]
             .copy_from_slice(&self.hash.to_byte_array());
-        bytes[WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE
-            ..WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE + TXID_SIZE]
+        bytes[WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE
+            ..WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE + TXID_SIZE]
             .copy_from_slice(&self.operator_funds.txid.to_byte_array());
-        bytes[WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE + TXID_SIZE
-            ..WOTS_SINGLE * Wots256PublicKey::SIZE + HASH_SIZE + TXID_SIZE + VOUT_SIZE]
+        bytes[WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE + TXID_SIZE
+            ..WOTS_SINGLE * WOTS256_ARRAYS + HASH_SIZE + TXID_SIZE + VOUT_SIZE]
             .copy_from_slice(&self.operator_funds.vout.to_le_bytes());
         bytes
     }
diff --git a/crates/types/src/wots.rs b/crates/types/src/wots.rs
@@ -22,9 +22,11 @@ pub const WOTS_DIGIT_WIDTH: usize = 4;
 pub const WOTS_DIGITS_PER_BYTE: usize = 8 / WOTS_DIGIT_WIDTH;
 
 /// The maximum number a WOTS digit can hold.
+#[allow(dead_code)]
 pub const WOTS_MAX_DIGIT: usize = (2 << WOTS_DIGIT_WIDTH) - 1;
 
 /// The number of WOTS digits required to represent a message for a given message length.
+#[allow(dead_code)]
 pub const fn wots_msg_digits(msg_len_bytes: usize) -> usize {
     WOTS_DIGITS_PER_BYTE * msg_len_bytes
 }
@@ -33,6 +35,7 @@ pub const fn wots_msg_digits(msg_len_bytes: usize) -> usize {
 ///
 /// The checksum of a WOTS commitment is the sum of the digit values themselves which is then
 /// encoded as a base256 integer. That integer is then signed using the same WOTS scheme.
+#[allow(dead_code)]
 pub const fn wots_checksum_digits(msg_len_bytes: usize) -> usize {
     let max_checksum = wots_msg_digits(msg_len_bytes) * WOTS_MAX_DIGIT;
 
@@ -52,47 +55,46 @@ pub const fn wots_checksum_digits(msg_len_bytes: usize) -> usize {
 }
 
 /// The total number of WOTS digit keys
+#[allow(dead_code)]
 pub const fn wots_total_digits(msg_len_bytes: usize) -> usize {
     wots_msg_digits(msg_len_bytes) + wots_checksum_digits(msg_len_bytes)
 }
 
 /// A variable-length Winternitz One-Time Signature (WOTS) public key.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "proptest", derive(Arbitrary))]
-pub struct WotsPublicKey<const MSG_LEN_BYTES: usize>(
-    pub [[u8; WOTS_SINGLE]; wots_total_digits(MSG_LEN_BYTES)],
-)
+pub struct WotsPublicKey<const MSG_LEN_BYTES: usize>(pub [[u8; WOTS_SINGLE]; MSG_LEN_BYTES])
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized;
+    [(); MSG_LEN_BYTES]: Sized;
 
 /// 160-bit Winternitz One-Time Signature (WOTS) public key.
-pub type Wots160PublicKey = WotsPublicKey<20>;
+pub type Wots160PublicKey = WotsPublicKey<44>;
 
 /// 256-bit Winternitz One-Time Signature (WOTS) public key.
-pub type Wots256PublicKey = WotsPublicKey<32>;
+pub type Wots256PublicKey = WotsPublicKey<68>;
 
 impl<const MSG_LEN_BYTES: usize> WotsPublicKey<MSG_LEN_BYTES>
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized,
-    [(); WOTS_SINGLE * wots_total_digits(MSG_LEN_BYTES)]: Sized,
+    [(); MSG_LEN_BYTES]: Sized,
+    [(); WOTS_SINGLE * MSG_LEN_BYTES]: Sized,
 {
     /// The size of this WOTS public key in bytes.
-    pub const SIZE: usize = wots_total_digits(MSG_LEN_BYTES);
+    pub const SIZE: usize = MSG_LEN_BYTES;
 
     /// Creates a new WOTS 160-bit public key from a byte array.
-    pub fn new(bytes: [[u8; WOTS_SINGLE]; wots_total_digits(MSG_LEN_BYTES)]) -> Self {
+    pub fn new(bytes: [[u8; WOTS_SINGLE]; MSG_LEN_BYTES]) -> Self {
         Self(bytes)
     }
 
     /// Converts the public key to a byte array.
-    pub fn to_bytes(&self) -> [[u8; WOTS_SINGLE]; wots_total_digits(MSG_LEN_BYTES)] {
+    pub fn to_bytes(&self) -> [[u8; WOTS_SINGLE]; MSG_LEN_BYTES] {
         self.0
     }
 
     /// Converts the public key to a flattened byte array.
     pub fn to_flattened_bytes(&self) -> Vec<u8> {
         // Changed return type to Vec<u8>
-        let mut bytes = Vec::with_capacity(WOTS_SINGLE * wots_total_digits(MSG_LEN_BYTES));
+        let mut bytes = Vec::with_capacity(WOTS_SINGLE * MSG_LEN_BYTES);
         for byte_array in &self.0 {
             bytes.extend_from_slice(byte_array);
         }
@@ -110,11 +112,11 @@ where
     pub fn from_flattened_bytes(bytes: &[u8]) -> Self {
         assert_eq!(
             bytes.len(),
-            WOTS_SINGLE * (2 * MSG_LEN_BYTES + 4),
+            WOTS_SINGLE * MSG_LEN_BYTES,
             "Invalid byte array length"
         );
 
-        let mut key = [[0u8; WOTS_SINGLE]; wots_total_digits(MSG_LEN_BYTES)];
+        let mut key = [[0u8; WOTS_SINGLE]; MSG_LEN_BYTES];
         for (i, byte_array) in key.iter_mut().enumerate() {
             byte_array.copy_from_slice(&bytes[i * WOTS_SINGLE..(i + 1) * WOTS_SINGLE]);
         }
@@ -124,9 +126,9 @@ where
 
 impl<const MSG_LEN_BYTES: usize> Deref for WotsPublicKey<MSG_LEN_BYTES>
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized,
+    [(); MSG_LEN_BYTES]: Sized,
 {
-    type Target = [[u8; WOTS_SINGLE]; wots_total_digits(MSG_LEN_BYTES)];
+    type Target = [[u8; WOTS_SINGLE]; MSG_LEN_BYTES];
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -135,7 +137,7 @@ where
 
 impl<const MSG_LEN_BYTES: usize> DerefMut for WotsPublicKey<MSG_LEN_BYTES>
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized,
+    [(); MSG_LEN_BYTES]: Sized,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
@@ -145,8 +147,8 @@ where
 // Custom Serialization for WotsPublicKey
 impl<const MSG_LEN_BYTES: usize> Serialize for WotsPublicKey<MSG_LEN_BYTES>
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized,
-    [(); WOTS_SINGLE * wots_total_digits(MSG_LEN_BYTES)]: Sized,
+    [(); MSG_LEN_BYTES]: Sized,
+    [(); WOTS_SINGLE * MSG_LEN_BYTES]: Sized,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -167,8 +169,8 @@ where
 // Custom Deserialization for WotsPublicKey
 impl<'de, const MSG_LEN_BYTES: usize> Deserialize<'de> for WotsPublicKey<MSG_LEN_BYTES>
 where
-    [(); wots_total_digits(MSG_LEN_BYTES)]: Sized,
-    [(); WOTS_SINGLE * wots_total_digits(MSG_LEN_BYTES)]: Sized,
+    [(); MSG_LEN_BYTES]: Sized,
+    [(); WOTS_SINGLE * MSG_LEN_BYTES]: Sized,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -178,26 +180,23 @@ where
 
         impl<'de, const M: usize> Visitor<'de> for WotsPublicKeyVisitor<M>
         where
-            [(); wots_total_digits(M)]: Sized,
+            [(); M]: Sized,
         {
             type Value = WotsPublicKey<M>;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str(&format!(
-                    "a WotsPublicKey with {} bytes",
-                    WOTS_SINGLE * (2 * M + 4)
-                ))
+                formatter.write_str(&format!("a WotsPublicKey with {} bytes", WOTS_SINGLE * M))
             }
 
             fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                if bytes.len() != WOTS_SINGLE * (2 * M + 4) {
+                if bytes.len() != WOTS_SINGLE * M {
                     return Err(E::invalid_length(bytes.len(), &self));
                 }
 
-                let mut array = [[0u8; WOTS_SINGLE]; wots_total_digits(M)];
+                let mut array = [[0u8; WOTS_SINGLE]; M];
                 for (i, chunk) in bytes.chunks(WOTS_SINGLE).enumerate() {
                     array[i].copy_from_slice(chunk);
                 }
@@ -208,7 +207,7 @@ where
             where
                 A: SeqAccess<'de>,
             {
-                let mut array = [[0u8; WOTS_SINGLE]; wots_total_digits(M)];
+                let mut array = [[0u8; WOTS_SINGLE]; M];
                 for (i, item) in array.iter_mut().enumerate() {
                     *item = seq
                         .next_element()?
@@ -249,8 +248,8 @@ mod tests {
 
     #[test]
     fn flattened_bytes_roundtrip() {
-        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(20)]); // 2 * 20 + 4
-        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(32)]); // 2 * 32 + 4
+        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; 44]); // 2 * 20 + 4
+        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; 68]); // 2 * 32 + 4
 
         // Test flattened bytes roundtrip
         let flattened160 = key160.to_flattened_bytes();
@@ -265,8 +264,8 @@ mod tests {
 
     #[test]
     fn json_serialization() {
-        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(20)]); // 2 * 20 + 4
-        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(32)]); // 2 * 32 + 4
+        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; 44]); // 2 * 20 + 4
+        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; 68]); // 2 * 32 + 4
 
         // Test JSON serialization
         let serialized160 = serde_json::to_string(&key160).unwrap();
@@ -280,8 +279,8 @@ mod tests {
 
     #[test]
     fn bincode_serialization() {
-        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(20)]); // 2 * 20 + 4
-        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; wots_total_digits(32)]); // 2 * 32 + 4
+        let key160 = Wots160PublicKey::new([[1u8; WOTS_SINGLE]; 44]); // 2 * 20 + 4
+        let key256 = Wots256PublicKey::new([[1u8; WOTS_SINGLE]; 68]); // 2 * 32 + 4
 
         // Test bincode serialization
         let serialized160 = bincode::serialize(&key160).unwrap();
@@ -304,7 +303,7 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn deserialize_too_many_elements20() {
+    fn deserialize_too_many_elements160() {
         // Create JSON string with 45 arrays
         let mut json = String::from("[");
         for i in 0..45 {
@@ -320,7 +319,7 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn deserialize_too_many_elements32() {
+    fn deserialize_too_many_elements256() {
         // Create JSON string with 33 arrays
         let mut json = String::from("[");
         for i in 0..33 {
@@ -336,10 +335,10 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn deserialize_invalid_array_length20() {
+    fn deserialize_invalid_array_length44() {
         // Create JSON with one array having wrong length (19 instead of 20)
         let mut json = String::from("[");
-        for i in 0..WotsPublicKey::<20>::SIZE {
+        for i in 0..WotsPublicKey::<44>::SIZE {
             if i == 14 {
                 json.push_str("[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"); // 19 elements
             } else {
@@ -356,16 +355,16 @@ mod tests {
 
     #[test]
     #[should_panic]
-    fn deserialize_invalid_array_length32() {
+    fn deserialize_invalid_array_length256() {
         // Create JSON with one array having wrong length (19 instead of 20)
         let mut json = String::from("[");
-        for i in 0..WotsPublicKey::<32>::SIZE {
+        for i in 0..WotsPublicKey::<68>::SIZE {
             if i == 20 {
                 json.push_str("[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]"); // 19 elements
             } else {
                 json.push_str("[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]");
             }
-            if i < WotsPublicKey::<32>::SIZE - 1 {
+            if i < WotsPublicKey::<68>::SIZE - 1 {
                 json.push(',');
             }
         }
@@ -447,7 +446,7 @@ mod tests {
             let flattened = key.to_flattened_bytes();
 
             // Verify the length is correct
-            prop_assert_eq!(flattened.len(), WOTS_SINGLE * (2 * 20 + 4));
+            prop_assert_eq!(flattened.len(), WOTS_SINGLE * 44);
 
             // Verify each segment matches the original arrays
             for (i, original_array) in key.0.iter().enumerate() {
@@ -461,7 +460,7 @@ mod tests {
             let flattened = key.to_flattened_bytes();
 
             // Verify the length is correct
-            prop_assert_eq!(flattened.len(), WOTS_SINGLE * (2 * 32 + 4));
+            prop_assert_eq!(flattened.len(), WOTS_SINGLE * 68);
 
             // Verify each segment matches the original arrays
             for (i, original_array) in key.0.iter().enumerate() {
diff --git a/crates/wire/src/lib.rs b/crates/wire/src/lib.rs
@@ -1,5 +1,3 @@
 //! Protobuf definitions for the Strata P2P protocol.
-#![expect(incomplete_features)] // the generic_const_exprs feature is incomplete
-#![feature(generic_const_exprs)] // but necessary for using const generic bounds in
 
 pub mod p2p;
diff --git a/crates/wire/src/p2p/v1/typed.rs b/crates/wire/src/p2p/v1/typed.rs
@@ -9,8 +9,8 @@ use bitcoin::{
 use musig2::{PartialSignature, PubNonce};
 use prost::{DecodeError, Message};
 use strata_p2p_types::{
-    OperatorPubKey, Scope, SessionId, StakeChainId, StakeData, Wots256PublicKey, WotsPublicKey,
-    WotsPublicKeys, WOTS_SINGLE,
+    OperatorPubKey, Scope, SessionId, StakeChainId, StakeData, Wots256PublicKey, WotsPublicKeys,
+    WOTS_SINGLE,
 };
 
 use super::proto::{
@@ -231,7 +231,7 @@ impl StakeChainExchange {
                     curr.read_exact(bytes)
                         .map_err(|err| DecodeError::new(err.to_string()))?;
                 }
-                let wots = WotsPublicKey::<32>::new(wots);
+                let wots = Wots256PublicKey::new(wots);
 
                 // Parse the sha256 hash.
                 let mut sha256_hash = [0; 32];
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,5 +1,6 @@
 [toolchain]
-channel = "nightly-2025-02-01"
+# update this after https://github.com/rust-lang/rust/issues/134044 is fixed.
+channel = "nightly-2024-11-01"
 components = [
   "cargo",
   "clippy",
