Feat: Reintroduce Alloy

bins/revme/Cargo.toml

@@ -10,25 +10,22 @@ version = "0.2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bytes = "1.5"
 hash-db = "0.15"
 hashbrown = "0.14"
-hex = "0.4"
 indicatif = "0.17"
 plain_hasher = "0.2"
-primitive-types = { version = "0.12", features = ["rlp", "serde"] }
 revm = { path = "../../crates/revm", version = "3.4.0", default-features = false, features = [
     "ethersdb",
     "std",
     "serde",
 ] }
-rlp = { version = "0.5", default-features = false }
-ruint = { version = "1.8.0", features = ["rlp", "serde"] }
+alloy-rlp = { version = "0.3", default-features = false, features = [
+    "arrayvec",
+] }
+ruint = { version = "1.9.0", features = ["rlp", "serde"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
-sha3 = { version = "0.10", default-features = false }
 structopt = "0.3"
 thiserror = "1.0"
 triehash = "0.8"
 walkdir = "2.4"
-hex-literal = "0.4"

bins/revme/src/cli_env.rs

@@ -1,7 +1,4 @@
-use std::str::FromStr;
-
-use bytes::Bytes;
-use revm::primitives::{Env, TransactTo, B160, U256};
+use revm::primitives::{Address, Bytes, Env, TransactTo, U256};
 use structopt::StructOpt;
 
 #[derive(StructOpt, Clone, Debug)]
@@ -63,8 +60,8 @@ pub struct CliEnvBlock {
     pub number: Option<u64>,
     /// Coinbase or miner or address that created and signed the block.
     /// Address where we are going to send gas spend
-    #[structopt(long = "env.block.coinbase", parse(try_from_str = parse_b160))]
-    pub coinbase: Option<B160>,
+    #[structopt(long = "env.block.coinbase")]
+    pub coinbase: Option<Address>,
     #[structopt(long = "env.block.timestamp")]
     pub timestamp: Option<u64>,
     #[structopt(long = "env.block.difficulty")]
@@ -77,32 +74,24 @@ pub struct CliEnvBlock {
 #[derive(StructOpt, Clone, Debug)]
 pub struct CliEnvTx {
     /// Caller or Author or tx signer
-    #[structopt(long = "env.tx.caller", parse(try_from_str = parse_b160))]
-    pub caller: Option<B160>,
+    #[structopt(long = "env.tx.caller")]
+    pub caller: Option<Address>,
     #[structopt(long = "env.tx.gas_limit")]
     pub tx_gas_limit: Option<u64>,
     #[structopt(long = "env.tx.gas_price")]
     pub gas_price: Option<u64>,
     #[structopt(long = "env.tx.gas_priority_fee")]
     pub gas_priority_fee: Option<u64>,
-    #[structopt(long = "env.tx.to", parse(try_from_str = parse_b160))]
-    pub transact_to: Option<B160>,
+    #[structopt(long = "env.tx.to")]
+    pub transact_to: Option<Address>,
     #[structopt(long = "env.tx.value")]
     pub value: Option<u64>,
-    #[structopt(long = "env.tx.data", parse(try_from_str = parse_hex))]
+    #[structopt(long = "env.tx.data")]
     pub data: Option<Bytes>,
     #[structopt(long = "env.tx.chain_id")]
     pub chain_id: Option<u64>,
     #[structopt(long = "env.tx.nonce")]
     pub nonce: Option<u64>,
     //#[structopt(long = "env.")]
-    //TODO pub access_list: Vec<(B160, Vec<U256>)>,
-}
-
-fn parse_hex(src: &str) -> Result<Bytes, hex::FromHexError> {
-    Ok(Bytes::from(hex::decode(src)?))
-}
-
-pub fn parse_b160(input: &str) -> Result<B160, <B160 as FromStr>::Err> {
-    B160::from_str(input)
+    //TODO pub access_list: Vec<(Address, Vec<U256>)>,
 }

bins/revme/src/statetest/merkle_trie.rs

@@ -1,79 +1,74 @@
-use bytes::Bytes;
+use alloy_rlp::{RlpEncodable, RlpMaxEncodedLen};
 use hash_db::Hasher;
 use plain_hasher::PlainHasher;
-use primitive_types::{H160, H256};
 use revm::{
     db::PlainAccount,
-    primitives::{keccak256, Log, B160, B256, U256},
+    primitives::{keccak256, Address, Log, B256, U256},
 };
-use rlp::RlpStream;
-use sha3::{Digest, Keccak256};
 use triehash::sec_trie_root;
 
-pub fn log_rlp_hash(logs: Vec<Log>) -> B256 {
-    //https://github.com/ethereum/go-ethereum/blob/356bbe343a30789e77bb38f25983c8f2f2bfbb47/cmd/evm/internal/t8ntool/execution.go#L255
-    let mut stream = RlpStream::new();
-    stream.begin_unbounded_list();
-    for log in logs {
-        stream.begin_list(3);
-        stream.append(&log.address.0.as_ref());
-        stream.begin_unbounded_list();
-        for topic in log.topics {
-            stream.append(&topic.0.as_ref());
-        }
-        stream.finalize_unbounded_list();
-        stream.append(&log.data);
-    }
-    stream.finalize_unbounded_list();
-    let out = stream.out().freeze();
-
+pub fn log_rlp_hash(logs: &[Log]) -> B256 {
+    let mut out = Vec::with_capacity(alloy_rlp::list_length(logs));
+    alloy_rlp::encode_list(logs, &mut out);
     keccak256(&out)
 }
 
 pub fn state_merkle_trie_root<'a>(
-    accounts: impl IntoIterator<Item = (B160, &'a PlainAccount)>,
+    accounts: impl IntoIterator<Item = (Address, &'a PlainAccount)>,
 ) -> B256 {
-    let vec = accounts
-        .into_iter()
-        .map(|(address, info)| {
-            let acc_root = trie_account_rlp(info);
-            (H160::from(address.0), acc_root)
-        })
-        .collect();
+    trie_root(accounts.into_iter().map(|(address, acc)| {
+        (
+            address,
+            alloy_rlp::encode_fixed_size(&TrieAccount::new(acc)),
+        )
+    }))
+}
 
-    trie_root(vec)
+#[derive(RlpEncodable, RlpMaxEncodedLen)]
+struct TrieAccount {
+    nonce: u64,
+    balance: U256,
+    root_hash: B256,
+    code_hash: B256,
 }
 
-/// Returns the RLP for this account.
-pub fn trie_account_rlp(acc: &PlainAccount) -> Bytes {
-    let mut stream = RlpStream::new_list(4);
-    stream.append(&acc.info.nonce);
-    stream.append(&acc.info.balance);
-    stream.append(&{
-        sec_trie_root::<KeccakHasher, _, _, _>(
-            acc.storage
-                .iter()
-                .filter(|(_k, &v)| v != U256::ZERO)
-                .map(|(&k, v)| (H256::from(k.to_be_bytes()), rlp::encode(v))),
-        )
-    });
-    stream.append(&acc.info.code_hash.0.as_ref());
-    stream.out().freeze()
+impl TrieAccount {
+    #[inline(always)]
+    fn new(acc: &PlainAccount) -> Self {
+        Self {
+            nonce: acc.info.nonce,
+            balance: acc.info.balance,
+            root_hash: sec_trie_root::<KeccakHasher, _, _, _>(
+                acc.storage
+                    .iter()
+                    .filter(|(_k, &v)| v != U256::ZERO)
+                    .map(|(k, v)| (k.to_be_bytes::<32>(), alloy_rlp::encode_fixed_size(v))),
+            ),
+            code_hash: acc.info.code_hash,
+        }
+    }
 }
 
-pub fn trie_root(acc_data: Vec<(H160, Bytes)>) -> B256 {
-    B256(sec_trie_root::<KeccakHasher, _, _, _>(acc_data).0)
+#[inline]
+pub fn trie_root<I, A, B>(input: I) -> B256
+where
+    I: IntoIterator<Item = (A, B)>,
+    A: AsRef<[u8]>,
+    B: AsRef<[u8]>,
+{
+    sec_trie_root::<KeccakHasher, _, _, _>(input)
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct KeccakHasher;
 
 impl Hasher for KeccakHasher {
-    type Out = H256;
+    type Out = B256;
     type StdHasher = PlainHasher;
     const LENGTH: usize = 32;
+
+    #[inline]
     fn hash(x: &[u8]) -> Self::Out {
-        let out = Keccak256::digest(x);
-        H256::from_slice(out.as_slice())
+        keccak256(x)
     }
 }