MastForest serialization

air/src/constraints/stack/op_flags/mod.rs

@@ -840,7 +840,7 @@ impl<E: FieldElement> OpFlags<E> {
     /// Operation Flag of U32ASSERT2 operation.
     #[inline(always)]
     pub fn u32assert2(&self) -> E {
-        self.degree6_op_flags[get_op_index(Operation::U32assert2(ZERO).op_code())]
+        self.degree6_op_flags[get_op_index(Operation::U32assert2(0).op_code())]
     }
 
     /// Operation Flag of U32ADD3 operation.

assembly/src/assembler/instruction/mod.rs

@@ -119,17 +119,17 @@ impl Assembler {
             // ----- u32 manipulation -------------------------------------------------------------
             Instruction::U32Test => span_builder.push_ops([Dup0, U32split, Swap, Drop, Eqz]),
             Instruction::U32TestW => u32_ops::u32testw(span_builder),
-            Instruction::U32Assert => span_builder.push_ops([Pad, U32assert2(ZERO), Drop]),
+            Instruction::U32Assert => span_builder.push_ops([Pad, U32assert2(0), Drop]),
             Instruction::U32AssertWithError(err_code) => {
-                span_builder.push_ops([Pad, U32assert2(Felt::from(err_code.expect_value())), Drop])
+                span_builder.push_ops([Pad, U32assert2(err_code.expect_value()), Drop])
             }
-            Instruction::U32Assert2 => span_builder.push_op(U32assert2(ZERO)),
+            Instruction::U32Assert2 => span_builder.push_op(U32assert2(0)),
             Instruction::U32Assert2WithError(err_code) => {
-                span_builder.push_op(U32assert2(Felt::from(err_code.expect_value())))
+                span_builder.push_op(U32assert2(err_code.expect_value()))
             }
-            Instruction::U32AssertW => u32_ops::u32assertw(span_builder, ZERO),
+            Instruction::U32AssertW => u32_ops::u32assertw(span_builder, 0),
             Instruction::U32AssertWWithError(err_code) => {
-                u32_ops::u32assertw(span_builder, Felt::from(err_code.expect_value()))
+                u32_ops::u32assertw(span_builder, err_code.expect_value())
             }
 
             Instruction::U32Cast => span_builder.push_ops([U32split, Drop]),

assembly/src/assembler/instruction/u32_ops.rs

@@ -6,7 +6,6 @@ use crate::{
 use vm_core::{
     AdviceInjector, Felt,
     Operation::{self, *},
-    ZERO,
 };
 
 /// This enum is intended to determine the mode of operation passed to the parsing function
@@ -45,7 +44,7 @@ pub fn u32testw(span_builder: &mut BasicBlockBuilder) {
 ///
 /// Implemented by executing `U32ASSERT2` on each pair of elements in the word.
 /// Total of 6 VM cycles.
-pub fn u32assertw(span_builder: &mut BasicBlockBuilder, err_code: Felt) {
+pub fn u32assertw(span_builder: &mut BasicBlockBuilder, err_code: u32) {
     #[rustfmt::skip]
     let ops = [
         // Test the first and the second elements
@@ -171,7 +170,7 @@ pub fn u32not(span_builder: &mut BasicBlockBuilder) {
     let ops = [
         // Perform the operation
         Push(Felt::from(u32::MAX)),
-        U32assert2(ZERO),
+        U32assert2(0),
         Swap,
         U32sub,
 

core/Cargo.toml

@@ -18,19 +18,14 @@ doctest = false
 
 [features]
 default = ["std"]
-std = [
-    "miden-crypto/std",
-    "miden-formatting/std",
-    "math/std",
-    "winter-utils/std",
-    "thiserror/std",
-]
+std = ["miden-crypto/std", "miden-formatting/std", "math/std", "winter-utils/std", "thiserror/std"]
 
 [dependencies]
 math = { package = "winter-math", version = "0.9", default-features = false }
-#miden-crypto = { version = "0.9", default-features = false }
 miden-crypto = { git = "https://github.com/0xPolygonMiden/crypto", branch = "next", default-features = false }
 miden-formatting = { version = "0.1", default-features = false }
+num-derive = { version = "0.4", default-features = false }
+num-traits = { version = "0.2", default-features = false }
 thiserror = { version = "1.0", git = "https://github.com/bitwalker/thiserror", branch = "no-std", default-features = false }
 winter-utils = { package = "winter-utils", version = "0.9", default-features = false }
 

core/src/mast/mod.rs

@@ -6,8 +6,11 @@ use miden_crypto::hash::rpo::RpoDigest;
 mod node;
 pub use node::{
     get_span_op_group_count, BasicBlockNode, CallNode, DynNode, JoinNode, LoopNode, MastNode,
-    OpBatch, SplitNode, OP_BATCH_SIZE, OP_GROUP_SIZE,
+    OpBatch, OperationOrDecorator, SplitNode, OP_BATCH_SIZE, OP_GROUP_SIZE,
 };
+use winter_utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
+
+mod serialization;
 
 #[cfg(test)]
 mod tests;
@@ -18,6 +21,9 @@ pub trait MerkleTreeNode {
     fn to_display<'a>(&'a self, mast_forest: &'a MastForest) -> impl fmt::Display + 'a;
 }
 
+// MAST NODE ID
+// ================================================================================================
+
 /// An opaque handle to a [`MastNode`] in some [`MastForest`]. It is the responsibility of the user
 /// to use a given [`MastNodeId`] with the corresponding [`MastForest`].
 ///
@@ -27,14 +33,49 @@ pub trait MerkleTreeNode {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct MastNodeId(u32);
 
+impl MastNodeId {
+    /// Returns a new `MastNodeId` with the provided inner value, or an error if the provided
+    /// `value` is greater than the number of nodes in the forest.
+    ///
+    /// For use in deserialization.
+    pub fn from_u32_safe(
+        value: u32,
+        mast_forest: &MastForest,
+    ) -> Result<Self, DeserializationError> {
+        if (value as usize) < mast_forest.nodes.len() {
+            Ok(Self(value))
+        } else {
+            Err(DeserializationError::InvalidValue(format!(
+                "Invalid deserialized MAST node ID '{}', but only {} nodes in the forest",
+                value,
+                mast_forest.nodes.len(),
+            )))
+        }
+    }
+}
+
 impl fmt::Display for MastNodeId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "MastNodeId({})", self.0)
     }
 }
 
+impl Serializable for MastNodeId {
+    fn write_into<W: ByteWriter>(&self, target: &mut W) {
+        self.0.write_into(target)
+    }
+}
+
+impl Deserializable for MastNodeId {
+    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
+        let inner = source.read_u32()?;
+
+        Ok(Self(inner))
+    }
+}
+
 // MAST FOREST
-// ===============================================================================================
+// ================================================================================================
 
 /// Represents one or more procedures, represented as a collection of [`MastNode`]s.
 ///
@@ -94,7 +135,7 @@ impl MastForest {
     /// Returns the [`MastNode`] associated with the provided [`MastNodeId`] if valid, or else
     /// `None`.
     ///
-    /// This is the faillible version of indexing (e.g. `mast_forest[node_id]`).
+    /// This is the failable version of indexing (e.g. `mast_forest[node_id]`).
     #[inline(always)]
     pub fn get_node_by_id(&self, node_id: MastNodeId) -> Option<&MastNode> {
         let idx = node_id.0 as usize;