Merge branch 'aip-61-adex-v5' into issue-392-get-all-spenders-info

Author: simzzz

docs/config/dev.toml

@@ -32,7 +32,7 @@ validators_whitelist = []
 
 [[token_address_whitelist]]
 # DAI
-address = '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359'
+address = '0x73967c6a0904aa032c103b4104747e88c566b1a2'
 # 1 * 10^-10 = 0.0_000_000_001
 min_token_units_for_deposit = '100000000'
 min_validator_fee = '100000000'

primitives/src/sentry/accounting.rs renamed to primitives/src/balances.rs

@@ -1,26 +1,14 @@
 use std::{convert::TryFrom, marker::PhantomData};
 
-use crate::{balances_map::UnifiedMap, channel_v5::Channel, Address, UnifiedNum};
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Deserializer, Serialize};
+use crate::{Address, UnifiedMap, UnifiedNum};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use thiserror::Error;
 
-#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct Accounting<S: BalancesState> {
-    pub channel: Channel,
-    #[serde(flatten)]
-    pub balances: Balances<S>,
-    pub updated: Option<DateTime<Utc>>,
-    pub created: DateTime<Utc>,
-}
-
 #[derive(Serialize, Debug, Clone, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
-pub struct Balances<S> {
+pub struct Balances<S: BalancesState> {
     pub earners: UnifiedMap,
     pub spenders: UnifiedMap,
-    #[serde(skip_serializing, skip_deserializing)]
     state: PhantomData<S>,
 }
 
@@ -82,6 +70,14 @@ impl<S: BalancesState> Balances<S> {
             .entry(earner)
             .or_insert_with(UnifiedNum::default);
     }
+
+    pub fn into_unchecked(self) -> Balances<UncheckedState> {
+        Balances {
+            earners: self.earners,
+            spenders: self.spenders,
+            state: PhantomData::default(),
+        }
+    }
 }
 
 #[derive(Debug, Error)]
@@ -103,15 +99,25 @@ pub enum Error {
     },
 }
 
