perf(l1,l2): use keccak-asm

Cargo.toml

@@ -74,6 +74,7 @@ tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
 
 async-trait = "0.1.88"
 ethereum-types = { version = "0.15.1", features = ["serialize"] }
+keccak-asm.version = "0.1.4"
 serde = { version = "1.0.203", features = ["derive"] }
 serde_with = "3.11.0"
 serde_json = "1.0.117"
@@ -85,7 +86,6 @@ hex-literal = "0.4.1"
 crc32fast = "1.4.2"
 lazy_static = "1.5.0"
 sha2 = "0.10.8"
-sha3 = "0.10.8"
 tokio-util = { version = "0.7.15", features = ["rt"] }
 jsonwebtoken = "9.3.0"
 rand = "0.8.5"

crates/blockchain/Cargo.toml

@@ -16,7 +16,7 @@ ethrex-vm.workspace = true
 secp256k1.workspace = true
 
 thiserror.workspace = true
-sha3.workspace = true
+keccak-asm.workspace = true
 tracing.workspace = true
 bytes.workspace = true
 hex.workspace = true

crates/blockchain/payload.rs

@@ -23,7 +23,7 @@ use ethrex_vm::{Evm, EvmError};
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_storage::{Store, error::StoreError};
 
-use sha3::{Digest, Keccak256};
+use keccak_asm::{Digest, Keccak256};
 
 use ethrex_metrics::metrics;
 

crates/common/Cargo.toml

@@ -20,7 +20,7 @@ serde_json.workspace = true
 thiserror.workspace = true
 sha2.workspace = true
 kzg-rs.workspace = true
-sha3.workspace = true
+keccak-asm.workspace = true
 secp256k1.workspace = true
 once_cell = "1.20.2"
 libc = "0.2"

crates/common/constants.rs

@@ -1,6 +1,6 @@
 use crate::H256;
 use ethrex_rlp::constants::RLP_NULL;
-use sha3::{Digest as _, Keccak256};
+use keccak_asm::{Digest as _, Keccak256};
 use std::{str::FromStr, sync::LazyLock};
 
 // = Keccak256(RLP([])) as of EIP-3675

crates/common/evm.rs

@@ -1,6 +1,6 @@
 use ethereum_types::Address;
 use ethrex_rlp::encode::RLPEncode;
-use sha3::{Digest, Keccak256};
+use keccak_asm::{Digest, Keccak256};
 
 /// Calculates the address of a new conctract using the CREATE
 /// opcode as follows:

crates/common/trie/Cargo.toml

@@ -14,7 +14,7 @@ anyhow = "1.0.86"
 bytes.workspace = true
 tracing.workspace = true
 thiserror.workspace = true
-sha3.workspace = true
+keccak-asm.workspace = true
 hex.workspace = true
 serde.workspace = true
 serde_json = "1.0.117"

crates/common/trie/node_hash.rs

@@ -1,6 +1,6 @@
 use ethereum_types::H256;
 use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode, error::RLPDecodeError, structs::Encoder};
-use sha3::{Digest, Keccak256};
+use keccak_asm::{Digest, Keccak256};
 
 /// Struct representing a trie node hash
 /// If the encoded node is less than 32 bits, contains the encoded node itself

crates/common/trie/trie.rs

@@ -13,7 +13,7 @@ mod verify_range;
 use ethereum_types::H256;
 use ethrex_rlp::constants::RLP_NULL;
 use ethrex_rlp::encode::RLPEncode;
-use sha3::{Digest, Keccak256};
+use keccak_asm::{Digest, Keccak256};
 use std::collections::{BTreeMap, HashSet};
 use std::sync::{Arc, Mutex};
 

crates/common/trie/verify_range.rs

@@ -2,7 +2,7 @@ use std::collections::{BTreeMap, VecDeque};
 
 use ethereum_types::H256;
 use ethrex_rlp::decode::RLPDecode;
