Issue #78 heartbeat service (#89)

* domain - re-export ValidatorId & impl Error for RepositoryError

* validator - `allow(clippy::needless_lifetimes)`

* domain - validator - impl `TryFrom<&str>` for `ValidatorId`

* validator - application - heartbeat - make it compile with most of the things done

* validator - application - HeartbeatSender:
- HeartbeatError::User
- remove panic! and use the User error

* adapter - Cargo.toml - `dummy-adapter` feature:
- add `serde`
- move `hex` inside

* adapter - signable_state_root:
- ChannelId, BalanceRoot and signable_state_root assoc fn
- Dummy - DummySignature & DummyStateRoot
- Dummy - Hexable trait
- Dummy - impl Hexable for ChannelId, BalanceRoot & DummyStateRoot
-

* validator - State - Singature & StateRoot:
- use Display instead of Debug

* domain - channel - ChannelId - `id` to `bytes` field

* validator - applicaiton - heartbeat - use `signable_state_root`

* validator - application - heartbeat - handle if it's time for Heartbeat

Author: elpiel

Cargo.lock

@@ -6,17 +6,17 @@ edition = "2018"
 
 [features]
 # Allows you to use a Dummy implementation of the Adapter for testing purposes
-dummy-adapter = []
+dummy-adapter = ["serde", "hex"]
 
 [dependencies]
 domain = {path = "../domain"}
 # Futures
-futures-preview = { version = "=0.3.0-alpha.16" }
+futures-preview = {version = "=0.3.0-alpha.16"}
 # Time handling
 chrono = "0.4"
 time = "0.1.42"
 # To/From Hex
-# @TODO: Move this to the `dummy-adapter` feature if we use it only there!
-hex = "0.3.2"
+hex = {version = "0.3.2", optional = true}
+serde =  {version = "^1.0", features = ['derive'], optional = true}
 [dev-dependencies]
 domain = {path = "../domain", features = ["fixtures"]}

adapter/Cargo.toml

@@ -9,6 +9,22 @@ use crate::sanity::SanityChecker;
 use std::error::Error;
 use std::fmt;
 
