keccak mode

Author: lightsing

Cargo.lock

@@ -21,7 +21,7 @@ tiny-keccak = "2.0"
 
 # dependencies from scroll-tech
 poseidon-bn254 = { git = "https://github.com/scroll-tech/poseidon-bn254", branch = "master", features = ["bn254"] }
-zktrie-ng = { git = "https://github.com/scroll-tech/zktrie-ng", branch = "master", features = ["scroll"] }
+zktrie-ng = { git = "https://github.com/scroll-tech/zktrie-ng", branch = "feat/keccak", features = ["scroll"] }
 
 # binary dependencies
 anyhow = "1.0"
@@ -102,9 +102,9 @@ alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch =
 alloy-sol-types = {git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.10" }
 
 # for local development
-# [patch."https://github.com/scroll-tech/revm"]
-# revm = { path = "../revm/crates/revm" }
-# revm-primitives = { path = "../revm/crates/primitives" }
+#[patch."https://github.com/scroll-tech/revm"]
+#revm = { path = "../revm/crates/revm" }
+#revm-primitives = { path = "../revm/crates/primitives" }
 
 #[profile.release]
 #debug-assertions = true

Cargo.toml

@@ -5,7 +5,7 @@ use sbv::{
     core::{BlockExecutionResult, ChunkInfo, EvmExecutorBuilder, HardforkConfig},
     primitives::{
         types::{BlockTrace, LegacyStorageTrace},
-        zk_trie::db::kv::HashMapDb,
+        zk_trie::{db::kv::HashMapDb, hash::poseidon::Poseidon},
         Block, B256,
     },
 };
@@ -88,6 +88,7 @@ impl RunFileCommand {
         let mut executor = EvmExecutorBuilder::new(&mut code_db, &mut zktrie_db)
             .hardfork_config(fork_config)
             .chain_id(traces[0].chain_id())
+            .hash_scheme(Poseidon)
             .build(traces[0].root_before())?;
         for trace in traces.iter() {
             executor.insert_codes(trace)?;

crates/bin/src/commands/run_file.rs

@@ -1,7 +1,7 @@
 use sbv::primitives::zk_trie::db::NodeDb;
 use sbv::{
     core::{EvmExecutorBuilder, HardforkConfig, VerificationError},
-    primitives::{zk_trie::db::kv::HashMapDb, Block},
+    primitives::{zk_trie::db::kv::HashMapDb, zk_trie::hash::poseidon::Poseidon, Block},
 };
 
 pub fn verify<T: Block + Clone>(
@@ -53,6 +53,7 @@ fn verify_inner<T: Block + Clone>(
     let mut executor = EvmExecutorBuilder::new(&mut code_db, &mut zktrie_db)
         .hardfork_config(*fork_config)
         .chain_id(l2_trace.chain_id())
+        .hash_scheme(Poseidon)
         .build(root_before)?;
 
     executor.insert_codes(&l2_trace)?;

crates/bin/src/utils.rs

@@ -10,7 +10,7 @@ use sbv_primitives::{
             kv::{KVDatabase, KVDatabaseItem},
             NodeDb,
         },
-        hash::{key_hasher::NoCacheHasher, poseidon::Poseidon, ZkHash},
+        hash::{key_hasher::NoCacheHasher, HashScheme, ZkHash},
         scroll_types::Account,
         trie::ZkTrie,
     },
@@ -21,7 +21,7 @@ use std::{cell::RefCell, collections::HashMap, fmt};
 type Result<T, E = DatabaseError> = std::result::Result<T, E>;
 
 /// A database that consists of account and storage information.
-pub struct EvmDatabase<'a, CodeDb, ZkDb> {
+pub struct EvmDatabase<'a, CodeDb, ZkDb, H> {
     /// Map of code hash to bytecode.
     pub(crate) code_db: &'a mut CodeDb,
     /// Cache of analyzed code
@@ -30,24 +30,26 @@ pub struct EvmDatabase<'a, CodeDb, ZkDb> {
     storage_root_caches: RefCell<HashMap<Address, ZkHash>>,
     /// Storage trie cache, avoid re-creating trie for the same account.
     /// Need to invalidate before `update`, otherwise the trie root may be outdated
-    storage_trie_caches: RefCell<HashMap<ZkHash, Option<ZkTrie<Poseidon>>>>,
+    storage_trie_caches: RefCell<HashMap<ZkHash, Option<ZkTrie<H>>>>,
     /// Current uncommitted zkTrie root based on the block trace.
     committed_zktrie_root: B256,
     /// The underlying zkTrie database.
     pub(crate) zktrie_db: &'a mut NodeDb<ZkDb>,
     /// Current view of zkTrie database.
-    zktrie: ZkTrie<Poseidon>,
+    zktrie: ZkTrie<H>,
 }
 
-impl<CodeDb, Db> fmt::Debug for EvmDatabase<'_, CodeDb, Db> {
+impl<CodeDb, Db, HashScheme> fmt::Debug for EvmDatabase<'_, CodeDb, Db, HashScheme> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("EvmDatabase")
             .field("committed_zktrie_root", &self.committed_zktrie_root)
             .finish()
     }
 }
 
-impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmDatabase<'a, CodeDb, ZkDb> {
+impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static, H: HashScheme>
+    EvmDatabase<'a, CodeDb, ZkDb, H>
+{
     /// Initialize an EVM database from a zkTrie root.
     pub fn new_from_root(
         committed_zktrie_root: B256,
@@ -79,7 +81,7 @@ impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmDatabase<'a, CodeDb,
     }
 
     #[inline]
-    pub(crate) fn update_storage_root_cache(&self, address: Address, storage_root: ZkTrie) {
+    pub(crate) fn update_storage_root_cache(&self, address: Address, storage_root: ZkTrie<H>) {
         let new_root = *storage_root.root().unwrap_ref();
         let old = self
             .storage_root_caches
@@ -142,7 +144,9 @@ impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmDatabase<'a, CodeDb,
     }
 }
 
-impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> DatabaseRef for EvmDatabase<'_, CodeDb, ZkDb> {
+impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static, H: HashScheme> DatabaseRef
+    for EvmDatabase<'_, CodeDb, ZkDb, H>
+{
     type Error = DatabaseError;
 
     /// Get basic account information.

crates/core/src/database.rs

@@ -1,97 +1,125 @@
 use crate::{error::DatabaseError, EvmDatabase, EvmExecutor, HardforkConfig};
 use revm::db::CacheDB;
 use sbv_primitives::{
-    alloy_primitives::ChainId, zk_trie::db::kv::KVDatabase, zk_trie::db::NodeDb, B256,
+    alloy_primitives::ChainId,
+    zk_trie::{
+        db::{kv::KVDatabase, NodeDb},
+        hash::HashScheme,
+    },
+    B256,
 };
 use std::fmt::{self, Debug};
 
 /// Builder for EVM executor.
-pub struct EvmExecutorBuilder<'a, H, C, CodeDb, ZkDb> {
-    hardfork_config: H,
+pub struct EvmExecutorBuilder<'a, HC, C, CodeDb, ZkDb, H> {
+    hardfork_config: HC,
     chain_id: C,
     code_db: &'a mut CodeDb,
     zktrie_db: &'a mut NodeDb<ZkDb>,
+    hash_scheme: H,
 }
 
-impl<H: Debug, C: Debug, CodeDb, ZkDb> Debug for EvmExecutorBuilder<'_, H, C, CodeDb, ZkDb> {
+impl<HC: Debug, C: Debug, CodeDb, ZkDb, H: Debug> Debug
+    for EvmExecutorBuilder<'_, HC, C, CodeDb, ZkDb, H>
+{
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("EvmExecutorBuilder")
             .field("hardfork_config", &self.hardfork_config)
             .field("chain_id", &self.chain_id)
             .field("code_db", &"...")
             .field("zktrie_db", &"...")
+            .field("hash_scheme", &self.hash_scheme)
             .finish()
     }
 }
 
-impl<'a, CodeDb, ZkDb> EvmExecutorBuilder<'a, (), (), CodeDb, ZkDb> {
+impl<'a, CodeDb, ZkDb> EvmExecutorBuilder<'a, (), (), CodeDb, ZkDb, ()> {
     /// Create a new builder.
     pub fn new(code_db: &'a mut CodeDb, zktrie_db: &'a mut NodeDb<ZkDb>) -> Self {
         Self {
             hardfork_config: (),
             chain_id: (),
             code_db,
             zktrie_db,
+            hash_scheme: (),
         }
     }
 }
 
-impl<'a, H, C, CodeDb, ZkDb> EvmExecutorBuilder<'a, H, C, CodeDb, ZkDb> {
+impl<'a, HC, C, CodeDb, ZkDb, H> EvmExecutorBuilder<'a, HC, C, CodeDb, ZkDb, H> {
     /// Set hardfork config.
     pub fn hardfork_config<H1>(
         self,
         hardfork_config: H1,
-    ) -> EvmExecutorBuilder<'a, H1, C, CodeDb, ZkDb> {
+    ) -> EvmExecutorBuilder<'a, H1, C, CodeDb, ZkDb, H> {
         EvmExecutorBuilder {
             hardfork_config,
             chain_id: self.chain_id,
             code_db: self.code_db,
             zktrie_db: self.zktrie_db,
+            hash_scheme: self.hash_scheme,
         }
     }
 
     /// Set chain id.
-    pub fn chain_id<C1>(self, chain_id: C1) -> EvmExecutorBuilder<'a, H, C1, CodeDb, ZkDb> {
+    pub fn chain_id<C1>(self, chain_id: C1) -> EvmExecutorBuilder<'a, HC, C1, CodeDb, ZkDb, H> {
         EvmExecutorBuilder {
             hardfork_config: self.hardfork_config,
             chain_id,
             code_db: self.code_db,
             zktrie_db: self.zktrie_db,
+            hash_scheme: self.hash_scheme,
         }
     }
 
     /// Set code db.
     pub fn code_db<CodeDb1>(
         self,
         code_db: &'a mut CodeDb1,
-    ) -> EvmExecutorBuilder<'a, H, C, CodeDb1, ZkDb> {
+    ) -> EvmExecutorBuilder<'a, HC, C, CodeDb1, ZkDb, H> {
         EvmExecutorBuilder {
             hardfork_config: self.hardfork_config,
             chain_id: self.chain_id,
             code_db,
             zktrie_db: self.zktrie_db,
+            hash_scheme: self.hash_scheme,
         }
     }
 
     /// Set zktrie db.
     pub fn zktrie_db<ZkDb1>(
         self,
         zktrie_db: &'a mut NodeDb<ZkDb1>,
-    ) -> EvmExecutorBuilder<H, C, CodeDb, ZkDb1> {
+    ) -> EvmExecutorBuilder<HC, C, CodeDb, ZkDb1, H> {
         EvmExecutorBuilder {
             hardfork_config: self.hardfork_config,
             chain_id: self.chain_id,
             code_db: self.code_db,
             zktrie_db,
+            hash_scheme: self.hash_scheme,
+        }
+    }
+
+    /// Set hash scheme.
+    pub fn hash_scheme<H1>(
+        self,
+        hash_scheme: H1,
+    ) -> EvmExecutorBuilder<'a, HC, C, CodeDb, ZkDb, H1> {
+        EvmExecutorBuilder {
+            hardfork_config: self.hardfork_config,
+            chain_id: self.chain_id,
+            code_db: self.code_db,
+            zktrie_db: self.zktrie_db,
+            hash_scheme,
         }
     }
 }
 
-impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static>
-    EvmExecutorBuilder<'a, HardforkConfig, ChainId, CodeDb, ZkDb>
+impl<'a, CodeDb: KVDatabase, ZkDb: KVDatabase + 'static, H: HashScheme>
+    EvmExecutorBuilder<'a, HardforkConfig, ChainId, CodeDb, ZkDb, H>
 {
     /// Initialize an EVM executor from a block trace as the initial state.
-    pub fn build(self, root: B256) -> Result<EvmExecutor<'a, CodeDb, ZkDb>, DatabaseError> {
+    pub fn build(self, root: B256) -> Result<EvmExecutor<'a, CodeDb, ZkDb, H>, DatabaseError> {
         let db = cycle_track!(
             CacheDB::new(EvmDatabase::new_from_root(
                 root,

crates/core/src/executor/builder.rs

@@ -12,7 +12,7 @@ use sbv_primitives::{
     alloy_primitives::Bytes,
     zk_trie::{
         db::kv::KVDatabase,
-        hash::{key_hasher::NoCacheHasher, poseidon::Poseidon},
+        hash::{key_hasher::NoCacheHasher, HashScheme},
         scroll_types::Account,
         trie::ZkTrie,
     },
@@ -24,10 +24,10 @@ mod builder;
 pub use builder::EvmExecutorBuilder;
 
 /// EVM executor that handles the block.
-pub struct EvmExecutor<'db, CodeDb, ZkDb> {
+pub struct EvmExecutor<'db, CodeDb, ZkDb, H> {
     chain_id: ChainId,
     hardfork_config: HardforkConfig,
-    db: CacheDB<EvmDatabase<'db, CodeDb, ZkDb>>,
+    db: CacheDB<EvmDatabase<'db, CodeDb, ZkDb, H>>,
 }
 
 /// Block execution result
@@ -39,9 +39,11 @@ pub struct BlockExecutionResult {
     pub tx_rlps: Vec<Bytes>,
 }
 
-impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmExecutor<'_, CodeDb, ZkDb> {
+impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static, H: HashScheme>
+    EvmExecutor<'_, CodeDb, ZkDb, H>
+{
     /// Get reference to the DB
-    pub fn db(&self) -> &CacheDB<EvmDatabase<CodeDb, ZkDb>> {
+    pub fn db(&self) -> &CacheDB<EvmDatabase<CodeDb, ZkDb, H>> {
         &self.db
     }
 
@@ -190,7 +192,7 @@ impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmExecutor<'_, CodeDb, ZkD
     }
 
     fn commit_changes_inner(&mut self) -> Result<B256, DatabaseError> {
-        let mut zktrie = ZkTrie::<Poseidon>::new_with_root(
+        let mut zktrie = ZkTrie::<H>::new_with_root(
             self.db.db.zktrie_db,
             NoCacheHasher,
             self.db.db.committed_zktrie_root(),
@@ -245,7 +247,7 @@ impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmExecutor<'_, CodeDb, ZkD
                 // get storage tire
                 cycle_tracker_start!("update storage_tire");
                 let mut storage_trie = cycle_track!(
-                    ZkTrie::<Poseidon>::new_with_root(
+                    ZkTrie::<H>::new_with_root(
                         self.db.db.zktrie_db,
                         NoCacheHasher,
                         storage_root_before,
@@ -357,7 +359,7 @@ impl<CodeDb: KVDatabase, ZkDb: KVDatabase + 'static> EvmExecutor<'_, CodeDb, ZkD
     }
 }
 
-impl<CodeDb, ZkDb> Debug for EvmExecutor<'_, CodeDb, ZkDb> {
+impl<CodeDb, ZkDb, H> Debug for EvmExecutor<'_, CodeDb, ZkDb, H> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("EvmExecutor").field("db", &self.db).finish()
     }

crates/core/src/executor/mod.rs

@@ -21,8 +21,9 @@ thiserror.workspace = true
 tokio = { workspace = true, features = ["fs", "io-util", "macros", "rt-multi-thread", "signal", "sync", "time"] }
 tokio-retry.workspace = true
 url.workspace = true
+zktrie-ng = { workspace = true, features = ["clap", "serde"] }
 
-sbv = { workspace = true, features = ["sled"]}
+sbv = { workspace = true, features = ["sled"] }
 
 tracing-subscriber = { workspace = true, optional = true }