revm bits

bins/revme/src/cli_env.rs

@@ -1,8 +1,7 @@
 use std::str::FromStr;
 
 use bytes::Bytes;
-use revm::{Env, TransactTo};
-use ruint::aliases::{B160, U256};
+use revm::{Env, TransactTo,B160,U256};
 use structopt::StructOpt;
 
 #[derive(StructOpt, Clone, Debug)]

bins/revme/src/statetest/merkle_trie.rs

@@ -2,10 +2,8 @@ use bytes::Bytes;
 use hash_db::Hasher;
 use plain_hasher::PlainHasher;
 use primitive_types::{H160, H256};
-use revm::common::keccak256;
-use revm::{db::DbAccount, Log};
+use revm::{db::DbAccount, Log ,U256,B160,B256,common::keccak256,};
 use rlp::RlpStream;
-use ruint::aliases::{B160, B256, U256};
 use sha3::{Digest, Keccak256};
 use triehash::sec_trie_root;
 

bins/revme/src/statetest/models/deserializer.rs

@@ -1,9 +1,9 @@
 use bytes::Bytes;
-use ruint::aliases::{B160, U256};
 use serde::{
     de::{self, Error},
     Deserialize,
 };
+use revm::{U256,B160};
 
 pub fn deserialize_str_as_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
 where

bins/revme/src/statetest/models/mod.rs

@@ -1,5 +1,5 @@
 use bytes::Bytes;
-use ruint::aliases::{B160, B256, U256};
+use revm::{B160, B256, U256};
 use std::collections::{BTreeMap, HashMap};
 mod deserializer;
 mod spec;

bins/revme/src/statetest/runner.rs

@@ -8,8 +8,7 @@ use std::{
 };
 
 use indicatif::ProgressBar;
-use revm::{db::AccountState, Bytecode, CreateScheme, Env, ExecutionResult, SpecId, TransactTo};
-use ruint::aliases::{B160, B256, U256};
+use revm::{db::AccountState, U256,Bytecode, bits::{B160,B256},CreateScheme, Env, ExecutionResult, SpecId, TransactTo};
 use std::sync::atomic::Ordering;
 use walkdir::{DirEntry, WalkDir};
 

bins/revme/src/statetest/trace.rs

