Simplify some light client types and testing

tendermint-lite/src/lib.rs

@@ -1,4 +1,2 @@
 pub mod requester;
-pub mod state;
 pub mod store;
-pub mod threshold;

tendermint-lite/src/main.rs

@@ -1,19 +1,15 @@
 use tendermint::hash;
 use tendermint::lite;
-use tendermint::lite::Error;
-use tendermint::lite::{
-    Header as _, Requester as _, SignedHeader as _, Store as _, TrustedState as _,
-    ValidatorSet as _,
-};
+use tendermint::lite::{Error, TrustThresholdFraction};
+use tendermint::lite::{Header as _, Requester as _, Store as _, ValidatorSet as _};
 use tendermint::rpc;
 use tendermint::{block::Height, Hash};
 
-use tendermint_lite::{
-    requester::RPCRequester, state::State, store::MemStore, threshold::TrustThresholdOneThird,
-};
+use tendermint_lite::{requester::RPCRequester, store::MemStore};
 
 use core::future::Future;
 use std::time::{Duration, SystemTime};
+use tendermint_lite::store::State;
 use tokio::runtime::Builder;
 
 // TODO: these should be config/args
@@ -22,9 +18,6 @@ static SUBJECTIVE_VALS_HASH_HEX: &str =
     "A5A7DEA707ADE6156F8A981777CA093F178FC790475F6EC659B6617E704871DD";
 static RPC_ADDR: &str = "localhost:26657";
 
