N-ary Test Chains Support

relayer/src/foreign_client.rs

@@ -1382,6 +1382,18 @@ impl<DstChain: ChainHandle, SrcChain: ChainHandle> ForeignClient<DstChain, SrcCh
             },
         }
     }
+
+    pub fn map_chain<DstChain2: ChainHandle, SrcChain2: ChainHandle>(
+        self,
+        map_dst: impl Fn(DstChain) -> DstChain2,
+        map_src: impl Fn(SrcChain) -> SrcChain2,
+    ) -> ForeignClient<DstChain2, SrcChain2> {
+        ForeignClient {
+            id: self.id,
+            dst_chain: map_dst(self.dst_chain),
+            src_chain: map_src(self.src_chain),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]

tools/integration-test/src/bin/test_setup_with_binary_channel.rs

@@ -45,6 +45,7 @@ impl BinaryChannelTest for Test {
     fn run<ChainA: ChainHandle, ChainB: ChainHandle>(
         &self,
         _config: &TestConfig,
+        _relayer: RelayerDriver,
         _chains: ConnectedChains<ChainA, ChainB>,
         _channel: ConnectedChannel<ChainA, ChainB>,
     ) -> Result<(), Error> {

tools/integration-test/src/bootstrap/binary/chain.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use std::sync::RwLock;
 use tracing::{debug, info};
 
+use crate::relayer::driver::RelayerDriver;
 use crate::types::binary::chains::ConnectedChains;
 use crate::types::config::TestConfig;
 use crate::types::single::node::FullNode;
@@ -35,7 +36,13 @@ pub fn boostrap_chain_pair_with_nodes(
     node_a: FullNode,
     node_b: FullNode,
     config_modifier: impl FnOnce(&mut Config),
-) -> Result<ConnectedChains<impl ChainHandle, impl ChainHandle>, Error> {
+) -> Result<
+    (
+        RelayerDriver,
+        ConnectedChains<impl ChainHandle, impl ChainHandle>,
+    ),
+    Error,
+> {
     let mut config = Config::default();
 
     add_chain_config(&mut config, &node_a)?;
@@ -65,10 +72,13 @@ pub fn boostrap_chain_pair_with_nodes(
     let client_a_to_b = bootstrap_foreign_client(&handle_a, &handle_b)?;
     let client_b_to_a = bootstrap_foreign_client(&handle_b, &handle_a)?;
 
-    let chains = ConnectedChains::new(
+    let relayer = RelayerDriver {
         config_path,
         config,
         registry,
+    };
+
+    let chains = ConnectedChains::new(
         handle_a,
         handle_b,
         MonoTagged::new(node_a),
@@ -77,7 +87,7 @@ pub fn boostrap_chain_pair_with_nodes(
         client_b_to_a,
     );
 
-    Ok(chains)
+    Ok((relayer, chains))
 }
 
 /**
@@ -96,7 +106,13 @@ pub fn boostrap_self_connected_chain(
     test_config: &TestConfig,
     node: FullNode,
     config_modifier: impl FnOnce(&mut Config),
-) -> Result<ConnectedChains<impl ChainHandle, impl ChainHandle>, Error> {
+) -> Result<
+    (
+        RelayerDriver,
+        ConnectedChains<impl ChainHandle, impl ChainHandle>,
+    ),
+    Error,
+> {
     let mut config = Config::default();
 
     add_chain_config(&mut config, &node)?;
@@ -115,17 +131,22 @@ pub fn boostrap_self_connected_chain(
 
     let foreign_client = bootstrap_foreign_client(&handle, &handle)?;
 
-    Ok(ConnectedChains::new(
+    let relayer = RelayerDriver {
         config_path,
         config,
         registry,
+    };
+
+    let chains = ConnectedChains::new(
         handle.clone(),
         handle,
         MonoTagged::new(node.clone()),
         MonoTagged::new(node),
         foreign_client.clone(),
         foreign_client,
-    ))
+    );
+
+    Ok((relayer, chains))
 }
 
 pub fn pad_client_ids<ChainA: ChainHandle, ChainB: ChainHandle>(
@@ -148,7 +169,7 @@ pub fn pad_client_ids<ChainA: ChainHandle, ChainB: ChainHandle>(
    client collects information from `ChainA` and submits them as transactions
    to `ChainB`.
 
-   The returned `ForeignClient` is tagged in contravariant position, i.e.
+   The returned `ForeignClient` is tagged in contravariant ordering, i.e.
    `ChainB` then `ChainB`, because `ForeignClient` takes the the destination
    chain in the first position.
 */

tools/integration-test/src/bootstrap/mod.rs

@@ -13,4 +13,5 @@
 
 pub mod binary;
 pub mod init;
+pub mod nary;
 pub mod single;

tools/integration-test/src/bootstrap/nary/chain.rs

@@ -0,0 +1,98 @@
+use core::convert::TryInto;
+use ibc_relayer::chain::handle::ChainHandle;
+use ibc_relayer::config::Config;
+use ibc_relayer::foreign_client::ForeignClient;
+use ibc_relayer::registry::SharedRegistry;
+use std::sync::Arc;
+use std::sync::RwLock;
+
+use crate::bootstrap::binary::chain::{
+    add_chain_config, add_keys_to_chain_handle, bootstrap_foreign_client, new_registry,
+    save_relayer_config,
+};
+use crate::error::{handle_generic_error, Error};
+use crate::relayer::driver::RelayerDriver;
+use crate::types::config::TestConfig;
+use crate::types::nary::chains::{ConnectedChains, DynamicConnectedChains};
+use crate::types::single::node::FullNode;
+
+pub fn boostrap_chains_with_nodes<const SIZE: usize>(
+    test_config: &TestConfig,
+    full_nodes: [FullNode; SIZE],
+    config_modifier: impl FnOnce(&mut Config),
+) -> Result<(RelayerDriver, ConnectedChains<impl ChainHandle, SIZE>), Error> {
+    let (relayer, chains) =
+        boostrap_chains_with_any_nodes(test_config, full_nodes.into(), config_modifier)?;
+
+    Ok((relayer, chains.try_into()?))
+}
+
+pub fn boostrap_chains_with_any_nodes(
+    test_config: &TestConfig,
+    full_nodes: Vec<FullNode>,
+    config_modifier: impl FnOnce(&mut Config),
+) -> Result<(RelayerDriver, DynamicConnectedChains<impl ChainHandle>), Error> {
+    let mut config = Config::default();
+
+    for node in full_nodes.iter() {
+        add_chain_config(&mut config, node)?;
+    }
+
+    config_modifier(&mut config);
+
+    let config_path = test_config.chain_store_dir.join("relayer-config.toml");
+
+    save_relayer_config(&config, &config_path)?;
+
+    let config = Arc::new(RwLock::new(config));
+
+    let registry = new_registry(config.clone());
+
+    let mut chain_handles = Vec::new();
+
+    for node in full_nodes.iter() {
+        let handle = spawn_chain_handle(&registry, node)?;
+        chain_handles.push(handle);
+    }
+
+    let mut foreign_clients: Vec<Vec<ForeignClient<_, _>>> = Vec::new();
+
+    for handle_a in chain_handles.iter() {
+        let mut foreign_clients_b = Vec::new();
+
+        for handle_b in chain_handles.iter() {
+            let foreign_client = bootstrap_foreign_client(handle_a, handle_b)?;
+            foreign_clients_b.push(foreign_client);
+        }
+
+        foreign_clients.push(foreign_clients_b);
+    }
+
+    let relayer = RelayerDriver {
+        config_path,
+        config,
+        registry,
+    };
+
+    let connected_chains = DynamicConnectedChains {
+        chain_handles,
+        full_nodes,
+        foreign_clients,
+    };
+
+    Ok((relayer, connected_chains))
+}
+
+pub fn spawn_chain_handle<Handle: ChainHandle>(
+    registry: &SharedRegistry<Handle>,
+    node: &FullNode,
+) -> Result<Handle, Error> {
+    let chain_id = &node.chain_driver.chain_id;
+    let handle = registry
+        .get_or_spawn(chain_id)
+        .map_err(handle_generic_error)?;
+
+    add_keys_to_chain_handle(&handle, &node.wallets)?;
+
+    Ok(handle)
+}

tools/integration-test/src/bootstrap/nary/channel.rs

@@ -0,0 +1,107 @@
+use core::convert::TryInto;
+use ibc::core::ics24_host::identifier::PortId;
+use ibc_relayer::chain::handle::ChainHandle;
+
+use crate::bootstrap::binary::channel::bootstrap_channel_with_connection;
+use crate::bootstrap::nary::connection::bootstrap_connections_dynamic;
+use crate::error::{handle_generic_error, Error};
+use crate::types::binary::channel::ConnectedChannel;
+use crate::types::nary::chains::{ConnectedChains, DynamicConnectedChains};
+use crate::types::nary::channel::{ConnectedChannels, DynamicConnectedChannels};
+use crate::types::nary::connection::{ConnectedConnections, DynamicConnectedConnections};
+use crate::types::tagged::*;
+use crate::util::array::{assert_same_dimension, into_nested_vec};
+
+pub fn bootstrap_channels_with_connections_dynamic<Handle: ChainHandle>(
+    connections: DynamicConnectedConnections<Handle>,
+    chains: &[Handle],
+    ports: &[Vec<PortId>],
+    bootstrap_with_random_ids: bool,
+) -> Result<DynamicConnectedChannels<Handle>, Error> {
+    let size = chains.len();
+
+    assert_same_dimension(size, &connections.connections)?;
+    assert_same_dimension(size, ports)?;
+
+    let mut channels: Vec<Vec<ConnectedChannel<Handle, Handle>>> = Vec::new();
+
+    for (i, connections_b) in connections.connections.into_iter().enumerate() {
+        let mut channels_b: Vec<ConnectedChannel<Handle, Handle>> = Vec::new();
+
+        for (j, connection) in connections_b.into_iter().enumerate() {
+            if i <= j {
+                let chain_a = &chains[i];
+                let chain_b = &chains[j];
+
+                let port_a = &ports[i][j];
+                let port_b = &ports[j][i];
+
+                let channel = bootstrap_channel_with_connection(
+                    chain_a,
+                    chain_b,
+                    connection,
+                    &DualTagged::new(port_a),
+                    &DualTagged::new(port_b),
+                    bootstrap_with_random_ids,
+                )?;
+
+                channels_b.push(channel);
+            } else {
+                let counter_channel = &channels[j][i];
+                let channel = counter_channel.clone().flip();
+
+                channels_b.push(channel);
+            }
+        }
+
+        channels.push(channels_b);
+    }
+
+    Ok(DynamicConnectedChannels { channels })
+}
+
+pub fn bootstrap_channels_with_connections<Handle: ChainHandle, const SIZE: usize>(
+    connections: ConnectedConnections<Handle, SIZE>,
+    chains: &[Handle; SIZE],
+    ports: [[PortId; SIZE]; SIZE],
+    bootstrap_with_random_ids: bool,
+) -> Result<ConnectedChannels<Handle, SIZE>, Error> {
+    let channels = bootstrap_channels_with_connections_dynamic(
+        connections.into(),
+        chains,
+        &into_nested_vec(ports),
+        bootstrap_with_random_ids,
+    )?;
+
+    channels.try_into().map_err(handle_generic_error)
+}
+
+pub fn bootstrap_channels_dynamic<Handle: ChainHandle>(
+    chains: &DynamicConnectedChains<Handle>,
+    ports: &[Vec<PortId>],
+    bootstrap_with_random_ids: bool,
+) -> Result<DynamicConnectedChannels<Handle>, Error> {
+    let connections =
+        bootstrap_connections_dynamic(&chains.foreign_clients, bootstrap_with_random_ids)?;
+
+    bootstrap_channels_with_connections_dynamic(
+        connections,
+        &chains.chain_handles,
+        ports,
+        bootstrap_with_random_ids,
+    )
+}
+
+pub fn bootstrap_channels<Handle: ChainHandle, const SIZE: usize>(
+    chains: &ConnectedChains<Handle, SIZE>,
+    ports: [[PortId; SIZE]; SIZE],
+    bootstrap_with_random_ids: bool,
+) -> Result<ConnectedChannels<Handle, SIZE>, Error> {
+    let channels = bootstrap_channels_dynamic(
+        &chains.clone().into(),
+        &into_nested_vec(ports),
+        bootstrap_with_random_ids,
+    )?;
+
+    channels.try_into()
+}

tools/integration-test/src/bootstrap/nary/connection.rs

@@ -0,0 +1,59 @@
+use core::convert::TryInto;
+use ibc_relayer::chain::handle::ChainHandle;
+use ibc_relayer::foreign_client::ForeignClient;
+
+use crate::bootstrap::binary::connection::bootstrap_connection;
+use crate::error::Error;
+use crate::types::binary::connection::ConnectedConnection;
+use crate::types::nary::connection::{ConnectedConnections, DynamicConnectedConnections};
+use crate::util::array::{assert_same_dimension, into_nested_vec};
+
+pub fn bootstrap_connections_dynamic<Handle: ChainHandle>(
+    foreign_clients: &[Vec<ForeignClient<Handle, Handle>>],
+    bootstrap_with_random_ids: bool,
+) -> Result<DynamicConnectedConnections<Handle>, Error> {
+    let size = foreign_clients.len();
+
+    assert_same_dimension(size, foreign_clients)?;
+
+    let mut connections: Vec<Vec<ConnectedConnection<Handle, Handle>>> = Vec::new();
+
+    for (i, foreign_clients_b) in foreign_clients.iter().enumerate() {
+        let mut connections_b: Vec<ConnectedConnection<Handle, Handle>> = Vec::new();
+
+        for (j, foreign_client) in foreign_clients_b.iter().enumerate() {
+            if i <= j {
+                let counter_foreign_client = &foreign_clients[j][i];
+
+                let connection = bootstrap_connection(
+                    counter_foreign_client,
+                    foreign_client,
+                    bootstrap_with_random_ids,
+                )?;
+
+                connections_b.push(connection);
+            } else {
+                let counter_connection = &connections[j][i];
+                let connection = counter_connection.clone().flip();
+
+                connections_b.push(connection);
+            }
+        }
+
+        connections.push(connections_b);
+    }
+
+    Ok(DynamicConnectedConnections { connections })
+}
+
+pub fn bootstrap_connections<Handle: ChainHandle, const SIZE: usize>(
+    foreign_clients: [[ForeignClient<Handle, Handle>; SIZE]; SIZE],
+    bootstrap_with_random_ids: bool,
+) -> Result<ConnectedConnections<Handle, SIZE>, Error> {
+    let connections = bootstrap_connections_dynamic(
+        &into_nested_vec(foreign_clients),
+        bootstrap_with_random_ids,
+    )?;
+
+    connections.try_into()
+}