Add commands to initialize light client for given chain and start verifying headers

.gitignore

@@ -9,3 +9,5 @@ Cargo.lock
 # These are backup files generated by rustfmt
 **/*.rs.bk
 
+# Ignore database folders
+**/*.db/

modules/Cargo.toml

@@ -15,7 +15,7 @@ default = ["paths-cosmos"]
 paths-cosmos = []
 
 [dependencies]
-tendermint = { git = "https://github.com/interchainio/tendermint-rs.git" }
+tendermint = { git = "https://github.com/informalsystems/tendermint-rs.git" }
 
 anomaly = "0.2.0"
 thiserror = "1.0.11"

modules/src/ics02_client/client_type.rs

@@ -1,8 +1,6 @@
 use super::error;
 use anomaly::fail;
 
-pub struct Tendermint;
-
 /// Type of the consensus algorithm
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum ClientType {
@@ -18,12 +16,6 @@ impl ClientType {
     }
 }
 
-impl From<Tendermint> for ClientType {
-    fn from(_: Tendermint) -> Self {
-        Self::Tendermint
-    }
-}
-
 impl std::str::FromStr for ClientType {
     type Err = error::Error;
 

relayer/cli/.gitignore

@@ -1,2 +1,5 @@
 /target
 **/*.rs.bk
+
+*.sh
+*.db

relayer/cli/Cargo.toml

@@ -9,11 +9,14 @@ authors = [
 
 [dependencies]
 relayer = { path = "../relay" }
+tendermint = { git = "https://github.com/informalsystems/tendermint-rs.git" }
 
 anomaly = "0.2.0"
 gumdrop = "0.7"
 serde = { version = "1", features = ["serde_derive"] }
 thiserror = "1"
+abscissa_tokio = "0.5.1"
+tokio = "0.2.13"
 
 [dependencies.abscissa_core]
 version = "0.5.2"

relayer/cli/src/application.rs

@@ -82,7 +82,11 @@ impl Application for CliApp {
     /// beyond the default ones provided by the framework, this is the place
     /// to do so.
     fn register_components(&mut self, command: &Self::Cmd) -> Result<(), FrameworkError> {
-        let components = self.framework_components(command)?;
+        use abscissa_tokio::TokioComponent;
+
+        let mut components = self.framework_components(command)?;
+        components.push(Box::new(TokioComponent::new()?));
+
         self.state.components.register(components)
     }
 

relayer/cli/src/commands.rs

@@ -6,10 +6,11 @@
 //! application's configuration file.
 
 mod config;
+mod light;
 mod start;
 mod version;
 
-use self::{config::ConfigCmd, start::StartCmd, version::VersionCmd};
+use self::{config::ConfigCmd, light::LightCmd, start::StartCmd, version::VersionCmd};
 
 use crate::config::Config;
 use abscissa_core::{Command, Configurable, FrameworkError, Help, Options, Runnable};
@@ -25,6 +26,10 @@ pub enum CliCmd {
     #[options(help = "get usage information")]
     Help(Help<Self>),
 
+    /// The `version` subcommand
+    #[options(help = "display version information")]
+    Version(VersionCmd),
+
     /// The `start` subcommand
     #[options(help = "start the relayer")]
     Start(StartCmd),
@@ -33,9 +38,9 @@ pub enum CliCmd {
     #[options(help = "manipulate the relayer configuration")]
     Config(ConfigCmd),
 
-    /// The `version` subcommand
-    #[options(help = "display version information")]
-    Version(VersionCmd),
+    /// The `light` subcommand
+    #[options(help = "basic functionality for managing the lite clients")]
+    Light(LightCmd),
 }
 
 /// This trait allows you to define how application configuration is loaded.

relayer/cli/src/commands/light.rs

@@ -0,0 +1,13 @@
+//! `light` subcommand
+
+use abscissa_core::{Command, Options, Runnable};
+
+mod init;
+
+/// `light` subcommand
+#[derive(Command, Debug, Options, Runnable)]
+pub enum LightCmd {
+    /// The `light init` subcommand
+    #[options(help = "initiate a light client for a given chain")]
+    Init(init::InitCmd),
+}

relayer/cli/src/commands/light/init.rs

@@ -0,0 +1,111 @@
+use std::future::Future;
+
+// use crate::application::APPLICATION;
+use crate::prelude::*;
+
+use abscissa_core::{Command, Options, Runnable};
+
+use tendermint::chain::Id as ChainId;
+use tendermint::hash::Hash;
+use tendermint::lite::Height;
+
+use relayer::chain::tendermint::TendermintChain;
+use relayer::client::trust_options::TrustOptions;
+use relayer::config::{ChainConfig, Config};
+use relayer::store::{sled::SledStore, Store};
+
+#[derive(Command, Debug, Options)]
+pub struct InitCmd {
+    #[options(free, help = "identifier of the chain to initialize light client for")]
+    chain_id: Option<ChainId>,
+
+    #[options(help = "trusted header hash", short = "x")]
+    hash: Option<Hash>,
+
+    #[options(help = "trusted header height", short = "h")]
+    height: Option<Height>,
+}
+
+#[derive(Clone, Debug)]
+struct InitOptions {
+    /// identifier of chain to initialize light client for
+    chain_id: ChainId,
+
+    /// trusted header hash
+    trusted_hash: Hash,
+
+    /// trusted header height
+    trusted_height: Height,
+}
+
+impl InitCmd {
+    fn get_chain_config_and_options(
+        &self,
+        config: &Config,
+    ) -> Result<(ChainConfig, InitOptions), String> {
+        match (&self.chain_id, &self.hash, self.height) {
+            (Some(chain_id), Some(trusted_hash), Some(trusted_height)) => {
+                let chain_config = config.chains.iter().find(|c| c.id == *chain_id);
+
+                match chain_config {
+                    Some(chain_config) => {
+                        let opts = InitOptions {
+                            chain_id: *chain_id,
+                            trusted_hash: *trusted_hash,
+                            trusted_height,
+                        };
+
+                        Ok((chain_config.clone(), opts))
+                    }
+                    None => Err(format!("cannot find chain {} in config", chain_id)),
+                }
+            }
+
+            (None, _, _) => Err("missing chain identifier".to_string()),
+            (_, None, _) => Err("missing trusted hash".to_string()),
+            (_, _, None) => Err("missing trusted height".to_string()),
+        }
+    }
+}
+
+impl Runnable for InitCmd {
+    /// Initialize the light client for the given chain
+    fn run(&self) {
+        // FIXME: This just hangs and never runs the given future
+        // abscissa_tokio::run(&APPLICATION, ...).unwrap();
+
+        let config = app_config();
+
+        let (chain_config, opts) = match self.get_chain_config_and_options(&config) {
+            Err(err) => {
+                status_err!("invalid options: {}", err);
+                return;
+            }
+            Ok(result) => result,
+        };
+
+        block_on(async {
+            let trust_options = TrustOptions::new(
+                opts.trusted_hash,
+                opts.trusted_height,
+                chain_config.trusting_period,
+                Default::default(),
+            )
+            .unwrap();
+
+            let mut store: SledStore<TendermintChain> =
+                relayer::store::persistent(format!("store_{}.db", chain_config.id));
+
+            store.set_trust_options(trust_options).unwrap(); // FIXME: unwrap
+        });
+    }
+}
+
+fn block_on<F: Future>(future: F) -> F::Output {
+    tokio::runtime::Builder::new()
+        .basic_scheduler()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(future)
+}

relayer/cli/src/commands/start.rs

@@ -1,24 +1,105 @@
-//! `start` subcommand
+use std::future::Future;
+use std::time::{Duration, SystemTime};
 
-/// App-local prelude includes `app_reader()`/`app_writer()`/`app_config()`
-/// accessors along with logging macros. Customize as you see fit.
+// use crate::application::APPLICATION;
 use crate::prelude::*;
 
 use abscissa_core::{Command, Options, Runnable};
 
-/// `start` subcommand
-///
-/// The `Options` proc macro generates an option parser based on the struct
-/// definition, and is defined in the `gumdrop` crate. See their documentation
-/// for a more comprehensive example:
-///
-/// <https://docs.rs/gumdrop/>
+use tendermint::lite::types::Header;
+
+use relayer::chain::tendermint::TendermintChain;
+use relayer::chain::Chain;
+use relayer::client::Client;
+use relayer::config::ChainConfig;
+use relayer::store::Store;
+
 #[derive(Command, Debug, Options)]
 pub struct StartCmd {}
 
 impl Runnable for StartCmd {
-    /// Start the application.
     fn run(&self) {
-        status_ok!("{}", "Quitting...");
+        let config = app_config().clone();
+
+        // FIXME: This just hangs and never runs the given future
+        // abscissa_tokio::run(&APPLICATION, ...).unwrap();
+
+        block_on(async {
+            for chain_config in config.chains {
+                status_info!(
+                    "Relayer",
+                    "Spawning light client for chain {}",
+                    chain_config.id
+                );
+
+                let _handle = tokio::spawn(async move {
+                    let client = create_client(chain_config).await;
+                    let trusted_state = client.last_trusted_state().unwrap();
+
+                    status_ok!(
+                        client.chain().id(),
+                        "Spawned new client now at trusted state: {} at height {}",
+                        trusted_state.last_header().header().hash(),
+                        trusted_state.last_header().header().height(),
+                    );
+
+                    update_headers(client).await;
+                });
+            }
+
+            start_relayer().await
+        })
+    }
+}
+
+async fn start_relayer() {
+    let mut interval = tokio::time::interval(Duration::from_secs(3));
+
+    loop {
+        status_info!("Relayer", "Relayer is running");
+
+        interval.tick().await;
     }
 }
+
+async fn update_headers<C: Chain, S: Store<C>>(mut client: Client<C, S>) {
+    let mut interval = tokio::time::interval(Duration::from_secs(3));
+
+    loop {
+        let result = client.update(SystemTime::now()).await;
+
+        match result {
+            Ok(Some(trusted_state)) => status_ok!(
+                client.chain().id(),
+                "Updated to trusted state: {} at height {}",
+                trusted_state.header().hash(),
+                trusted_state.header().height()
+            ),
+
+            Ok(None) => status_info!(client.chain().id(), "Ignoring update to a previous state"),
+            Err(err) => status_info!(client.chain().id(), "Error when updating headers: {}", err),
+        }
+
+        interval.tick().await;
+    }
+}
+
+async fn create_client(
+    chain_config: ChainConfig,
+) -> Client<TendermintChain, impl Store<TendermintChain>> {
+    let chain = TendermintChain::from_config(chain_config).unwrap();
+
+    let store = relayer::store::persistent(format!("store_{}.db", chain.id()));
+    let trust_options = store.get_trust_options().unwrap(); // FIXME: unwrap
+
+    Client::new(chain, store, trust_options).await.unwrap()
+}
+
+fn block_on<F: Future>(future: F) -> F::Output {
+    tokio::runtime::Builder::new()
+        .basic_scheduler()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(future)
+}

relayer/relay/Cargo.toml

@@ -7,15 +7,19 @@ authors = [
   "Romain Ruetschi <romain@informal.systems>"
 ]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 relayer-modules = { path = "../../modules" }
-tendermint = { git = "https://github.com/interchainio/tendermint-rs.git" }
+tendermint = { git = "https://github.com/informalsystems/tendermint-rs.git" }
 
 anomaly = "0.2.0"
 humantime-serde = "1.0.0"
 serde = "1.0.97"
 serde_derive = "1.0"
 thiserror = "1.0.11"
 toml = "0.5"
+async-trait = "0.1.24"
+sled = "0.31.0"
+serde_cbor = "0.11.1"
+
+[dev-dependencies]
+tokio = { version = "0.2.13", features = ["macros"] }