Implement Merkle proof #15

junha1 · 2020-02-04T01:49:49Z

Here I implemented a high-level abstraction of cryptographical proof, with an instantiation of the our TrieDB. I didn't implement malicious case of unit test.

I'll make a new issue to add some malicious case of unit test after this PR get merged

Closes #10

sgkim126

Check clippy.

src/proof.rs

junha1 · 2020-02-04T03:22:46Z

@sgkim126 I fixed all the mentioned points

src/proof.rs

junha1 · 2020-02-04T07:55:46Z

@majecty @sgkim126 Please check. I refactored the code into concrete way. All the abstractions stay in my forked repo.

src/proof.rs

sgkim126 · 2020-02-04T09:08:03Z

src/proof.rs

+                        None => proof.len() == 1,
+                    }
+                }
+                _ => false,


None => false,

src/triedb.rs

sgkim126 · 2020-02-04T09:17:35Z

src/triedb.rs

+                None => Ok((None, Vec::new())), // empty trie
+            }
+        }
+        let x = make_proof_upto(self.db, &NibbleSlice::new(&key), self.root())?;


let (value, proof) = make_proof_upto(self.db, &NibbleSlice::new(&key), self.root())?; let unit = Unit { hash: *self.root(), key: *key, value, }; Ok((unit, CryptoProof(proof)))

x.0 is already an Option<Bytes>.
and you don't need 0: ... to create a new type.

sgkim126 · 2020-02-04T09:22:01Z

src/triedb.rs

