Merge pull request #140 from AdExNetwork/issue-118-123-leader-follower-and-producer-ticks

Issues #118 Leader/follower

Author: samparsky

adapter/src/lib.rs

@@ -4,18 +4,21 @@
 #![deny(clippy::match_bool)]
 #![doc(test(attr(feature(async_await, await_macro))))]
 
-use ethabi::encode;
-use ethabi::param_type::{ParamType, Reader};
-use ethabi::token::{LenientTokenizer, StrictTokenizer, Token, Tokenizer};
 use std::error::Error;
+
+use ethabi::encode;
+use ethabi::param_type::ParamType;
+use ethabi::token::{LenientTokenizer, StrictTokenizer, Tokenizer};
 use tiny_keccak::Keccak;
 
-pub mod dummy;
-pub mod ethereum;
+use primitives::BigNum;
 
 pub use self::dummy::DummyAdapter;
 pub use self::ethereum::EthereumAdapter;
 
+pub mod dummy;
+pub mod ethereum;
+
 pub enum AdapterTypes {
     DummyAdapter(DummyAdapter),
     EthereumAdapter(EthereumAdapter),
@@ -25,9 +28,11 @@ pub fn get_signable_state_root(
     channel_id: &str,
     balance_root: &str,
 ) -> Result<[u8; 32], Box<dyn Error>> {
-    let types = ["bytes32".to_string(), "bytes32".to_string()];
-    let values = [channel_id.to_string(), balance_root.to_string()];
-    let encoded = encode_params(&types, &values, true)?;
+    let params = [
+        (ParamType::FixedBytes(32), channel_id),
+        (ParamType::FixedBytes(32), balance_root),
+    ];
+    let encoded = encode_params(&params, true)?;
 
     let mut result = Keccak::new_keccak256();
     result.update(&encoded);
@@ -38,10 +43,12 @@ pub fn get_signable_state_root(
     Ok(res)
 }
 
-pub fn get_balance_leaf(acc: &str, amnt: &str) -> Result<[u8; 32], Box<dyn Error>> {
-    let types: Vec<String> = vec!["address".to_string(), "uint256".to_string()];
-    let values = [acc.to_string(), amnt.to_string()];
-    let encoded = encode_params(&types, &values, true)?;
+pub fn get_balance_leaf(acc: &str, amnt: &BigNum) -> Result<[u8; 32], Box<dyn Error>> {
+    let params = [
+        (ParamType::Address, acc),
+        (ParamType::Uint(256), &amnt.to_str_radix(16)),
+    ];
+    let encoded = encode_params(&params, true)?;
 
     let mut result = Keccak::new_keccak256();
     result.update(&encoded);
@@ -83,29 +90,20 @@ impl EthereumChannel {
     }
 
     pub fn hash(&self, contract_addr: &str) -> Result<[u8; 32], Box<dyn Error>> {
-        let types: Vec<String> = vec![
-            "address",
-            "address",
-            "address",
-            "uint256",
-            "uint256",
-            "address[]",
-            "bytes32",
-        ]
-        .into_iter()
-        .map(ToString::to_string)
-        .collect();
-
-        let values = [
-            contract_addr.to_string(),
-            self.creator.to_owned(),
-            self.token_addr.to_owned(),
-            self.token_amount.to_owned(),
-            self.valid_until.to_owned(),
-            self.validators.to_owned(),
-            self.spec.to_owned(),
+        let params = [
+            (ParamType::Address, contract_addr),
+            (ParamType::Address, &self.creator),
+            (ParamType::Address, &self.token_addr),
+            (ParamType::Uint(256), &self.token_amount),
+            (ParamType::Uint(256), &self.valid_until),
+            (
+                ParamType::Array(Box::new(ParamType::Address)),
+                &self.validators,
+            ),
+            (ParamType::FixedBytes(32), &self.spec),
         ];
-        let encoded = encode_params(&types, &values, true)?;
+
+        let encoded = encode_params(&params, true)?;
         let mut result = Keccak::new_keccak256();
         result.update(&encoded);
 
@@ -149,50 +147,31 @@ impl EthereumChannel {
     }
 }
 
-fn encode_params(
-    types: &[String],
-    values: &[String],
-    lenient: bool,
-) -> Result<Vec<u8>, Box<dyn Error>> {
-    assert_eq!(types.len(), values.len());
-
-    let types: Vec<ParamType> = types
-        .iter()
-        .map(|s| Reader::read(s))
-        .collect::<Result<_, _>>()?;
-
-    let params: Vec<_> = types
-        .into_iter()
-        .zip(values.iter().map(|s| s as &str))
-        .collect();
-
-    let tokens = parse_tokens(&params, lenient)?;
-    let result = encode(&tokens);
-
-    Ok(result.to_vec())
-}
-
-fn parse_tokens(params: &[(ParamType, &str)], lenient: bool) -> Result<Vec<Token>, Box<dyn Error>> {
-    params
+fn encode_params(params: &[(ParamType, &str)], lenient: bool) -> Result<Vec<u8>, Box<dyn Error>> {
+    let tokens = params
         .iter()
-        .map(|&(ref param, value)| {
+        .map(|(param, value)| {
             if lenient {
                 LenientTokenizer::tokenize(param, value)
             } else {
                 StrictTokenizer::tokenize(param, value)
             }
         })
-        .collect::<Result<_, _>>()
-        .map_err(From::from)
+        .collect::<Result<Vec<_>, _>>()?;
+
+    Ok(encode(&tokens).to_vec())
 }
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use std::convert::TryFrom;
+
     use byteorder::{BigEndian, ByteOrder};
     use chrono::{TimeZone, Utc};
+
     use primitives::merkle_tree::MerkleTree;
-    use std::convert::TryFrom;
+
+    use super::*;
 
     #[test]
     fn test_get_signable_state_root_hash_is_aligned_with_js_impl() {

primitives/src/adapter.rs

@@ -1,11 +1,7 @@
-use futures::prelude::*;
-use std::collections::HashMap;
-use std::pin::Pin;
-// use domain::validator::message::State;
 use crate::channel_validator::ChannelValidator;
 use crate::validator::ValidatorDesc;
 use crate::{Channel, Config};
-//use crate::sanity::SanityChecker;
+use std::collections::HashMap;
 use std::error::Error;
 use std::fmt;
 use std::fmt::Debug;

primitives/src/big_num.rs

@@ -40,6 +40,10 @@ impl BigNum {
 
         self.0.to_u64()
     }
+
+    pub fn to_str_radix(&self, radix: u32) -> String {
+        self.0.to_str_radix(radix)
+    }
 }
 
 impl Integer for BigNum {

primitives/src/config.rs

@@ -30,7 +30,7 @@ pub struct Config {
     pub max_channels: u32,
     pub wait_time: u32,
     pub aggr_throttle: u32,
-    pub heartbeat_time: u32,
+    pub heartbeat_time: u32, // in milliseconds
     pub channels_find_limit: u32,
     pub events_find_limit: u32,
     pub health_threshold_promilles: u32,

primitives/src/sentry.rs

@@ -1,15 +1,16 @@
 use crate::validator::{ApproveState, Heartbeat, MessageTypes, NewState};
-use crate::{BalancesMap, BigNum, Channel};
+use crate::{BigNum, Channel};
 use chrono::{DateTime, Utc};
-use hex::FromHex;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct LastApproved {
-    new_state: NewState,
-    approved_state: ApproveState,
+    /// NewState can be None if the channel is brand new
+    pub new_state: Option<NewState>,
+    /// ApproveState can be None if the channel is brand new
+    pub approved_state: Option<ApproveState>,
 }
 
 #[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
@@ -69,7 +70,7 @@ pub struct ChannelAllResponse {
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct LastApprovedResponse {
-    pub last_approved: LastApproved,
+    pub last_approved: Option<LastApproved>,
     pub heartbeats: Option<Vec<Heartbeat>>,
 }
 

primitives/src/util/tests/prep_db.rs

@@ -11,9 +11,10 @@ lazy_static! {
         ids.insert("leader", "awesomeLeader".into());
         ids.insert("follower", "awesomeFollower".into());
         ids.insert("user", "awesomeTestUser".into());
-        ids.insert("publisher", "myAwesomePublisher".into());
+        ids.insert("publisher", "b7d3f81e857692d13e9d63b232a90f4a1793189e".into());
         ids.insert("publisher2", "myAwesomePublisher2".into());
         ids.insert("creator", "awesomeCreator".into());
+        ids.insert("tester", "2892f6C41E0718eeeDd49D98D648C789668cA67d".into());
 
         ids
     };
@@ -27,6 +28,7 @@ lazy_static! {
         auth.insert("publisher", "testing".into());
         auth.insert("publisher2", "testing2".into());
         auth.insert("creator", "awesomeCreator".into());
+        auth.insert("tester", "AUTH_awesomeTester".into());
 
         auth
     };
@@ -47,7 +49,7 @@ lazy_static! {
         let nonce = BigNum::from(<Faker as Number>::between(100_000_000, 999_999_999));
 
         Channel {
-            id: "awesomeTestChannel".to_string(),
+            id: "061d5e2a67d0a9a10f1c732bca12a676d83f79663a396f7d87b3e30b9b411088".to_string(),
             creator: "awesomeCreator".to_string(),
             deposit_asset: "DAI".to_string(),
             deposit_amount: 1_000.into(),

primitives/src/validator.rs

@@ -53,7 +53,7 @@ pub struct ApproveState {
 pub struct NewState {
     pub state_root: String,
     pub signature: String,
-    pub balances: String,
+    pub balances: BalancesMap,
 }
 
 #[derive(Default, Serialize, Deserialize, Debug, Clone)]
@@ -62,7 +62,7 @@ pub struct RejectState {
     pub reason: String,
     pub state_root: String,
     pub signature: String,
-    pub balances: Option<String>,
+    pub balances: Option<BalancesMap>,
     pub timestamp: Option<DateTime<Utc>>,
 }
 

validator_worker/src/core/events.rs

@@ -1,14 +1,11 @@
-use std::collections::HashMap;
-
-use chrono::{DateTime, Utc};
 use num_traits::CheckedSub;
-use serde::{Deserialize, Serialize};
 
-use crate::core::fees::get_balances_after_fees_tree;
 use primitives::sentry::{AggregateEvents, EventAggregate};
 use primitives::validator::Accounting;
 use primitives::{BalancesMap, BigNum, Channel, DomainError};
 
+use crate::core::fees::get_balances_after_fees_tree;
+
 pub(crate) fn merge_aggrs(
     accounting: &Accounting,
     aggregates: &[EventAggregate],
@@ -81,12 +78,15 @@ fn merge_payouts_into_balances<'a, T: Iterator<Item = &'a AggregateEvents>>(
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use chrono::Utc;
+
     use primitives::util::tests::prep_db::{
         DUMMY_CHANNEL, DUMMY_VALIDATOR_FOLLOWER, DUMMY_VALIDATOR_LEADER,
     };
     use primitives::{Channel, ChannelSpec, ValidatorDesc};
 
+    use super::*;
+
     #[test]
     fn should_merge_event_aggrs_and_apply_fees() {
         // fees: 100