V5 validator workflow - Follower & Leader ticks

adapter/Cargo.toml

@@ -29,6 +29,7 @@ reqwest = { version = "0.11", features = ["json"] }
 sha2 = "0.9"
 base64 = "0.13"
 lazy_static = "^1.4"
+thiserror = "^1"
 # Futures
 futures = "0.3"
 async-trait = "0.1"

adapter/src/dummy.rs

@@ -107,7 +107,7 @@ impl Adapter for DummyAdapter {
 
     fn verify(
         &self,
-        signer: &ValidatorId,
+        signer: ValidatorId,
         _state_root: &str,
         signature: &str,
     ) -> AdapterResult<bool, Self::AdapterError> {

adapter/src/ethereum.rs

@@ -172,7 +172,7 @@ impl Adapter for EthereumAdapter {
     /// `sig` is hex string which **should be** `0x` prefixed
     fn verify(
         &self,
-        signer: &ValidatorId,
+        signer: ValidatorId,
         state_root: &str,
         sig: &str,
     ) -> AdapterResult<bool, Self::AdapterError> {
@@ -543,7 +543,7 @@ mod test {
             "0x9e07f12958ce7c5eb1362eb9461e4745dd9d74a42b921391393caea700bfbd6e1ad876a7d8f9202ef1fe6110dbfe87840c5676ca5c4fda9f3330694a1ac2a1fc1b";
         let verify = eth_adapter
             .verify(
-                &ValidatorId::try_from("2892f6C41E0718eeeDd49D98D648C789668cA67d")
+                ValidatorId::try_from("2892f6C41E0718eeeDd49D98D648C789668cA67d")
                     .expect("Failed to parse id"),
                 "8bc45d8eb27f4c98cab35d17b0baecc2a263d6831ef0800f4c190cbfac6d20a3",
                 &signature,
@@ -555,7 +555,7 @@ mod test {
 
         let verify2 = eth_adapter
             .verify(
-                &ValidatorId::try_from("ce07CbB7e054514D590a0262C93070D838bFBA2e")
+                ValidatorId::try_from("ce07CbB7e054514D590a0262C93070D838bFBA2e")
                     .expect("Failed to parse id"),
                 message2,
                 &signature2,

adapter/src/lib.rs

@@ -2,14 +2,13 @@
 #![deny(clippy::all)]
 #![deny(clippy::match_bool)]
 
-use std::error::Error;
-
-use primitives::{channel::ChannelError, Address, BigNum};
+use primitives::{Address, BigNum};
 use tiny_keccak::Keccak;
 use web3::{
     ethabi::{encode, token::Token},
     types::{Address as EthAddress, U256},
 };
+use thiserror::Error;
 
 pub use self::dummy::DummyAdapter;
 pub use self::ethereum::EthereumAdapter;
@@ -22,10 +21,14 @@ pub enum AdapterTypes {
     EthereumAdapter(Box<EthereumAdapter>),
 }
 
+#[derive(Debug, Error)]
+#[error("{0}")]
+pub struct BalanceLeafError(String);
+
 pub fn get_signable_state_root(
     channel_id: &[u8],
     balance_root: &[u8; 32],
-) -> Result<[u8; 32], Box<dyn Error>> {
+) -> [u8; 32] {
     let tokens = [
         Token::FixedBytes(channel_id.to_vec()),
         Token::FixedBytes(balance_root.to_vec()),
@@ -39,18 +42,18 @@ pub fn get_signable_state_root(
     let mut res: [u8; 32] = [0; 32];
     result.finalize(&mut res);
 
-    Ok(res)
+    res
 }
 
 pub fn get_balance_leaf(
     is_spender: bool,
     acc: &Address,
     amnt: &BigNum,
-) -> Result<[u8; 32], Box<dyn Error>> {
+) -> Result<[u8; 32], BalanceLeafError> {
     let address = Token::Address(EthAddress::from_slice(acc.as_bytes()));
     let amount = Token::Uint(
         U256::from_dec_str(&amnt.to_str_radix(10))
-            .map_err(|_| ChannelError::InvalidArgument("failed to parse amt".into()))?,
+            .map_err(|_| BalanceLeafError("Failed to parse amt".into()))?,
     );
 
     let tokens = if is_spender {
@@ -95,8 +98,7 @@ mod test {
         let state_root = get_signable_state_root(
             &hex::decode(&channel_id).expect("failed"),
             &merkle_tree.root(),
-        )
-        .expect("Should get state_root");
+        );
 
         let expected_hex =
             hex::decode("b68cde9b0c8b63ac7152e78a65c736989b4b99bfc252758b1c3fd6ca357e0d6b")

primitives/src/adapter.rs

@@ -89,7 +89,7 @@ pub trait Adapter: Send + Sync + fmt::Debug + Clone {
     /// Verify, based on the signature & state_root, that the signer is the same
     fn verify(
         &self,
-        signer: &ValidatorId,
+        signer: ValidatorId,
         state_root: &str,
         signature: &str,
     ) -> AdapterResult<bool, Self::AdapterError>;

validator_worker/src/channel.rs

@@ -1,11 +1,10 @@
 use crate::{
     error::{Error, TickError},
-    follower,
+    follower, leader,
     sentry_interface::{campaigns::all_campaigns, Validator, Validators},
     SentryApi,
 };
 use primitives::{adapter::Adapter, channel_v5::Channel, config::Config, util::ApiUrl, ChannelId};
-// use slog::{error, info, Logger};
 use slog::Logger;
 use std::collections::{hash_map::Entry, HashSet};
 
@@ -15,27 +14,22 @@ pub async fn channel_tick<A: Adapter + 'static>(
     logger: &Logger,
     channel: Channel,
     validators: Validators,
-) -> Result<ChannelId, Error<A::AdapterError>> {
+) -> Result<ChannelId, Error> {
     let tick = channel
         .find_validator(adapter.whoami())
         .ok_or(Error::ChannelNotIntendedForUs)?;
 
-    let sentry = SentryApi::init(
-        adapter,
-        logger.clone(),
-        config.clone(),
-        (channel, validators),
-    )?;
-    // `GET /channel/:id/spender/all`
-    let all_spenders = sentry.get_all_spenders().await?;
+    let sentry = SentryApi::init(adapter, logger.clone(), config.clone(), validators)?;
+    // 1. `GET /channel/:id/spender/all`
+    let all_spenders = sentry.get_all_spenders(channel.id()).await?;
 
-    // `GET /channel/:id/accounting`
+    // 2. `GET /channel/:id/accounting`
     // Validation #1:
     // sum(Accounting.spenders) == sum(Accounting.earners)
     let accounting = sentry.get_accounting(channel.id()).await?;
 
     // Validation #2:
-    // spender.spender_leaf.total_deposit >= accounting.balances.spenders[spender.address]
+    // spender.total_deposit >= accounting.balances.spenders[spender.address]
     if !all_spenders.iter().all(|(address, spender)| {
         spender.total_deposited
             >= accounting
@@ -48,22 +42,28 @@ pub async fn channel_tick<A: Adapter + 'static>(
         return Err(Error::Validation);
     }
 
+    let token = config
+        .token_address_whitelist
+        .get(&channel.token)
+        .ok_or(Error::ChannelTokenNotWhitelisted)?;
+
     // TODO: Add timeout
-    let _tick_result = match tick {
-        primitives::Validator::Leader(_v) => todo!(),
-        primitives::Validator::Follower(_v) => {
-            follower::tick(&sentry, channel, accounting.balances)
+    match tick {
+        primitives::Validator::Leader(_v) => {
+            let _leader_tick_status = leader::tick(&sentry, channel, accounting.balances, token)
                 .await
-                .map_err(|err| Error::FollowerTick(channel.id(), TickError::Tick(err)))?
+                .map_err(|err| Error::LeaderTick(channel.id(), TickError::Tick(Box::new(err))))?;
+        }
+        primitives::Validator::Follower(_v) => {
+            let _follower_tick_status =
+                follower::tick(&sentry, channel, all_spenders, accounting.balances, token)
+                    .await
+                    .map_err(|err| {
+                        Error::FollowerTick(channel.id(), TickError::Tick(Box::new(err)))
+                    })?;
         }
     };
 
-    // Validation #3
-    // Accounting.balances != NewState.balances
-
-    // Validation #4
-    // OUTPACE Rules:
-
     Ok(channel.id())
 }