Relay context refactoring, part 3 (#498)

* Implement SelectRelayChains * Use SelectRelayAToB in CosmosRelay * Implement MessageBatchSenderGetter for SelectRelayChains * Rename message batch sender fields * Use generic type aliases inside CosmosRelayFields * Define ExtraPacketRelayer to simplify constraint debugging of composed packet relayer * Add DefaultPacketRelayer * Add DefaultTargetUpdateClientMessageBuilder * Remove sketch abstract relay contexts
informalsystems · Dec 11, 2024 · 0b03530 · 0b03530
1 parent be7d07f
commit 0b03530
Show file tree

Hide file tree

Showing 20 changed files with 325 additions and 56 deletions.
diff --git a/crates/chain/chain-components/src/traits/queries/consensus_state.rs b/crates/chain/chain-components/src/traits/queries/consensus_state.rs
@@ -93,16 +93,16 @@ where
 
 #[async_trait]
 pub trait CanQueryConsensusStateWithLatestHeight<Counterparty>:
-    HasClientIdType<Counterparty> + HasErrorType
-where
-    Counterparty: HasConsensusStateType<Self> + HasHeightType,
+    HasClientIdType<Counterparty>
+    + CanUseCounterparty<Counterparty, Counterparty: HasConsensusStateType<Self> + HasHeightType>
+    + HasErrorType
 {
     async fn query_consensus_state_with_latest_height(
         &self,
         tag: PhantomData<Counterparty>,
         client_id: &Self::ClientId,
-        consensus_height: &Counterparty::Height,
-    ) -> Result<Counterparty::ConsensusState, Self::Error>;
+        consensus_height: &HeightOf<Counterparty>,
+    ) -> Result<ConsensusStateOf<Counterparty, Self>, Self::Error>;
 }
 
 impl<Chain, Counterparty> CanQueryConsensusStateWithLatestHeight<Counterparty> for Chain

diff --git a/crates/cosmos/cosmos-relayer/src/contexts/relay.rs b/crates/cosmos/cosmos-relayer/src/contexts/relay.rs
@@ -16,13 +16,16 @@ use hermes_relayer_components::error::traits::retry::{
     MaxErrorRetryGetterComponent, RetryableErrorComponent,
 };
 use hermes_relayer_components::multi::traits::chain_at::{
-    ChainGetterAtComponent, ChainTypeAtComponent,
+    ChainAt, ChainGetterAtComponent, ChainTypeAtComponent,
 };
 use hermes_relayer_components::multi::traits::client_id_at::ClientIdAtGetterComponent;
+use hermes_relayer_components::multi::traits::relay_at::ClientIdAt;
+use hermes_relayer_components::multi::types::index::Index;
 use hermes_relayer_components::multi::types::tags::{Dst, Src};
 use hermes_relayer_components::relay::impls::packet_lock::{
     PacketMutexGetterComponent, PacketMutexOf, ProvidePacketLockWithMutex,
 };
+use hermes_relayer_components::relay::impls::selector::SelectRelayAToB;
 use hermes_relayer_components::relay::traits::auto_relayer::CanAutoRelay;
 use hermes_relayer_components::relay::traits::chains::HasRelayClientIds;
 use hermes_relayer_components::relay::traits::client_creator::CanCreateClient;
@@ -39,7 +42,9 @@ use hermes_relayer_components_extra::components::extra::relay::{
     ExtraRelayPreset, IsExtraRelayPreset,
 };
 use hermes_runtime::types::runtime::HermesRuntime;
-use hermes_runtime_components::traits::runtime::{RuntimeGetterComponent, RuntimeTypeComponent};
+use hermes_runtime_components::traits::runtime::{
+    RuntimeGetterComponent, RuntimeOf, RuntimeTypeComponent,
+};
 use ibc::core::host::types::identifiers::ClientId;
 
 use crate::contexts::chain::CosmosChain;
