Merge pull request #389 from AdExNetwork/aip-61-all-around-generic-changes

AIP #61 v5: All around generic changes

Author: elpiel

Cargo.lock

@@ -6,13 +6,13 @@ use std::error::Error;
 
 use chrono::{DateTime, Utc};
 use hex::FromHex;
-use primitives::{channel::ChannelError, BigNum, Channel, ValidatorId};
+use primitives::{channel::ChannelError, Address, BigNum, Channel, ValidatorId};
 use sha2::{Digest, Sha256};
 use std::convert::TryFrom;
 use tiny_keccak::Keccak;
 use web3::{
     ethabi::{encode, token::Token},
-    types::{Address, U256},
+    types::{Address as EthAddress, U256},
 };
 
 pub use self::dummy::DummyAdapter;
@@ -46,9 +46,9 @@ pub fn get_signable_state_root(
     Ok(res)
 }
 
-pub fn get_balance_leaf(acc: &ValidatorId, amnt: &BigNum) -> Result<[u8; 32], Box<dyn Error>> {
+pub fn get_balance_leaf(acc: &Address, amnt: &BigNum) -> Result<[u8; 32], Box<dyn Error>> {
     let tokens = [
-        Token::Address(Address::from_slice(acc.inner())),
+        Token::Address(EthAddress::from_slice(acc.as_bytes())),
         Token::Uint(
             U256::from_dec_str(&amnt.to_str_radix(10))
                 .map_err(|_| ChannelError::InvalidArgument("failed to parse amt".into()))?,
@@ -67,11 +67,11 @@ pub fn get_balance_leaf(acc: &ValidatorId, amnt: &BigNum) -> Result<[u8; 32], Bo
 
 // OnChain channel Representation
 pub struct EthereumChannel {
-    pub creator: Address,
-    pub token_addr: Address,
+    pub creator: EthAddress,
+    pub token_addr: EthAddress,
     pub token_amount: U256,
     pub valid_until: U256,
-    pub validators: Vec<Address>,
+    pub validators: Vec<EthAddress>,
     pub spec: [u8; 32],
 }
 
@@ -121,16 +121,16 @@ impl EthereumChannel {
             return Err(ChannelError::InvalidArgument("invalid token amount".into()));
         }
 
-        let creator = Address::from_slice(creator);
-        let token_addr = Address::from_slice(token_addr);
+        let creator = EthAddress::from_slice(creator);
+        let token_addr = EthAddress::from_slice(token_addr);
         let token_amount = U256::from_dec_str(&token_amount)
             .map_err(|_| ChannelError::InvalidArgument("failed to parse token amount".into()))?;
         let valid_until = U256::from_dec_str(&valid_until.timestamp().to_string())
             .map_err(|_| ChannelError::InvalidArgument("failed to parse valid until".into()))?;
 
         let validators = validators
             .iter()
-            .map(|v| Address::from_slice(v.inner()))
+            .map(|v| EthAddress::from_slice(v.as_bytes()))
             .collect();
 
         Ok(Self {
@@ -145,7 +145,7 @@ impl EthereumChannel {
 
     pub fn hash(&self, contract_addr: &[u8; 20]) -> [u8; 32] {
         let tokens = [
-            Token::Address(Address::from_slice(contract_addr)),
+            Token::Address(EthAddress::from_slice(contract_addr)),
             Token::Address(self.creator.to_owned()),
             Token::Address(self.token_addr.to_owned()),
             Token::Uint(self.token_amount.to_owned()),

adapter/src/lib.rs

@@ -25,6 +25,7 @@ slog-async = "^2.3.0"
 thiserror = "^1.0"
 chrono = { version = "0.4", features = ["serde"] }
 time = "0.1.42"
+uuid = { version = "0.8", features = ["v4"] }
 # For encoding the Channel to a ChannelId
 ethabi = "13.0.0"
 # For the nonce U256

primitives/Cargo.toml

@@ -1,6 +1,6 @@
 use hex::{FromHex, FromHexError};
 use serde::{Deserialize, Serialize, Serializer};
-use std::{convert::TryFrom, fmt};
+use std::{convert::TryFrom, fmt, str::FromStr};
 use thiserror::Error;
 
 use crate::{targeting::Value, DomainError, ToETHChecksum, ToHex};
@@ -29,6 +29,10 @@ impl Address {
     pub fn as_bytes(&self) -> &[u8; 20] {
         &self.0
     }
+
+    pub fn from_bytes(bytes: &[u8; 20]) -> Self {
+        Self(*bytes)
+    }
 }
 
 impl Serialize for Address {
@@ -67,6 +71,14 @@ impl AsRef<[u8]> for Address {
     }
 }
 
+impl FromStr for Address {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(from_bytes(s, Prefix::Insensitive)?))
+    }
+}
+
 impl TryFrom<&str> for Address {
     type Error = Error;
 
@@ -83,6 +95,14 @@ impl TryFrom<&String> for Address {
     }
 }
 
+impl TryFrom<&[u8]> for Address {
+    type Error = Error;
+
+    fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
+        Ok(Self(from_bytes(slice, Prefix::Insensitive)?))
+    }
+}
+
 impl TryFrom<Value> for Address {
     type Error = DomainError;
 
@@ -135,3 +155,46 @@ pub fn from_bytes<T: AsRef<[u8]>>(from: T, prefix: Prefix) -> Result<[u8; 20], E
         _ => Err(Error::Length),
     }
 }
+
+#[cfg(feature = "postgres")]
+pub mod postgres {
+    use super::Address;
+    use crate::ToETHChecksum;
+    use bytes::BytesMut;
+    use postgres_types::{FromSql, IsNull, ToSql, Type};
+    use std::error::Error;
+
+    impl<'a> FromSql<'a> for Address {
+        fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
+            let str_slice = <&str as FromSql>::from_sql(ty, raw)?;
+
+            Ok(str_slice.parse()?)
+        }
+
+        fn accepts(ty: &Type) -> bool {
+            matches!(*ty, Type::TEXT | Type::VARCHAR)
+        }
+    }
+
+    impl ToSql for Address {
+        fn to_sql(
+            &self,
+            ty: &Type,
+            w: &mut BytesMut,
+        ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+            self.to_checksum().to_sql(ty, w)
+        }
+
+        fn accepts(ty: &Type) -> bool {
+            <String as ToSql>::accepts(ty)
+        }
+
+        fn to_sql_checked(
+            &self,
+            ty: &Type,
+            out: &mut BytesMut,
+        ) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
+            self.to_checksum().to_sql_checked(ty, out)
+        }
+    }
+}

primitives/src/address.rs

@@ -1,46 +1,58 @@
-use std::collections::BTreeMap;
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::{
+        btree_map::{Entry, IntoIter, Iter, Values},
+        BTreeMap,
+    },
+    iter::FromIterator,
+    ops::Index,
+};
 
-use crate::{BigNum, ValidatorId};
-use std::collections::btree_map::{Entry, IntoIter, Iter, Values};
+use crate::{Address, BigNum, UnifiedNum};
 
-use serde::{Deserialize, Serialize};
-use std::iter::FromIterator;
-use std::ops::Index;
+pub type UnifiedMap = Map<Address, UnifiedNum>;
+pub type BalancesMap = Map<Address, BigNum>;
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(transparent)]
-pub struct BalancesMap(BTreeMap<ValidatorId, BigNum>);
+pub struct Map<K: Ord, V>(BTreeMap<K, V>);
+
+impl<K: Ord, V> Default for Map<K, V> {
+    fn default() -> Self {
+        Map(BTreeMap::default())
+    }
+}
 
-impl Index<&'_ ValidatorId> for BalancesMap {
-    type Output = BigNum;
+impl<K: Ord, V> Index<&'_ K> for Map<K, V> {
+    type Output = V;
 
-    fn index(&self, index: &ValidatorId) -> &Self::Output {
+    fn index(&self, index: &K) -> &Self::Output {
         self.0.index(index)
     }
 }
 
-impl BalancesMap {
-    pub fn iter(&self) -> Iter<'_, ValidatorId, BigNum> {
+impl<K: Ord, V> Map<K, V> {
+    pub fn iter(&self) -> Iter<'_, K, V> {
         self.0.iter()
     }
 
-    pub fn values(&self) -> Values<'_, ValidatorId, BigNum> {
+    pub fn values(&self) -> Values<'_, K, V> {
         self.0.values()
     }
 
-    pub fn get(&self, key: &ValidatorId) -> Option<&BigNum> {
+    pub fn get(&self, key: &K) -> Option<&V> {
         self.0.get(key)
     }
 
-    pub fn contains_key(&self, key: &ValidatorId) -> bool {
+    pub fn contains_key(&self, key: &K) -> bool {
         self.0.contains_key(key)
     }
 
-    pub fn entry(&mut self, key: ValidatorId) -> Entry<'_, ValidatorId, BigNum> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
         self.0.entry(key)
     }
 
-    pub fn insert(&mut self, key: ValidatorId, value: BigNum) -> Option<BigNum> {
+    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
         self.0.insert(key, value)
     }
 
@@ -53,18 +65,18 @@ impl BalancesMap {
     }
 }
 
-impl FromIterator<(ValidatorId, BigNum)> for BalancesMap {
-    fn from_iter<I: IntoIterator<Item = (ValidatorId, BigNum)>>(iter: I) -> Self {
+impl<K: Ord, V> FromIterator<(K, V)> for Map<K, V> {
+    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
         // @TODO: Is there better way to do this?
-        let btree_map: BTreeMap<ValidatorId, BigNum> = iter.into_iter().collect();
+        let btree_map: BTreeMap<K, V> = iter.into_iter().collect();
 
-        BalancesMap(btree_map)
+        Map(btree_map)
     }
 }
 
-impl IntoIterator for BalancesMap {
-    type Item = (ValidatorId, BigNum);
-    type IntoIter = IntoIter<ValidatorId, BigNum>;
+impl<K: Ord, V> IntoIterator for Map<K, V> {
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
@@ -73,42 +85,73 @@ impl IntoIterator for BalancesMap {
 
 #[cfg(test)]
 mod test {
+    use serde_json::json;
+
     use super::*;
-    use crate::util::tests::prep_db::IDS;
-    use crate::BigNum;
+    use crate::util::tests::prep_db::ADDRESSES;
 
     #[test]
-    fn test_balances_map_serialization() {
-        let data = vec![
-            (IDS["leader"].clone(), BigNum::from(50_u64)),
-            (IDS["follower"].clone(), BigNum::from(100_u64)),
-        ];
+    fn test_unified_map_de_serialization() {
+        let unified_map: UnifiedMap = vec![
+            (ADDRESSES["leader"].clone(), UnifiedNum::from(50_u64)),
+            (ADDRESSES["follower"].clone(), UnifiedNum::from(100_u64)),
+        ]
+        .into_iter()
+        .collect();
+
+        let actual_json = serde_json::to_value(&unified_map).expect("Should serialize it");
+        let expected_json = json!({
+            "0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3":100,
+            "0xce07CbB7e054514D590a0262C93070D838bFBA2e":50
+        });
 
-        let balances_map: BalancesMap = data.into_iter().collect();
+        assert_eq!(expected_json, actual_json);
+
+        let balances_map_from_json: UnifiedMap =
+            serde_json::from_value(actual_json).expect("Should deserialize it");
+
+        assert_eq!(unified_map, balances_map_from_json);
+    }
+
+    #[test]
+    fn test_balances_map_de_serialization() {
+        let balances_map: BalancesMap = vec![
+            (ADDRESSES["leader"].clone(), BigNum::from(50_u64)),
+            (ADDRESSES["follower"].clone(), BigNum::from(100_u64)),
+        ]
+        .into_iter()
+        .collect();
 
-        let actual_json = serde_json::to_string(&balances_map).expect("Should serialize it");
-        let expected_json = r#"{"0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3":"100","0xce07CbB7e054514D590a0262C93070D838bFBA2e":"50"}"#;
+        let actual_json = serde_json::to_value(&balances_map).expect("Should serialize it");
+        let expected_json = json!({
+            "0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3":"100",
+            "0xce07CbB7e054514D590a0262C93070D838bFBA2e":"50"
+        });
 
         assert_eq!(expected_json, actual_json);
 
         let balances_map_from_json: BalancesMap =
-            serde_json::from_str(&actual_json).expect("Should deserialize it");
+            serde_json::from_value(actual_json).expect("Should deserialize it");
 
         assert_eq!(balances_map, balances_map_from_json);
     }
 
     #[test]
     fn test_balances_map_deserialization_with_same_keys() {
         // the first is ETH Checksummed, the second is lowercase!
-        let json = r#"{"0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3":"100","0xc91763d7f14ac5c5ddfbcd012e0d2a61ab9bded3":"20","0xce07CbB7e054514D590a0262C93070D838bFBA2e":"50"}"#;
+        let json = json!({
+            "0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3":"100",
+            "0xc91763d7f14ac5c5ddfbcd012e0d2a61ab9bded3":"20",
+            "0xce07CbB7e054514D590a0262C93070D838bFBA2e":"50"
+        });
 
         let actual_deserialized: BalancesMap =
-            serde_json::from_str(&json).expect("Should deserialize it");
+            serde_json::from_value(json).expect("Should deserialize it");
 
         let expected_deserialized: BalancesMap = vec![
-            (IDS["leader"].clone(), BigNum::from(50_u64)),
+            (ADDRESSES["leader"].clone(), BigNum::from(50_u64)),
             // only the second should be accepted, as it appears second in the string and it's the latest one
-            (IDS["follower"].clone(), BigNum::from(20_u64)),
+            (ADDRESSES["follower"].clone(), BigNum::from(20_u64)),
         ]
         .into_iter()
         .collect();