-use sha3::{Digest, Keccak256};
+use keccak_asm::{Digest, Keccak256};
 
 use crate::{
     ProofTrie, Trie, TrieError, ValueRLP,

crates/common/types/account.rs

@@ -3,9 +3,9 @@ use std::collections::HashMap;
 use bytes::Bytes;
 use ethereum_types::{H256, U256};
 use ethrex_trie::Trie;
+use keccak_asm::{Digest as _, Keccak256};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
-use sha3::{Digest as _, Keccak256};
 
 use ethrex_rlp::{
     decode::RLPDecode,

crates/common/types/block_execution_witness.rs

@@ -13,11 +13,11 @@ use bytes::Bytes;
 use ethereum_types::{Address, H256, U256};
 use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode};
 use ethrex_trie::{EMPTY_TRIE_HASH, NodeRLP, Trie};
+use keccak_asm::{Digest, Keccak256};
 use rkyv::{Archive, Deserialize as RDeserialize, Serialize as RSerialize};
 use serde::de::{SeqAccess, Visitor};
 use serde::ser::SerializeSeq;
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
-use sha3::{Digest, Keccak256};
 
 /// State produced by the guest program execution inside the zkVM. It is
 /// essentially built from the `ExecutionWitness`.

crates/common/types/genesis.rs

@@ -2,9 +2,9 @@ use bytes::Bytes;
 use ethereum_types::{Address, Bloom, H256, U256};
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_trie::Trie;
+use keccak_asm::{Digest, Keccak256};
 use rkyv::{Archive, Deserialize as RDeserialize, Serialize as RSerialize};
 use serde::{Deserialize, Serialize};
-use sha3::{Digest, Keccak256};
 use std::{
     collections::{BTreeMap, HashMap},
     io::{BufReader, Error},

crates/common/types/transaction.rs

@@ -3,12 +3,12 @@ use std::{cmp::min, fmt::Display};
 use crate::utils::keccak;
 use bytes::Bytes;
 use ethereum_types::{Address, H256, Signature, U256};
+use keccak_asm::{Digest, Keccak256};
 pub use mempool::MempoolTransaction;
 use rkyv::{Archive, Deserialize as RDeserialize, Serialize as RSerialize};
 use secp256k1::{Message, ecdsa::RecoveryId};
 use serde::{Serialize, ser::SerializeStruct};
 pub use serde_impl::{AccessListEntry, GenericTransaction, GenericTransactionError};
-use sha3::{Digest, Keccak256};
 
 use ethrex_rlp::{
     constants::RLP_NULL,

crates/common/utils.rs

@@ -1,8 +1,7 @@
 use crate::H256;
 use ethereum_types::U256;
 use hex::FromHexError;
-use sha3::Digest;
-use sha3::Keccak256;
+use keccak_asm::{Digest, Keccak256};
 
 pub const ZERO_U256: U256 = U256([0, 0, 0, 0]);
 

crates/l2/common/Cargo.toml

@@ -17,7 +17,7 @@ bytes.workspace = true
 thiserror.workspace = true
 serde.workspace = true
 lambdaworks-crypto.workspace = true
-sha3.workspace = true
+keccak-asm.workspace = true
 secp256k1.workspace = true
 hex.workspace = true
 serde_with.workspace = true

crates/networking/p2p/Cargo.toml

@@ -18,6 +18,7 @@ ethrex-threadpool.workspace = true
 ethereum-types.workspace = true
 
 async-trait.workspace = true
+keccak-asm.workspace = true
 tracing.workspace = true
 tokio = { workspace = true, features = ["full"] }
 tokio-util = { workspace = true, features = ["codec", "net"] }
@@ -37,7 +38,6 @@ rocksdb = { workspace = true, optional = true }
 prometheus = "0.14.0"
 
 tokio-stream = "0.1.17"
-sha3 = "0.10.8"
 
 serde_json = "1.0.117"
 

crates/networking/p2p/discv4/messages.rs

@@ -10,11 +10,11 @@ use ethrex_rlp::{
     error::RLPDecodeError,
     structs::{self, Decoder, Encoder},
 };
+use keccak_asm::{Digest, Keccak256};
 use secp256k1::{
     SecretKey,
     ecdsa::{RecoverableSignature, RecoveryId},
 };
-use sha3::{Digest, Keccak256};
 use std::{convert::Into, io::ErrorKind};
 
 #[derive(Debug, thiserror::Error)]

crates/networking/p2p/rlpx/connection/codec.rs

@@ -14,7 +14,7 @@ use aes::{
 use bytes::{Buf, BytesMut};
 use ethrex_common::{H128, H256};
 use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode as _};
-use sha3::{Digest as _, Keccak256};
+use keccak_asm::{Digest as _, Keccak256};
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_util::codec::{Decoder, Encoder, Framed};
 

crates/networking/p2p/rlpx/connection/handshake.rs

@@ -22,12 +22,12 @@ use ethrex_rlp::{
     structs::{Decoder, Encoder},
 };
 use futures::{StreamExt, stream::SplitStream};
+use keccak_asm::{Digest, Keccak256};
 use rand::Rng;
 use secp256k1::{
     PublicKey, SecretKey,
     ecdsa::{RecoverableSignature, RecoveryId},
 };
-use sha3::{Digest, Keccak256};
 use std::{
     collections::HashMap,
     net::SocketAddr,

crates/networking/p2p/rlpx/error.rs

@@ -107,8 +107,8 @@ impl From<secp256k1::Error> for PeerConnectionError {
     }
 }
 
-impl From<sha3::digest::InvalidLength> for PeerConnectionError {
-    fn from(e: sha3::digest::InvalidLength) -> Self {
+impl From<keccak_asm::digest::InvalidLength> for PeerConnectionError {
+    fn from(e: keccak_asm::digest::InvalidLength) -> Self {
         PeerConnectionError::CryptographyError(e.to_string())
     }
 }

crates/networking/p2p/rlpx/utils.rs

@@ -1,8 +1,8 @@
 use ethrex_common::{H256, H512};
 use ethrex_rlp::error::{RLPDecodeError, RLPEncodeError};
+use keccak_asm::{Digest, Keccak256};
 use secp256k1::ecdh::shared_secret_point;
 use secp256k1::{PublicKey, SecretKey};
-use sha3::{Digest, Keccak256};
 use snap::raw::{Decoder as SnappyDecoder, Encoder as SnappyEncoder, max_compress_len};
 use std::array::TryFromSliceError;