Fixes after testing with GM

relayer/src/foreign_client.rs

@@ -76,6 +76,13 @@ pub struct ForeignClient {
     pub src_chain: Box<dyn ChainHandle>,
 }
 
+/// Used in Output messages.
+/// Provides a concise description of a [`ForeignClient`],
+/// using the format:
+///     {CHAIN-ID} -> {CHAIN-ID}:{CLIENT}
+/// where the first chain identifier is for the source
+/// chain, and the second chain identifier is the
+/// destination (which hosts the client) chain.
 impl fmt::Display for ForeignClient {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(

relayer/src/object.rs

@@ -18,12 +18,14 @@ use crate::chain::{
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Client {
     /// Destination chain identifier.
+    /// This is the chain hosting the client.
     pub dst_chain_id: ChainId,
 
-    /// Source channel identifier.
+    /// Client identifier (allocated on the destination chain `dst_chain_id`).
     pub dst_client_id: ClientId,
 
     /// Source chain identifier.
+    /// This is the chain whose headers the client worker is verifying.
     pub src_chain_id: ChainId,
 }
 
@@ -148,27 +150,27 @@ impl Object {
 
     /// Build the client object associated with the given channel event attributes.
     pub fn for_chan_open_events(
-        e: &Attributes,
-        dst_chain: &dyn ChainHandle,
+        e: &Attributes,          // The attributes of the emitted event
+        chain: &dyn ChainHandle, // The chain which emitted the event
     ) -> Result<Self, BoxError> {
         let channel_id = e
             .channel_id()
             .as_ref()
             .ok_or_else(|| format!("channel_id missing in OpenAck event '{:?}'", e))?;
 
-        let client = channel_connection_client(dst_chain, e.port_id(), channel_id)?.client;
+        let client = channel_connection_client(chain, e.port_id(), channel_id)?.client;
         if client.client_state.refresh_period().is_none() {
             return Err(format!(
                 "client '{}' on chain {} does not require refresh",
                 client.client_id,
-                dst_chain.id()
+                chain.id()
             )
             .into());
         }
 
         Ok(Client {
             dst_client_id: client.client_id.clone(),
-            dst_chain_id: dst_chain.id(),
+            dst_chain_id: chain.id(), // The object's destination is the chain hosting the client
             src_chain_id: client.client_state.chain_id(),
         }
         .into())

relayer/src/registry.rs

@@ -32,6 +32,11 @@ impl Registry {
         }
     }
 
+    /// Return the size of the registry, i.e., the number of distinct chain runtimes.
+    pub fn size(&self) -> usize {
+        self.handles.len()
+    }
+
     /// Get the [`ChainHandle`] associated with the given [`ChainId`].
     ///
     /// If there is no handle yet, this will first spawn the runtime and then

relayer/src/supervisor.rs

@@ -230,7 +230,7 @@ impl Supervisor {
         });
 
         self.workers
-            .get_or_spawn(client_object, chain.clone(), counterparty_chain.clone());
+            .get_or_spawn(client_object, counterparty_chain.clone(), chain.clone());
 
         // TODO: Only start the Uni worker if there are outstanding packets or ACKs.
         //  https://github.com/informalsystems/ibc-rs/issues/901
@@ -273,6 +273,11 @@ impl Supervisor {
             }
         }
 
+        // At least one chain runtime should be alive and kicking, otherwise bail.
+        if self.registry.size() == 0 {
+            return Err("supervisor was not able to connect to any chain".into());
+        }
+
         self.spawn_workers();
 
         loop {

relayer/src/worker/client.rs

@@ -33,8 +33,8 @@ impl ClientWorker {
     pub fn run(self) -> Result<(), BoxError> {
         let mut client = ForeignClient::restore(
             &self.client.dst_client_id,
-            self.chains.a.clone(),
             self.chains.b.clone(),
+            self.chains.a.clone(),
         );
 
         info!(