Allow sub-contexts to have different Error types with functions to inject errors into Self::Error

crates/relayer-cosmos/src/base/impls/chain.rs

@@ -12,6 +12,8 @@ use ibc_relayer_framework::base::one_for_all::traits::chain::{
     OfaBaseChain, OfaChainTypes, OfaIbcChain,
 };
 use ibc_relayer_framework::base::one_for_all::traits::runtime::OfaRuntimeContext;
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
+use ibc_relayer_runtime::tokio::error::Error as TokioError;
 use ibc_relayer_types::clients::ics07_tendermint::consensus_state::ConsensusState;
 use ibc_relayer_types::core::ics04_channel::events::WriteAcknowledgement;
 use ibc_relayer_types::core::ics04_channel::packet::Sequence;
@@ -27,7 +29,6 @@ use crate::base::error::Error;
 use crate::base::traits::chain::CosmosChain;
 use crate::base::types::chain::CosmosChainWrapper;
 use crate::base::types::message::CosmosIbcMessage;
-use crate::base::types::runtime::CosmosRuntimeContext;
 
 impl<Chain> OfaChainTypes for CosmosChainWrapper<Chain>
 where
@@ -37,7 +38,7 @@ where
 
     type Error = Error;
 
-    type Runtime = CosmosRuntimeContext;
+    type Runtime = TokioRuntimeContext;
 
     type Height = Height;
 
@@ -73,6 +74,10 @@ impl<Chain> OfaBaseChain for CosmosChainWrapper<Chain>
 where
     Chain: CosmosChain,
 {
+    fn runtime_error(e: TokioError) -> Error {
+        Error::tokio(e)
+    }
+
     fn encode_raw_message(message: &CosmosIbcMessage, signer: &Signer) -> Result<Any, Error> {
         (message.to_protobuf_fn)(signer).map_err(Error::encode)
     }
@@ -108,7 +113,7 @@ where
         }
     }
 
