refactor(relayer, ethereum-client): A bunch of small refactorings to relayer and ethereum-client

ethereum/client/src/error.rs

@@ -1,11 +1,10 @@
+use alloy::transports::{RpcError, TransportErrorKind};
 use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("Not implemented")]
-    NotImplemented,
-    #[error("Error in HTTP transport")]
-    ErrorInHTTPTransport,
+    #[error("Error in HTTP transport: {0}")]
+    ErrorInHTTPTransport(RpcError<TransportErrorKind>),
     #[error("Wrong address")]
     WrongAddress,
     #[error("Wrong node URL")]
@@ -16,6 +15,8 @@ pub enum Error {
     ErrorDuringContractExecution(alloy::contract::Error),
     #[error("Error sending transaction: {0}")]
     ErrorSendingTransaction(alloy::contract::Error),
+    #[error("Error querying event: {0}")]
+    ErrorQueryingEvent(alloy::contract::Error),
     #[error("Error waiting transaction receipt")]
     ErrorWaitingTransactionReceipt,
     #[error("Error fetching transaction")]
@@ -24,10 +25,10 @@ pub enum Error {
     ErrorFetchingTransactionReceipt,
     #[error("Error fetching block")]
     ErrorFetchingBlock,
-    #[error("Wrong path to file")]
-    WrongPathToFile,
-    #[error("Wrong JSON format")]
-    WrongJsonFormation,
-    #[error("Cannot convert to U256")]
-    UnableToConvertToU256,
+}
+
+impl From<RpcError<TransportErrorKind>> for Error {
+    fn from(value: RpcError<TransportErrorKind>) -> Self {
+        Self::ErrorInHTTPTransport(value)
+    }
 }

ethereum/client/src/lib.rs

@@ -212,14 +212,9 @@ where
     }
 
     pub async fn get_approx_balance(&self, address: Address) -> Result<f64, Error> {
-        let balance = self.provider.get_balance(address).latest().await;
-
-        if let Ok(balance) = balance {
-            let balance: f64 = balance.into();
-            Ok(balance / 1_000_000_000_000_000_000.0)
-        } else {
-            Err(Error::ErrorInHTTPTransport)
-        }
+        let balance = self.provider.get_balance(address).latest().await?;
+        let balance: f64 = balance.into();
+        Ok(balance / 1_000_000_000_000_000_000.0)
     }
 
     pub async fn provide_merkle_root(
@@ -254,18 +249,11 @@ where
     }
 
     pub async fn block_number(&self) -> Result<u64, Error> {
-        self.provider
-            .get_block_number()
-            .await
-            .map_err(|_| Error::ErrorInHTTPTransport)
+        self.provider.get_block_number().await.map_err(|e| e.into())
     }
 
     pub async fn fetch_merkle_roots(&self, depth: u64) -> Result<Vec<MerkleRootEntry>, Error> {
-        let current_block: u64 = self
-            .provider
-            .get_block_number()
-            .await
-            .map_err(|_| Error::ErrorInHTTPTransport)?;
+        let current_block: u64 = self.provider.get_block_number().await?;
 
         self.fetch_merkle_roots_in_range(
             current_block.checked_sub(depth).unwrap_or_default(),
@@ -287,15 +275,14 @@ where
 
         let event: Event<T, P, MerkleRoot, Ethereum> = Event::new(self.provider.clone(), filter);
 
-        match event.query().await {
-            Ok(logs) => Ok(logs
-                .iter()
-                .map(|(event, _)| MerkleRootEntry {
-                    block_number: event.blockNumber.to(),
-                })
-                .collect()),
-            Err(_) => Err(Error::ErrorInHTTPTransport),
-        }
+        let logs = event.query().await.map_err(Error::ErrorQueryingEvent)?;
+
+        Ok(logs
+            .iter()
+            .map(|(event, _)| MerkleRootEntry {
+                block_number: event.blockNumber.to(),
+            })
+            .collect())
     }
 
     #[allow(clippy::too_many_arguments)]

ethereum/client/src/tests.rs

@@ -137,10 +137,7 @@ where
         erc20_treasury_proxy: *erc20_treasury_proxy.address(),
     };
 
-    let nonce = provider
-        .get_transaction_count(signer_address)
-        .await
-        .map_err(|_| Error::ErrorInHTTPTransport)?;
+    let nonce = provider.get_transaction_count(signer_address).await?;
 
     let relayer_proxy = ProxyContract::new(deployment.relayer_proxy, provider.clone());
 
@@ -158,10 +155,7 @@ where
         .await
         .map_err(|_| Error::ErrorWaitingTransactionReceipt)?;
 
-    let nonce = provider
-        .get_transaction_count(signer_address)
-        .await
-        .map_err(|_| Error::ErrorInHTTPTransport)?;
+    let nonce = provider.get_transaction_count(signer_address).await?;
 
     let pending_tx = message_queue_proxy
         .upgradeToAndCall(deployment.message_queue, Bytes::new())
@@ -177,10 +171,7 @@ where
         .await
         .map_err(|_| Error::ErrorWaitingTransactionReceipt)?;
 
-    let nonce = provider
-        .get_transaction_count(signer_address)
-        .await
-        .map_err(|_| Error::ErrorInHTTPTransport)?;
+    let nonce = provider.get_transaction_count(signer_address).await?;
 
     let pending_tx = erc20_treasury_proxy
         .upgradeToAndCall(deployment.erc20_treasury, Bytes::new())

gear-rpc-client/src/lib.rs

@@ -550,7 +550,7 @@ impl GearApi {
             .api
             .rpc()
             .request(
-                "gearBridge_merkleProof",
+                "gearEthBridge_merkleProof",
                 rpc_params![message_hash, Some(block)],
             )
             .await?;

relayer/src/proof_storage/gear.rs

@@ -115,15 +115,9 @@ impl GearProofStorage {
     ) -> anyhow::Result<GearProofStorage> {
         let wrapped_gear_api = WrappedGearApi::new(endpoint).await?;
 
-        assert_eq!(
-            &endpoint[..5],
-            "ws://",
-            "Invalid endpoint format: expected ws://..."
-        );
-
-        let endpoint: Vec<_> = endpoint[5..].split(':').collect();
-        let domain = ["ws://", endpoint[0]].concat();
-        let port = endpoint[1].parse::<u16>()?;
+        let endpoint: Vec<_> = endpoint.split(':').collect();
+        let domain = [endpoint[0], ":", endpoint[1]].concat();
+        let port = endpoint[2].parse::<u16>()?;
         let address = WSAddress::try_new(domain, port)?;
 
         let gear_api = GearApi::init_with(address, fee_payer).await?;

relayer/src/relay_merkle_roots.rs

@@ -206,7 +206,13 @@ impl MerkleRootRelayer {
     async fn prove_message_sent(&self) -> anyhow::Result<FinalProof> {
         let finalized_head = self.gear_api.latest_finalized_block().await?;
 
-        log::info!("Proving merkle root presense in block #{}", finalized_head);
+        let finalized_block_number = self.gear_api.block_hash_to_number(finalized_head).await?;
+
+        log::info!(
+            "Proving merkle root presense in block #{} with hash {}",
+            finalized_block_number,
+            finalized_head
+        );
 
         let authority_set_id = self
             .gear_api