Issue #72 ValidationMessage (#76)

* validator - infra - sentry - fix some comments

* domain - BalanceMap

* domain - make `big_num` module consistent and register `balance_map` module

* domain - validator - `Message` & `State`

* adapter - `Adapter` should impl `State` as well + impl for `DummyAdapter`

* adapter - dummy - hide doc-tests' `futures::executor::block_on`

* adapter - references associated types for `verify`

* domain - util - tests - past_datetime

* domain - validator - message:
- State - constraints
- Message - move enum types to structs
- `fixtures` module - add unimplemented fixtures

* domain - validator - message - move to separate file + add RejectState

* domain - util - tests - time - use `datetime_between` instead of `Faker` directly

* domain - validator - message - fixtures - add simple fixtures

* domain - validator - message - fix `serde` `rename_all` & add `RejectState` to `Message`

* fix `clippy` warning

Author: elpiel

adapter/src/adapter.rs

@@ -1,8 +1,11 @@
+use std::pin::Pin;
+
+use futures::{Future, FutureExt};
+
+use domain::validator::message::State;
 use domain::{Asset, BigNum, Channel};
 
 use crate::sanity::SanityChecker;
-use futures::{Future, FutureExt};
-use std::pin::Pin;
 
 pub type AdapterFuture<T> = Pin<Box<dyn Future<Output = Result<T, AdapterError>> + Send>>;
 
@@ -11,7 +14,7 @@ pub enum AdapterError {
     Authentication(String),
 }
 