@@ -52,14 +57,14 @@ pub struct CosmosRelay {
 
 #[derive(HasField)]
 pub struct CosmosRelayFields {
-    pub runtime: HermesRuntime,
-    pub src_chain: CosmosChain,
-    pub dst_chain: CosmosChain,
-    pub src_client_id: ClientId,
-    pub dst_client_id: ClientId,
+    pub runtime: RuntimeOf<CosmosRelay>,
+    pub chain_a: ChainAt<CosmosRelay, Index<0>>,
+    pub chain_b: ChainAt<CosmosRelay, Index<1>>,
+    pub client_id_a: ClientIdAt<CosmosRelay, Index<0>, Index<1>>,
+    pub client_id_b: ClientIdAt<CosmosRelay, Index<1>, Index<0>>,
     pub packet_lock_mutex: PacketMutexOf<CosmosRelay>,
-    pub src_chain_message_batch_sender: MessageBatchSenderOf<CosmosRelay, Src>,
-    pub dst_chain_message_batch_sender: MessageBatchSenderOf<CosmosRelay, Dst>,
+    pub message_batch_sender_a: MessageBatchSenderOf<CosmosRelay, Index<0>>,
+    pub message_batch_sender_b: MessageBatchSenderOf<CosmosRelay, Index<1>>,
 }
 
 pub trait HasCosmosRelayFields: Send + Sync + 'static {
@@ -93,12 +98,12 @@ impl CosmosRelay {
         let relay = Self {
             fields: Arc::new(CosmosRelayFields {
                 runtime,
-                src_chain,
-                dst_chain,
-                src_client_id,
-                dst_client_id,
-                src_chain_message_batch_sender,
-                dst_chain_message_batch_sender,
+                chain_a: src_chain,
+                chain_b: dst_chain,
+                client_id_a: src_client_id,
+                client_id_b: dst_client_id,
+                message_batch_sender_a: src_chain_message_batch_sender,
+                message_batch_sender_b: dst_chain_message_batch_sender,
                 packet_lock_mutex: Arc::new(Mutex::new(BTreeSet::new())),
             }),
         };
@@ -120,8 +125,8 @@ delegate_components! {
         RuntimeTypeComponent: WithType<HermesRuntime>,
         RuntimeGetterComponent: WithField<symbol!("runtime")>,
         [
-            ChainTypeAtComponent<Src>,
-            ChainTypeAtComponent<Dst>,
+            ChainTypeAtComponent<Index<0>>,
+            ChainTypeAtComponent<Index<1>>,
         ]:
             WithType<CosmosChain>,
         [
@@ -134,20 +139,29 @@ delegate_components! {
             ReturnMaxRetry<3>,
         PacketLockComponent:
             ProvidePacketLockWithMutex,
-        ChainGetterAtComponent<Src>:
-            UseField<symbol!("src_chain")>,
-        ChainGetterAtComponent<Dst>:
-            UseField<symbol!("dst_chain")>,
+        ChainGetterAtComponent<Index<0>>:
+            UseField<symbol!("chain_a")>,
+        ChainGetterAtComponent<Index<1>>:
+            UseField<symbol!("chain_b")>,
         ClientIdAtGetterComponent<Src, Dst>:
-            UseField<symbol!("src_client_id")>,
+            UseField<symbol!("client_id_a")>,
         ClientIdAtGetterComponent<Dst, Src>:
-            UseField<symbol!("dst_client_id")>,
+            UseField<symbol!("client_id_b")>,
         PacketMutexGetterComponent:
             UseField<symbol!("packet_lock_mutex")>,
-        MessageBatchSenderGetterComponent<Src>:
-            UseField<symbol!("src_chain_message_batch_sender")>,
-        MessageBatchSenderGetterComponent<Dst>:
-            UseField<symbol!("dst_chain_message_batch_sender")>,
+        MessageBatchSenderGetterComponent<Index<0>>:
+            UseField<symbol!("message_batch_sender_a")>,
+        MessageBatchSenderGetterComponent<Index<1>>:
+            UseField<symbol!("message_batch_sender_b")>,
+        [
+            ChainTypeAtComponent<Src>,
+            ChainTypeAtComponent<Dst>,
+            ChainGetterAtComponent<Src>,
+            ChainGetterAtComponent<Dst>,
+            MessageBatchSenderGetterComponent<Src>,
+            MessageBatchSenderGetterComponent<Dst>,
+        ]:
+            SelectRelayAToB,
     }
 }
 

diff --git a/crates/relayer/relayer-components-extra/src/batch/traits/channel.rs b/crates/relayer/relayer-components-extra/src/batch/traits/channel.rs
@@ -2,6 +2,8 @@ use core::marker::PhantomData;
 
 use cgp::core::field::impls::use_field::UseField;
 use cgp::prelude::*;
+use hermes_relayer_components::multi::types::tags::{Dst, Src};
+use hermes_relayer_components::relay::impls::selector::SelectRelayChains;
 
 use crate::batch::traits::types::HasMessageBatchChannelTypes;
 
@@ -26,3 +28,25 @@ where
         context.get_field(PhantomData)
     }
 }
+
+impl<Relay, SrcTag, DstTag, Sender> MessageBatchSenderGetter<Relay, Src>
+    for SelectRelayChains<SrcTag, DstTag>
+where
+    Relay: HasMessageBatchSender<SrcTag, MessageBatchSender = Sender>
+        + HasMessageBatchChannelTypes<Src, MessageBatchSender = Sender>,
+{
+    fn get_batch_sender(context: &Relay, _tag: PhantomData<Src>) -> &Sender {
+        context.get_batch_sender(PhantomData::<SrcTag>)
+    }
+}
+
+impl<Relay, SrcTag, DstTag, Sender> MessageBatchSenderGetter<Relay, Dst>
+    for SelectRelayChains<SrcTag, DstTag>
+where
+    Relay: HasMessageBatchSender<DstTag, MessageBatchSender = Sender>
+        + HasMessageBatchChannelTypes<Dst, MessageBatchSender = Sender>,
+{
+    fn get_batch_sender(context: &Relay, _tag: PhantomData<Dst>) -> &Sender {
+        context.get_batch_sender(PhantomData::<DstTag>)
+    }
+}
diff --git a/crates/relayer/relayer-components-extra/src/components/extra/relay.rs b/crates/relayer/relayer-components-extra/src/components/extra/relay.rs
@@ -3,14 +3,10 @@ use cgp::prelude::*;
 pub use hermes_relayer_components::components::default::relay::*;
 use hermes_relayer_components::relay::impls::message_senders::chain_sender::SendIbcMessagesToChain;
 use hermes_relayer_components::relay::impls::message_senders::update_client::SendIbcMessagesWithUpdateClient;
-use hermes_relayer_components::relay::impls::packet_relayers::general::filter_relayer::FilterRelayer;
-use hermes_relayer_components::relay::impls::packet_relayers::general::full_relay::FullCycleRelayer;
-use hermes_relayer_components::relay::impls::packet_relayers::general::lock::LockPacketRelayer;
-use hermes_relayer_components::relay::impls::packet_relayers::general::log::LoggerRelayer;
 
 use crate::batch::impls::message_sender::SendMessagesToBatchWorker;
 pub use crate::batch::types::sink::BatchWorkerSink;
-use crate::relay::components::packet_relayers::retry::RetryRelayer;
+use crate::relay::impls::packet_relayers::extra::ExtraPacketRelayer;
 
 with_default_relay_preset! {
     [
@@ -24,7 +20,7 @@ with_default_relay_preset! {
                 IbcMessageSenderComponent<BatchWorkerSink>:
                     SendIbcMessagesWithUpdateClient<SendIbcMessagesToChain>,
                 PacketRelayerComponent:
-                    LockPacketRelayer<LoggerRelayer<FilterRelayer<RetryRelayer<FullCycleRelayer>>>>,
+                    ExtraPacketRelayer,
                 Components:
                     DefaultRelayPreset,
             }

diff --git a/...ponents-extra/src/relay/components/mod.rs → ...r-components-extra/src/relay/impls/mod.rs b/...ponents-extra/src/relay/components/mod.rs → ...r-components-extra/src/relay/impls/mod.rs
diff --git a/crates/relayer/relayer-components-extra/src/relay/impls/packet_relayers/extra.rs b/crates/relayer/relayer-components-extra/src/relay/impls/packet_relayers/extra.rs
@@ -0,0 +1,62 @@
+use cgp::prelude::CanRaiseError;
+use hermes_chain_type_components::traits::types::timeout::HasTimeoutType;
+use hermes_logging_components::traits::has_logger::HasLogger;
+use hermes_logging_components::traits::logger::CanLog;
+use hermes_relayer_components::chain::traits::packet::fields::CanReadOutgoingPacketFields;
+use hermes_relayer_components::chain::traits::queries::chain_status::CanQueryChainStatus;
+use hermes_relayer_components::chain::traits::types::ibc::{HasChannelIdType, HasPortIdType};
+use hermes_relayer_components::chain::traits::types::ibc_events::write_ack::HasWriteAckEvent;
+use hermes_relayer_components::error::impls::error::MaxRetryExceededError;
+use hermes_relayer_components::error::traits::retry::{HasMaxErrorRetry, HasRetryableError};
+use hermes_relayer_components::relay::impls::packet_relayers::general::filter_relayer::FilterRelayer;
+use hermes_relayer_components::relay::impls::packet_relayers::general::full_relay::{
+    FullCycleRelayer, LogRelayPacketAction,
+};
+use hermes_relayer_components::relay::impls::packet_relayers::general::lock::{
+    LockPacketRelayer, LogSkipRelayLockedPacket,
+};
+use hermes_relayer_components::relay::impls::packet_relayers::general::log::{
+    LogRelayPacketStatus, LoggerRelayer,
+};
+use hermes_relayer_components::relay::traits::chains::{HasRelayChains, HasRelayPacketType};
+use hermes_relayer_components::relay::traits::packet_filter::CanFilterRelayPackets;
+use hermes_relayer_components::relay::traits::packet_lock::HasPacketLock;
+use hermes_relayer_components::relay::traits::packet_relayer::PacketRelayer;
+use hermes_relayer_components::relay::traits::packet_relayers::ack_packet::CanRelayAckPacket;
+use hermes_relayer_components::relay::traits::packet_relayers::receive_packet::CanRelayReceivePacket;
+use hermes_relayer_components::relay::traits::packet_relayers::timeout_unordered_packet::CanRelayTimeoutUnorderedPacket;
+
+use crate::relay::impls::packet_relayers::retry::RetryRelayer;
+
+pub struct ExtraPacketRelayer;
+
+impl<Relay, SrcChain, DstChain> PacketRelayer<Relay> for ExtraPacketRelayer
+where
+    Relay: CanRelayAckPacket
+        + CanRelayReceivePacket
+        + CanRelayTimeoutUnorderedPacket
+        + HasLogger
+        + HasRelayChains<SrcChain = SrcChain, DstChain = DstChain>
+        + HasRelayPacketType
+        + CanFilterRelayPackets
+        + HasPacketLock
+        + HasMaxErrorRetry
+        + HasRetryableError
+        + CanRaiseError<SrcChain::Error>
+        + CanRaiseError<DstChain::Error>
+        + for<'a> CanRaiseError<MaxRetryExceededError<'a, Relay>>,
+    SrcChain: CanQueryChainStatus + CanReadOutgoingPacketFields<DstChain>,
+    DstChain: CanQueryChainStatus
+        + HasWriteAckEvent<Relay::SrcChain>
+        + HasChannelIdType<SrcChain>
+        + HasPortIdType<SrcChain>
+        + HasTimeoutType,
+    Relay::Logger: for<'a> CanLog<LogRelayPacketAction<'a, Relay>>
+        + for<'a> CanLog<LogRelayPacketStatus<'a, Relay>>
+        + for<'a> CanLog<LogSkipRelayLockedPacket<'a, Relay>>,
+{
+    async fn relay_packet(relay: &Relay, packet: &Relay::Packet) -> Result<(), Relay::Error> {
+        <LockPacketRelayer<LoggerRelayer<FilterRelayer<RetryRelayer<FullCycleRelayer>>>>>::
+            relay_packet(relay, packet).await
+    }
+}
diff --git a/...c/relay/components/packet_relayers/mod.rs → ...ra/src/relay/impls/packet_relayers/mod.rs b/...c/relay/components/packet_relayers/mod.rs → ...ra/src/relay/impls/packet_relayers/mod.rs
@@ -1 +1,2 @@
+pub mod extra;
 pub mod retry;
diff --git a/...relay/components/packet_relayers/retry.rs → .../src/relay/impls/packet_relayers/retry.rs b/...relay/components/packet_relayers/retry.rs → .../src/relay/impls/packet_relayers/retry.rs
diff --git a/crates/relayer/relayer-components-extra/src/relay/mod.rs b/crates/relayer/relayer-components-extra/src/relay/mod.rs
@@ -1 +1 @@
-pub mod components;
+pub mod impls;
diff --git a/crates/relayer/relayer-components/src/components/default/relay.rs b/crates/relayer/relayer-components/src/components/default/relay.rs
@@ -20,16 +20,11 @@ use crate::relay::impls::message_senders::update_client::SendIbcMessagesWithUpda
 use crate::relay::impls::packet_clearers::packets::ClearAllPackets;
 use crate::relay::impls::packet_filters::chain::FilterRelayPacketWithChains;
 use crate::relay::impls::packet_relayers::ack::base_ack_packet::BaseAckPacketRelayer;
-use crate::relay::impls::packet_relayers::general::filter_relayer::FilterRelayer;
-use crate::relay::impls::packet_relayers::general::full_relay::FullCycleRelayer;
-use crate::relay::impls::packet_relayers::general::lock::LockPacketRelayer;
-use crate::relay::impls::packet_relayers::general::log::LoggerRelayer;
+use crate::relay::impls::packet_relayers::general::default::DefaultPacketRelayer;
 use crate::relay::impls::packet_relayers::receive::base_receive_packet::BaseReceivePacketRelayer;
 use crate::relay::impls::packet_relayers::receive::skip_received_packet::SkipReceivedPacketRelayer;
 use crate::relay::impls::packet_relayers::timeout_unordered::timeout_unordered_packet::BaseTimeoutUnorderedPacketRelayer;
-use crate::relay::impls::update_client::build::BuildUpdateClientMessages;
-use crate::relay::impls::update_client::skip::SkipUpdateClient;
-use crate::relay::impls::update_client::wait::WaitUpdateClient;
+use crate::relay::impls::update_client::default::DefaultTargetUpdateClientMessageBuilder;
 pub use crate::relay::traits::auto_relayer::AutoRelayerComponent;
 pub use crate::relay::traits::channel::open_ack::ChannelOpenAckRelayerComponent;
 pub use crate::relay::traits::channel::open_confirm::ChannelOpenConfirmRelayerComponent;
@@ -55,8 +50,8 @@ pub use crate::relay::traits::update_client_message_builder::TargetUpdateClientM
 cgp_preset! {
     DefaultRelayPreset {
         IbcMessageSenderComponent<MainSink>: SendIbcMessagesWithUpdateClient<SendIbcMessagesToChain>,
-        TargetUpdateClientMessageBuilderComponent: SkipUpdateClient<WaitUpdateClient<BuildUpdateClientMessages>>,
-        PacketRelayerComponent: LockPacketRelayer<LoggerRelayer<FilterRelayer<FullCycleRelayer>>>,
+        TargetUpdateClientMessageBuilderComponent: DefaultTargetUpdateClientMessageBuilder,
+        PacketRelayerComponent: DefaultPacketRelayer,
         ReceivePacketRelayerComponent: SkipReceivedPacketRelayer<BaseReceivePacketRelayer>,
         AckPacketRelayerComponent: BaseAckPacketRelayer,
         TimeoutUnorderedPacketRelayerComponent: BaseTimeoutUnorderedPacketRelayer,

diff --git a/crates/relayer/relayer-components/src/relay/impls/mod.rs b/crates/relayer/relayer-components/src/relay/impls/mod.rs
@@ -8,4 +8,5 @@ pub mod packet_clearers;
 pub mod packet_filters;
 pub mod packet_lock;
 pub mod packet_relayers;
+pub mod selector;
 pub mod update_client;
diff --git a/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/default.rs b/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/default.rs
@@ -0,0 +1,56 @@
+use cgp::prelude::CanRaiseError;
+use hermes_chain_components::traits::packet::fields::CanReadOutgoingPacketFields;
+use hermes_chain_components::traits::types::ibc::{HasChannelIdType, HasPortIdType};
+use hermes_chain_components::traits::types::timestamp::HasTimeoutType;
+use hermes_logging_components::traits::has_logger::HasLogger;
+use hermes_logging_components::traits::logger::CanLog;
+
+use crate::chain::traits::queries::chain_status::CanQueryChainStatus;
+use crate::chain::traits::types::ibc_events::write_ack::HasWriteAckEvent;
+use crate::relay::impls::packet_relayers::general::filter_relayer::FilterRelayer;
+use crate::relay::impls::packet_relayers::general::full_relay::{
+    FullCycleRelayer, LogRelayPacketAction,
+};
+use crate::relay::impls::packet_relayers::general::lock::{
+    LockPacketRelayer, LogSkipRelayLockedPacket,
+};
+use crate::relay::impls::packet_relayers::general::log::{LogRelayPacketStatus, LoggerRelayer};
+use crate::relay::traits::chains::{HasRelayChains, HasRelayPacketType};
+use crate::relay::traits::packet_filter::CanFilterRelayPackets;
+use crate::relay::traits::packet_lock::HasPacketLock;
+use crate::relay::traits::packet_relayer::PacketRelayer;
+use crate::relay::traits::packet_relayers::ack_packet::CanRelayAckPacket;
+use crate::relay::traits::packet_relayers::receive_packet::CanRelayReceivePacket;
+use crate::relay::traits::packet_relayers::timeout_unordered_packet::CanRelayTimeoutUnorderedPacket;
+
+pub struct DefaultPacketRelayer;
+
+impl<Relay, SrcChain, DstChain> PacketRelayer<Relay> for DefaultPacketRelayer
+where
+    Relay: CanRelayAckPacket
+        + CanRelayReceivePacket
+        + CanRelayTimeoutUnorderedPacket
+        + HasRelayPacketType
+        + HasLogger
+        + HasPacketLock
+        + CanFilterRelayPackets
+        + HasRelayChains<SrcChain = SrcChain, DstChain = DstChain>
+        + CanRaiseError<SrcChain::Error>
+        + CanRaiseError<DstChain::Error>,
+    SrcChain: CanQueryChainStatus + CanReadOutgoingPacketFields<DstChain>,
+    DstChain: CanQueryChainStatus
+        + HasWriteAckEvent<Relay::SrcChain>
+        + HasChannelIdType<SrcChain>
+        + HasPortIdType<SrcChain>
+        + HasTimeoutType,
+    Relay::Logger: for<'a> CanLog<LogRelayPacketAction<'a, Relay>>
+        + for<'a> CanLog<LogRelayPacketStatus<'a, Relay>>
+        + for<'a> CanLog<LogSkipRelayLockedPacket<'a, Relay>>,
+{
+    async fn relay_packet(relay: &Relay, packet: &Relay::Packet) -> Result<(), Relay::Error> {
+        <LockPacketRelayer<LoggerRelayer<FilterRelayer<FullCycleRelayer>>>>::relay_packet(
+            relay, packet,
+        )
+        .await
+    }
+}
diff --git a/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/full_relay.rs b/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/full_relay.rs
@@ -7,7 +7,7 @@ use hermes_logging_components::traits::logger::CanLog;
 
 use crate::chain::traits::queries::chain_status::CanQueryChainStatus;
 use crate::chain::traits::types::ibc_events::write_ack::HasWriteAckEvent;
-use crate::relay::traits::chains::{HasRelayChains, PacketOf};
+use crate::relay::traits::chains::{HasRelayChains, HasRelayPacketType, PacketOf};
 use crate::relay::traits::packet_relayer::PacketRelayer;
 use crate::relay::traits::packet_relayers::ack_packet::CanRelayAckPacket;
 use crate::relay::traits::packet_relayers::receive_packet::CanRelayReceivePacket;
@@ -37,6 +37,7 @@ where
     Relay: CanRelayAckPacket
         + CanRelayReceivePacket
         + CanRelayTimeoutUnorderedPacket
+        + HasRelayPacketType
         + HasLogger
         + HasRelayChains<SrcChain = SrcChain, DstChain = DstChain>
         + CanRaiseError<SrcChain::Error>
@@ -49,7 +50,7 @@ where
         + HasTimeoutType,
     Relay::Logger: for<'a> CanLog<LogRelayPacketAction<'a, Relay>>,
 {
-    async fn relay_packet(relay: &Relay, packet: &PacketOf<Relay>) -> Result<(), Relay::Error> {
+    async fn relay_packet(relay: &Relay, packet: &Relay::Packet) -> Result<(), Relay::Error> {
         let src_chain = relay.src_chain();
         let dst_chain = relay.dst_chain();
         let logger = relay.logger();

diff --git a/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/mod.rs b/crates/relayer/relayer-components/src/relay/impls/packet_relayers/general/mod.rs
@@ -1,3 +1,4 @@
+pub mod default;
 pub mod filter_relayer;
 pub mod full_relay;
 pub mod lock;