feat: SMT Proofs (Inclusion and Exclusion)

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- [#648](https://github.com/FuelLabs/fuel-vm/pull/648): Added support for generating proofs for Sparse Merkle Trees (SMTs) and proof verification. Proofs can be used to attest to the inclusion or exclusion of data from the set.
+
 ### Changed
 
 #### Breaking

fuel-merkle/Cargo.toml

@@ -24,6 +24,8 @@ criterion = { workspace = true }
 datatest-stable = "0.1"
 fuel-merkle-test-helpers = { path = "test-helpers" }
 hex = "0.4"
+proptest = "1.4"
+proptest-derive = "0.4"
 rand = "0.8"
 serde_json = "1.0"
 serde_yaml = "0.9"

fuel-merkle/src/common/msb.rs

@@ -25,7 +25,7 @@ impl GetBit for u8 {
 
 pub trait Msb {
     fn get_bit_at_index_from_msb(&self, index: u32) -> Option<Bit>;
-    fn common_prefix_count(&self, other: &Self) -> u32;
+    fn common_prefix_count(&self, other: &[u8]) -> u32;
 }
 
 impl<const N: usize> Msb for [u8; N] {
@@ -38,7 +38,7 @@ impl<const N: usize> Msb for [u8; N] {
             .and_then(|byte| byte.get_bit(byte_bit_index))
     }
 
-    fn common_prefix_count(&self, other: &Self) -> u32 {
+    fn common_prefix_count(&self, other: &[u8]) -> u32 {
         let mut count = 0;
         for (byte1, byte2) in self.iter().zip(other.iter()) {
             // For each pair of bytes, compute the similarity of each byte using

fuel-merkle/src/common/path.rs

@@ -22,7 +22,7 @@ pub trait Path {
 }
 
 pub trait ComparablePath {
-    fn common_path_length(&self, other: &Self) -> u32;
+    fn common_path_length(&self, other: &[u8]) -> u32;
 }
 
 impl<T> Path for T
@@ -38,7 +38,7 @@ impl<T> ComparablePath for T
 where
     T: Msb,
 {
-    fn common_path_length(&self, other: &Self) -> u32 {
+    fn common_path_length(&self, other: &[u8]) -> u32 {
         self.common_prefix_count(other)
     }
 }

fuel-merkle/src/common/path_iterator.rs

@@ -90,10 +90,12 @@ pub struct PathIter<T: ParentNode> {
 impl<T> PathIter<T>
 where
     T: ParentNode + Clone,
+    T::Key: Clone,
 {
-    pub fn new(root: &T, leaf_key: T::Key) -> Self {
+    pub fn new(root: &T, leaf_key: &T::Key) -> Self {
         let initial = (Ok(root.clone()), Ok(root.clone()));
 
+        #[rustfmt::skip]
         // The initial offset from the most significant bit (MSB).
         //
         // The offset from the MSB indicates which bit to read when deducing the
@@ -116,30 +118,30 @@ where
         // With an 8-bit key and heights 1 through 7:
         //
         // Height Depth
-        // 7      0                        127                    Offset = Bits - Height =
-        // 8 - 7 = 1                                 / \
+        // 7      0                        127                    Offset = Bits - Height = 8 - 7 = 1
+        //                                 / \
         //                                /   \
         // ...                          ...   ...
         //                              /       \
         //                             /         \
-        // 3       4                  07         247              Offset = Bits - Height =
-        // 8 - 3 = 5                           /  \        / \
+        // 3      4                   07         247              Offset = Bits - Height = 8 - 3 = 5
+        //                           /  \        / \
         //                          /    \     ...  \
         //                         /      \          \
         //                        /        \          \
         //                       /          \          \
         //                      /            \          \
-        // 2       5          03              11        251       Offset = Bits - Height =
-        // 8 - 2 = 6                   /  \            /  \       / \
+        // 2      5           03              11        251       Offset = Bits - Height = 8 - 2 = 6
+        //                   /  \            /  \       / \
         //                  /    \          /    \    ...  \
-        // 1       6      01      05      09      13       253    Offset = Bits - Height =
-        // 8 - 1 = 7               /  \    /  \    /  \    /  \      / \
-        // 0       7    00  02  04  06  08  10  12  14   252 254
+        // 1      6       01      05      09      13       253    Offset = Bits - Height = 8 - 1 = 7
+        //               /  \    /  \    /  \    /  \      / \
+        // 0      7     00  02  04  06  08  10  12  14   252 254
         //              00  01  02  03  04  05  06  07   126 127
         //
         let initial_offset = T::key_size_in_bits() - root.height();
         Self {
-            leaf_key,
+            leaf_key: leaf_key.clone(),
             current: Some(initial),
             current_offset: initial_offset,
         }
@@ -187,14 +189,15 @@ where
 }
 
 pub trait AsPathIterator<T: ParentNode> {
-    fn as_path_iter(&self, leaf_key: T::Key) -> PathIter<T>;
+    fn as_path_iter(&self, leaf_key: &T::Key) -> PathIter<T>;
 }
 
 impl<T> AsPathIterator<T> for T
 where
     T: ParentNode + Clone,
+    T::Key: Clone,
 {
-    fn as_path_iter(&self, leaf_key: T::Key) -> PathIter<T> {
+    fn as_path_iter(&self, leaf_key: &T::Key) -> PathIter<T> {
         PathIter::new(self, leaf_key)
     }
 }
@@ -307,7 +310,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(0);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -322,7 +325,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(1);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -337,7 +340,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(2);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -352,7 +355,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(3);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -367,7 +370,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(4);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -382,7 +385,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(5);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -397,7 +400,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(6);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -412,7 +415,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(7);
             let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_path = vec![
@@ -448,7 +451,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(0);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -463,7 +466,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(1);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -478,7 +481,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(2);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -493,7 +496,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(3);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -508,7 +511,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(4);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -523,7 +526,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(5);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -538,7 +541,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(6);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -553,7 +556,7 @@ mod test {
         {
             let leaf = Node::from_leaf_index(7);
             let (_, side): (Vec<TestNode>, Vec<TestNode>) = root
-                .as_path_iter(leaf.leaf_key())
+                .as_path_iter(&leaf.leaf_key())
                 .map(|(path, side)| (path.unwrap(), side.unwrap()))
                 .unzip();
             let expected_side = vec![
@@ -573,7 +576,7 @@ mod test {
         let leaf = Node::from_leaf_index(4); // 0b0100
 
         let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-            .as_path_iter(leaf.leaf_key())
+            .as_path_iter(&leaf.leaf_key())
             .map(|(path, side)| (path.unwrap(), side.unwrap()))
             .unzip();
 
@@ -594,7 +597,7 @@ mod test {
         let leaf = Node::from_leaf_index(61); // 0b00111101
 
         let (path, _): (Vec<TestNode>, Vec<TestNode>) = root
-            .as_path_iter(leaf.leaf_key())
+            .as_path_iter(&leaf.leaf_key())
             .map(|(path, side)| (path.unwrap(), side.unwrap()))
             .unzip();
 
@@ -619,7 +622,7 @@ mod test {
         let leaf = Node::from_leaf_index(0);
 
         let (path, side): (Vec<TestNode>, Vec<TestNode>) = root
-            .as_path_iter(leaf.leaf_key())
+            .as_path_iter(&leaf.leaf_key())
             .map(|(path, side)| (path.unwrap(), side.unwrap()))
             .unzip();
 

fuel-merkle/src/common/position_path.rs

@@ -51,7 +51,7 @@ impl PositionPathIter {
         Self {
             rightmost_position: Position::from_leaf_index(leaves_count - 1),
             current_side_node: None,
-            path_iter: root.as_path_iter(leaf.leaf_key()),
+            path_iter: root.as_path_iter(&leaf.leaf_key()),
         }
     }
 }

fuel-merkle/src/sparse.rs

@@ -18,6 +18,7 @@ pub use merkle_tree::{
 };
 pub use primitive::Primitive;
 pub mod in_memory;
+pub mod proof;
 
 use crate::common::Bytes32;
 

fuel-merkle/src/sparse/in_memory.rs

@@ -6,6 +6,7 @@ use crate::{
     sparse::{
         self,
         merkle_tree::MerkleTreeKey,
+        proof::Proof,
         Primitive,
     },
     storage::{
@@ -177,6 +178,10 @@ impl MerkleTree {
     pub fn root(&self) -> Bytes32 {
         self.tree.root()
     }
+
+    pub fn generate_proof(&self, key: &MerkleTreeKey) -> Option<Proof> {
+        self.tree.generate_proof(key).ok()
+    }
 }
 
 impl Default for MerkleTree {