@@ -3,9 +3,8 @@ pub use revm::Inspector;
 use revm::{
     opcode::{self},
     CallInputs, CreateInputs, Database, EVMData, Gas, GasInspector, Return,
-};
-use ruint::aliases::B160;
-
+    bits::B160,
+}; 
 #[derive(Clone)]
 pub struct CustomPrintTracer {
     gas_inspector: GasInspector,

crates/revm/Cargo.toml

@@ -25,6 +25,11 @@ serde = { version = "1.0", features = ["derive","rc"], optional = true }
 tokio = { version = "1.21", features = ["rt-multi-thread", "macros"], optional = true }
 web3 = { git = "https://github.com/tomusdrw/rust-web3", version = "0.19", optional = true }
 
+# bits B256 B160 crate
+fixed-hash = { version = "0.8", default-features = false }
+hex-literal = "0.3"
+derive_more = "0.99"
+
 # sha3 keccak hasher
 sha3 = { version = "0.10", default-features = false, features = []}
 

crates/revm/src/bits.rs

@@ -0,0 +1,18 @@
+use derive_more::{AsRef, Deref};
+use fixed_hash::{construct_fixed_hash, impl_fixed_hash_conversions};
+
+construct_fixed_hash! {
+    /// My 256 bit hash type.
+    #[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
+    #[derive(AsRef,Deref)]
+    pub struct B256(32);
+}
+
+construct_fixed_hash! {
+    /// My 256 bit hash type.
+    #[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
+    #[derive(AsRef,Deref)]
+    pub struct B160(20);
+}
+
+impl_fixed_hash_conversions!(B256, B160);

crates/revm/src/common.rs

@@ -1,7 +1,7 @@
-use ruint::aliases::B256;
+use crate::bits::B256;
 use sha3::{Digest, Keccak256};
 
 #[inline(always)]
 pub fn keccak256(input: &[u8]) -> B256 {
-    B256::try_from_be_slice(Keccak256::digest(input).as_slice()).unwrap()
+    B256::from_slice(Keccak256::digest(input).as_slice())
 }

crates/revm/src/db.rs

@@ -5,14 +5,13 @@ pub mod web3db;
 #[cfg(feature = "web3db")]
 pub use web3db::Web3DB;
 
-pub use in_memory_db::{AccountState, BenchmarkDB, CacheDB, DbAccount, EmptyDB, InMemoryDB};
-
-use crate::{interpreter::bytecode::Bytecode, Account};
-use hashbrown::HashMap as Map;
-use ruint::aliases::{B160, B256, U256};
-
+use crate::bits::{B160, B256};
 use crate::AccountInfo;
+use crate::U256;
+use crate::{interpreter::bytecode::Bytecode, Account};
 use auto_impl::auto_impl;
+use hashbrown::HashMap as Map;
+pub use in_memory_db::{AccountState, BenchmarkDB, CacheDB, DbAccount, EmptyDB, InMemoryDB};
 
 #[auto_impl(& mut, Box)]
 pub trait Database {

crates/revm/src/db/in_memory_db.rs

@@ -2,10 +2,10 @@ use super::{DatabaseCommit, DatabaseRef};
 use crate::common::keccak256;
 use crate::{interpreter::bytecode::Bytecode, Database, KECCAK_EMPTY};
 use crate::{Account, AccountInfo, Log};
+use crate::{U256,B160,B256};
 use alloc::vec::Vec;
 use core::convert::Infallible;
 use hashbrown::{hash_map::Entry, HashMap as Map};
-use ruint::aliases::{B160, B256, U256};
 
 pub type InMemoryDB = CacheDB<EmptyDB>;
 
@@ -95,7 +95,7 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
     pub fn new(db: ExtDB) -> Self {
         let mut contracts = Map::new();
         contracts.insert(KECCAK_EMPTY, Bytecode::new());
-        contracts.insert(B256::ZERO, Bytecode::new());
+        contracts.insert(B256::zero(), Bytecode::new());
         Self {
             accounts: Map::new(),
             contracts,
@@ -114,7 +114,7 @@ impl<ExtDB: DatabaseRef> CacheDB<ExtDB> {
                     .or_insert_with(|| code.clone());
             }
         }
-        if account.code_hash == B256::ZERO {
+        if account.code_hash == B256::zero() {
             account.code_hash = KECCAK_EMPTY;
         }
     }
@@ -363,7 +363,7 @@ impl Database for BenchmarkDB {
     type Error = Infallible;
     /// Get basic account information.
     fn basic(&mut self, address: B160) -> Result<Option<AccountInfo>, Self::Error> {
-        if address == B160::ZERO {
+        if address == B160::zero() {
             return Ok(Some(AccountInfo {
                 nonce: 1,
                 balance: U256::from(10000000),

crates/revm/src/db/web3db.rs

@@ -1,6 +1,7 @@
-use crate::{interpreter::bytecode::Bytecode, AccountInfo, Database, KECCAK_EMPTY};
+use crate::{
+    interpreter::bytecode::Bytecode, AccountInfo, Database, B160, B256, KECCAK_EMPTY, U256,
+};
 use bytes::Bytes;
-use ruint::aliases::{B160, B256, U256};
 use tokio::runtime::{Handle, Runtime};
 use web3::{
     transports::Http,
@@ -51,7 +52,7 @@ impl Database for Web3DB {
     type Error = ();
 
     fn basic(&mut self, address: B160) -> Result<Option<AccountInfo>, Self::Error> {
-        let add = wH160::from(address);
+        let add = wH160::from(address.0);
         let f = async {
             let nonce = self.web3.eth().transaction_count(add, self.block_number);
             let balance = self.web3.eth().balance(add, self.block_number);
@@ -82,7 +83,7 @@ impl Database for Web3DB {
     }
 
     fn storage(&mut self, address: B160, index: U256) -> Result<U256, Self::Error> {
-        let add = wH160::from(address);
+        let add = wH160::from(address.0);
         let index = wU256::from(index);
         let f = async {
             let storage = self
@@ -116,6 +117,6 @@ impl Database for Web3DB {
                 .ok()
                 .flatten()
         };
-        Ok(self.block_on(f).unwrap().hash.unwrap().into())
+        Ok(B256(self.block_on(f).unwrap().hash.unwrap().0))
     }
 }

crates/revm/src/evm_impl.rs

@@ -10,13 +10,14 @@ use crate::{
     CreateInputs, CreateScheme, Env, ExecutionResult, Gas, Inspector, Log, Return, Spec,
     SpecId::{self, *},
     TransactOut, TransactTo, Transfer, KECCAK_EMPTY,
+    bits::{B160,B256},
+    U256,
 };
 use alloc::vec::Vec;
 use bytes::Bytes;
 use core::{cmp::min, marker::PhantomData};
 use hashbrown::HashMap as Map;
 use revm_precompiles::{Precompile, PrecompileOutput, Precompiles};
-use ruint::aliases::{B160, B256, U160, U256};
 
 pub struct EVMData<'a, DB: Database> {
     pub env: &'a mut Env,
@@ -647,7 +648,7 @@ impl<'a, GSPEC: Spec, DB: Database, const INSPECT: bool> EVMImpl<'a, GSPEC, DB,
                     } else {
                         Return::PrecompileError
                     };
-                    self.data.journaled_state.checkpoint_revert(checkpoint); //TODO check if we are discarding or reverting
+                    self.data.journaled_state.checkpoint_revert(checkpoint);
                     (ret, gas, Bytes::new())
                 }
             }
@@ -765,7 +766,7 @@ impl<'a, GSPEC: Spec, DB: Database + 'a, const INSPECT: bool> Host
         }
         if acc.is_empty() {
             // TODO check this for pre tangerine fork
-            return Some((B256::ZERO, is_cold));
+            return Some((B256::zero(), is_cold));
         }
 
         Some((acc.info.code_hash, is_cold))
@@ -834,9 +835,7 @@ pub fn create_address(caller: B160, nonce: u64) -> B160 {
     stream.append(&caller);
     stream.append(&nonce);
     let out = keccak256(&stream.out());
-    U160::try_from_be_slice(&out.to_be_bytes_vec()[12..])
-        .unwrap()
-        .into()
+    B160::from_slice(&out.to_be_bytes_vec()[12..])
 }
 
 /// Returns the address for the `CREATE2` scheme: [`CreateScheme::Create2`]

crates/revm/src/gas/calc.rs

@@ -1,6 +1,5 @@
 use super::constants::*;
-use crate::{models::SelfDestructResult, Spec, SpecId::*};
-use ruint::aliases::U256;
+use crate::{models::SelfDestructResult, Spec, SpecId::*, U256};
 
 #[allow(clippy::collapsible_else_if)]
 pub fn sstore_refund<SPEC: Spec>(original: U256, current: U256, new: U256) -> i64 {

crates/revm/src/inspector.rs

@@ -1,11 +1,10 @@
-use bytes::Bytes;
-use ruint::aliases::{B160, B256};
-
 use crate::{
-    evm_impl::EVMData, opcode, spec_opcode_gas, CallInputs, CreateInputs, Database, Gas,
-    Interpreter, Return,
+    bits::{B160, B256},
+    evm_impl::EVMData,
+    opcode, spec_opcode_gas, CallInputs, CreateInputs, Database, Gas, Interpreter, Return,
 };
 use auto_impl::auto_impl;
+use bytes::Bytes;
 
 #[auto_impl(&mut, Box)]
 pub trait Inspector<DB: Database> {
@@ -244,10 +243,9 @@ mod tests {
     use crate::db::BenchmarkDB;
     use crate::{
         opcode, Bytecode, CallInputs, CreateInputs, Database, EVMData, Gas, GasInspector,
-        Inspector, Interpreter, OpCode, Return, TransactTo,
+        Inspector, Interpreter, OpCode, Return, TransactTo,B160, B256,
     };
     use bytes::Bytes;
-    use ruint::aliases::{B160, B256};
 
     #[derive(Default, Debug)]
     struct StackInspector {

crates/revm/src/instructions.rs

@@ -13,9 +13,8 @@ mod system;
 
 pub use opcode::{OpCode, OPCODE_JUMPMAP};
 
-use crate::{interpreter::Interpreter, CallScheme, Host, Spec, SpecId::*};
+use crate::{interpreter::Interpreter, CallScheme, Host, U256,Spec, SpecId::*};
 use core::ops::{BitAnd, BitOr, BitXor};
-use ruint::aliases::U256;
 
 #[macro_export]
 macro_rules! return_ok {

crates/revm/src/instructions/arithmetic.rs

@@ -1,7 +1,5 @@
-use crate::{gas, Interpreter, Return, Spec};
-
+use crate::{gas, Interpreter, Return, Spec,U256};
 use super::i256::{i256_div, i256_mod};
-use ruint::aliases::U256;
 
 pub fn div(op1: U256, op2: U256) -> U256 {
     op1.checked_div(op2).unwrap_or_default()

crates/revm/src/instructions/bitwise.rs

@@ -1,7 +1,6 @@
 use core::cmp::Ordering;
-
 use super::i256::{i256_cmp, i256_sign, two_compl, Sign};
-use ruint::aliases::U256;
+use crate::U256;
 
 pub fn slt(op1: U256, op2: U256) -> U256 {
     if i256_cmp(op1, op2) == Ordering::Less {

crates/revm/src/instructions/control.rs

@@ -1,5 +1,4 @@
-use crate::{gas, interpreter::Interpreter, Return, Spec, SpecId::*};
-use ruint::aliases::U256;
+use crate::{gas, U256, interpreter::Interpreter, Return, Spec, SpecId::*};
 
 pub fn jump(interp: &mut Interpreter) -> Return {
     // gas!(interp, gas::MID);