feat: add tests from github.com/jsign/verkle-test-vectors

morph-dev · morph-dev · commit 377ed98b22f6 · 2024-04-12T21:21:18.000+03:00
diff --git a/verkle/src/account.rs b/verkle/src/account.rs
@@ -0,0 +1,115 @@
+use alloy_primitives::{Address, B128, B256, U256};
+use banderwagon::Fr;
+
+use crate::{
+    committer::DEFAULT_COMMITER,
+    constants::{
+        BALANCE_LEAF_KEY, CODE_KECCAK_LEAF_KEY, CODE_OFFSET, CODE_SIZE_LEAF_KEY,
+        HEADER_STORAGE_OFFSET, MAIN_STORAGE_OFFSET, NONCE_LEAF_KEY, VERKLE_NODE_WIDTH_U256,
+        VERSION_LEAF_KEY,
+    },
+    stem::Stem,
+    utils::fr_to_b256,
+    TrieKey, TrieValue,
+};
+
+pub struct AccountStorageLayout {
+    pub address: Address,
+    base_storage_stem: Stem,
+}
+
+impl AccountStorageLayout {
+    pub fn new(address: Address) -> Self {
+        Self {
+            address,
+            base_storage_stem: tree_key(address, U256::ZERO, 0).into(),
+        }
+    }
+
+    pub fn version_key(&self) -> TrieKey {
+        TrieKey::from_stem_and_last_byte(&self.base_storage_stem, VERSION_LEAF_KEY)
+    }
+
+    pub fn balance_key(&self) -> TrieKey {
+        TrieKey::from_stem_and_last_byte(&self.base_storage_stem, BALANCE_LEAF_KEY)
+    }
+
+    pub fn nonce_key(&self) -> TrieKey {
+        TrieKey::from_stem_and_last_byte(&self.base_storage_stem, NONCE_LEAF_KEY)
+    }
+
+    pub fn code_hash_key(&self) -> TrieKey {
+        TrieKey::from_stem_and_last_byte(&self.base_storage_stem, CODE_KECCAK_LEAF_KEY)
+    }
+
+    pub fn code_size_key(&self) -> TrieKey {
+        TrieKey::from_stem_and_last_byte(&self.base_storage_stem, CODE_SIZE_LEAF_KEY)
+    }
+
+    pub fn storage_slot_key(&self, storage_key: U256) -> TrieKey {
+        let pos = if storage_key < CODE_OFFSET - HEADER_STORAGE_OFFSET {
+            HEADER_STORAGE_OFFSET + storage_key
+        } else {
+            MAIN_STORAGE_OFFSET + storage_key
+        };
+        tree_key(
+            self.address,
+            pos / VERKLE_NODE_WIDTH_U256,
+            (pos % VERKLE_NODE_WIDTH_U256).byte(0),
+        )
+    }
+
+    pub fn code_key(&self, chunk_id: usize) -> TrieKey {
+        let pos = CODE_OFFSET + U256::from(chunk_id);
+        tree_key(
+            self.address,
+            pos / VERKLE_NODE_WIDTH_U256,
+            (pos % VERKLE_NODE_WIDTH_U256).byte(0),
+        )
+    }
+
+    pub fn chunkify_code(&self, code: &[u8]) -> Vec<(TrieKey, TrieValue)> {
+        const PUSH_OFFSET: u8 = 95;
+        const PUSH1: u8 = PUSH_OFFSET + 1;
+        const PUSH32: u8 = PUSH_OFFSET + 32;
+
+        let mut remaining_push_data = 0u8;
+        let mut result = vec![];
+        for (chunk_id, chunk) in code.chunks(31).enumerate() {
+            let mut value = Vec::with_capacity(32);
+            value.push(remaining_push_data.min(31));
+            value.extend(chunk);
+            value.resize(32, 0);
+            result.push((self.code_key(chunk_id), TrieValue::from_le_slice(&value)));
+
+            for chunk_byte in chunk {
+                if remaining_push_data > 0 {
+                    remaining_push_data -= 1;
+                } else if (PUSH1..=PUSH32).contains(chunk_byte) {
+                    remaining_push_data = chunk_byte - PUSH_OFFSET;
+                }
+            }
+        }
+        result
+    }
+}
+
+fn tree_key(address: Address, tree_index: U256, sub_index: u8) -> TrieKey {
+    let address_bytes = *B256::left_padding_from(address.as_slice());
+    let tree_index_bytes = tree_index.to_le_bytes::<32>();
+
+    let scalars = [
+        2u128 + 256 * 64,
+        u128::from_le_bytes(B128::from_slice(&address_bytes[..16]).0),
+        u128::from_le_bytes(B128::from_slice(&address_bytes[16..]).0),
+        u128::from_le_bytes(B128::from_slice(&tree_index_bytes[..16]).0),
+        u128::from_le_bytes(B128::from_slice(&tree_index_bytes[16..]).0),
+    ]
+    .map(Fr::from);
+    let commitment = DEFAULT_COMMITER.commit_lagrange(&scalars);
+    let hash_commitment = commitment.map_to_scalar_field();
+
+    let mut key = fr_to_b256(&hash_commitment);
+    key[31] = sub_index;
+    key.into()
+}
diff --git a/verkle/src/constants.rs b/verkle/src/constants.rs
@@ -1 +1,14 @@
+use alloy_primitives::U256;
+
 pub const VERKLE_NODE_WIDTH: usize = 256;