-pub trait Adapter: SanityChecker {
+pub trait Adapter: SanityChecker + State {
     fn config(&self) -> &Config;
 
     fn validate_channel(&self, channel: &Channel) -> AdapterFuture<bool> {
@@ -22,7 +25,12 @@ pub trait Adapter: SanityChecker {
     fn sign(&self, state_root: &str) -> AdapterFuture<String>;
 
     /// Verify, based on the signature & state_root, that the signer is the same
-    fn verify(&self, signer: &str, state_root: &str, signature: &str) -> AdapterFuture<bool>;
+    fn verify(
+        &self,
+        signer: &str,
+        state_root: &Self::StateRoot,
+        signature: &Self::Signature,
+    ) -> AdapterFuture<bool>;
 
     /// Gets authentication for specific validator
     fn get_auth(&self, validator: &str) -> AdapterFuture<String>;

adapter/src/dummy.rs

@@ -1,10 +1,12 @@
 use std::collections::HashMap;
 
+use futures::future::{err, ok, FutureExt};
 use hex::encode;
 
+use domain::validator::message::State;
+
 use crate::adapter::{Adapter, AdapterError, AdapterFuture, Config};
 use crate::sanity::SanityChecker;
-use futures::future::{err, ok, FutureExt};
 
 #[derive(Debug)]
 pub struct DummyParticipant {
@@ -21,26 +23,31 @@ pub struct DummyAdapter<'a> {
 
 impl SanityChecker for DummyAdapter<'_> {}
 
-impl Adapter for DummyAdapter<'_> {
+impl State for DummyAdapter<'_> {
+    type Signature = String;
+    type StateRoot = String;
+}
+
+impl<'a> Adapter for DummyAdapter<'a> {
     fn config(&self) -> &Config {
         &self.config
     }
 
     /// Example:
     ///
     /// ```
+    /// # futures::executor::block_on(async {
     /// use adapter::{ConfigBuilder, Adapter};
     /// use adapter::dummy::DummyAdapter;
     /// use std::collections::HashMap;
     ///
-    /// futures::executor::block_on(async {
-    ///     let config = ConfigBuilder::new("identity").build();
-    ///     let adapter = DummyAdapter { config, participants: HashMap::new() };
+    /// let config = ConfigBuilder::new("identity").build();
+    /// let adapter = DummyAdapter { config, participants: HashMap::new() };
     ///
-    ///     let actual = await!(adapter.sign("abcdefghijklmnopqrstuvwxyz012345")).unwrap();
-    ///     let expected = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
-    ///     assert_eq!(expected, &actual);
-    /// });
+    /// let actual = await!(adapter.sign("abcdefghijklmnopqrstuvwxyz012345")).unwrap();
+    /// let expected = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
+    /// assert_eq!(expected, &actual);
+    /// # });
     /// ```
     fn sign(&self, state_root: &str) -> AdapterFuture<String> {
         let signature = format!(
@@ -54,19 +61,24 @@ impl Adapter for DummyAdapter<'_> {
     /// Example:
     ///
     /// ```
+    /// # futures::executor::block_on(async {
     /// use adapter::{ConfigBuilder, Adapter};
     /// use adapter::dummy::DummyAdapter;
     /// use std::collections::HashMap;
     ///
-    /// futures::executor::block_on(async {
-    ///     let config = ConfigBuilder::new("identity").build();
-    ///     let adapter = DummyAdapter { config, participants: HashMap::new() };
+    /// 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", signature)));
-    /// });
+    /// 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())));
+    /// # });
     /// ```
-    fn verify(&self, signer: &str, _state_root: &str, signature: &str) -> AdapterFuture<bool> {
+    fn verify(
+        &self,
+        signer: &str,
+        _state_root: &Self::StateRoot,
+        signature: &Self::Signature,
+    ) -> 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() {
@@ -82,27 +94,27 @@ impl Adapter for DummyAdapter<'_> {
     /// Example:
     ///
     /// ```
+    /// # futures::executor::block_on(async {
     /// use std::collections::HashMap;
     /// use adapter::dummy::{DummyParticipant, DummyAdapter};
     /// use adapter::{ConfigBuilder, Adapter};
     ///
-    /// futures::executor::block_on(async {
-    ///    let mut participants = HashMap::new();
-    ///    participants.insert(
-    ///        "identity_key",
-    ///        DummyParticipant {
-    ///            identity: "identity".to_string(),
-    ///            token: "token".to_string(),
-    ///        },
-    ///    );
+    /// let mut participants = HashMap::new();
+    /// participants.insert(
+    ///     "identity_key",
+    ///     DummyParticipant {
+    ///         identity: "identity".to_string(),
+    ///         token: "token".to_string(),
+    ///     },
+    /// );
     ///
-    ///    let adapter = DummyAdapter {
-    ///        config: ConfigBuilder::new("identity").build(),
-    ///        participants,
-    ///    };
+    /// let adapter = DummyAdapter {
+    ///     config: ConfigBuilder::new("identity").build(),
+    ///     participants,
+    /// };
     ///
-    ///    assert_eq!(Ok("token".to_string()), await!(adapter.get_auth("identity")));
-    /// });
+    /// assert_eq!(Ok("token".to_string()), await!(adapter.get_auth("identity")));
+    /// # });
     /// ```
     fn get_auth(&self, validator: &str) -> AdapterFuture<String> {
         let participant = self
@@ -141,8 +153,11 @@ mod test {
 
             assert_eq!(expected_signature, &actual_signature);
 
-            let is_verified =
-                await!(adapter.verify("identity", "doesn't matter", &actual_signature));
+            let is_verified = await!(adapter.verify(
+                "identity",
+                &"doesn't matter".to_string(),
+                &actual_signature.to_string()
+            ));
 
             assert_eq!(Ok(true), is_verified);
         });

domain/src/balances_map.rs

@@ -0,0 +1,5 @@
+use std::collections::BTreeMap;
+
+use crate::BigNum;
+
+pub type BalancesMap = BTreeMap<String, BigNum>;

domain/src/bignum.rs renamed to domain/src/big_num.rs

@@ -7,7 +7,7 @@ use hex::FromHex;
 use serde::{Deserialize, Serialize};
 use serde_hex::{SerHex, StrictPfx};
 
-use crate::bignum::BigNum;
+use crate::big_num::BigNum;
 use crate::util::serde::ts_milliseconds_option;
 use crate::{AdUnit, Asset, DomainError, EventSubmission, TargetingTag, ValidatorDesc};
 

domain/src/channel.rs

@@ -8,7 +8,8 @@ pub use util::tests as test_util;
 
 pub use self::ad_unit::AdUnit;
 pub use self::asset::Asset;
-pub use self::bignum::BigNum;
+pub use self::balances_map::BalancesMap;
+pub use self::big_num::BigNum;
 pub use self::channel::{Channel, ChannelId, ChannelSpec, SpecValidator, SpecValidators};
 pub use self::event_submission::EventSubmission;
 #[cfg(feature = "repositories")]
@@ -18,7 +19,8 @@ pub use self::validator::ValidatorDesc;
 
 pub mod ad_unit;
 pub mod asset;
-pub mod bignum;
+pub mod balances_map;
+pub mod big_num;
 pub mod channel;
 pub mod event_submission;
 pub mod targeting_tag;

domain/src/lib.rs

@@ -3,7 +3,7 @@ use fake::faker::Chrono;
 use fake::Faker;
 use time::Duration;
 
-/// Creates a DatTime<Utc> between two dates. If `to` is not provided it will use
+/// Creates a DateTime<Utc> between two dates. If `to` is not provided it will use
 /// `Now + 365 days`.
 ///
 pub fn datetime_between(from: &DateTime<Utc>, to: Option<&DateTime<Utc>>) -> DateTime<Utc> {
@@ -13,3 +13,17 @@ pub fn datetime_between(from: &DateTime<Utc>, to: Option<&DateTime<Utc>>) -> Dat
         .parse()
         .expect("Whoops, DateTime<Utc> should be created from Fake...")
 }
+
+/// Creates a DateTime<Utc> in the past between `from` and `Now - 1 sec`.
+/// If `from` is not provided it will use `-1 week`
+///
+pub fn past_datetime(from: Option<&DateTime<Utc>>) -> DateTime<Utc> {
+    // make sure that we always generate DateTimes in the past, so use `Now - 1 sec`
+    let to = Utc::now() - Duration::seconds(1);
+
+    let default_from = Utc::now() - Duration::weeks(1);
+
+    let from = from.unwrap_or(&default_from);
+
+    datetime_between(&from, Some(&to))
+}

domain/src/util/tests/time.rs

@@ -1,7 +1,11 @@
 use serde::{Deserialize, Serialize};
 
+pub use message::Message;
+
 use crate::BigNum;
 
+pub mod message;
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ValidatorDesc {

domain/src/validator.rs

@@ -0,0 +1,132 @@
+use chrono::{DateTime, Utc};
+use serde::de::DeserializeOwned;
+use serde::export::fmt::Debug;
+use serde::{Deserialize, Serialize};
+
+use crate::BalancesMap;
+
+pub trait State {
+    type Signature: DeserializeOwned + Serialize + Debug;
+    type StateRoot: DeserializeOwned + Serialize + Debug;
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "type")]
+pub enum Message<S: State> {
+    ApproveState(ApproveState<S>),
+    NewState(NewState<S>),
+    RejectState(RejectState),
+    Heartbeat(Heartbeat<S>),
+    Accounting(Accounting),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ApproveState<S: State> {
+    state_root: S::StateRoot,
+    signature: S::Signature,
+    is_healthy: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct NewState<S: State> {
+    state_root: S::StateRoot,
+    signature: S::Signature,
+    balances: BalancesMap,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RejectState {
+    reason: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Heartbeat<S: State> {
+    signature: S::Signature,
+    timestamp: DateTime<Utc>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Accounting {
+    #[serde(rename = "last_ev_aggr")]
+    last_event_aggregate: DateTime<Utc>,
+    #[serde(rename = "balances_pre_fees")]
+    pre_fees: BalancesMap,
+    balances: BalancesMap,
+}
+
+#[cfg(any(test, feature = "fixtures"))]
+pub mod fixtures {
+    use fake::faker::*;
+
+    use crate::test_util::time::past_datetime;
+
+    use super::*;
+
+    #[derive(Serialize, Deserialize, Debug)]
+    pub struct DummyState {}
+
+    impl State for DummyState {
+        type Signature = String;
+        type StateRoot = String;
+    }
+
+    pub fn get_approve_state<S: State>(
+        state_root: S::StateRoot,
+        signature: S::Signature,
+        is_healthy: bool,
+    ) -> ApproveState<S> {
+        ApproveState {
+            state_root,
+            signature,
+            is_healthy,
+        }
+    }
+
+    pub fn get_new_state<S: State>(
+        state_root: S::StateRoot,
+        signature: S::Signature,
+        balances: BalancesMap,
+    ) -> NewState<S> {
+        NewState {
+            state_root,
+            signature,
+            balances,
+        }
+    }
+
+    pub fn get_reject_state(reason: Option<String>) -> RejectState {
+        RejectState {
+            reason: reason.unwrap_or_else(|| <Faker as Lorem>::sentence(5, 4)),
+        }
+    }
+
+    pub fn get_heartbeat<S: State>(signature: S::Signature) -> Heartbeat<S> {
+        Heartbeat {
+            signature,
+            timestamp: past_datetime(None),
+        }
+    }
+
+    pub fn get_accounting(
+        balances: BalancesMap,
+        pre_fees: Option<BalancesMap>,
+        last_ev_aggr: Option<DateTime<Utc>>,
+    ) -> Accounting {
+        let last_event_aggregate = last_ev_aggr.unwrap_or_else(|| past_datetime(None));
+        assert!(
+            last_event_aggregate < Utc::now(),
+            "You cannot have a last_event_aggregate < Now"
+        );
+
+        Accounting {
+            last_event_aggregate,
+            pre_fees: pre_fees.unwrap_or_else(BalancesMap::default),
+            balances,
+        }
+    }
+}