feat: handle custom chains (#34)

* feat: handle custom chains

* fix: add `new_with_genesis` fn

* fix: CI

Author: leruaa

Cargo.lock

@@ -18,6 +18,9 @@ rsp-witness-db.workspace = true
 rsp-primitives.workspace = true
 rsp-client-executor.workspace = true
 rsp-mpt.workspace = true
+
+# reth
+reth-chainspec.workspace = true
 reth-primitives.workspace = true
 reth-evm.workspace = true
 reth-evm-ethereum.workspace = true

crates/client-executor/Cargo.toml

@@ -5,6 +5,7 @@ use revm::state::Bytecode;
 use revm_primitives::{Address, HashMap, B256, U256};
 use rsp_client_executor::io::WitnessInput;
 use rsp_mpt::EthereumState;
+use rsp_primitives::genesis::Genesis;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
@@ -16,6 +17,8 @@ use serde_with::serde_as;
 #[serde_as]
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct EVMStateSketch {
+    /// The genesis block specification.
+    pub genesis: Genesis,
     /// The current block header.
     #[serde_as(as = "alloy_consensus::serde_bincode_compat::Header")]
     pub header: Header,

crates/client-executor/src/io.rs

@@ -5,6 +5,7 @@ use alloy_evm::{Database, Evm, IntoTxEnv};
 use alloy_sol_types::{sol, SolCall};
 use eyre::OptionExt;
 use io::EVMStateSketch;
+use reth_chainspec::ChainSpec;
 use reth_evm::{ConfigureEvm, EvmEnv};
 use reth_evm_ethereum::{EthEvm, EthEvmConfig};
 use reth_primitives::Header;
@@ -13,6 +14,7 @@ use revm::{
 };
 use revm_primitives::{Address, Bytes, TxKind, B256, U256};
 use rsp_client_executor::io::{TrieDB, WitnessInput};
+use rsp_primitives::genesis::Genesis;
 
 /// Input to a contract call.
 ///
@@ -84,6 +86,7 @@ impl IntoTxEnv<TxEnv> for &ContractInput {
                 ContractCalldata::Create(_) => TxKind::Create,
                 ContractCalldata::Call(_) => TxKind::Call(self.contract_address),
             },
+            chain_id: None,
             ..Default::default()
         }
     }
