add relayer cli

ipc/cli/src/commands/checkpoint/mod.rs

@@ -3,10 +3,12 @@
 use crate::commands::checkpoint::list_checkpoints::{
     ListBottomUpCheckpoints, ListBottomUpCheckpointsArgs,
 };
+use crate::commands::checkpoint::relayer::{BottomUpRelayer, BottomUpRelayerArgs};
 use crate::{CommandLineHandler, GlobalArguments};
 use clap::{Args, Subcommand};
 
 mod list_checkpoints;
+mod relayer;
 
 #[derive(Debug, Args)]
 #[command(name = "checkpoint", about = "checkpoint related commands")]
@@ -20,11 +22,13 @@ impl CheckpointCommandsArgs {
     pub async fn handle(&self, global: &GlobalArguments) -> anyhow::Result<()> {
         match &self.command {
             Commands::ListBottomup(args) => ListBottomUpCheckpoints::handle(global, args).await,
+            Commands::Relayer(args) => BottomUpRelayer::handle(global, args).await,
         }
     }
 }
 
 #[derive(Debug, Subcommand)]
 pub(crate) enum Commands {
     ListBottomup(ListBottomUpCheckpointsArgs),
+    Relayer(BottomUpRelayerArgs),
 }

ipc/cli/src/commands/checkpoint/relayer.rs

@@ -0,0 +1,79 @@
+// Copyright 2022-2023 Protocol Labs
+// SPDX-License-Identifier: MIT
+
+use crate::commands::get_subnet_config;
+use crate::{CommandLineHandler, GlobalArguments};
+use anyhow::anyhow;
+use async_trait::async_trait;
+use clap::Args;
+use fvm_shared::address::Address;
+use ipc_identity::EvmKeyStore;
+use ipc_provider::checkpoint::BottomUpCheckpointManager;
+use ipc_provider::new_evm_keystore_from_path;
+use ipc_sdk::subnet_id::SubnetID;
+use std::str::FromStr;
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+
+const DEFAULT_CHECKPOINT_INTERVAL: u64 = 15;
+
+/// The command to run the bottom up relayer in the background.
+pub(crate) struct BottomUpRelayer;
+
+#[async_trait]
+impl CommandLineHandler for BottomUpRelayer {
+    type Arguments = BottomUpRelayerArgs;
+
+    async fn handle(global: &GlobalArguments, arguments: &Self::Arguments) -> anyhow::Result<()> {
+        log::debug!("start bottom up relayer with args: {:?}", arguments);
+
+        let config_path = global.config_path();
+
+        let mut keystore = new_evm_keystore_from_path(&config_path)?;
+        let validator = match (arguments.validator.as_ref(), keystore.get_default()?) {
+            (Some(validator), _) => Address::from_str(validator)?,
+            (None, Some(addr)) => {
+                log::info!("using default address: {addr:?}");
+                Address::try_from(addr)?
+            }
+            _ => {
+                return Err(anyhow!("no validator address provided"));
+            }
+        };
+
+        let subnet = SubnetID::from_str(&arguments.subnet)?;
+        let parent = subnet
+            .parent()
+            .ok_or_else(|| anyhow!("root does not have parent"))?;
+
+        let child = get_subnet_config(&config_path, &subnet)?;
+        let parent = get_subnet_config(&config_path, &parent)?;
+
+        let manager = BottomUpCheckpointManager::new_evm_manager(
+            parent.clone(),
+            child.clone(),
+            Arc::new(RwLock::new(keystore)),
+        )
+        .await?;
+
+        let interval = Duration::from_secs(
+            arguments
+                .checkpoint_interval_sec
+                .unwrap_or(DEFAULT_CHECKPOINT_INTERVAL),
+        );
+        manager.run(validator, interval).await;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Args)]
+#[command(about = "Start the bottom up relayer")]
+pub(crate) struct BottomUpRelayerArgs {
+    #[arg(long, short, help = "The subnet id of the checkpointing subnet")]
+    pub subnet: String,
+    #[arg(long, short, help = "The number of seconds to submit checkpoint")]
+    pub checkpoint_interval_sec: Option<u64>,
+    #[arg(long, short, help = "The hex encoded address of the validator")]
+    pub validator: Option<String>,
+}

ipc/cli/src/commands/mod.rs

@@ -14,15 +14,18 @@ use crate::commands::checkpoint::CheckpointCommandsArgs;
 use crate::commands::crossmsg::CrossMsgsCommandsArgs;
 use crate::commands::util::UtilCommandsArgs;
 use crate::GlobalArguments;
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 
 use clap::{Command, CommandFactory, Parser, Subcommand};
 use clap_complete::{generate, Generator, Shell};
 use fvm_shared::econ::TokenAmount;
 use ipc_sdk::ethers_address_to_fil_address;
 
+use ipc_provider::config::{Config, Subnet};
+use ipc_sdk::subnet_id::SubnetID;
 use std::fmt::Debug;
 use std::io;
+use std::path::Path;
 use std::str::FromStr;
 
 use crate::commands::config::ConfigCommandsArgs;
@@ -146,6 +149,19 @@ pub(crate) fn require_fil_addr_from_str(s: &str) -> anyhow::Result<fvm_shared::a
     Ok(addr)
 }
 
+/// Get the subnet configuration from the config path
+pub(crate) fn get_subnet_config(
+    config_path: impl AsRef<Path>,
+    subnet: &SubnetID,
+) -> Result<Subnet> {
+    let config = Config::from_file(&config_path)?;
+    Ok(config
+        .subnets
+        .get(subnet)
+        .ok_or_else(|| anyhow!("{subnet} is not configured"))?
+        .clone())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::f64_to_token_amount;

ipc/identity/src/evm/mod.rs

@@ -91,7 +91,7 @@ pub fn random_eth_key_info() -> KeyInfo {
 }
 
 #[cfg(feature = "with-ethers")]
-#[derive(Clone, Eq, Hash, PartialEq, Default)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq, Default)]
 pub struct EthKeyAddress {
     inner: ethers::types::Address,
 }

ipc/provider/src/checkpoint.rs

@@ -89,16 +89,14 @@ impl<T: BottomUpCheckpointRelayer + Send + Sync + 'static> BottomUpCheckpointMan
     }
 
     /// Run the bottom up checkpoint submission daemon in the background
-    pub fn run(self, validator: Address, submission_interval: Duration) {
-        tokio::spawn(async move {
-            loop {
-                if let Err(e) = self.submit_checkpoint(&validator).await {
-                    log::error!("cannot submit checkpoint for validator: {validator} due to {e}");
-                }
-
-                tokio::time::sleep(submission_interval).await;
+    pub async fn run(self, validator: Address, submission_interval: Duration) {
+        loop {
+            if let Err(e) = self.submit_checkpoint(&validator).await {
+                log::error!("cannot submit checkpoint for validator: {validator} due to {e}");
             }
-        });
+
+            tokio::time::sleep(submission_interval).await;
+        }
     }
 
     /// Submit the checkpoint from the target validator address