Merge branch 'main' into next

Author: bobbinth

CHANGELOG.md

@@ -13,9 +13,11 @@
 - [BREAKING] Added validation to `PartialMmr::from_parts()` and `Deserializable` implementation, added `from_parts_unchecked()` for performance-critical code ([#812](https://github.com/0xMiden/crypto/pull/812)).
 - Added `Signature::from_der()` for ECDSA signatures over secp256k1 ([#842](https://github.com/0xMiden/crypto/pull/842)).
 
-## 0.22.3 (unreleased)
+## 0.22.3 (2026-02-23)
 
 - Refactored to introduce a unified `Felt` type for on-chain and off-chain code ([#819](https://github.com/0xMiden/crypto/pull/819)).
+- Change `Ord for Word` to use lexicographic ordering ([#847](https://github.com/0xMiden/crypto/pull/847)).
+- Add `From<{u8, u16, u32}> for Felt` and `TryFrom<u64> for Felt` ([#848](https://github.com/0xMiden/crypto/pull/848)).
 
 ## 0.22.2 (2026-02-01)
 

miden-field/src/lib.rs

@@ -17,7 +17,7 @@ pub use wasm_miden::Felt;
 #[cfg(not(all(target_family = "wasm", miden)))]
 mod native;
 #[cfg(not(all(target_family = "wasm", miden)))]
-pub use native::Felt;
+pub use native::{Felt, FeltFromIntError};
 
 pub mod utils;
 

miden-field/src/native/mod.rs

@@ -357,6 +357,43 @@ impl PermutationMonomial<7> for Felt {
 // CONVERSIONS
 // ================================================================================================
 
+impl From<u8> for Felt {
+    fn from(int: u8) -> Self {
+        Self::from_u8(int)
+    }
+}
+
+impl From<u16> for Felt {
+    fn from(int: u16) -> Self {
+        Self::from_u16(int)
+    }
+}
+
+impl From<u32> for Felt {
+    fn from(int: u32) -> Self {
+        Self::from_u32(int)
+    }
+}
+
+impl TryFrom<u64> for Felt {
+    type Error = FeltFromIntError;
+
+    fn try_from(int: u64) -> Result<Felt, Self::Error> {
+        Felt::from_canonical_checked(int).ok_or(FeltFromIntError(int))
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("integer {0} is equal to or exceeds the felt modulus {modulus}", modulus = Felt::ORDER)]
+pub struct FeltFromIntError(u64);
+
+impl FeltFromIntError {
+    /// Returns the integer for which the conversion failed.
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+}
+
 impl Deref for Felt {
     type Target = Goldilocks;
 

miden-field/src/native/tests.rs

@@ -293,3 +293,10 @@ fn felt_from_prime_subfield_is_transparent() {
     let f = Felt::from_prime_subfield(g);
     assert_eq!(f, g);
 }
+
+/// Ensures TryFrom<u64> fails for inputs at or exceeding the modulus.
+#[test]
+fn felt_try_from_u64_fails_on_large_inputs() {
+    Felt::try_from(u64::MAX).unwrap_err();
+    Felt::try_from(Felt::ORDER).unwrap_err();
+}

miden-field/src/word/lexicographic.rs

@@ -70,19 +70,7 @@ impl<T: Into<Word> + Copy> Ord for LexicographicWord<T> {
         let self_word: Word = self.0.into();
         let other_word: Word = other.0.into();
 
-        for (felt0, felt1) in self_word
-            .iter()
-            .rev()
-            .map(Felt::as_canonical_u64)
-            .zip(other_word.iter().rev().map(Felt::as_canonical_u64))
-        {
-            let ordering = felt0.cmp(&felt1);
-            if let Ordering::Less | Ordering::Greater = ordering {
-                return ordering;
-            }
-        }
-
-        Ordering::Equal
+        self_word.cmp(&other_word)
     }
 }
 
@@ -132,31 +120,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn lexicographic_word_ordering() {
-        for (expected, key0, key1) in [
-            (Ordering::Equal, [0, 0, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [1, 0, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 1, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 0, 1, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 0, 0, 1u32], [0, 0, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [1, 0, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 1, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 1, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 0, 1u32]),
-            (Ordering::Greater, [0, 0, 0, 1u32], [1, 1, 1, 0u32]),
-            (Ordering::Greater, [0, 0, 1, 0u32], [1, 1, 0, 0u32]),
-            (Ordering::Less, [1, 1, 1, 0u32], [0, 0, 0, 1u32]),
-            (Ordering::Less, [1, 1, 0, 0u32], [0, 0, 1, 0u32]),
-        ] {
-            assert_eq!(
-                LexicographicWord::from(key0.map(Felt::from_u32))
-                    .cmp(&LexicographicWord::from(key1.map(Felt::from_u32))),
-                expected
-            );
-        }
-    }
-
     #[test]
     fn lexicographic_serialization() {
         let word = Word::from([1u64, 2, 3, 4].map(Felt::new));

miden-field/src/word/mod.rs

@@ -35,6 +35,9 @@ mod tests;
 // ================================================================================================
 
 /// A unit of data consisting of 4 field elements.
+///
+/// For ordering a word with `Ord` the word's elements are treated as limbs of an integer
+/// in little-endian limb order and thus comparison starts from the most significant element.
 #[derive(Default, Copy, Clone, Eq, PartialEq)]
 #[cfg_attr(
     not(all(target_family = "wasm", miden)),
@@ -306,10 +309,10 @@ impl IndexMut<Range<usize>> for Word {
 
 impl Ord for Word {
     fn cmp(&self, other: &Self) -> Ordering {
-        // Compare the canonical u64 representation of both elements.
+        // Compare the canonical u64 representation of both words.
         //
-        // It will iterate the elements and will return the first computation different than
-        // `Equal`. Otherwise, the ordering is equal.
+        // It will iterate the elements in reverse and will return the first computation different
+        // than `Equal`. Otherwise, the ordering is equal.
         //
         // We use `as_canonical_u64()` to ensure we're comparing the actual field element values
         // in their canonical form (that is, `x in [0,p)`). P3's Goldilocks field uses unreduced
@@ -319,14 +322,19 @@ impl Ord for Word {
         // We must iterate over and compare each element individually. A simple bytestring
         // comparison would be inappropriate because the `Word`s are represented in
         // "lexicographical" order.
-        self.as_elements_array()
+        for (felt0, felt1) in self
             .iter()
+            .rev()
             .map(Felt::as_canonical_u64)
-            .zip(other.as_elements_array().iter().map(Felt::as_canonical_u64))
-            .fold(Ordering::Equal, |ord, (a, b)| match ord {
-                Ordering::Equal => a.cmp(&b),
-                _ => ord,
-            })
+            .zip(other.iter().rev().map(Felt::as_canonical_u64))
+        {
+            let ordering = felt0.cmp(&felt1);
+            if let Ordering::Less | Ordering::Greater = ordering {
+                return ordering;
+            }
+        }
+
+        Ordering::Equal
     }
 }
 

miden-field/src/word/tests.rs

@@ -1,4 +1,5 @@
 use alloc::{collections::BTreeMap, string::String, vec::Vec};
+use core::cmp::Ordering;
 
 use miden_serde_utils::SliceReader;
 use proptest::prelude::*;
@@ -259,3 +260,27 @@ proptest! {
         prop_assert_eq!(map.get(&word), Some(&2));
     }
 }
+
+#[test]
+fn word_is_ordered_lexicographically() {
+    for (expected, key0, key1) in [
+        (Ordering::Equal, [0, 0, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [1, 0, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 1, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 0, 1, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 0, 0, 1u32], [0, 0, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [1, 0, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 1, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 1, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 0, 1u32]),
+        (Ordering::Greater, [0, 0, 0, 1u32], [1, 1, 1, 0u32]),
+        (Ordering::Greater, [0, 0, 1, 0u32], [1, 1, 0, 0u32]),
+        (Ordering::Less, [1, 1, 1, 0u32], [0, 0, 0, 1u32]),
+        (Ordering::Less, [1, 1, 0, 0u32], [0, 0, 1, 0u32]),
+    ] {
+        assert_eq!(
+            Word::from(key0.map(Felt::from_u32)).cmp(&Word::from(key1.map(Felt::from_u32))),
+            expected
+        );
+    }
+}