Add flag to enable interactive prompt in create channel CLI

guide/src/commands/path-setup/channels.md

@@ -23,7 +23,7 @@ POSITIONAL ARGUMENTS:
     <CONNECTION_A>    Identifier of the connection on chain `a` to use in creating the new channel
 
 FLAGS:
-    -c, --chain-b-id <CHAIN_B_ID>      Identifier of the side `b` chain for the new channel
+    -c, --chain-b <CHAIN_B_ID>         Identifier of the side `b` chain for the new channel
     -h, --help                         Print help information
         --new-client-connection        Indicates that a new client and connection will be created
                                        underlying the new channel
@@ -213,7 +213,7 @@ pops up notifying you that a new client and a new connection will be initialized
 as part of the process:
 
 ```shell
-hermes create channel ibc-0 --chain-b-id ibc-1 --port-a transfer --port-b transfer -o unordered --new-client-connection
+hermes create channel ibc-0 --chain-b ibc-1 --port-a transfer --port-b transfer -o unordered --new-client-connection
 ```
 
 ```json

relayer-cli/src/commands/create/channel.rs

@@ -100,7 +100,7 @@ impl Runnable for CreateChannelCommand {
     fn run(&self) {
         match &self.connection_a {
             Some(conn) => self.run_reusing_connection(conn),
-            None => match &self.chain_b_id {
+            None => match &self.chain_b {
                 Some(chain_b) => {
                     if self.new_client_connection {
                         match Confirm::new()
@@ -129,26 +129,24 @@ impl Runnable for CreateChannelCommand {
                         }
                     } else {
                         Output::error(
-                                "The `--new-client-connection` flag is required if invoking with `<chain-b-id>`".to_string()
+                                "The `--new-client-connection` flag is required if invoking with `<chain-b>`".to_string()
                             )
                             .exit();
                     }
                 }
-                None => {
-                    Output::error("Missing one of `<chain-b-id>` or `<connection-a>`".to_string())
-                        .exit()
-                }
+                None => Output::error("Missing one of `<chain-b>` or `<connection-a>`".to_string())
+                    .exit(),
             },
         }
     }
 }
 
 impl CreateChannelCommand {
     /// Creates a new channel, as well as a new underlying connection and clients.
-    fn run_using_new_connection(&self, chain_b_id: &ChainId) {
+    fn run_using_new_connection(&self, chain_b: &ChainId) {
         let config = app_config();
 
-        let chains = ChainHandlePair::spawn(&config, &self.chain_a_id, chain_b_id)
+        let chains = ChainHandlePair::spawn(&config, &self.chain_a, chain_b)
             .unwrap_or_else(exit_with_unrecoverable_error);
 
         info!(
@@ -179,36 +177,36 @@ impl CreateChannelCommand {
     }
 
     /// Creates a new channel, reusing an already existing connection and its clients.
-    fn run_reusing_connection(&self, connection_a_id: &ConnectionId) {
+    fn run_reusing_connection(&self, connection_a: &ConnectionId) {
         let config = app_config();
 
         // Validate & spawn runtime for side a.
-        let chain_a = spawn_chain_runtime(&config, &self.chain_a_id)
+        let chain_a = spawn_chain_runtime(&config, &self.chain_a)
             .unwrap_or_else(exit_with_unrecoverable_error);
 
         // Query the connection end.
         let height = Height::new(chain_a.id().version(), 0);
         let conn_end = chain_a
-            .query_connection(connection_a_id, height)
+            .query_connection(connection_a, height)
             .unwrap_or_else(exit_with_unrecoverable_error);
 
         // Query the client state, obtain the identifier of chain b.
-        let chain_b_id = chain_a
+        let chain_b = chain_a
             .query_client_state(conn_end.client_id(), height)
             .map(|cs| cs.chain_id())
             .unwrap_or_else(exit_with_unrecoverable_error);
 
         // Spawn the runtime for side b.
         let chain_b =
-            spawn_chain_runtime(&config, &chain_b_id).unwrap_or_else(exit_with_unrecoverable_error);
+            spawn_chain_runtime(&config, &chain_b).unwrap_or_else(exit_with_unrecoverable_error);
 
         // Create the foreign client handles.
         let client_a = ForeignClient::find(chain_b.clone(), chain_a.clone(), conn_end.client_id())
             .unwrap_or_else(exit_with_unrecoverable_error);
         let client_b = ForeignClient::find(chain_a, chain_b, conn_end.counterparty().client_id())
             .unwrap_or_else(exit_with_unrecoverable_error);
 
-        let identified_end = IdentifiedConnectionEnd::new(connection_a_id.clone(), conn_end);
+        let identified_end = IdentifiedConnectionEnd::new(connection_a.clone(), conn_end);
 
         let connection = Connection::find(client_a, client_b, &identified_end)
             .unwrap_or_else(exit_with_unrecoverable_error);