@@ -121,6 +124,8 @@ impl ContractPublicValues {
 /// An executor that executes smart contract calls inside a zkVM.
 #[derive(Debug)]
 pub struct ClientExecutor<'a> {
+    /// The genesis block specification.
+    pub genesis: &'a Genesis,
     /// The database that the executor uses to access state.
     pub witness_db: TrieDB<'a>,
     /// The block header.
@@ -131,34 +136,42 @@ impl<'a> ClientExecutor<'a> {
     /// Instantiates a new [`ClientExecutor`]
     pub fn new(state_sketch: &'a EVMStateSketch) -> eyre::Result<Self> {
         // let header = state_sketch.header.clone();
-        Ok(Self { witness_db: state_sketch.witness_db().unwrap(), header: &state_sketch.header })
+        Ok(Self {
+            genesis: &state_sketch.genesis,
+            witness_db: state_sketch.witness_db().unwrap(),
+            header: &state_sketch.header,
+        })
     }
 
     /// Executes the smart contract call with the given [`ContractInput`] in SP1.
     ///
     /// Storage accesses are already validated against the `witness_db`'s state root.
     pub fn execute(&self, call: ContractInput) -> eyre::Result<ContractPublicValues> {
         let cache_db = CacheDB::new(&self.witness_db);
-        let mut evm = new_evm(cache_db, self.header, U256::ZERO);
+        let mut evm = new_evm(cache_db, self.header, U256::ZERO, self.genesis);
         let tx_output = evm.transact(&call)?;
         let tx_output_bytes = tx_output.result.output().ok_or_eyre("Error decoding result")?;
         Ok(ContractPublicValues::new(call, tx_output_bytes.clone(), self.header.hash_slow()))
     }
 }
 
-/// TODO Add support for other chains besides Ethereum Mainnet.
 /// Instantiates a new EVM, which is ready to run `call`.
-pub fn new_evm<DB>(db: DB, header: &Header, total_difficulty: U256) -> EthEvm<DB, NoOpInspector>
+pub fn new_evm<DB>(
+    db: DB,
+    header: &Header,
+    difficulty: U256,
+    genesis: &Genesis,
+) -> EthEvm<DB, NoOpInspector>
 where
     DB: Database,
 {
-    let chain_spec = Arc::new(rsp_primitives::chain_spec::mainnet().unwrap());
+    let chain_spec = Arc::new(ChainSpec::try_from(genesis).unwrap());
 
     let EvmEnv { cfg_env, mut block_env, .. } = EthEvmConfig::new(chain_spec).evm_env(header);
 
     // Set the base fee to 0 to enable 0 gas price transactions.
     block_env.basefee = 0;
-    block_env.difficulty = total_difficulty;
+    block_env.difficulty = difficulty;
 
     let evm = Context::mainnet()
         .with_db(db)

crates/client-executor/src/lib.rs

@@ -6,8 +6,8 @@ use std::collections::BTreeSet;
 use alloy_consensus::Header;
 use alloy_evm::Evm;
 use alloy_provider::{network::AnyNetwork, Provider};
-use alloy_rpc_types::{BlockId, BlockNumberOrTag};
-use eyre::eyre;
+use alloy_rpc_types::BlockId;
+use eyre::{eyre, Ok};
 use revm::database::CacheDB;
 use revm_primitives::{Bytes, B256, U256};
 use rsp_mpt::EthereumState;
@@ -16,12 +16,16 @@ use rsp_rpc_db::RpcDb;
 
 use sp1_cc_client_executor::{io::EVMStateSketch, new_evm, ContractInput};
 
+pub use rsp_primitives::genesis::Genesis;
+
 /// An executor that fetches data from a [`Provider`].
 ///
 /// This executor keeps track of the state being accessed, and eventually compresses it into an
 /// [`EVMStateSketch`].
 #[derive(Debug, Clone)]
 pub struct HostExecutor<P: Provider<AnyNetwork> + Clone> {
+    /// The genesis block specification.
+    pub genesis: Genesis,
     /// The header of the block to execute our view functions on.
     pub header: Header,
     /// The [`RpcDb`] used to back the EVM.
@@ -31,28 +35,20 @@ pub struct HostExecutor<P: Provider<AnyNetwork> + Clone> {
 }
 
 impl<P: Provider<AnyNetwork> + Clone> HostExecutor<P> {
-    /// Create a new [`HostExecutor`] with a specific [`Provider`] and [`BlockNumberOrTag`].
-    pub async fn new(provider: P, block_number: BlockNumberOrTag) -> eyre::Result<Self> {
-        let block = provider
-            .get_block_by_number(block_number)
-            .full()
-            .await?
-            .ok_or(eyre!("couldn't fetch block: {}", block_number))?;
-
-        let rpc_db = RpcDb::new(provider.clone(), block.header.number);
-        let header = block
-            .inner
-            .header
-            .inner
-            .clone()
-            .try_into_header()
-            .map_err(|_| eyre!("fail to convert header"))?;
-
-        Ok(Self { header, rpc_db, provider })
+    /// Creates a new [`HostExecutor`] with a specific [`Provider`] and `block_identifier`
+    /// on Ethereum Mainnet. For a custom chain, use [`HostExecutor::new_with_genesis`].
+    pub async fn new<B: Into<BlockId>>(provider: P, block_identifier: B) -> eyre::Result<Self> {
+        Self::new_with_genesis(provider, block_identifier, Genesis::Mainnet).await
     }
 
-    /// Create a new [`HostExecutor`] with a specific [`Provider`] and [`BlockId`].
-    pub async fn new_with_blockid(provider: P, block_identifier: BlockId) -> eyre::Result<Self> {
+    /// Creates a new [`HostExecutor`] with a specific [`Provider`] and `block_identifier`
+    /// on a custom chain using the provided [`Genesis`].
+    pub async fn new_with_genesis<B: Into<BlockId>>(
+        provider: P,
+        block_identifier: B,
+        genesis: Genesis,
+    ) -> eyre::Result<Self> {
+        let block_identifier = block_identifier.into();
         let block = provider
             .get_block(block_identifier)
             .full()
@@ -67,15 +63,26 @@ impl<P: Provider<AnyNetwork> + Clone> HostExecutor<P> {
             .clone()
             .try_into_header()
             .map_err(|_| eyre!("fail to convert header"))?;
-        Ok(Self { header, rpc_db, provider })
+
+        Ok(Self { genesis, header, rpc_db, provider })
     }
 
     /// Executes the smart contract call with the given [`ContractInput`].
-    pub async fn execute(&mut self, call: ContractInput) -> eyre::Result<Bytes> {
+    pub async fn execute(&self, call: ContractInput) -> eyre::Result<Bytes> {
         let cache_db = CacheDB::new(&self.rpc_db);
-        let mut evm = new_evm(cache_db, &self.header, U256::ZERO);
+        let mut evm = new_evm(cache_db, &self.header, U256::ZERO, &self.genesis);
+
         let output = evm.transact(&call)?;
-        let output_bytes = output.result.output().ok_or(eyre!("Error getting result"))?;
+
+        let output_bytes = match output.result {
+            revm::context::result::ExecutionResult::Success { output, .. } => {
+                Ok(output.data().clone())
+            }
+            revm::context::result::ExecutionResult::Revert { output, .. } => Ok(output),
+            revm::context::result::ExecutionResult::Halt { reason, .. } => {
+                Err(eyre!("Execution halted: {reason:?}"))
+            }
+        }?;
 
         Ok(output_bytes.clone())
     }
@@ -124,6 +131,7 @@ impl<P: Provider<AnyNetwork> + Clone> HostExecutor<P> {
         }
 
         Ok(EVMStateSketch {
+            genesis: self.genesis.clone(),
             header: self.header.clone(),
             ancestor_headers,
             state,

crates/host-executor/src/lib.rs

@@ -4,6 +4,7 @@ use alloy_rpc_types::BlockNumberOrTag;
 use alloy_sol_macro::sol;
 use alloy_sol_types::SolCall;
 use revm_primitives::{hex, Bytes};
+use rsp_primitives::genesis::Genesis;
 use sp1_cc_client_executor::{ClientExecutor, ContractInput, ContractPublicValues};
 use url::Url;
 use ERC20Basic::nameCall;
@@ -131,7 +132,8 @@ async fn test_contract_creation() -> eyre::Result<()> {
     let rpc_url = std::env::var("ETH_SEPOLIA_RPC_URL")
         .unwrap_or_else(|_| panic!("Missing ETH_SEPOLIA_RPC_URL in env"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor =
+        HostExecutor::new_with_genesis(provider.clone(), block_number, Genesis::Sepolia).await?;
 
     // Keep track of the block hash. Later, validate the client's execution against this.
     let bytes = hex::decode(bytecode).expect("Decoding failed");
@@ -158,7 +160,8 @@ async fn test_e2e(contract_input: ContractInput) -> eyre::Result<ContractPublicV
     // Use `RPC_URL` to get all of the necessary state for the smart contract call.
     let rpc_url = std::env::var("ETH_RPC_URL").unwrap_or_else(|_| panic!("Missing RPC_URL"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor =
+        HostExecutor::new_with_genesis(provider.clone(), block_number, Genesis::Sepolia).await?;
 
     let _contract_output = host_executor.execute(contract_input.clone()).await?;
 

crates/host-executor/src/test.rs

@@ -9,7 +9,7 @@ use alloy_provider::RootProvider;
 use alloy_rpc_types::BlockNumberOrTag;
 use alloy_sol_types::SolValue;
 use sp1_cc_client_executor::ContractInput;
-use sp1_cc_host_executor::HostExecutor;
+use sp1_cc_host_executor::{Genesis, HostExecutor};
 use url::Url;
 
 /// The following bytecode corresponds to the following solidity contract:
@@ -42,7 +42,8 @@ async fn main() -> eyre::Result<()> {
     let rpc_url = std::env::var("ETH_SEPOLIA_RPC_URL")
         .unwrap_or_else(|_| panic!("Missing ETH_SEPOLIA_RPC_URL in env"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor =
+        HostExecutor::new_with_genesis(provider.clone(), block_number, Genesis::Sepolia).await?;
 
     // Keep track of the block hash. Later, validate the client's execution against this.
     let bytes = hex::decode(BYTECODE).expect("Decoding failed");

examples/example-deploy/host/src/main.rs

@@ -55,7 +55,7 @@ async fn main() -> eyre::Result<()> {
     let rpc_url =
         std::env::var("ETH_RPC_URL").unwrap_or_else(|_| panic!("Missing ETH_RPC_URL in env"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor = HostExecutor::new(provider.clone(), block_number).await?;
 
     // Keep track of the block hash. Later, the client's execution will be validated against this.
     let block_hash = host_executor.header.hash_slow();

examples/multiplexer/host/src/main.rs

@@ -82,7 +82,7 @@ async fn main() -> eyre::Result<()> {
     let rpc_url =
         std::env::var("ETH_RPC_URL").unwrap_or_else(|_| panic!("Missing ETH_RPC_URL in env"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor = HostExecutor::new(provider.clone(), block_number).await?;
 
     // Keep track of the block hash. Later, validate the client's execution against this.
     let block_hash = host_executor.header.hash_slow();

examples/uniswap/host/src/main.rs

@@ -7,7 +7,7 @@ use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use secp256k1::{generate_keypair, Message, PublicKey, SECP256K1};
 use sp1_cc_client_executor::{ContractInput, ContractPublicValues};
-use sp1_cc_host_executor::HostExecutor;
+use sp1_cc_host_executor::{Genesis, HostExecutor};
 use sp1_sdk::{include_elf, utils, ProverClient, SP1Stdin};
 use url::Url;
 use SimpleStaking::verifySignedCall;
@@ -58,7 +58,8 @@ async fn main() -> eyre::Result<()> {
     let rpc_url = std::env::var("ETH_SEPOLIA_RPC_URL")
         .unwrap_or_else(|_| panic!("Missing ETH_SEPOLIA_RPC_URL in env"));
     let provider = RootProvider::new_http(Url::parse(&rpc_url)?);
-    let mut host_executor = HostExecutor::new(provider.clone(), block_number).await?;
+    let host_executor =
+        HostExecutor::new_with_genesis(provider.clone(), block_number, Genesis::Sepolia).await?;
 
     // Keep track of the block hash. Later, validate the client's execution against this.
     let block_hash = host_executor.header.hash_slow();