refactor: move to revm

Cargo.toml

@@ -1,13 +1,14 @@
 [workspace]
 members = [
-    "evm-adapters",
     "utils",
     "cast",
     "forge",
     "cli",
     "cli/test-utils",
     "config",
     "fmt",
+    "ui",
+    "evm"
 ]
 
 # Binary size optimizations
@@ -18,11 +19,6 @@ codegen-units = 1
 panic = "abort"
 debug = true
 
-## Patch sputnik with more recent primitive types
-# https://github.com/rust-blockchain/evm/pulls
-[patch."https://github.com/rust-blockchain/evm"]
-evm = { git = "https://github.com/gakonst/evm", branch = "bump-primitive-types" }
-
 ## Patch ethers-rs with a local checkout then run `cargo update -p ethers`
 #[patch."https://github.com/gakonst/ethers-rs"]
 #ethers = { path = "../ethers-rs" }

cast/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cast"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "foundry-cli"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 
@@ -26,7 +26,6 @@ foundry-utils = { path = "../utils" }
 forge = { path = "../forge" }
 foundry-config = { path = "../config" }
 cast = { path = "../cast" }
-evm-adapters = { path = "../evm-adapters" }
 ui = { path = "../ui" }
 dunce = "1.0.2"
 # ethers = "0.5"
@@ -39,16 +38,14 @@ tokio = { version = "1.11.0", features = ["macros"] }
 regex = { version = "1.5.4", default-features = false }
 ansi_term = "0.12.1"
 rpassword = "5.0.1"
-tracing-subscriber = "0.2.20"
+tracing-error = "0.2.0"
+tracing-subscriber = { version = "0.3", features = ["registry", "env-filter", "fmt"] }
 tracing = "0.1.26"
 hex = "0.4.3"
 rayon = "1.5.1"
 serde = "1.0.133"
 futures = "0.3.17"
 
-## EVM Implementations
-# evm = { version = "0.30.1" }
-sputnik = { package = "evm", git = "https://github.com/rust-blockchain/evm", default-features = false, features = ["std"], optional = true }
 proptest = "1.0.0"
 glob = "0.3.0"
 semver = "1.0.5"
@@ -68,17 +65,11 @@ pretty_assertions = "1.0.0"
 toml = "0.5"
 
 [features]
-default = ["sputnik-evm", "rustls"]
+default = ["rustls"]
 solc-asm = ["ethers/solc-sha2-asm"]
 rustls = ["ethers/rustls"]
 openssl = ["ethers/openssl"]
 
-sputnik-evm = [
-    "sputnik",
-    "evm-adapters/sputnik",
-    "evm-adapters/sputnik-helpers",
-]
-
 integration-tests = []
 
 [[bin]]

cli/src/cast.rs

@@ -15,7 +15,7 @@ use ethers::{
     },
     providers::{Middleware, Provider},
     signers::{LocalWallet, Signer},