-pub trait BalancesState {}
+pub trait BalancesState: std::fmt::Debug + Eq + Clone + Serialize + DeserializeOwned {
+    fn from_unchecked(balances: Balances<UncheckedState>) -> Result<Balances<Self>, Error>;
+}
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct CheckedState;
-impl BalancesState for CheckedState {}
+impl BalancesState for CheckedState {
+    fn from_unchecked(balances: Balances<UncheckedState>) -> Result<Balances<Self>, Error> {
+        balances.check()
+    }
+}
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct UncheckedState;
-impl BalancesState for UncheckedState {}
+impl BalancesState for UncheckedState {
+    fn from_unchecked(balances: Balances<Self>) -> Result<Balances<Self>, Error> {
+        Ok(balances)
+    }
+}
 
 impl TryFrom<Balances<UncheckedState>> for Balances<CheckedState> {
     type Error = Error;
@@ -123,82 +129,30 @@ impl TryFrom<Balances<UncheckedState>> for Balances<CheckedState> {
 
 /// This modules implements the needed non-generic structs that help with Deserialization of the `Balances<S>`
 mod de {
-    use super::*;
-
-    #[derive(Deserialize)]
-    struct DeserializeAccounting {
-        pub channel: Channel,
-        #[serde(flatten)]
-        pub balances: DeserializeBalances,
-        pub created: DateTime<Utc>,
-        pub updated: Option<DateTime<Utc>>,
-    }
+    use serde::Deserializer;
 
-    impl<'de> Deserialize<'de> for Accounting<UncheckedState> {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            let de_acc = DeserializeAccounting::deserialize(deserializer)?;
-
-            Ok(Self {
-                channel: de_acc.channel,
-                balances: Balances::<UncheckedState>::try_from(de_acc.balances)
-                    .map_err(serde::de::Error::custom)?,
-                created: de_acc.created,
-                updated: de_acc.updated,
-            })
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Accounting<CheckedState> {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            let unchecked_acc = Accounting::<UncheckedState>::deserialize(deserializer)?;
-
-            Ok(Self {
-                channel: unchecked_acc.channel,
-                balances: unchecked_acc
-                    .balances
-                    .check()
-                    .map_err(serde::de::Error::custom)?,
-                created: unchecked_acc.created,
-                updated: unchecked_acc.updated,
-            })
-        }
-    }
+    use super::*;
 
     #[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
     struct DeserializeBalances {
         pub earners: UnifiedMap,
         pub spenders: UnifiedMap,
     }
 
-    impl<'de> Deserialize<'de> for Balances<CheckedState> {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            let unchecked_balances = Balances::<UncheckedState>::deserialize(deserializer)?;
-
-            unchecked_balances.check().map_err(serde::de::Error::custom)
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Balances<UncheckedState> {
+    impl<'de, S: BalancesState> Deserialize<'de> for Balances<S> {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where
             D: Deserializer<'de>,
         {
             let deser_balances = DeserializeBalances::deserialize(deserializer)?;
 
-            Ok(Balances {
+            let unchecked_balances = Balances {
                 earners: deser_balances.earners,
                 spenders: deser_balances.spenders,
                 state: PhantomData::<UncheckedState>::default(),
-            })
+            };
+
+            S::from_unchecked(unchecked_balances).map_err(serde::de::Error::custom)
         }
     }
 

primitives/src/lib.rs

@@ -6,6 +6,7 @@ pub use self::{
     ad_slot::AdSlot,
     ad_unit::AdUnit,
     address::Address,
+    balances::Balances,
     balances_map::{BalancesMap, UnifiedMap},
     big_num::BigNum,
     campaign::{Campaign, CampaignId},
@@ -22,6 +23,7 @@ mod ad_unit;
 pub mod adapter;
 pub mod address;
 pub mod analytics;
+pub mod balances;
 pub mod balances_map;
 pub mod big_num;
 pub mod campaign;

primitives/src/sentry.rs

@@ -1,19 +1,30 @@
 use crate::{
+    balances::BalancesState,
+    channel_v5::Channel as ChannelV5,
     spender::Spender,
     validator::{ApproveState, Heartbeat, MessageTypes, NewState, Type as MessageType},
-    Address, BigNum, Channel, ChannelId, ValidatorId, IPFS,
+    Address, Balances, BigNum, Channel, ChannelId, ValidatorId, IPFS,
 };
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt, hash::Hash};
 
-pub mod accounting;
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct Accounting<S: BalancesState> {
+    pub channel: ChannelV5,
+    #[serde(flatten, bound = "S: BalancesState")]
+    pub balances: Balances<S>,
+    pub updated: Option<DateTime<Utc>>,
+    pub created: DateTime<Utc>,
+}
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
-pub struct LastApproved {
+pub struct LastApproved<S: BalancesState> {
     /// NewState can be None if the channel is brand new
-    pub new_state: Option<MessageResponse<NewState>>,
+    #[serde(bound = "S: BalancesState")]
+    pub new_state: Option<MessageResponse<NewState<S>>>,
     /// ApproveState can be None if the channel is brand new
     pub approve_state: Option<MessageResponse<ApproveState>>,
 }
@@ -54,7 +65,7 @@ pub mod message {
     }
 
     impl<T: Type> TryFrom<MessageTypes> for Message<T> {
-        type Error = MessageTypeError<T>;
+        type Error = MessageError<T>;
 
         fn try_from(value: MessageTypes) -> Result<Self, Self::Error> {
             <T as TryFrom<MessageTypes>>::try_from(value).map(Self)
@@ -82,8 +93,7 @@ pub mod message {
                     "type":"ApproveState",
                     "stateRoot":"4739522efc1e81499541621759dadb331eaf08829d6a3851b4b654dfaddc9935",
                     "signature":"0x00128a39b715e87475666c3220fc0400bf34a84d24f77571d2b4e1e88b141d52305438156e526ff4fe96b7a13e707ab2f6f3ca00bd928dabc7f516b56cfe6fd61c",
-                    "isHealthy":true,
-                    "exhausted":false
+                    "isHealthy":true
                 },
                 "received":"2021-01-05T14:00:48.549Z"
             });
@@ -97,7 +107,6 @@ pub mod message {
                     state_root: "4739522efc1e81499541621759dadb331eaf08829d6a3851b4b654dfaddc9935".to_string(),
                     signature: "0x00128a39b715e87475666c3220fc0400bf34a84d24f77571d2b4e1e88b141d52305438156e526ff4fe96b7a13e707ab2f6f3ca00bd928dabc7f516b56cfe6fd61c".to_string(),
                     is_healthy: true,
-                    exhausted: false,
                 }),
             };
 
@@ -185,8 +194,9 @@ pub struct ChannelListResponse {
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
-pub struct LastApprovedResponse {
-    pub last_approved: Option<LastApproved>,
+pub struct LastApprovedResponse<S: BalancesState> {
+    #[serde(bound = "S: BalancesState")]
+    pub last_approved: Option<LastApproved<S>>,
     /// None -> withHeartbeat=true wasn't passed
     /// Some(vec![]) (empty vec) or Some(heartbeats) - withHeartbeat=true was passed
     #[serde(default, skip_serializing_if = "Option::is_none")]

primitives/src/util/tests/prep_db.rs

@@ -43,13 +43,13 @@ lazy_static! {
         addresses
     };
 
-    // These are the real Addresses of these stablecoins, however, they are only used for testing!
+    // These are the Goerli testnet  Addresses of these stablecoins
     pub static ref TOKENS: HashMap<String, Address> = {
         let mut tokens = HashMap::new();
 
-        tokens.insert("DAI".into(), "0x6b175474e89094c44da98b954eedeac495271d0f".parse::<Address>().expect("Should parse"));
-        tokens.insert("USDT".into(), "0xdac17f958d2ee523a2206206994597c13d831ec7".parse::<Address>().expect("failed to parse id"));
-        tokens.insert("USDC".into(), "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48".parse::<Address>().expect("failed to parse id"));
+        tokens.insert("DAI".into(), "0x73967c6a0904aa032c103b4104747e88c566b1a2".parse::<Address>().expect("Should parse"));
+        tokens.insert("USDT".into(), "0x509ee0d083ddf8ac028f2a56731412edd63223b9".parse::<Address>().expect("failed to parse id"));
+        tokens.insert("USDC".into(), "0x44dcfcead37be45206af6079648988b29284b2c6".parse::<Address>().expect("failed to parse id"));
         tokens
     };