starknet_patricia: from merkle node to preimage

Author: AvivYossef-starkware

Cargo.lock

@@ -353,6 +353,7 @@ simple_logger = "4.0.0"
 socket2 = "0.5.8"
 starknet-core = "0.16.0"
 starknet-crypto = "0.8.1"
+starknet-rust-core = "0.16.0"
 starknet-types-core = "0.2.4"
 starknet_api = { path = "crates/starknet_api", version = "0.0.0" }
 starknet_committer.path = "crates/starknet_committer"

Cargo.toml

@@ -30,6 +30,7 @@ serde_json.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true
 starknet_patricia_storage.workspace = true
+starknet-rust-core.workspace = true
 strum.workspace = true
 strum_macros.workspace = true
 thiserror.workspace = true

crates/starknet_patricia/Cargo.toml

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use ethnum::U256;
 use starknet_api::hash::HashOutput;
+use starknet_rust_core::types::MerkleNode;
 use starknet_types_core::felt::Felt;
 
 use crate::patricia_merkle_tree::node_data::errors::{
@@ -238,6 +239,39 @@ impl Preimage {
     }
 }
 
+impl From<&MerkleNode> for Preimage {
+    fn from(node: &MerkleNode) -> Self {
+        match node {
+            MerkleNode::BinaryNode(binary_node) => Preimage::Binary(BinaryData {
+                left_hash: HashOutput(binary_node.left),
+                right_hash: HashOutput(binary_node.right),
+            }),
+            MerkleNode::EdgeNode(edge_node) => {
+                let length = u8::try_from(edge_node.length).unwrap_or_else(|_| {
+                    panic!(
+                        "EdgeNode length {} exceeds u8::MAX when converting to Preimage",
+                        edge_node.length
+                    )
+                });
+                Preimage::Edge(EdgeData {
+                    bottom_hash: HashOutput(edge_node.child),
+                    path_to_bottom: PathToBottom::new(
+                        EdgePath(U256::from_be_bytes(edge_node.path.to_bytes_be())),
+                        EdgePathLength(length),
+                    )
+                    .unwrap_or_else(|_| {
+                        panic!(
+                            "Failed to create PathToBottom from MerkleNode edge: path={:?}, \
+                             length={}",
+                            edge_node.path, edge_node.length
+                        )
+                    }),
+                })
+            }
+        }
+    }
+}
+
 impl TryFrom<&Vec<Felt>> for Preimage {
     type Error = PreimageError;
 

crates/starknet_patricia/src/patricia_merkle_tree/node_data/inner_node.rs

@@ -1,7 +1,17 @@
 use ethnum::U256;
 use rstest::rstest;
+use starknet_api::hash::HashOutput;
+use starknet_rust_core::types::{BinaryNode, EdgeNode, MerkleNode};
+use starknet_types_core::felt::Felt;
 
-use crate::patricia_merkle_tree::node_data::inner_node::{EdgePathLength, PathToBottom};
+use crate::patricia_merkle_tree::node_data::inner_node::{
+    BinaryData,
+    EdgeData,
+    EdgePath,
+    EdgePathLength,
+    PathToBottom,
+    Preimage,
+};
 
 #[rstest]
 #[case(PathToBottom::from("1011"), 1, PathToBottom::from("011"))]
@@ -20,3 +30,63 @@ fn test_remove_first_edges(
         expected
     );
 }
+
+#[rstest]
+#[case(Felt::ONE, Felt::TWO)]
+#[case(Felt::ZERO, Felt::ZERO)]
+#[case(Felt::from(0x1234_u128), Felt::from(0xABCD_u128))]
+fn test_preimage_from_binary_merkle_node(#[case] left: Felt, #[case] right: Felt) {
+    let merkle_node = MerkleNode::BinaryNode(BinaryNode { left, right });
+
+    let preimage = Preimage::from(&merkle_node);
+
+    let expected =
+        Preimage::Binary(BinaryData { left_hash: HashOutput(left), right_hash: HashOutput(right) });
+    assert_eq!(preimage, expected);
+}
+
+#[rstest]
+#[case(Felt::ONE, Felt::from(0b101_u128), 3)]
+#[case(Felt::from(0xBEEF_u128), Felt::from(42_u128), 7)]
+#[case(Felt::ZERO, Felt::ZERO, 0)]
+fn test_preimage_from_edge_merkle_node(
+    #[case] child: Felt,
+    #[case] path: Felt,
+    #[case] length: u64,
+) {
+    let merkle_node = MerkleNode::EdgeNode(EdgeNode { child, path, length });
+
+    let preimage = Preimage::from(&merkle_node);
+
+    let expected = Preimage::Edge(EdgeData {
+        bottom_hash: HashOutput(child),
+        path_to_bottom: PathToBottom::new(
+            EdgePath(U256::from_be_bytes(path.to_bytes_be())),
+            EdgePathLength::new(u8::try_from(length).unwrap()).unwrap(),
+        )
+        .unwrap(),
+    });
+    assert_eq!(preimage, expected);
+}
+
+#[test]
+#[should_panic(expected = "EdgeNode length 256 exceeds u8::MAX")]
+fn test_preimage_from_edge_merkle_node_length_exceeds_u8() {
+    let merkle_node =
+        MerkleNode::EdgeNode(EdgeNode { child: Felt::ONE, path: Felt::ZERO, length: 256 });
+
+    let _ = Preimage::from(&merkle_node);
+}
+
+#[test]
+#[should_panic(expected = "Failed to create PathToBottom from MerkleNode edge")]
+fn test_preimage_from_edge_merkle_node_path_mismatch() {
+    // Path 0b1111 (4 bits) with length 2 should fail - path is too long for the stated length.
+    let merkle_node = MerkleNode::EdgeNode(EdgeNode {
+        child: Felt::ONE,
+        path: Felt::from(0b1111_u128),
+        length: 2,
+    });
+
+    let _ = Preimage::from(&merkle_node);
+}