+pub const VERKLE_NODE_WIDTH_U256: U256 = U256::from_limbs([256, 0, 0, 0]);
+
+// Storage layout parameters
+pub const VERSION_LEAF_KEY: u8 = 0;
+pub const BALANCE_LEAF_KEY: u8 = 1;
+pub const NONCE_LEAF_KEY: u8 = 2;
+pub const CODE_KECCAK_LEAF_KEY: u8 = 3;
+pub const CODE_SIZE_LEAF_KEY: u8 = 4;
+pub const HEADER_STORAGE_OFFSET: U256 = U256::from_limbs([64, 0, 0, 0]);
+pub const CODE_OFFSET: U256 = U256::from_limbs([128, 0, 0, 0]);
+pub const MAIN_STORAGE_OFFSET: U256 = U256::from_limbs([0, 0, 0, 2u64.pow(56)]);
diff --git a/verkle/src/lib.rs b/verkle/src/lib.rs
@@ -2,8 +2,10 @@ use alloy_primitives::{B256, U256};
 use derive_more::{Constructor, Deref, From, Index};
 
 use banderwagon::Fr;
+use stem::Stem;
 pub use trie::Trie;
 
+pub mod account;
 mod committer;
 mod constants;
 pub mod crs;
@@ -20,6 +22,12 @@ type Db = dyn db::Db<Fr, Vec<u8>>;
 pub struct TrieKey(B256);
 
 impl TrieKey {
+    pub fn from_stem_and_last_byte(stem: &Stem, last_byte: u8) -> Self {
+        let mut key = B256::right_padding_from(stem.as_slice());
+        key[B256::len_bytes() - 1] = last_byte;
+        key.into()
+    }
+
     pub fn length() -> usize {
         B256::len_bytes()
     }
diff --git a/verkle/src/nodes/branch.rs b/verkle/src/nodes/branch.rs
@@ -64,7 +64,7 @@ impl Default for BranchNode {
 }
 
 impl NodeTrait for BranchNode {
-    fn commitment(&self) -> Fr {
+    fn hash_commitment(&self) -> Fr {
         self.cp.map_to_scalar_field()
     }
 }
@@ -83,7 +83,7 @@ impl Encode for BranchNode {
                 if node.is_empty() {
                     None
                 } else {
-                    Some((index as u8, fr_to_b256(&node.commitment())))
+                    Some((index as u8, fr_to_b256(&node.hash_commitment())))
                 }
             })
             .collect();
diff --git a/verkle/src/nodes/leaf.rs b/verkle/src/nodes/leaf.rs
@@ -63,13 +63,12 @@ impl LeafNode {
         &self.stem
     }
 
-    fn calculate_commitment(&self) -> Fr {
-        let c = self.const_cp
+    fn calculate_commitment(&self) -> Element {
+        self.const_cp
             + DEFAULT_COMMITER.commit_sparse(vec![
                 (2, self.cp1.map_to_scalar_field()),
                 (3, self.cp2.map_to_scalar_field()),
-            ]);
-        c.map_to_scalar_field()
+            ])
     }
 
     pub fn get(&self, index: u8) -> Option<&TrieValue> {
@@ -119,12 +118,13 @@ impl LeafNode {
 }
 
 impl NodeTrait for LeafNode {
-    fn commitment(&self) -> Fr {
-        self.c.unwrap_or_else(|| self.calculate_commitment())
+    fn hash_commitment(&self) -> Fr {
+        self.c
+            .unwrap_or_else(|| self.calculate_commitment().map_to_scalar_field())
     }
 
     fn commit(&mut self) -> Fr {
-        self.c = self.c.or_else(|| Some(self.calculate_commitment()));
+        self.c = Some(self.hash_commitment());
         self.c.expect("Value must be present")
     }
 }
diff --git a/verkle/src/nodes/node.rs b/verkle/src/nodes/node.rs
@@ -10,10 +10,10 @@ use crate::{Db, TrieKey, TrieValue};
 use super::{BranchNode, LeafNode};
 
 pub trait NodeTrait {
-    fn commitment(&self) -> Fr;
+    fn hash_commitment(&self) -> Fr;
 
     fn commit(&mut self) -> Fr {
-        self.commitment()
+        self.hash_commitment()
     }
 }
 
@@ -25,11 +25,11 @@ pub enum Node {
 }
 
 impl NodeTrait for Node {
-    fn commitment(&self) -> Fr {
+    fn hash_commitment(&self) -> Fr {
         match self {
             Node::Empty => Fr::zero(),
-            Node::Branch(branch_node) => branch_node.commitment(),
-            Node::Leaf(leaf_node) => leaf_node.commitment(),
+            Node::Branch(branch_node) => branch_node.hash_commitment(),
+            Node::Leaf(leaf_node) => leaf_node.hash_commitment(),
             Node::Commitment(c) => *c,
         }
     }
@@ -50,12 +50,12 @@ impl Node {
     }
 
     pub fn check(&self, commitment: &Fr) -> Result<()> {
-        if &self.commitment() == commitment {
+        if &self.hash_commitment() == commitment {
             Ok(())
         } else {
             Err(anyhow!(
                 "Node's commitment {:?} doesn't match expected {commitment:?}",
-                self.commitment()
+                self.hash_commitment()
             ))
         }
     }
diff --git a/verkle/src/stem.rs b/verkle/src/stem.rs
@@ -3,34 +3,42 @@ use ssz::{Decode, Encode};
 
 use crate::TrieKey;
 
-const STEM_LENGTH: usize = 31;
-
 #[derive(PartialEq, Eq, AsRef, Deref, Index)]
-pub struct Stem([u8; STEM_LENGTH]);
+pub struct Stem([u8; Self::STEM_LENGTH]);
+
+impl Stem {
+    const STEM_LENGTH: usize = 31;
+}
 
 impl From<&TrieKey> for Stem {
     fn from(key: &TrieKey) -> Self {
-        let mut stem = [0u8; STEM_LENGTH];
-        stem.copy_from_slice(&key[..STEM_LENGTH]);
+        let mut stem = [0u8; Self::STEM_LENGTH];
+        stem.copy_from_slice(&key[..Self::STEM_LENGTH]);
         Stem(stem)
     }
 }
 
+impl From<TrieKey> for Stem {
+    fn from(key: TrieKey) -> Self {
+        Self::from(&key)
+    }
+}
+
 impl Encode for Stem {
     fn is_ssz_fixed_len() -> bool {
         true
     }
 
     fn ssz_fixed_len() -> usize {
-        STEM_LENGTH
+        Self::STEM_LENGTH
     }
 
     fn ssz_append(&self, buf: &mut Vec<u8>) {
         buf.extend(self.as_ref())
     }
 
     fn ssz_bytes_len(&self) -> usize {
-        STEM_LENGTH
+        Self::STEM_LENGTH
     }
 }
 
@@ -40,15 +48,15 @@ impl Decode for Stem {
     }
 
     fn ssz_fixed_len() -> usize {
-        STEM_LENGTH
+        Self::STEM_LENGTH
     }
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
         match <[u8; 31]>::try_from(bytes) {
             Ok(stem) => Ok(Self(stem)),
             Err(_) => Err(ssz::DecodeError::InvalidByteLength {
                 len: bytes.len(),
-                expected: STEM_LENGTH,
+                expected: Self::STEM_LENGTH,
             }),
         }
     }
diff --git a/verkle/src/trie.rs b/verkle/src/trie.rs
@@ -1,8 +1,9 @@
-use alloy_primitives::B256;
+use alloy_primitives::{keccak256, Address, B256, U256};
 use anyhow::Result;
 use banderwagon::Fr;
 
 use crate::{
+    account::AccountStorageLayout,
     nodes::{BranchNode, Node},
     utils::{b256_to_fr, fr_to_b256},
     Db, TrieKey, TrieValue,
@@ -45,6 +46,43 @@ impl Trie {
     pub fn root_hash_commitment(&mut self) -> Result<Fr> {
         self.root.write_and_commit(self.db.as_mut())
     }
+
+    pub fn create_eoa(&mut self, address: Address, balance: U256, nonce: u64) -> Result<()> {
+        let storage = AccountStorageLayout::new(address);
+        self.insert(storage.version_key(), TrieValue::ZERO)?;
+        self.insert(storage.balance_key(), balance)?;
+        self.insert(storage.nonce_key(), TrieValue::from(nonce))?;
+        self.insert(
+            storage.code_hash_key(),
+            TrieValue::from_le_slice(
+                hex::decode("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")?
+                    .as_slice(),
+            ),
+        )?;
+        Ok(())
+    }
+
+    pub fn create_sc(
+        &mut self,
+        address: Address,
+        balance: U256,
+        nonce: u64,
+        code: Vec<u8>,
+    ) -> Result<()> {
+        let storage = AccountStorageLayout::new(address);
+        self.insert(storage.version_key(), TrieValue::ZERO)?;
+        self.insert(storage.balance_key(), balance)?;
+        self.insert(storage.nonce_key(), TrieValue::from(nonce))?;
+        self.insert(
+            storage.code_hash_key(),
+            TrieValue::from_le_bytes(keccak256(&code).0),
+        )?;
+        self.insert(storage.code_size_key(), TrieValue::from(code.len()))?;
+        for (chunk_key, chunk_value) in storage.chunkify_code(&code) {
+            self.insert(chunk_key, chunk_value)?;
+        }
+        Ok(())
+    }
 }
 
 #[cfg(test)]
diff --git a/verkle/tests/golang_interop.rs b/verkle/tests/golang_interop.rs
diff --git a/verkle/tests/verkle_test_vectors.rs b/verkle/tests/verkle_test_vectors.rs

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ impl Default for BranchNode {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`impl NodeTrait for BranchNode {`
`67`		`- fn commitment(&self) -> Fr {`
	`67`	`+ fn hash_commitment(&self) -> Fr {`
`68`	`68`	`self.cp.map_to_scalar_field()`
`69`	`69`	`}`
`70`	`70`	`}`
`@@ -83,7 +83,7 @@ impl Encode for BranchNode {`
`83`	`83`	`if node.is_empty() {`
`84`	`84`	`None`
`85`	`85`	`} else {`
`86`		`- Some((index as u8, fr_to_b256(&node.commitment())))`
	`86`	`+ Some((index as u8, fr_to_b256(&node.hash_commitment())))`
`87`	`87`	`}`
`88`	`88`	`})`
`89`	`89`	`.collect();`
Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,12 @@ impl LeafNode {`
`63`	`63`	`&self.stem`
`64`	`64`	`}`
`65`	`65`
`66`		`- fn calculate_commitment(&self) -> Fr {`
`67`		`- let c = self.const_cp`
	`66`	`+ fn calculate_commitment(&self) -> Element {`
	`67`	`+ self.const_cp`
`68`	`68`	`+ DEFAULT_COMMITER.commit_sparse(vec![`
`69`	`69`	`(2, self.cp1.map_to_scalar_field()),`
`70`	`70`	`(3, self.cp2.map_to_scalar_field()),`
`71`		`- ]);`
`72`		`- c.map_to_scalar_field()`
	`71`	`+ ])`
`73`	`72`	`}`
`74`	`73`
`75`	`74`	`pub fn get(&self, index: u8) -> Option<&TrieValue> {`
`@@ -119,12 +118,13 @@ impl LeafNode {`
`119`	`118`	`}`
`120`	`119`
`121`	`120`	`impl NodeTrait for LeafNode {`
`122`		`- fn commitment(&self) -> Fr {`
`123`		`- self.c.unwrap_or_else(\|\| self.calculate_commitment())`
	`121`	`+ fn hash_commitment(&self) -> Fr {`
	`122`	`+ self.c`
	`123`	`+ .unwrap_or_else(\|\| self.calculate_commitment().map_to_scalar_field())`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`fn commit(&mut self) -> Fr {`
`127`		`- self.c = self.c.or_else(\|\| Some(self.calculate_commitment()));`
	`127`	`+ self.c = Some(self.hash_commitment());`
`128`	`128`	`self.c.expect("Value must be present")`
`129`	`129`	`}`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,10 @@ use crate::{Db, TrieKey, TrieValue};`
`10`	`10`	`use super::{BranchNode, LeafNode};`
`11`	`11`
`12`	`12`	`pub trait NodeTrait {`
`13`		`- fn commitment(&self) -> Fr;`
	`13`	`+ fn hash_commitment(&self) -> Fr;`
`14`	`14`
`15`	`15`	`fn commit(&mut self) -> Fr {`
`16`		`- self.commitment()`
	`16`	`+ self.hash_commitment()`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`@@ -25,11 +25,11 @@ pub enum Node {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`impl NodeTrait for Node {`
`28`		`- fn commitment(&self) -> Fr {`
	`28`	`+ fn hash_commitment(&self) -> Fr {`
`29`	`29`	`match self {`
`30`	`30`	`Node::Empty => Fr::zero(),`
`31`		`- Node::Branch(branch_node) => branch_node.commitment(),`
`32`		`- Node::Leaf(leaf_node) => leaf_node.commitment(),`
	`31`	`+ Node::Branch(branch_node) => branch_node.hash_commitment(),`
	`32`	`+ Node::Leaf(leaf_node) => leaf_node.hash_commitment(),`
`33`	`33`	`Node::Commitment(c) => *c,`
`34`	`34`	`}`
`35`	`35`	`}`
`@@ -50,12 +50,12 @@ impl Node {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`pub fn check(&self, commitment: &Fr) -> Result<()> {`
`53`		`- if &self.commitment() == commitment {`
	`53`	`+ if &self.hash_commitment() == commitment {`
`54`	`54`	`Ok(())`
`55`	`55`	`} else {`
`56`	`56`	`Err(anyhow!(`
`57`	`57`	`"Node's commitment {:?} doesn't match expected {commitment:?}",`
`58`		`- self.commitment()`
	`58`	`+ self.hash_commitment()`
`59`	`59`	`))`
`60`	`60`	`}`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,34 +3,42 @@ use ssz::{Decode, Encode};`
`3`	`3`
`4`	`4`	`use crate::TrieKey;`
`5`	`5`
`6`		`-const STEM_LENGTH: usize = 31;`
`7`		`-`
`8`	`6`	`#[derive(PartialEq, Eq, AsRef, Deref, Index)]`
`9`		`-pub struct Stem([u8; STEM_LENGTH]);`
	`7`	`+pub struct Stem([u8; Self::STEM_LENGTH]);`
	`8`	`+`
	`9`	`+impl Stem {`
	`10`	`+ const STEM_LENGTH: usize = 31;`
	`11`	`+}`
`10`	`12`
`11`	`13`	`impl From<&TrieKey> for Stem {`
`12`	`14`	`fn from(key: &TrieKey) -> Self {`
`13`		`- let mut stem = [0u8; STEM_LENGTH];`
`14`		`- stem.copy_from_slice(&key[..STEM_LENGTH]);`
	`15`	`+ let mut stem = [0u8; Self::STEM_LENGTH];`
	`16`	`+ stem.copy_from_slice(&key[..Self::STEM_LENGTH]);`
`15`	`17`	`Stem(stem)`
`16`	`18`	`}`
`17`	`19`	`}`
`18`	`20`
	`21`	`+impl From<TrieKey> for Stem {`
	`22`	`+ fn from(key: TrieKey) -> Self {`
	`23`	`+ Self::from(&key)`
	`24`	`+ }`
	`25`	`+}`
	`26`	`+`
`19`	`27`	`impl Encode for Stem {`
`20`	`28`	`fn is_ssz_fixed_len() -> bool {`
`21`	`29`	`true`
`22`	`30`	`}`
`23`	`31`
`24`	`32`	`fn ssz_fixed_len() -> usize {`
`25`		`- STEM_LENGTH`
	`33`	`+ Self::STEM_LENGTH`
`26`	`34`	`}`
`27`	`35`
`28`	`36`	`fn ssz_append(&self, buf: &mut Vec<u8>) {`
`29`	`37`	`buf.extend(self.as_ref())`
`30`	`38`	`}`
`31`	`39`
`32`	`40`	`fn ssz_bytes_len(&self) -> usize {`
`33`		`- STEM_LENGTH`
	`41`	`+ Self::STEM_LENGTH`
`34`	`42`	`}`
`35`	`43`	`}`
`36`	`44`
`@@ -40,15 +48,15 @@ impl Decode for Stem {`
`40`	`48`	`}`
`41`	`49`
`42`	`50`	`fn ssz_fixed_len() -> usize {`
`43`		`- STEM_LENGTH`
	`51`	`+ Self::STEM_LENGTH`
`44`	`52`	`}`
`45`	`53`
`46`	`54`	`fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {`
`47`	`55`	`match <[u8; 31]>::try_from(bytes) {`
`48`	`56`	`Ok(stem) => Ok(Self(stem)),`
`49`	`57`	`Err(_) => Err(ssz::DecodeError::InvalidByteLength {`
`50`	`58`	`len: bytes.len(),`
`51`		`- expected: STEM_LENGTH,`
	`59`	`+ expected: Self::STEM_LENGTH,`
`52`	`60`	`}),`
`53`	`61`	`}`
`54`	`62`	`}`