cleanup and error handling

Cargo.toml

@@ -18,7 +18,7 @@ hex = "0.4.3"
 libflate = "1.2.0"
 openssl = { version = "0.10", features = ["vendored"] }
 once_cell = "1"
-jsonrpsee = {version = "0.17.0", features = ["server", "http-client", "ws-client", "macros", "client-ws-transport-native-tls"]}
+jsonrpsee = {version = "0.17.0", features = ["server", "macros"]}
 
 # Logging and Metrics
 chrono = "0.4.22"

src/config/mod.rs

@@ -125,8 +125,8 @@ pub struct ChainConfig {
     /// Network blocktime
     #[serde(default = "default_blocktime")]
     pub blocktime: u64,
-    /// L2 To L1 Message parser address
-    pub l2_to_l1_message_parser_address: Address,
+    /// L2 To L1 Message passer address
+    pub l2_to_l1_message_passer: Address,
 }
 
 /// Optimism system config contract values
@@ -212,7 +212,7 @@ impl ChainConfig {
             system_config_contract: addr("0xAe851f927Ee40dE99aaBb7461C00f9622ab91d60"),
             batch_inbox: addr("0xff00000000000000000000000000000000000420"),
             deposit_contract: addr("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
-            l2_to_l1_message_parser_address: addr("0xEF2ec5A5465f075E010BE70966a8667c94BCe15a"),
+            l2_to_l1_message_passer: addr("0xEF2ec5A5465f075E010BE70966a8667c94BCe15a"),
             max_channel_size: 100_000_000,
             channel_timeout: 300,
             seq_window_size: 3600,
@@ -244,7 +244,7 @@ impl ChainConfig {
             system_config_contract: addr("0xb15eea247ece011c68a614e4a77ad648ff495bc1"),
             batch_inbox: addr("0x8453100000000000000000000000000000000000"),
             deposit_contract: addr("0xe93c8cd0d409341205a592f8c4ac1a5fe5585cfa"),
-            l2_to_l1_message_parser_address: addr("0x4200000000000000000000000000000000000016"),
+            l2_to_l1_message_passer: addr("0x4200000000000000000000000000000000000016"),
             max_channel_size: 100_000_000,
             channel_timeout: 100,
             seq_window_size: 3600,

src/driver/mod.rs

@@ -68,7 +68,6 @@ impl Driver<EngineApi> {
 
         tracing::info!("syncing from: {:?}", finalized_head.hash);
 
-        let config_clone = config.clone();
         let config = Arc::new(config);
         let chain_watcher = ChainWatcher::new(
             finalized_epoch.number,
@@ -83,10 +82,9 @@ impl Driver<EngineApi> {
         )));
 
         let engine_driver = EngineDriver::new(finalized_head, finalized_epoch, provider, &config)?;
-        let pipeline = Pipeline::new(state.clone(), config)?;
+        let pipeline = Pipeline::new(state.clone(), config.clone())?;
 
-        let config_arc = Arc::new(config_clone);
-        let _addr = rpc::run_server(config_arc).await?;
+        let _addr = rpc::run_server(config).await?;
 
         Ok(Self {
             engine_driver,

src/rpc/mod.rs

@@ -1,4 +1,4 @@
-use std::{net::SocketAddr, sync::Arc};
+use std::{net::SocketAddr, sync::Arc, fmt::Display};
 
 use crate::config::Config;
 
@@ -18,7 +18,7 @@ use jsonrpsee::{
 
 use serde::{Deserialize, Serialize};
 
-#[rpc(server, client, namespace = "optimism")]
+#[rpc(server, namespace = "optimism")]
 pub trait Rpc {
     #[method(name = "outputAtBlock")]
     async fn output_at_block(&self, block_number: u64) -> Result<OutputRootResponse, Error>;
@@ -33,28 +33,32 @@ pub struct RpcServerImpl {
 impl RpcServer for RpcServerImpl {
     async fn output_at_block(&self, block_number: u64) -> Result<OutputRootResponse, Error> {
         let l2_provider =
-            Provider::try_from(self.config.l2_rpc_url.clone()).expect("invalid L2 RPC url");
+            convert_err(Provider::try_from(self.config.l2_rpc_url.clone()))?;
 
-        let block = l2_provider.get_block(block_number).await.unwrap().unwrap();
+        let block = match convert_err(l2_provider.get_block(block_number).await)? {
+            Some(block) => block,
+            None => return Err(Error::Custom("unable to get block".to_string()))
+        };
 
         let state_root = block.state_root;
-        let block_hash = block.hash.unwrap();
+        let block_hash = match block.hash {
+            Some(hash) => hash,
+            None => return Err(Error::Custom("block hash not found".to_string()))
+        };
         let locations = vec![];
         let block_id = Some(BlockId::from(block_hash));
 
-        let state_proof = l2_provider
+        let state_proof = convert_err(l2_provider
             .get_proof(
-                self.config.chain.l2_to_l1_message_parser_address,
+                self.config.chain.l2_to_l1_message_passer,
                 locations,
                 block_id,
             )
-            .await
-            .unwrap();
+            .await)?;
 
         let withdrawal_storage_root = state_proof.storage_hash;
 
         let output_root = compute_l2_output_root(block, state_proof.storage_hash);
-        // TODO: Verify proof like this - https://github.com/ethereum-optimism/optimism/blob/b65152ca11d7d4c2f23156af8a03339b6798c04d/op-node/node/api.go#L111
 
         let version: H256 = Default::default();
 
@@ -67,6 +71,10 @@ impl RpcServer for RpcServerImpl {
     }
 }
 
+fn convert_err<T, E: Display>(res: Result<T, E>) -> Result<T, Error> {
+    res.map_err(|err| Error::Custom(err.to_string()))
+}
+
 fn compute_l2_output_root(block: Block<H256>, storage_root: H256) -> H256 {
     let version: H256 = Default::default();
     let digest = keccak256(