-// TODO: this should somehow be configurable ...
-static THRESHOLD: &TrustThresholdOneThird = &TrustThresholdOneThird {};
-
 pub fn block_on<F: Future>(future: F) -> F::Output {
     Builder::new()
         .basic_scheduler()
@@ -52,7 +45,7 @@ fn main() {
         let latest = (&req).signed_header(0).unwrap();
         let latest_peer_height = latest.header().height();
 
-        let latest = store.get(Height::from(0)).unwrap();
+        let latest = store.get(0).unwrap();
         let latest_height = latest.last_header().header().height();
 
         // only bisect to higher heights
@@ -63,19 +56,14 @@ fn main() {
 
         println!(
             "attempting bisection from height {:?} to height {:?}",
-            store
-                .get(Height::from(0))
-                .unwrap()
-                .last_header()
-                .header()
-                .height(),
+            store.get(0).unwrap().last_header().header().height(),
             latest_peer_height,
         );
 
         let now = &SystemTime::now();
         lite::verify_and_update_bisection(
             latest_peer_height,
-            THRESHOLD,
+            &TrustThresholdFraction::default(),
             &trusting_period,
             now,
             &req,
@@ -106,13 +94,13 @@ fn subjective_init(
     store: &mut MemStore,
     req: &RPCRequester,
 ) -> Result<(), Error> {
-    if store.get(height).is_ok() {
+    if store.get(height.value()).is_ok() {
         // we already have this !
         return Ok(());
     }
 
     // check that the val hash matches
-    let vals = req.validator_set(height)?;
+    let vals = req.validator_set(height.value())?;
 
     if vals.hash() != vals_hash {
         // TODO
@@ -123,11 +111,11 @@ fn subjective_init(
 
     // TODO: validate signed_header.commit() with the vals ...
 
-    let next_vals = req.validator_set(height.increment())?;
+    let next_vals = req.validator_set(height.increment().value())?;
 
     // TODO: check next_vals ...
 
-    let trusted_state = &State::new(&signed_header, &next_vals);
+    let trusted_state = State::new(&signed_header, &next_vals);
 
     store.add(trusted_state)?;
 

tendermint-lite/src/requester.rs

@@ -1,9 +1,12 @@
-use tendermint::block;
-use tendermint::lite;
+use tendermint::block::signed_header::SignedHeader as TMCommit;
+use tendermint::block::Header as TMHeader;
 use tendermint::rpc;
 use tendermint::validator;
+use tendermint::{block, lite};
 
 use core::future::Future;
+use tendermint::lite::{Height, SignedHeader};
+use tendermint::validator::Set;
 use tokio::runtime::Builder;
 
 /// RPCRequester wraps the Tendermint rpc::Client.
@@ -17,33 +20,26 @@ impl RPCRequester {
     }
 }
 
-impl lite::types::Requester for RPCRequester {
-    type SignedHeader = block::signed_header::SignedHeader;
-    type ValidatorSet = validator::Set;
+type TMSignedHeader = SignedHeader<TMCommit, TMHeader>;
 
+impl lite::types::Requester<TMCommit, TMHeader> for RPCRequester {
     /// Request the signed header at height h.
     /// If h==0, request the latest signed header.
     /// TODO: use an enum instead of h==0.
-    fn signed_header<H>(&self, h: H) -> Result<Self::SignedHeader, lite::Error>
-    where
-        H: Into<block::Height>,
-    {
+    fn signed_header(&self, h: Height) -> Result<TMSignedHeader, lite::Error> {
         let height: block::Height = h.into();
         let r = match height.value() {
             0 => block_on(self.client.latest_commit()),
             _ => block_on(self.client.commit(height)),
         };
         match r {
-            Ok(response) => Ok(response.signed_header),
+            Ok(response) => Ok(response.signed_header.into()),
             Err(_error) => Err(lite::Error::RequestFailed),
         }
     }
 
     /// Request the validator set at height h.
-    fn validator_set<H>(&self, h: H) -> Result<Self::ValidatorSet, lite::Error>
-    where
-        H: Into<block::Height>,
-    {
+    fn validator_set(&self, h: Height) -> Result<Set, lite::Error> {
         let r = block_on(self.client.validators(h));
         match r {
             Ok(response) => Ok(validator::Set::new(response.validators)),
@@ -66,7 +62,6 @@ mod tests {
     use super::*;
     use tendermint::lite::types::Header as LiteHeader;
     use tendermint::lite::types::Requester as LiteRequester;
-    use tendermint::lite::types::SignedHeader as LiteSignedHeader;
     use tendermint::lite::types::ValidatorSet as LiteValSet;
     use tendermint::rpc;
 

tendermint-lite/src/store.rs

@@ -1,8 +1,9 @@
-use crate::state::State;
-use tendermint::block::Height;
-use tendermint::lite::{Error, Header, SignedHeader, Store, TrustedState};
+use tendermint::lite::{Error, Header, Height, Store, TrustedState};
 
 use std::collections::HashMap;
+use tendermint::block;
+
+pub type State = TrustedState<block::signed_header::SignedHeader, block::header::Header>;
 
 #[derive(Default)]
 pub struct MemStore {
@@ -13,25 +14,23 @@ pub struct MemStore {
 impl MemStore {
     pub fn new() -> MemStore {
         MemStore {
-            height: Height::from(0),
+            height: 0,
             store: HashMap::new(),
         }
     }
 }
 
-impl Store for MemStore {
-    type TrustedState = State;
-
-    fn add(&mut self, trusted: &Self::TrustedState) -> Result<(), Error> {
+impl Store<block::signed_header::SignedHeader, block::header::Header> for MemStore {
+    fn add(&mut self, trusted: State) -> Result<(), Error> {
         let height = trusted.last_header().header().height();
         self.height = height;
-        self.store.insert(height, trusted.clone());
+        self.store.insert(height, trusted);
         Ok(())
     }
 
-    fn get(&self, h: Height) -> Result<&Self::TrustedState, Error> {
+    fn get(&self, h: Height) -> Result<&State, Error> {
         let mut height = h;
-        if h.value() == 0 {
+        if h == 0 {
             height = self.height
         }
         match self.store.get(&height) {

tendermint/Cargo.toml

@@ -56,3 +56,5 @@ zeroize = { version = "1.1", features = ["zeroize_derive"] }
 [dev-dependencies]
 serde_json = "1"
 tokio = "0.2"
+# Note: used in tests only:
+tendermint-lite = {path = "../tendermint-lite"}

tendermint/src/lite.rs

@@ -5,8 +5,4 @@ pub mod verifier;
 
 pub use self::types::*;
 
-// TODO: don't expose this once the json tests
-// switch to using one of the other functions
-pub use self::verifier::verify_single;
-
 pub use self::verifier::{verify_and_update_bisection, verify_and_update_single};