Add untested/unintegrated nomad-substrate crate

Cargo.toml

@@ -10,6 +10,7 @@ members = [
     "nomad-base",
     "nomad-test",
     "chains/nomad-ethereum",
+    "chains/nomad-substrate",
     "agents/kathy",
     "agents/updater",
     "agents/relayer",

accumulator/CHANGELOG.md

@@ -2,4 +2,5 @@
 
 ### Unreleased
 
+- Adds deserialization implementation for generic arrays to allow `LightMerkle<N>` to derive `Serialize/Deserialize`
 - adds a changelog

accumulator/src/light.rs

@@ -3,14 +3,23 @@ use ethers::{core::types::H256, prelude::U256};
 use crate::{
     error::IngestionError, utils::hash_concat, Merkle, MerkleProof, Proof, TREE_DEPTH, ZERO_HASHES,
 };
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy)]
 /// An incremental merkle tree, modeled on the eth2 deposit contract
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct LightMerkle<const N: usize> {
+    #[serde(with = "arrays")]
     branch: [H256; N],
     count: usize,
 }
 
+impl<const N: usize> LightMerkle<N> {
+    /// Instantiate new LightMerkle from branch and count
+    pub fn new(branch: [H256; N], count: usize) -> Self {
+        Self { branch, count }
+    }
+}
+
 impl<const N: usize> Default for LightMerkle<N> {
     fn default() -> Self {
         let mut branch: [H256; N] = [Default::default(); N];
@@ -106,6 +115,65 @@ impl<const N: usize> LightMerkle<N> {
     }
 }
 
+mod arrays {
+    use std::{convert::TryInto, marker::PhantomData};
+
+    use serde::{
+        de::{SeqAccess, Visitor},
+        ser::SerializeTuple,
+        Deserialize, Deserializer, Serialize, Serializer,
+    };
+    pub fn serialize<S: Serializer, T: Serialize, const N: usize>(
+        data: &[T; N],
+        ser: S,
+    ) -> Result<S::Ok, S::Error> {
+        let mut s = ser.serialize_tuple(N)?;
+        for item in data {
+            s.serialize_element(item)?;
+        }
+        s.end()
+    }
+
+    struct ArrayVisitor<T, const N: usize>(PhantomData<T>);
+
+    impl<'de, T, const N: usize> Visitor<'de> for ArrayVisitor<T, N>
+    where
+        T: Deserialize<'de>,
+    {
+        type Value = [T; N];
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str(&format!("an array of length {}", N))
+        }
+
+        #[inline]
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            // can be optimized using MaybeUninit
+            let mut data = Vec::with_capacity(N);
+            for _ in 0..N {
+                match (seq.next_element())? {
+                    Some(val) => data.push(val),
+                    None => return Err(serde::de::Error::invalid_length(N, &self)),
+                }
+            }
+            match data.try_into() {
+                Ok(arr) => Ok(arr),
+                Err(_) => unreachable!(),
+            }
+        }
+    }
+    pub fn deserialize<'de, D, T, const N: usize>(deserializer: D) -> Result<[T; N], D::Error>
+    where
+        D: Deserializer<'de>,
+        T: Deserialize<'de>,
+    {
+        deserializer.deserialize_tuple(N, ArrayVisitor::<T, N>(PhantomData))
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

agents/processor/src/processor.rs

@@ -14,12 +14,12 @@ use tracing::{
 };
 
 use nomad_base::{
-    cancel_task, decl_agent, decl_channel, AgentCore, CachingHome, CachingReplica, NomadAgent,
-    NomadDB, ProcessorError,
+    cancel_task, decl_agent, decl_channel, AgentCore, CachingHome, CachingReplica,
+    ChainCommunicationError, NomadAgent, NomadDB, ProcessorError,
 };
 use nomad_core::{
     accumulator::{MerkleProof, NomadProof},
-    ChainCommunicationError, CommittedMessage, Common, Home, HomeEvents, MessageStatus,
+    CommittedMessage, Common, Home, HomeEvents, MessageStatus,
 };
 
 use crate::{prover_sync::ProverSync, push::Pusher, settings::ProcessorSettings as Settings};
@@ -259,7 +259,7 @@ impl Replica {
         // Other errors are bubbled up
         match result {
             Ok(_) => {}
-            Err(ChainCommunicationError::NotExecuted(txid)) => {
+            Err(ChainCommunicationError::TxNotExecuted(txid)) => {
                 warn!(txid = ?txid, "Error in processing. May indicate an internal revert of the handler.");
             }
             Err(e) => {

agents/processor/src/prover_sync.rs

@@ -1,10 +1,9 @@
 use color_eyre::eyre::{bail, Result};
 use ethers::core::types::H256;
-use nomad_base::NomadDB;
+use nomad_base::{ChainCommunicationError, NomadDB};
 use nomad_core::{
     accumulator::{Merkle, NomadTree, ProvingError},
     db::DbError,
-    ChainCommunicationError,
 };
 use std::{fmt::Display, time::Duration};
 use tokio::{

agents/relayer/src/relayer.rs

@@ -193,12 +193,11 @@ impl NomadAgent for Relayer {
 
 #[cfg(test)]
 mod test {
-    use ethers::prelude::{ProviderError, H256};
+    use ethers::prelude::H256;
     use nomad_base::{
         chains::PageSettings, CommonIndexers, ContractSync, ContractSyncMetrics, CoreMetrics,
         HomeIndexers, IndexSettings, NomadDB,
     };
-    use nomad_core::ChainCommunicationError;
     use nomad_test::mocks::{MockHomeContract, MockIndexer, MockReplicaContract};
     use nomad_test::test_utils;
     use std::collections::HashMap;
@@ -261,13 +260,7 @@ mod test {
                 replica_mock
                     .expect__committed_root()
                     .times(..)
-                    .returning(|| {
-                        Err(ChainCommunicationError::ProviderError(
-                            ProviderError::CustomError(
-                                "I am replica and I always throw the error".to_string(),
-                            ),
-                        ))
-                    });
+                    .returning(|| Err(nomad_test::mocks::MockError));
             }
 
             let replica_indexer: Arc<CommonIndexers> = Arc::new(MockIndexer::new().into());

agents/watcher/src/watcher.rs

@@ -15,11 +15,12 @@ use tokio::{
 use tracing::{error, info, info_span, instrument::Instrumented, Instrument};
 
 use nomad_base::{
-    cancel_task, AgentCore, BaseError, CachingHome, ConnectionManagers, NomadAgent, NomadDB,
+    cancel_task, AgentCore, BaseError, CachingHome, ChainCommunicationError, ConnectionManagers,
+    NomadAgent, NomadDB,
 };
 use nomad_core::{
-    ChainCommunicationError, Common, CommonEvents, ConnectionManager, DoubleUpdate,
-    FailureNotification, Home, SignedFailureNotification, SignedUpdate, Signers, TxOutcome,
+    Common, CommonEvents, ConnectionManager, DoubleUpdate, FailureNotification, Home,
+    SignedFailureNotification, SignedUpdate, Signers, TxOutcome,
 };
 
 use crate::settings::WatcherSettings as Settings;

chains/nomad-ethereum/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ### Unreleased
 
+- Add `EthereumError` error enum to wrap ethers and gelato errors (ethereum-specific)
+- Make existing contract methods return `Result<_, EthereumError>` now instead of using old `nomad_core::ChainCommunicationError`
 - impl `std::fmt::Display` for `EthereumHome` and `EthereumReplica`
 - use gelato-sdk as a github dep rather than a crate
 - adds a changelog

chains/nomad-ethereum/src/error.rs

@@ -0,0 +1,39 @@
+use crate::gelato::GelatoError;
+use ethers::core::types::H256;
+use ethers::prelude::{ContractError, Middleware, ProviderError};
+use std::error::Error as StdError;
+
+/// Ethereum-specific error wrapper
+#[derive(Debug, thiserror::Error)]
+pub enum EthereumError {
+    /// Ethers provider error
+    #[error("{0}")]
+    ProviderError(#[from] ProviderError),
+    /// Ethers contract error
+    #[error("{0}")]
+    ContractError(Box<dyn StdError + Send + Sync>),
+    /// Middleware error
+    #[error("{0}")]
+    MiddlewareError(Box<dyn StdError + Send + Sync>),
+    /// Gelato client error
+    #[error("{0}")]
+    GelatoError(#[from] GelatoError),
+    /// A transaction was dropped from the mempool
+    #[error("Transaction dropped from mempool {0:?}")]
+    DroppedError(H256),
+    /// Transaction was not executed successfully
+    #[error("Transaction was not executed successfully {0:?}")]
+    TxNotExecuted(H256),
+    /// Any other error
+    #[error("{0}")]
+    CustomError(#[from] Box<dyn StdError + Send + Sync>),
+}
+
+impl<M> From<ContractError<M>> for EthereumError
+where
+    M: Middleware + 'static,
+{
+    fn from(e: ContractError<M>) -> Self {
+        Self::ContractError(e.into())
+    }
+}

chains/nomad-ethereum/src/gelato.rs

@@ -5,15 +5,15 @@ use ethers::{
 };
 use gelato_sdk::{
     get_forwarder,
-    rpc::{RelayResponse, TaskState},
+    rpc::{CheckOrDate, RelayResponse, TaskState},
     FeeToken, ForwardRequestBuilder, GelatoClient,
 };
-use std::sync::Arc;
+use std::{error::Error as StdError, sync::Arc};
 use tokio::task::JoinHandle;
 use tokio::time::{sleep, Duration};
 use tracing::info;
 
-use nomad_core::{ChainCommunicationError, Signers, TxOutcome};
+use nomad_core::{Signers, TxOutcome};
 
 pub(crate) const ACCEPTABLE_STATES: [TaskState; 4] = [
     TaskState::CheckPending,
@@ -22,6 +22,25 @@ pub(crate) const ACCEPTABLE_STATES: [TaskState; 4] = [
     TaskState::WaitingForConfirmation,
 ];
 
+/// Gelato-specific errors
+#[derive(Debug, thiserror::Error)]
+pub enum GelatoError {
+    /// Gelato client error
+    #[error("{0}")]
+    ClientError(#[from] gelato_sdk::ClientError),
+    /// Failed task error
+    #[error("Gelato task failed. Id: {task_id}. Check info: {check_info:?}.")]
+    FailedTaskError {
+        /// Task id
+        task_id: H256,
+        /// Status
+        check_info: Option<CheckOrDate>,
+    },
+    /// Custom error
+    #[error("{0}")]
+    CustomError(#[from] Box<dyn StdError + Send + Sync>),
+}
+
 /// Gelato client for submitting txs to single chain
 #[derive(Debug, Clone)]
 pub struct SingleChainGelatoClient<M> {
@@ -75,7 +94,7 @@ where
         domain: u32,
         contract_address: Address,
         tx: &TypedTransaction,
-    ) -> Result<TxOutcome, ChainCommunicationError> {
+    ) -> Result<TxOutcome, GelatoError> {
         let task_id = self
             .dispatch_tx(domain, contract_address, tx)
             .await?
@@ -86,7 +105,7 @@ where
         info!(task_id = ?&task_id, "Polling Gelato task...");
         self.poll_task_id(task_id)
             .await
-            .map_err(|e| ChainCommunicationError::TxSubmissionError(e.into()))?
+            .map_err(|e| GelatoError::CustomError(e.into()))?
     }
 
     /// Dispatch tx to Gelato and return task id.
@@ -95,7 +114,7 @@ where
         domain: u32,
         contract_address: Address,
         tx: &TypedTransaction,
-    ) -> Result<RelayResponse, ChainCommunicationError> {
+    ) -> Result<RelayResponse, GelatoError> {
         // If gas limit not hardcoded in tx, eth_estimateGas
         let gas_limit = tx
             .gas()
@@ -104,7 +123,7 @@ where
                     .eth_client
                     .estimate_gas(tx)
                     .await
-                    .map_err(|e| ChainCommunicationError::MiddlewareError(e.into()))?,
+                    .map_err(|e| GelatoError::CustomError(e.into()))?,
             )
             .as_u64()
             .into();
@@ -118,28 +137,22 @@ where
 
         self.send_forward_request(contract_address, data, gas_limit)
             .await
-            .map_err(|e| ChainCommunicationError::TxSubmissionError(e.into()))
     }
 
     /// Poll task id and return tx hash of transaction if successful, error if
     /// otherwise.
-    pub fn poll_task_id(
-        &self,
-        task_id: H256,
-    ) -> JoinHandle<Result<TxOutcome, ChainCommunicationError>> {
+    pub fn poll_task_id(&self, task_id: H256) -> JoinHandle<Result<TxOutcome, GelatoError>> {
         let gelato = self.gelato();
 
         tokio::spawn(async move {
             loop {
-                let status = gelato
-                    .get_task_status(task_id)
-                    .await
-                    .map_err(|e| ChainCommunicationError::TxSubmissionError(e.into()))?;
+                let status = gelato.get_task_status(task_id).await?;
 
                 if !ACCEPTABLE_STATES.contains(&status.task_state) {
-                    return Err(ChainCommunicationError::TxSubmissionError(
-                        format!("Gelato task failed: {:?}", status).into(),
-                    ));
+                    return Err(GelatoError::FailedTaskError {
+                        task_id,
+                        check_info: status.last_check,
+                    });
                 }
 
                 if let Some(execution) = &status.execution {
@@ -172,15 +185,14 @@ where
         target: Address,
         data: impl Into<Bytes>,
         gas_limit: U64,
-    ) -> Result<RelayResponse, ChainCommunicationError> {
+    ) -> Result<RelayResponse, GelatoError> {
         // add 100k gas padding for Gelato contract ops
         let adjusted_limit = gas_limit + U64::from(100_000);
 
         let max_fee = self
             .gelato()
             .get_estimated_fee(self.chain_id, self.fee_token, adjusted_limit, false)
-            .await
-            .map_err(|e| ChainCommunicationError::CustomError(e.into()))?;
+            .await?;
 
         let request = ForwardRequestBuilder::default()
             .chain_id(self.chain_id)
@@ -201,9 +213,6 @@ where
             "Signed gelato forward request."
         );
 
-        self.gelato()
-            .send_forward_request(&request)
-            .await
-            .map_err(|e| ChainCommunicationError::TxSubmissionError(e.into()))
+        Ok(self.gelato().send_forward_request(&request).await?)
     }
 }