-    types::{Address, Chain, NameOrAddress, Signature, U256, U64},
+    types::{Address, Chain, NameOrAddress, Signature, U256},
     utils::get_contract_address,
 };
 use opts::{
@@ -36,9 +36,8 @@ use std::{
 use clap::{IntoApp, Parser};
 use clap_complete::generate;
 
-use crate::utils::read_secret;
+use crate::{cmd::Cmd, utils::read_secret};
 use eyre::WrapErr;
-use futures::join;
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
@@ -542,64 +541,7 @@ async fn main() -> eyre::Result<()> {
             let selector = contract.abi().functions().last().unwrap().short_signature();
             println!("0x{}", hex::encode(selector));
         }
-        Subcommands::FindBlock { timestamp, rpc_url } => {
-            let ts_target = U256::from(timestamp);
-            let provider = Provider::try_from(rpc_url)?;
-            let last_block_num = provider.get_block_number().await?;
-            let cast_provider = Cast::new(provider);
-
-            let res = join!(cast_provider.timestamp(last_block_num), cast_provider.timestamp(1));
-            let ts_block_latest = res.0.unwrap();
-            let ts_block_1 = res.1.unwrap();
-
-            let block_num = if ts_block_latest.lt(&ts_target) {
-                // If the most recent block's timestamp is below the target, return it
-                last_block_num
-            } else if ts_block_1.gt(&ts_target) {
-                // If the target timestamp is below block 1's timestamp, return that
-                U64::from(1)
-            } else {
-                // Otherwise, find the block that is closest to the timestamp
-                let mut low_block = U64::from(1); // block 0 has a timestamp of 0: https://github.com/ethereum/go-ethereum/issues/17042#issuecomment-559414137
-                let mut high_block = last_block_num;
-                let mut matching_block: Option<U64> = None;
-                while high_block.gt(&low_block) && matching_block.is_none() {
-                    // Get timestamp of middle block (this approach approach to avoids overflow)
-                    let high_minus_low_over_2 = high_block
-                        .checked_sub(low_block)
-                        .ok_or_else(|| eyre::eyre!("unexpected underflow"))
-                        .unwrap()
-                        .checked_div(U64::from(2))
-                        .unwrap();
-                    let mid_block = high_block.checked_sub(high_minus_low_over_2).unwrap();
-                    let ts_mid_block = cast_provider.timestamp(mid_block).await?;
-
-                    // Check if we've found a match or should keep searching
-                    if ts_mid_block.eq(&ts_target) {
-                        matching_block = Some(mid_block)
-                    } else if high_block.checked_sub(low_block).unwrap().eq(&U64::from(1)) {
-                        // The target timestamp is in between these blocks. This rounds to the
-                        // highest block if timestamp is equidistant between blocks
-                        let res = join!(
-                            cast_provider.timestamp(high_block),
-                            cast_provider.timestamp(low_block)
-                        );
-                        let ts_high = res.0.unwrap();
-                        let ts_low = res.1.unwrap();
-                        let high_diff = ts_high.checked_sub(ts_target).unwrap();
-                        let low_diff = ts_target.checked_sub(ts_low).unwrap();
-                        let is_low = low_diff.lt(&high_diff);
-                        matching_block = if is_low { Some(low_block) } else { Some(high_block) }
-                    } else if ts_mid_block.lt(&ts_target) {
-                        low_block = mid_block;
-                    } else {
-                        high_block = mid_block;
-                    }
-                }
-                matching_block.unwrap_or(low_block)
-            };
-            println!("{}", block_num);
-        }
+        Subcommands::FindBlock(cmd) => cmd.run()?,
         Subcommands::Wallet { command } => match command {
             WalletSubcommands::New { path, password, unsafe_password } => {
                 let mut rng = thread_rng();

cli/src/cmd/cast/find_block.rs

@@ -0,0 +1,90 @@
+//! cast find-block subcommand
+
+use crate::cmd::Cmd;
+use cast::Cast;
+use clap::Parser;
+use ethers::prelude::*;
+use eyre::Result;
+use futures::join;
+
+#[derive(Debug, Clone, Parser)]
+pub struct FindBlockArgs {
+    #[clap(help = "The UNIX timestamp to search for (in seconds)")]
+    timestamp: u64,
+    #[clap(long, env = "ETH_RPC_URL")]
+    rpc_url: String,
+}
+
+impl Cmd for FindBlockArgs {
+    type Output = ();
+
+    fn run(self) -> Result<Self::Output> {
+        let FindBlockArgs { timestamp, rpc_url } = self;
+        let rt = tokio::runtime::Runtime::new().expect("could not start tokio rt");
+        rt.block_on(Self::query_block(timestamp, rpc_url))?;
+        Ok(())
+    }
+}
+
+impl FindBlockArgs {
+    async fn query_block(timestamp: u64, rpc_url: String) -> Result<()> {
+        let ts_target = U256::from(timestamp);
+        let provider = Provider::try_from(rpc_url)?;
+        let last_block_num = provider.get_block_number().await?;
+        let cast_provider = Cast::new(provider);
+
+        let res = join!(cast_provider.timestamp(last_block_num), cast_provider.timestamp(1));
+        let ts_block_latest = res.0.unwrap();
+        let ts_block_1 = res.1.unwrap();
+
+        let block_num = if ts_block_latest.lt(&ts_target) {
+            // If the most recent block's timestamp is below the target, return it
+            last_block_num
+        } else if ts_block_1.gt(&ts_target) {
+            // If the target timestamp is below block 1's timestamp, return that
+            U64::from(1_u64)
+        } else {
+            // Otherwise, find the block that is closest to the timestamp
+            let mut low_block = U64::from(1_u64); // block 0 has a timestamp of 0: https://github.com/ethereum/go-ethereum/issues/17042#issuecomment-559414137
+            let mut high_block = last_block_num;
+            let mut matching_block: Option<U64> = None;
+            while high_block.gt(&low_block) && matching_block.is_none() {
+                // Get timestamp of middle block (this approach approach to avoids overflow)
+                let high_minus_low_over_2 = high_block
+                    .checked_sub(low_block)
+                    .ok_or_else(|| eyre::eyre!("unexpected underflow"))
+                    .unwrap()
+                    .checked_div(U64::from(2_u64))
+                    .unwrap();
+                let mid_block = high_block.checked_sub(high_minus_low_over_2).unwrap();
+                let ts_mid_block = cast_provider.timestamp(mid_block).await?;
+
+                // Check if we've found a match or should keep searching
+                if ts_mid_block.eq(&ts_target) {
+                    matching_block = Some(mid_block)
+                } else if high_block.checked_sub(low_block).unwrap().eq(&U64::from(1_u64)) {
+                    // The target timestamp is in between these blocks. This rounds to the
+                    // highest block if timestamp is equidistant between blocks
+                    let res = join!(
+                        cast_provider.timestamp(high_block),
+                        cast_provider.timestamp(low_block)
+                    );
+                    let ts_high = res.0.unwrap();
+                    let ts_low = res.1.unwrap();
+                    let high_diff = ts_high.checked_sub(ts_target).unwrap();
+                    let low_diff = ts_target.checked_sub(ts_low).unwrap();
+                    let is_low = low_diff.lt(&high_diff);
+                    matching_block = if is_low { Some(low_block) } else { Some(high_block) }
+                } else if ts_mid_block.lt(&ts_target) {
+                    low_block = mid_block;
+                } else {
+                    high_block = mid_block;
+                }
+            }
+            matching_block.unwrap_or(low_block)
+        };
+        println!("{}", block_num);
+
+        Ok(())
+    }
+}

cli/src/cmd/cast/mod.rs

@@ -0,0 +1,8 @@
+//! Subcommands for cast
+//!
+//! All subcommands should respect the `foundry_config::Config`.
+//! If a subcommand accepts values that are supported by the `Config`, then the subcommand should
+//! implement `figment::Provider` which allows the subcommand to override the config's defaults, see
+//! [`foundry_config::Config`].
+
+pub mod find_block;

cli/src/cmd/bind.rs → cli/src/cmd/forge/bind.rs

@@ -1,4 +1,4 @@
-use crate::cmd::Cmd;
+use crate::cmd::utils::Cmd;
 
 use clap::{Parser, ValueHint};
 use ethers::contract::MultiAbigen;

cli/src/cmd/build.rs → cli/src/cmd/forge/build.rs

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 
 use crate::{cmd::Cmd, opts::forge::CompilerArgs};
 
-use crate::cmd::watch::WatchArgs;
+use crate::cmd::forge::watch::WatchArgs;
 use clap::{Parser, ValueHint};
 use ethers::solc::remappings::Remapping;
 use foundry_config::{
@@ -191,7 +191,7 @@ impl Cmd for BuildArgs {
     type Output = ProjectCompileOutput;
     fn run(self) -> eyre::Result<Self::Output> {
         let project = self.project()?;
-        super::compile(&project, self.names, self.sizes)
+        crate::cmd::utils::compile(&project, self.names, self.sizes)
     }
 }
 
@@ -214,7 +214,7 @@ impl BuildArgs {
     /// Returns the [`watchexec::InitConfig`] and [`watchexec::RuntimeConfig`] necessary to
     /// bootstrap a new [`watchexe::Watchexec`] loop.
     pub(crate) fn watchexec_config(&self) -> eyre::Result<(InitConfig, RuntimeConfig)> {
-        use crate::cmd::watch;
+        use crate::cmd::forge::watch;
         let init = watch::init()?;
         let mut runtime = watch::runtime(&self.watch)?;
 

cli/src/cmd/config.rs → cli/src/cmd/forge/config.rs

@@ -1,7 +1,7 @@
 //! config command
 
 use crate::{
-    cmd::{build::BuildArgs, Cmd},
+    cmd::{forge::build::BuildArgs, utils::Cmd},
     opts::evm::EvmArgs,
 };
 use clap::Parser;

cli/src/cmd/create.rs → cli/src/cmd/forge/create.rs

@@ -1,7 +1,7 @@
 //! Create command
 
 use crate::{
-    cmd::{build::BuildArgs, Cmd},
+    cmd::{forge::build::BuildArgs, Cmd},
     opts::{EthereumOpts, WalletType},
     utils::parse_u256,
 };
@@ -70,10 +70,11 @@ impl Cmd for CreateArgs {
     fn run(self) -> Result<Self::Output> {
         // Find Project & Compile
         let project = self.opts.project()?;
-        let compiled = super::compile(&project, self.opts.names, self.opts.sizes)?;
+        let compiled = crate::cmd::utils::compile(&project, self.opts.names, self.opts.sizes)?;
 
         // Get ABI and BIN
-        let (abi, bin, _) = super::read_artifact(&project, compiled, self.contract.clone())?;
+        let (abi, bin, _) =
+            crate::cmd::utils::read_artifact(&project, compiled, self.contract.clone())?;
 
         let bin = match bin.object {
             BytecodeObject::Bytecode(_) => bin.object,

cli/src/cmd/flatten.rs → cli/src/cmd/forge/flatten.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use ethers::solc::remappings::Remapping;
 
-use crate::cmd::{build::BuildArgs, Cmd};
+use crate::cmd::{forge::build::BuildArgs, Cmd};
 use clap::{Parser, ValueHint};
 use foundry_config::Config;
 

cli/src/cmd/init.rs → cli/src/cmd/forge/init.rs

@@ -1,14 +1,14 @@
 //! init command
 
 use crate::{
-    cmd::{install::install, Cmd},
+    cmd::{forge::install::install, Cmd},
     opts::forge::Dependency,
     utils::p_println,
 };
 use clap::{Parser, ValueHint};
 use foundry_config::Config;
 
-use crate::cmd::{install::DependencyInstallOpts, remappings};
+use crate::cmd::forge::{install::DependencyInstallOpts, remappings};
 use ansi_term::Colour;
 use ethers::solc::remappings::Remapping;
 use std::{
@@ -102,10 +102,13 @@ impl Cmd for InitArgs {
 
             // write the contract file
             let contract_path = src.join("Contract.sol");
-            std::fs::write(contract_path, include_str!("../../../assets/ContractTemplate.sol"))?;
+            std::fs::write(contract_path, include_str!("../../../../assets/ContractTemplate.sol"))?;
             // write the tests
             let contract_path = test.join("Contract.t.sol");
-            std::fs::write(contract_path, include_str!("../../../assets/ContractTemplate.t.sol"))?;
+            std::fs::write(
+                contract_path,
+                include_str!("../../../../assets/ContractTemplate.t.sol"),
+            )?;
 
             let dest = root.join(Config::FILE_NAME);
             if !dest.exists() {
@@ -159,7 +162,7 @@ fn init_git_repo(root: &Path, no_commit: bool) -> eyre::Result<()> {
 
     if !is_git.success() {
         let gitignore_path = root.join(".gitignore");
-        std::fs::write(gitignore_path, include_str!("../../../assets/.gitignoreTemplate"))?;
+        std::fs::write(gitignore_path, include_str!("../../../../assets/.gitignoreTemplate"))?;
 
         Command::new("git")
             .arg("init")