+pub struct ChannelId(pub [u8; 32]);
+impl AsRef<[u8]> for ChannelId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+pub struct BalanceRoot(pub [u8; 32]);
+impl AsRef<[u8]> for BalanceRoot {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+pub struct SignableStateRoot<T: fmt::Display>(pub T);
+
 pub type AdapterFuture<T> = Pin<Box<dyn Future<Output = Result<T, AdapterError>> + Send>>;
 
 #[derive(Debug, Eq, PartialEq)]
@@ -46,6 +62,11 @@ pub trait Adapter: SanityChecker + State {
 
     /// Gets authentication for specific validator
     fn get_auth(&self, validator: &str) -> AdapterFuture<String>;
+
+    fn signable_state_root(
+        channel_id: ChannelId,
+        balance_root: BalanceRoot,
+    ) -> SignableStateRoot<Self::StateRoot>;
 }
 
 pub struct Config {

adapter/src/adapter.rs

@@ -1,19 +1,68 @@
-use std::collections::HashMap;
+use crate::adapter::{
+    Adapter, AdapterError, AdapterFuture, BalanceRoot, ChannelId, Config, SignableStateRoot,
+};
+use crate::sanity::SanityChecker;
 
 use futures::future::{err, ok, FutureExt};
 use hex::encode;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt;
 
 use domain::validator::message::State;
 
-use crate::adapter::{Adapter, AdapterError, AdapterFuture, Config};
-use crate::sanity::SanityChecker;
-
 #[derive(Debug)]
 pub struct DummyParticipant {
     pub identity: String,
     pub token: String,
 }
 
+pub trait Hexable: AsRef<[u8]> {
+    fn to_hex(&self) -> String {
+        format!("0x{}", encode(&self))
+    }
+}
+
+impl Hexable for ChannelId {}
+impl Hexable for BalanceRoot {}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DummySignature(pub String);
+
+impl fmt::Display for DummySignature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<S: Into<String>> From<S> for DummySignature {
+    fn from(value: S) -> Self {
+        Self(value.into())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DummyStateRoot(pub String);
+
+impl fmt::Display for DummyStateRoot {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<S: Into<String>> From<S> for DummyStateRoot {
+    fn from(value: S) -> Self {
+        Self(value.into())
+    }
+}
+
+impl AsRef<[u8]> for DummyStateRoot {
+    fn as_ref(&self) -> &[u8] {
+        &self.0.as_ref()
+    }
+}
+impl Hexable for DummyStateRoot {}
+
 pub struct DummyAdapter<'a> {
     pub config: Config,
     /// Dummy participants which will be used for
@@ -24,8 +73,8 @@ pub struct DummyAdapter<'a> {
 impl SanityChecker for DummyAdapter<'_> {}
 
 impl State for DummyAdapter<'_> {
-    type Signature = String;
-    type StateRoot = String;
+    type Signature = DummySignature;
+    type StateRoot = DummyStateRoot;
 }
 
 impl<'a> Adapter for DummyAdapter<'a> {
@@ -38,24 +87,24 @@ impl<'a> Adapter for DummyAdapter<'a> {
     /// ```
     /// # futures::executor::block_on(async {
     /// use adapter::{ConfigBuilder, Adapter};
-    /// use adapter::dummy::DummyAdapter;
+    /// use adapter::dummy::{DummyAdapter, DummySignature};
     /// use std::collections::HashMap;
     ///
     /// let config = ConfigBuilder::new("identity").build();
     /// let adapter = DummyAdapter { config, participants: HashMap::new() };
     ///
-    /// let actual = await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".to_string())).unwrap();
-    /// let expected = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
-    /// assert_eq!(expected, &actual);
+    /// let actual = await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".into())).unwrap();
+    /// let expected = "Dummy adapter signature for 0x6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
+    /// assert_eq!(DummySignature::from(expected), actual);
     /// # });
     /// ```
     fn sign(&self, state_root: &Self::StateRoot) -> AdapterFuture<Self::Signature> {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
-            encode(&state_root),
+            state_root.to_hex(),
             &self.config.identity
         );
-        ok(signature).boxed()
+        ok(signature.into()).boxed()
     }
 
     /// Example:
@@ -69,8 +118,8 @@ impl<'a> Adapter for DummyAdapter<'a> {
     /// let config = ConfigBuilder::new("identity").build();
     /// let adapter = DummyAdapter { config, participants: HashMap::new() };
     ///
-    /// let signature = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
-    /// assert_eq!(Ok(true), await!(adapter.verify("identity", &"doesn't matter".to_string(), &signature.to_string())));
+    /// let signature = "Dummy adapter signature for 0x6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
+    /// assert_eq!(Ok(true), await!(adapter.verify("identity", &"doesn't matter".into(), &signature.into())));
     /// # });
     /// ```
     fn verify(
@@ -81,7 +130,7 @@ impl<'a> Adapter for DummyAdapter<'a> {
     ) -> AdapterFuture<bool> {
         // select the `identity` and compare it to the signer
         // for empty string this will return array with 1 element - an empty string `[""]`
-        let is_same = match signature.rsplit(' ').take(1).next() {
+        let is_same = match signature.0.rsplit(' ').take(1).next() {
             Some(from) => from == signer,
             None => false,
         };
@@ -130,6 +179,19 @@ impl<'a> Adapter for DummyAdapter<'a> {
 
         future.boxed()
     }
+
+    fn signable_state_root(
+        channel_id: ChannelId,
+        balance_root: BalanceRoot,
+    ) -> SignableStateRoot<Self::StateRoot> {
+        let state_root = format!(
+            "Signable State Root for Adapter channel id {} with balance root {}",
+            channel_id.to_hex(),
+            balance_root.to_hex()
+        );
+
+        SignableStateRoot(state_root.into())
+    }
 }
 
 #[cfg(test)]
@@ -147,17 +209,16 @@ mod test {
                 participants: HashMap::new(),
             };
 
-            let expected_signature = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
-            let actual_signature =
-                await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".to_string()))
-                    .expect("Signing shouldn't fail");
+            let expected_signature = "Dummy adapter signature for 0x6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
+            let actual_signature = await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".into()))
+                .expect("Signing shouldn't fail");
 
-            assert_eq!(expected_signature, &actual_signature);
+            assert_eq!(DummySignature::from(expected_signature), actual_signature);
 
             let is_verified = await!(adapter.verify(
                 "identity",
-                &"doesn't matter".to_string(),
-                &actual_signature.to_string()
+                &"doesn't matter".into(),
+                &actual_signature.into()
             ));
 
             assert_eq!(Ok(true), is_verified);

adapter/src/dummy.rs

@@ -15,7 +15,7 @@ use crate::{AdUnit, Asset, DomainError, EventSubmission, TargetingTag, Validator
 #[serde(transparent)]
 pub struct ChannelId {
     #[serde(with = "SerHex::<StrictPfx>")]
-    pub id: [u8; 32],
+    pub bytes: [u8; 32],
 }
 
 impl fmt::Display for ChannelId {
@@ -31,7 +31,7 @@ impl fmt::Display for ChannelId {
     /// assert_eq!("0x061d5e2a67d0a9a10f1c732bca12a676d83f79663a396f7d87b3e30b9b411088", &channel_hex_string);
     /// ```
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        let hex_string = SerHex::<StrictPfx>::into_hex(&self.id).unwrap();
+        let hex_string = SerHex::<StrictPfx>::into_hex(&self.bytes).unwrap();
         write!(f, "{}", hex_string)
     }
 }
@@ -47,9 +47,9 @@ impl TryFrom<&str> for ChannelId {
     /// use std::convert::TryFrom;
     /// use domain::channel::ChannelId;
     ///
-    /// let bytes: [u8; 32] = [49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50];
+    /// let bytes: [u8; 32] = *b"12345678901234567890123456789012";
     ///
-    /// assert_eq!(ChannelId { id: bytes }, ChannelId::try_from("12345678901234567890123456789012").unwrap())
+    /// assert_eq!(ChannelId { bytes }, ChannelId::try_from("12345678901234567890123456789012").unwrap())
     /// ```
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         let bytes = value.as_bytes();
@@ -61,7 +61,7 @@ impl TryFrom<&str> for ChannelId {
         let mut id = [0; 32];
         id.copy_from_slice(&bytes[..32]);
 
-        Ok(Self { id })
+        Ok(Self { bytes: id })
     }
 }
 
@@ -78,7 +78,7 @@ impl ChannelId {
     ///
     /// let from_hex = domain::ChannelId::try_from_hex(hex_string).expect("This should be valid hex string");
     ///
-    /// let expected_channel_id = ChannelId{ id: [6, 29, 94, 42, 103, 208, 169, 161, 15, 28, 115, 43, 202, 18, 166, 118, 216, 63, 121, 102, 58, 57, 111, 125, 135, 179, 227, 11, 155, 65, 16, 136]};
+    /// let expected_channel_id = ChannelId{ bytes: [6, 29, 94, 42, 103, 208, 169, 161, 15, 28, 115, 43, 202, 18, 166, 118, 216, 63, 121, 102, 58, 57, 111, 125, 135, 179, 227, 11, 155, 65, 16, 136]};
     /// assert_eq!(expected_channel_id, from_hex)
     /// ```
     pub fn try_from_hex(hex: &str) -> Result<Self, DomainError> {
@@ -95,13 +95,13 @@ impl ChannelId {
         let mut id = [0; 32];
         id.copy_from_slice(&bytes[..32]);
 
-        Ok(Self { id })
+        Ok(Self { bytes: id })
     }
 }
 
 impl PartialEq<ChannelId> for &str {
     fn eq(&self, channel_id: &ChannelId) -> bool {
-        self.as_bytes() == channel_id.id
+        self.as_bytes() == channel_id.bytes
     }
 }
 

domain/src/channel.rs

@@ -22,7 +22,7 @@ pub fn get_channel_id(channel_id: &str) -> ChannelId {
         *byte = channel_id_bytes[index];
     }
 
-    ChannelId { id }
+    ChannelId { bytes: id }
 }
 
 pub fn get_channel(

domain/src/channel_fixtures.rs

@@ -7,10 +7,7 @@ fn coverts_str_to_channel_id() {
     let channel_id = ChannelId::try_from("12345678901234567890123456789012")
         .expect("Should create ChannelId from &str with 32 len numeric value");
 
-    assert_eq!(
-        "12345678901234567890123456789012".as_bytes(),
-        &channel_id.id
-    );
+    assert_eq!(b"12345678901234567890123456789012", &channel_id.bytes);
 
     assert!(
         ChannelId::try_from("1234567890123456789012345678901").is_err(),

domain/src/channel_test.rs

@@ -15,7 +15,7 @@ pub use self::event_submission::EventSubmission;
 #[cfg(feature = "repositories")]
 pub use self::repository::*;
 pub use self::targeting_tag::TargetingTag;
-pub use self::validator::ValidatorDesc;
+pub use self::validator::{ValidatorDesc, ValidatorId};
 
 pub mod ad_unit;
 pub mod asset;
@@ -58,6 +58,8 @@ pub mod repository {
     use std::pin::Pin;
 
     use futures::Future;
+    use std::error::Error;
+    use std::fmt;
 
     pub trait IOError: std::error::Error + Send {}
 
@@ -70,5 +72,16 @@ pub mod repository {
         User,
     }
 
+    impl Error for RepositoryError {}
+
+    impl fmt::Display for RepositoryError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match self {
+                RepositoryError::User => write!(f, "User error: TODO"),
+                RepositoryError::IO(error) => write!(f, "IO error: {}", error),
+            }
+        }
+    }
+
     pub type RepositoryFuture<T> = Pin<Box<dyn Future<Output = Result<T, RepositoryError>> + Send>>;
 }

domain/src/lib.rs

@@ -1,15 +1,26 @@
+use std::convert::TryFrom;
+
 use serde::{Deserialize, Serialize};
 
 pub use message::Message;
 
-use crate::BigNum;
+use crate::{BigNum, DomainError};
 
 pub mod message;
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(transparent)]
 pub struct ValidatorId(String);
 
+impl TryFrom<&str> for ValidatorId {
+    type Error = DomainError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        // @TODO: Should we have some constrains(like valid hex string starting with `0x`)? If not this should be just `From`.
+        Ok(Self(value.to_string()))
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ValidatorDesc {