+                        let left_path = path.mid(partial.len() + 1);
+                        match children[path.mid(partial.len()).at(0) as usize] {
+                            Some(x) => {
+                                let r = make_proof_upto(db, &left_path, &x)?;


This code creates two unnecessary vectors per branch.

let (value, mut reversed_proof) = make_proof_upto(db, &left_path, &x)?; reversed_proof.push(node_rlp); Ok((r.0, reversed_proof))

If you make make_proof_upto returns a reversed proof, you can make it more efficient.

sgkim126 · 2020-02-04T09:23:59Z

src/triedb.rs

+        }
+        let x = make_proof_upto(self.db, &NibbleSlice::new(&key), self.root())?;
+
+        let value: Option<Bytes> = x.0.map(|x| x.to_vec());


You just need to reverse the proof once here.

src/proof.rs

src/triedb.rs

junha1 · 2020-02-05T08:10:37Z

@sgkim126 @majecty please check the changes and #15 (comment)

majecty · 2020-02-06T04:55:10Z

src/triedb.rs

+    /// A proof creation logic for TrieDB.
+    /// A proof is basically a list of serialized trie nodes, Vec<Bytes>.
+    /// It starts from the one closest to the root, and to the leaf. (It may not reach the leaf in absence case)
+    /// Each node can be decoded with RLP. (Note that RLP doesn't guarantee format detail, so you must check our serialization code)
+    /// In case of precense, the list will contain path from the root to the leaf with the key.
+    /// In case of absence, the list will contain path to the last node that matches the key.
+    //
+    //          (A: [nil])
+    //         /         \
+    //      (B, g)        \
+    //      /    \         \
+    // (C, iant) (D, mail)  (E, clang)
+    //
+    // Here proof of key 'gmail' will be [(RLP encoding of A), (RLP encoding of B), (RLP encoding of D)]
+    // proof of key 'galbi' (absence) will be [(RLP encoding of A), (RLP encoding of B)]


@ScarletBlue Could you review this comment?
Also, please review other comments in code.

src/triedb.rs

majecty · 2020-02-06T05:50:21Z

src/triedb.rs

+                        match children[path.mid(partial.len()).at(0) as usize] {
+                            Some(x) => {
+                                let (value, mut reversed_proof) = make_proof_upto(db, &left_path, &x)?;
+                                reversed_proof.push(node_rlp);


It's good to use the name reversed_proof!

src/proof.rs

majecty · 2020-02-06T06:24:26Z

Let's wait the Seungwoo's review.

ScarletBlue · 2020-02-06T06:35:39Z

src/proof.rs

+        }
+    }
+
+    // here proof is created manually


proof is created manually here

ScarletBlue · 2020-02-06T06:36:41Z

src/triedb.rs

+impl<'db> CryptoStructure for TrieDB<'db> {
+    /// A proof creation logic for TrieDB.
+    /// A proof is basically a list of serialized trie nodes, Vec<Bytes>.
+    /// It starts from the one closest to the root, and to the leaf. (It may not reach the leaf in absence case)


It starts from the one closest to the root and to the leaf. (It may not reach the leaf in absence case.)

ScarletBlue · 2020-02-06T06:37:06Z

src/triedb.rs

+    /// A proof creation logic for TrieDB.
+    /// A proof is basically a list of serialized trie nodes, Vec<Bytes>.
+    /// It starts from the one closest to the root, and to the leaf. (It may not reach the leaf in absence case)
+    /// Each node can be decoded with RLP. (Note that RLP doesn't guarantee format detail, so you must check our serialization code)


Each node can be decoded with RLP. (Note that RLP doesn't guarantee format detail, so you must check our serialization code.)

ScarletBlue · 2020-02-06T06:37:35Z

src/triedb.rs

+    /// A proof is basically a list of serialized trie nodes, Vec<Bytes>.
+    /// It starts from the one closest to the root, and to the leaf. (It may not reach the leaf in absence case)
+    /// Each node can be decoded with RLP. (Note that RLP doesn't guarantee format detail, so you must check our serialization code)
+    /// In case of precense, the list will contain path from the root to the leaf with the key.


In case of precense, the list will contain a path from the root to the leaf with the key.

ScarletBlue · 2020-02-06T06:37:45Z

src/triedb.rs

+    /// It starts from the one closest to the root, and to the leaf. (It may not reach the leaf in absence case)
+    /// Each node can be decoded with RLP. (Note that RLP doesn't guarantee format detail, so you must check our serialization code)
+    /// In case of precense, the list will contain path from the root to the leaf with the key.
+    /// In case of absence, the list will contain path to the last node that matches the key.


In case of absence, the list will contain a path to the last node that matches the key.

ScarletBlue · 2020-02-06T06:38:00Z

src/triedb.rs

+    //      /    \         \
+    // (C, iant) (D, mail)  (E, clang)
+    //
+    // Here proof of key 'gmail' will be [(RLP encoding of A), (RLP encoding of B), (RLP encoding of D)]


Here, the proof of key 'gmail' will be [(RLP encoding of A), (RLP encoding of B), (RLP encoding of D)]

ScarletBlue · 2020-02-06T06:38:31Z

src/triedb.rs

+    // (C, iant) (D, mail)  (E, clang)
+    //
+    // Here proof of key 'gmail' will be [(RLP encoding of A), (RLP encoding of B), (RLP encoding of D)]
+    // proof of key 'galbi' (absence) will be [(RLP encoding of A), (RLP encoding of B)]


Here, the proof of key 'galbi' (absence) will be [(RLP encoding of A), (RLP encoding of B)]

ScarletBlue · 2020-02-06T06:40:19Z

src/triedb.rs

+    // Here proof of key 'gmail' will be [(RLP encoding of A), (RLP encoding of B), (RLP encoding of D)]
+    // proof of key 'galbi' (absence) will be [(RLP encoding of A), (RLP encoding of B)]
+    fn make_proof(&self, key: &H256) -> crate::Result<(CryptoProofUnit, CryptoProof)> {
+        // it makes reversed proof for sake of efficency on push() operation


it creates a reversed proof for the sake of a more efficient push() operation.

ScarletBlue · 2020-02-06T06:41:23Z

src/proof.rs

+/// A verification logic of TrieDB's Merkle proof.
+/// For the format of proof, check the make_proof() function.
+/// It verifies the proof with a given unit of test.
+/// It should never abort or fail, but only return 'false' as result of getting invalid or ill-formed proof.


It should never abort or fail, but only return 'false' as a result of getting an invalid or ill-formed proof.

majecty · 2020-02-06T06:50:32Z

@junha1 Please tell me when your PR is ready to be merged.

Here I implemented creation / verification logic of Merkle proof, with o ur TrieDB. It includes some massive iterative unit tests for some not-ma licious cases.

junha1 requested review from majecty and sgkim126 February 4, 2020 01:50

sgkim126 requested changes Feb 4, 2020

View reviewed changes

src/proof.rs Outdated Show resolved Hide resolved

src/proof.rs Outdated Show resolved Hide resolved

sgkim126 requested changes Feb 4, 2020

View reviewed changes

src/proof.rs Outdated Show resolved Hide resolved

src/proof.rs Outdated Show resolved Hide resolved

src/proof.rs Outdated Show resolved Hide resolved

src/proof.rs Outdated Show resolved Hide resolved

junha1 force-pushed the proof branch from 9c5a51a to 0617de6 Compare February 4, 2020 03:15

junha1 requested a review from sgkim126 February 4, 2020 03:22

sgkim126 reviewed Feb 4, 2020

View reviewed changes

src/proof.rs Outdated Show resolved Hide resolved

majecty requested changes Feb 4, 2020

View reviewed changes

src/proof.rs Outdated Show resolved Hide resolved

junha1 force-pushed the proof branch from 0617de6 to c2d8e28 Compare February 4, 2020 07:47

junha1 requested review from majecty and sgkim126 February 4, 2020 07:55

sgkim126 requested changes Feb 4, 2020

View reviewed changes

junha1 force-pushed the proof branch 2 times, most recently from 6486560 to 0e3fe01 Compare February 4, 2020 10:15

junha1 requested a review from sgkim126 February 4, 2020 10:22

majecty requested changes Feb 5, 2020

View reviewed changes

src/proof.rs Outdated Show resolved Hide resolved

src/triedb.rs Show resolved Hide resolved

junha1 force-pushed the proof branch from 0e3fe01 to 11c5004 Compare February 5, 2020 08:00

junha1 requested a review from majecty February 5, 2020 08:10

junha1 force-pushed the proof branch 3 times, most recently from 9fb12a5 to 8d09ab4 Compare February 6, 2020 04:25

majecty requested a review from ScarletBlue February 6, 2020 04:54

majecty reviewed Feb 6, 2020

View reviewed changes

sgkim126 approved these changes Feb 6, 2020

View reviewed changes

majecty requested changes Feb 6, 2020

View reviewed changes

junha1 force-pushed the proof branch from 8d09ab4 to e965271 Compare February 6, 2020 06:19

majecty approved these changes Feb 6, 2020

View reviewed changes

ScarletBlue suggested changes Feb 6, 2020

View reviewed changes

Implement Merkle proof

f1da2d0

Here I implemented creation / verification logic of Merkle proof, with o ur TrieDB. It includes some massive iterative unit tests for some not-ma licious cases.

junha1 force-pushed the proof branch from e965271 to f1da2d0 Compare February 6, 2020 06:52

ScarletBlue approved these changes Feb 6, 2020

View reviewed changes

majecty merged commit e41cc11 into CodeChain-io:master Feb 6, 2020

majecty mentioned this pull request Feb 13, 2020

Implement ICS PoC CodeChain-io/foundry#105

Closed

11 tasks

Implement Merkle proof #15

Implement Merkle proof #15

Uh oh!

Conversation

junha1 commented Feb 4, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

sgkim126 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

junha1 commented Feb 4, 2020

Uh oh!

Uh oh!

Uh oh!

junha1 commented Feb 4, 2020

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

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!

Uh oh!

Uh oh!

junha1 commented Feb 5, 2020

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

majecty commented Feb 6, 2020

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!

majecty commented Feb 6, 2020

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

junha1 commented Feb 4, 2020 •

edited

Loading