-    fn runtime(&self) -> &OfaRuntimeContext<CosmosRuntimeContext> {
+    fn runtime(&self) -> &OfaRuntimeContext<TokioRuntimeContext> {
         &self.runtime
     }
 

crates/relayer-cosmos/src/base/impls/relay.rs

@@ -23,7 +23,8 @@ use crate::base::traits::relay::CosmosRelay;
 use crate::base::types::chain::CosmosChainWrapper;
 use crate::base::types::message::CosmosIbcMessage;
 use crate::base::types::relay::CosmosRelayWrapper;
-use crate::base::types::runtime::CosmosRuntimeContext;
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
+use ibc_relayer_runtime::tokio::error::Error as TokioError;
 
 impl<Relay> OfaRelayTypes for CosmosRelayWrapper<Relay>
 where
@@ -33,7 +34,7 @@ where
 
     type Error = Error;
 
-    type Runtime = CosmosRuntimeContext;
+    type Runtime = TokioRuntimeContext;
 
     type Packet = Packet;
 
@@ -47,6 +48,18 @@ impl<Relay> OfaBaseRelay for CosmosRelayWrapper<Relay>
 where
     Relay: CosmosRelay,
 {
+    fn runtime_error(e: TokioError) -> Error {
+        Error::tokio(e)
+    }
+
+    fn src_chain_error(e: Error) -> Error {
+        e
+    }
+
+    fn dst_chain_error(e: Error) -> Error {
+        e
+    }
+
     fn mismatch_ibc_events_count_error(expected: usize, actual: usize) -> Self::Error {
         Error::mismatch_ibc_events_count(expected, actual)
     }
@@ -90,7 +103,7 @@ where
         &packet.timeout_timestamp
     }
 
-    fn runtime(&self) -> &OfaRuntimeContext<CosmosRuntimeContext> {
+    fn runtime(&self) -> &OfaRuntimeContext<TokioRuntimeContext> {
         &self.runtime
     }
 

crates/relayer-cosmos/src/base/types/chain.rs

@@ -1,16 +1,15 @@
 use alloc::sync::Arc;
 use ibc_relayer_framework::base::one_for_all::traits::runtime::OfaRuntimeContext;
-
-use crate::base::types::runtime::CosmosRuntimeContext;
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
 
 #[derive(Clone)]
 pub struct CosmosChainWrapper<Chain> {
     pub chain: Arc<Chain>,
-    pub runtime: OfaRuntimeContext<CosmosRuntimeContext>,
+    pub runtime: OfaRuntimeContext<TokioRuntimeContext>,
 }
 
 impl<Chain> CosmosChainWrapper<Chain> {
-    pub fn new(chain: Arc<Chain>, runtime: CosmosRuntimeContext) -> Self {
+    pub fn new(chain: Arc<Chain>, runtime: TokioRuntimeContext) -> Self {
         Self {
             chain,
             runtime: OfaRuntimeContext::new(runtime),

crates/relayer-cosmos/src/base/types/mod.rs

@@ -1,4 +1,3 @@
 pub mod chain;
 pub mod message;
 pub mod relay;
-pub mod runtime;

crates/relayer-cosmos/src/base/types/relay.rs

@@ -1,21 +1,21 @@
 use alloc::sync::Arc;
 use ibc_relayer_framework::base::one_for_all::traits::runtime::OfaRuntimeContext;
 use ibc_relayer_framework::common::one_for_all::types::chain::OfaChainWrapper;
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
 
 use crate::base::traits::relay::CosmosRelay;
 use crate::base::types::chain::CosmosChainWrapper;
-use crate::base::types::runtime::CosmosRuntimeContext;
 
 #[derive(Clone)]
 pub struct CosmosRelayWrapper<Relay: CosmosRelay> {
     pub relay: Arc<Relay>,
     pub src_chain: OfaChainWrapper<CosmosChainWrapper<Relay::SrcChain>>,
     pub dst_chain: OfaChainWrapper<CosmosChainWrapper<Relay::DstChain>>,
-    pub runtime: OfaRuntimeContext<CosmosRuntimeContext>,
+    pub runtime: OfaRuntimeContext<TokioRuntimeContext>,
 }
 
 impl<Relay: CosmosRelay> CosmosRelayWrapper<Relay> {
-    pub fn new(relay: Arc<Relay>, runtime: CosmosRuntimeContext) -> Self {
+    pub fn new(relay: Arc<Relay>, runtime: TokioRuntimeContext) -> Self {
         let src_chain = OfaChainWrapper::new(CosmosChainWrapper::new(
             relay.src_chain().clone(),
             runtime.clone(),

crates/relayer-cosmos/src/contexts/full/chain.rs

@@ -3,7 +3,7 @@ use ibc_relayer::chain::handle::ChainHandle;
 use ibc_relayer::keyring::KeyEntry;
 use ibc_relayer_framework::common::one_for_all::presets::FullPreset;
 use ibc_relayer_framework::full::batch::context::new_batch_channel;
-use ibc_relayer_framework::full::one_for_all::traits::batch::OfaBatchContext;
+use ibc_relayer_framework::full::one_for_all::traits::batch::OfaBatchWrapper;
 use ibc_relayer_framework::full::one_for_all::traits::telemetry::OfaTelemetryWrapper;
 use ibc_relayer_types::signer::Signer;
 
@@ -31,7 +31,7 @@ impl<Handle: ChainHandle> CosmosChainContext<Handle> {
         key_entry: KeyEntry,
         telemetry: CosmosTelemetry,
     ) -> Self {
-        let batch_channel = new_batch_channel::<OfaBatchContext<CosmosChainWrapper<Self>>>();
+        let batch_channel = new_batch_channel::<OfaBatchWrapper<CosmosChainWrapper<Self>>>();
 
         let chain = Self {
             handle,

crates/relayer-cosmos/src/contexts/full/relay.rs

@@ -8,11 +8,11 @@ use ibc_relayer_framework::full::batch::config::BatchConfig;
 use ibc_relayer_framework::full::batch::spawn::{
     BatchMessageWorkerSpawner, CanSpawnBatchMessageWorker,
 };
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
 
 use crate::base::traits::chain::CosmosChain;
 use crate::base::traits::relay::CosmosRelay;
 use crate::base::types::relay::CosmosRelayWrapper;
-use crate::base::types::runtime::CosmosRuntimeContext;
 use crate::contexts::full::chain::CosmosChainContext;
 use crate::full::traits::relay::CosmosFullRelay;
 
@@ -66,7 +66,7 @@ where
 }
 
 pub fn new_relay_context_with_batch<SrcChain, DstChain>(
-    runtime: CosmosRuntimeContext,
+    runtime: TokioRuntimeContext,
     src_chain: CosmosChainContext<SrcChain>,
     dst_chain: CosmosChainContext<DstChain>,
     src_to_dst_client: ForeignClient<DstChain, SrcChain>,

crates/relayer-cosmos/src/full/impls/chain.rs

@@ -1,8 +1,8 @@
 use ibc_relayer_framework::full::one_for_all::traits::chain::OfaFullChain;
 use ibc_relayer_framework::full::one_for_all::traits::telemetry::OfaTelemetryWrapper;
+use ibc_relayer_runtime::tokio::context::TokioRuntimeContext;
 
 use crate::base::types::chain::CosmosChainWrapper;
-use crate::base::types::runtime::CosmosRuntimeContext;
 use crate::full::traits::chain::CosmosFullChain;
 use crate::full::types::batch::CosmosBatchChannel;
 use crate::full::types::telemetry::CosmosTelemetry;
@@ -11,7 +11,7 @@ impl<Chain> OfaFullChain for CosmosChainWrapper<Chain>
 where
     Chain: CosmosFullChain,
 {
-    type BatchContext = CosmosRuntimeContext;
+    type BatchContext = TokioRuntimeContext;
 
     type Telemetry = CosmosTelemetry;
 

crates/relayer-cosmos/src/transaction/impls/broadcast.rs

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use ibc_proto::cosmos::tx::v1beta1::TxRaw;
 use ibc_relayer::chain::cosmos::types::tx::SignedTx;
-use ibc_relayer_framework::base::core::traits::error::{HasError, InjectError};
+use ibc_relayer_framework::base::core::traits::error::{HasErrorType, InjectError};
 use prost::EncodeError;
 use tendermint_rpc::endpoint::broadcast::tx_sync::Response;
 use tendermint_rpc::error::Error as RpcError;
@@ -10,7 +10,7 @@ use tendermint_rpc::Client;
 use crate::transaction::traits::fields::{HasRpcAddress, HasRpcClient};
 
 #[async_trait]
-pub trait CanBroadcastTxSync: HasError {
+pub trait CanBroadcastTxSync: HasErrorType {
     async fn broadcast_tx_sync(&self, tx: SignedTx) -> Result<Response, Self::Error>;
 }
 

crates/relayer-cosmos/src/transaction/impls/decoders/account.rs

@@ -1,13 +1,13 @@
 use ibc_proto::cosmos::auth::v1beta1::{BaseAccount, EthAccount};
 use ibc_proto::google::protobuf::Any;
-use ibc_relayer_framework::base::core::traits::error::HasError;
+use ibc_relayer_framework::base::core::traits::error::HasErrorType;
 use prost::{DecodeError, Message};
 
 use crate::transaction::traits::decoders::account::AccountDecoder;
 
 pub struct DecodeCosmosOrEthAccount;
 
-pub trait InjectDecodeCosmosOrEthAccountError: HasError {
+pub trait InjectDecodeCosmosOrEthAccountError: HasErrorType {
     fn unknown_account_type_error(type_url: &str) -> Self::Error;
 
     fn empty_base_account_error() -> Self::Error;

crates/relayer-cosmos/src/transaction/impls/encode.rs

@@ -6,15 +6,15 @@ use ibc_relayer::chain::cosmos::types::account::AccountSequence;
 use ibc_relayer::chain::cosmos::types::tx::SignedTx;
 use ibc_relayer::config::AddressType;
 use ibc_relayer::keyring::errors::Error as KeyringError;
-use ibc_relayer_framework::base::core::traits::error::{HasError, InjectError};
+use ibc_relayer_framework::base::core::traits::error::{HasErrorType, InjectError};
 use prost::EncodeError;
 
 use crate::transaction::traits::fields::{
     HasAccountNumber, HasAddressType, HasChainId, HasExtensionOptions, HasKeyEntry, HasMemo,
 };
 
 #[async_trait]
-pub trait CanSignTx: HasError {
+pub trait CanSignTx: HasErrorType {
     async fn sign_tx(
         &self,
         fee: &Fee,
@@ -23,36 +23,36 @@ pub trait CanSignTx: HasError {
     ) -> Result<SignedTx, Self::Error>;
 }
 
-trait CanEncodeKeyBytes: HasError {
+trait CanEncodeKeyBytes: HasErrorType {
     fn encode_key_bytes(&self) -> Result<Vec<u8>, Self::Error>;
 }
 
 #[async_trait]
-trait CanEncodeSignerInfo: HasError {
+trait CanEncodeSignerInfo: HasErrorType {
     async fn encode_signer_info(
         &self,
         account_sequence: &AccountSequence,
         key_bytes: Vec<u8>,
     ) -> Result<SignerInfo, Self::Error>;
 }
 
-trait CanEncodeTxBodyAndBytes: HasError {
+trait CanEncodeTxBodyAndBytes: HasErrorType {
     fn encode_tx_body_and_bytes(&self, messages: &[Any]) -> Result<(TxBody, Vec<u8>), Self::Error>;
 }
 
-trait CanEncodeAuthInfoAndBytes: HasError {
+trait CanEncodeAuthInfoAndBytes: HasErrorType {
     fn encode_auth_info_and_bytes(
         signer_info: SignerInfo,
         fee: Fee,
     ) -> Result<(AuthInfo, Vec<u8>), Self::Error>;
 }
 
-trait CanSignMessage: HasError {
+trait CanSignMessage: HasErrorType {
     fn sign_message(&self, message: Vec<u8>) -> Result<Vec<u8>, Self::Error>;
 }
 
 #[async_trait]
-trait CanEncodeSignDoc: HasError {
+trait CanEncodeSignDoc: HasErrorType {
     async fn encode_sign_doc(
         &self,
         auth_info_bytes: Vec<u8>,
@@ -63,7 +63,7 @@ trait CanEncodeSignDoc: HasError {
 #[async_trait]
 impl<Context> CanSignTx for Context
 where
-    Context: HasError
+    Context: HasErrorType
         + CanEncodeKeyBytes
         + CanEncodeSignerInfo
         + CanEncodeTxBodyAndBytes
@@ -119,7 +119,7 @@ where
 #[async_trait]
 impl<Context> CanEncodeSignerInfo for Context
 where
-    Context: HasError + HasAddressType,
+    Context: HasErrorType + HasAddressType,
 {
     async fn encode_signer_info(
         &self,

crates/relayer-cosmos/src/transaction/impls/estimate.rs

@@ -4,15 +4,15 @@ use core::marker::PhantomData;
 use ibc_proto::cosmos::tx::v1beta1::Fee;
 use ibc_relayer::chain::cosmos::gas::gas_amount_to_fee;
 use ibc_relayer::chain::cosmos::types::tx::SignedTx;
-use ibc_relayer_framework::base::core::traits::error::{HasError, InjectError};
+use ibc_relayer_framework::base::core::traits::error::{HasErrorType, InjectError};
 use ibc_relayer_types::core::ics24_host::identifier::ChainId;
 use tracing::{debug, error, warn};
 
 use crate::transaction::impls::simulate::CanSendTxSimulate;
 use crate::transaction::traits::fields::{HasChainId, HasDefaultGas, HasGasConfig, HasMaxGas};
 
 #[async_trait]
-pub trait CanEstimateTxFees: HasError {
+pub trait CanEstimateTxFees: HasErrorType {
     async fn estimate_tx_fees(&self, tx: SignedTx) -> Result<Fee, Self::Error>;
 }
 
@@ -33,12 +33,12 @@ where
 }
 
 #[async_trait]
-pub trait TxGasEstimator<Context: HasError> {
+pub trait TxGasEstimator<Context: HasErrorType> {
     async fn estimate_gas_with_tx(context: &Context, tx: SignedTx) -> Result<u64, Context::Error>;
 }
 
 #[async_trait]
-pub trait CanEstimateTxGas: HasError {
+pub trait CanEstimateTxGas: HasErrorType {
     async fn estimate_gas_with_tx(&self, tx: SignedTx) -> Result<u64, Self::Error>;
 }
 
@@ -69,7 +69,7 @@ where
 
 pub struct RecoverableTxGasEstimator<InEstimator>(PhantomData<InEstimator>);
 
-pub trait HasRecoverableErrorForSimulation: HasError {
+pub trait HasRecoverableErrorForSimulation: HasErrorType {
     fn can_recover_from_simulation_failure(e: &Self::Error) -> bool;
 }
 

crates/relayer-cosmos/src/transaction/impls/queries/account.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use ibc_proto::cosmos::auth::v1beta1::query_client::QueryClient;
 use ibc_proto::cosmos::auth::v1beta1::QueryAccountRequest;
 use ibc_relayer::chain::cosmos::types::account::Account;
-use ibc_relayer_framework::base::core::traits::error::{HasError, InjectError};
+use ibc_relayer_framework::base::core::traits::error::{HasErrorType, InjectError};
 use tonic::transport::Error as TransportError;
 use tonic::{Request, Status};
 
@@ -17,7 +17,7 @@ pub struct MaybeAccountQuerier;
 
 pub struct ReturnAccountFromContext;
 
-pub trait InjectQueryAccountError: HasError {
+pub trait InjectQueryAccountError: HasErrorType {
     fn address_not_found_error(address: &str) -> Self::Error;
 }
 
@@ -62,7 +62,7 @@ where
 #[async_trait]
 impl<Context> AccountQuerier<Context> for MaybeAccountQuerier
 where
-    Context: HasError,
+    Context: HasErrorType,
     Context: MaybeHasAccount,
     BaseAccountQuerier: AccountQuerier<Context>,
 {
@@ -83,7 +83,7 @@ where
 #[async_trait]
 impl<Context> AccountQuerier<Context> for ReturnAccountFromContext
 where
-    Context: HasError,
+    Context: HasErrorType,
     Context: HasAccount,
 {
     async fn query_account(context: &Context) -> Result<Account, Context::Error> {