feat: proof verifyer #13

frankykevin · 2025-12-11T21:17:12Z

No description provided.

ZelionD · 2025-12-22T23:52:10Z

ex/native/rdb/src/lib.rs

+        Err(e) => {
+            Ok((atoms::error(), e).encode(env))
+        }
+    }


Suggested change

}

}

}

ZelionD · 2025-12-22T23:56:30Z

ex/native/rdb/src/lib.rs

+    };
+
+    // Convert proof nodes to Vec<Vec<u8>>
+    let proof_nodes: Vec<Vec<u8>> = proof.iter().map(|b| b.as_slice().to_vec()).collect();


Suggested change

let proof_nodes: Vec<Vec<u8>> = proof.iter().map(|b| b.as_slice().to_vec()).collect();

let proof_nodes = proof.iter().map(|b| b.as_slice());

ZelionD · 2025-12-22T23:56:57Z

ex/native/rdb/src/lib.rs

+    let proof_nodes: Vec<Vec<u8>> = proof.iter().map(|b| b.as_slice().to_vec()).collect();
+
+    // Verify the proof
+    match mpt::verify_proof(root.as_slice(), &index_bytes, &proof_nodes) {


Suggested change

match mpt::verify_proof(root.as_slice(), &index_bytes, &proof_nodes) {

match mpt::verify_proof(root.as_slice(), &index_bytes, proof_nodes) {

ZelionD · 2025-12-22T23:57:57Z

ex/native/rdb/src/mpt.rs

+pub fn verify_proof(
+    root: &[u8],
+    key: &[u8],
+    proof: &[Vec<u8>],
+) -> Result<Vec<u8>, String> {


Suggested change

pub fn verify_proof(

root: &[u8],

key: &[u8],

proof: &[Vec<u8>],

) -> Result<Vec<u8>, String> {

pub fn verify_proof<'a>(

root: &'a [u8],

key: &'a [u8],

proof: impl Iterator<Item = &'a [u8]>,

) -> Result<Vec<u8>, String> {

ZelionD · 2025-12-22T23:58:45Z

ex/native/rdb/src/mpt.rs

+    if proof.is_empty() {
+        return Err("Proof is empty".to_string());
+    }


Can't be checked if proof is iterator, but should be covered with error below

ZelionD · 2025-12-23T00:01:30Z

ex/native/rdb/src/mpt.rs

+    for (i, node) in proof.iter().enumerate() {
+        // Verify node hash matches expected
+        let node_hash = KeccakHasher::hash(node);
+        if node_hash.as_ref() != expected_hash.as_slice() {


Vec compares to fixed array. if expected_hash != node_hash {

ZelionD · 2025-12-23T00:04:35Z

ex/native/rdb/src/mpt.rs

+        if node_hash.as_ref() != expected_hash.as_slice() {
+            // For inline nodes (< 32 bytes), the node itself might be the "hash"
+            if node.len() < 32 && node == &expected_hash {
+                // Inline node, continue


You've already explained what is being verified above, no need to add an empty branch with comment

ZelionD · 2025-12-23T00:06:09Z

ex/native/rdb/src/mpt.rs

+        let item_count = rlp.item_count().map_err(|e| format!("RLP decode error at node {}: {}", i, e))?;
+
+        match item_count {
+            2 => {


It's more clearer to have const defined above with an explanation

ZelionD · 2025-12-23T00:17:39Z

ex/native/rdb/src/mpt.rs

+/// # Returns
+/// * `Ok(value)` - Proof is valid and value was found
+/// * `Err(_)` - Proof is invalid
+pub fn verify_proof(


This function requires proper tests to verify the logic inside

ZelionD · 2025-12-23T00:29:47Z

ex/native/rdb/src/mpt.rs

+                if key_index >= key_nibbles.len() {
+                    // We've consumed all key nibbles, value is in position 16
+                    let value_rlp = rlp.at(16)
+                        .map_err(|e| format!("Failed to get value at branch node {}: {}", i, e))?;
+                    if value_rlp.is_empty() {
+                        return Err(format!("No value at branch node terminus at node {}", i));
+                    }
+                    let value: Vec<u8> = value_rlp.as_val()
+                        .map_err(|e| format!("Failed to decode value at branch node {}: {}", i, e))?;
+                    return Ok(value);
+                }
+
+                let nibble = key_nibbles[key_index] as usize;


Suggested change

if key_index >= key_nibbles.len() {

// We've consumed all key nibbles, value is in position 16

let value_rlp = rlp.at(16)

.map_err(|e| format!("Failed to get value at branch node {}: {}", i, e))?;

if value_rlp.is_empty() {

return Err(format!("No value at branch node terminus at node {}", i));

}

let value: Vec<u8> = value_rlp.as_val()

.map_err(|e| format!("Failed to decode value at branch node {}: {}", i, e))?;

return Ok(value);

}

let nibble = key_nibbles[key_index] as usize;

let Some(&nibble) = key_nibbles.get(key_index) else {

// We've consumed all key nibbles, value is in position 16

let value_rlp = rlp.at(16)

.map_err(|e| format!("Failed to get value at branch node {}: {}", i, e))?;

if value_rlp.is_empty() {

return Err(format!("No value at branch node terminus at node {}", i));

}

let value: Vec<u8> = value_rlp.as_val()

.map_err(|e| format!("Failed to decode value at branch node {}: {}", i, e))?;

return Ok(value);

};

key_index += 1;

let next = rlp.at(nibble as usize)

ZelionD · 2025-12-23T00:37:06Z

ex/native/rdb/src/mpt.rs

+                    if key_index >= key_nibbles.len() {
+                        return Err(format!("Key too short for path at node {}", i));
+                    }
+                    if *nibble != key_nibbles[key_index] {
+                        return Err(format!(
+                            "Path mismatch at node {}, nibble {}: expected {}, got {}",
+                            i,
+                            key_index,
+                            key_nibbles[key_index],
+                            nibble
+                        ));
+                    }
+                    key_index += 1;


Suggested change

if key_index >= key_nibbles.len() {

return Err(format!("Key too short for path at node {}", i));

}

if *nibble != key_nibbles[key_index] {

return Err(format!(

"Path mismatch at node {}, nibble {}: expected {}, got {}",

i,

key_index,

key_nibbles[key_index],

nibble

));

}

key_index += 1;

match key_nibbles.get(key_index) {

Some(expected_nibble) if nibble == expected_nibble => key_index += 1,

Some(expected_nibble) => {

return Err(format!(

"Path mismatch at node {}, nibble {}: expected {}, got {}",

i, key_index, expected_nibble, nibble

));

}

None => return Err(format!("Key too short for path at node {}", i)),

}

ZelionD · 2025-12-23T00:41:26Z

ex/native/rdb/src/mpt.rs

+    if encoded.is_empty() {
+        return (vec![], false);
+    }
+
+    let first = encoded[0];


Suggested change

if encoded.is_empty() {

return (vec![], false);

}

let first = encoded[0];

let Some(&first) = encoded.first() else {

return (vec![], false);

};

feat: proof verifyer

440607c

vans163 force-pushed the main branch from cb86e21 to 00edec8 Compare December 13, 2025 22:55

frankykevin requested a review from vans163 December 15, 2025 09:46

frankykevin assigned valentynfaychuk Dec 16, 2025

frankykevin and others added 3 commits December 16, 2025 20:20

fix: dependancy versoin

59c6b2d

fix: remove binary files

0ed46d9

Merge branch 'main' into feat/proof-verify

aa0777c

vans163 force-pushed the main branch 2 times, most recently from 4b305d9 to 6824044 Compare December 20, 2025 20:34

ZelionD reviewed Dec 22, 2025

View reviewed changes

ex/native/rdb/src/lib.rs

Err(e) => {

Ok((atoms::error(), e).encode(env))

}

}

Copy link

ZelionD Dec 22, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change

}

}

}

ZelionD reviewed Dec 22, 2025

View reviewed changes

ZelionD reviewed Dec 23, 2025

View reviewed changes

	let proof_nodes: Vec<Vec<u8>> = proof.iter().map(\|b\| b.as_slice().to_vec()).collect();
	let proof_nodes = proof.iter().map(\|b\| b.as_slice());

	match mpt::verify_proof(root.as_slice(), &index_bytes, &proof_nodes) {
	match mpt::verify_proof(root.as_slice(), &index_bytes, proof_nodes) {

feat: proof verifyer #13

Are you sure you want to change the base?

feat: proof verifyer #13

Uh oh!

Conversation

frankykevin commented Dec 11, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants