Merge pull request #240 from AdExNetwork/issue-235-checksummed-validator_id

Issue #235 checksummed validator

Author: elpiel

adapter/src/dummy.rs

@@ -2,7 +2,7 @@ use futures::future::{BoxFuture, FutureExt};
 use primitives::adapter::{Adapter, AdapterError, AdapterResult, DummyAdapterOptions, Session};
 use primitives::channel_validator::ChannelValidator;
 use primitives::config::Config;
-use primitives::{Channel, ValidatorId};
+use primitives::{Channel, ToETHChecksum, ValidatorId};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone)]
@@ -43,7 +43,7 @@ impl Adapter for DummyAdapter {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
             state_root,
-            self.whoami().to_hex_checksummed_string()
+            self.whoami().to_checksum()
         );
         Ok(signature)
     }
@@ -57,7 +57,7 @@ impl Adapter for DummyAdapter {
         // 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() {
-            Some(from) => from == signer.to_hex_checksummed_string(),
+            Some(from) => from == signer.to_checksum(),
             None => false,
         };
 

adapter/src/ethereum.rs

@@ -13,7 +13,7 @@ use primitives::{
     adapter::{Adapter, AdapterError, AdapterResult, KeystoreOptions, Session},
     channel_validator::ChannelValidator,
     config::Config,
-    Channel, ValidatorId,
+    Channel, ToETHChecksum, ValidatorId,
 };
 use serde::{Deserialize, Serialize};
 use serde_hex::{SerHexOpt, StrictPfx};
@@ -211,7 +211,7 @@ impl Adapter for EthereumAdapter {
             let verified = ewt_verify(header_encoded, payload_encoded, token_encoded)
                 .map_err(|e| map_error(&e.to_string()))?;
 
-            if self.whoami().to_hex_checksummed_string() != verified.payload.id {
+            if self.whoami().to_checksum() != verified.payload.id {
                 return Err(AdapterError::Configuration(
                     "token payload.id !== whoami(): token was not intended for us".to_string(),
                 ));
@@ -265,10 +265,10 @@ impl Adapter for EthereumAdapter {
 
         let era = Utc::now().timestamp_millis() as f64 / 60000.0;
         let payload = Payload {
-            id: validator.to_hex_checksummed_string(),
+            id: validator.to_checksum(),
             era: era.floor() as i64,
             identity: None,
-            address: self.whoami().to_hex_checksummed_string(),
+            address: self.whoami().to_checksum(),
         };
 
         ewt_sign(&wallet, &self.keystore_pwd, &payload)
@@ -424,7 +424,7 @@ mod test {
         let whoami = eth_adapter.whoami();
         assert_eq!(
             whoami.to_string(),
-            "0x2bdeafae53940669daa6f519373f686c1f3d3393",
+            "0x2bDeAFAE53940669DaA6F519373f686c1f3d3393",
             "failed to get correct whoami"
         );
 
@@ -460,7 +460,7 @@ mod test {
         let payload = Payload {
             id: "awesomeValidator".into(),
             era: 100_000,
-            address: eth_adapter.whoami().to_hex_checksummed_string(),
+            address: eth_adapter.whoami().to_checksum(),
             identity: None,
         };
         let wallet = eth_adapter.wallet.clone();
@@ -542,7 +542,7 @@ mod test {
             .expect("Failed to set balance");
 
         let leader_validator_desc = ValidatorDesc {
-            // keystore.json addresss (same with js)
+            // keystore.json address (same with js)
             id: ValidatorId::try_from("2bdeafae53940669daa6f519373f686c1f3d3393")
                 .expect("failed to create id"),
             url: "http://localhost:8005".to_string(),
@@ -551,7 +551,7 @@ mod test {
         };
 
         let follower_validator_desc = ValidatorDesc {
-            // keystore2.json addresss (same with js)
+            // keystore2.json address (same with js)
             id: ValidatorId::try_from("6704Fbfcd5Ef766B287262fA2281C105d57246a6")
                 .expect("failed to create id"),
             url: "http://localhost:8006".to_string(),
@@ -605,7 +605,7 @@ mod test {
             .expect("open channel");
 
         let contract_addr = <[u8; 20]>::from_hex(&format!("{:?}", adex_contract.address())[2..])
-            .expect("failed to deserialise contract addr");
+            .expect("failed to deserialize contract addr");
 
         let channel_id = eth_channel.hash(&contract_addr).expect("hash hex");
         // set id to proper id
@@ -669,7 +669,7 @@ mod test {
             .expect("failed to deserialize address");
 
         let payload = Payload {
-            id: eth_adapter.whoami().to_hex_checksummed_string(),
+            id: eth_adapter.whoami().to_checksum(),
             era: 100_000,
             address: format!("{:?}", leader_account),
             identity: Some(identity),

primitives/src/balances_map.rs

@@ -1,5 +1,93 @@
 use std::collections::BTreeMap;
 
-use crate::BigNum;
+use crate::{BigNum, ValidatorId};
+use std::collections::btree_map::{Entry, Iter, Values};
 
-pub type BalancesMap = BTreeMap<String, BigNum>;
+use serde::{ser::SerializeMap, Deserialize, Serialize, Serializer};
+use std::iter::FromIterator;
+use std::ops::Index;
+
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
+#[serde(transparent)]
+pub struct BalancesMap(BTreeMap<ValidatorId, BigNum>);
+
+impl Index<&'_ ValidatorId> for BalancesMap {
+    type Output = BigNum;
+
+    fn index(&self, index: &ValidatorId) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+
+impl BalancesMap {
+    pub fn iter(&self) -> Iter<'_, ValidatorId, BigNum> {
+        self.0.iter()
+    }
+
+    pub fn values(&self) -> Values<'_, ValidatorId, BigNum> {
+        self.0.values()
+    }
+
+    pub fn get(&self, key: &ValidatorId) -> Option<&BigNum> {
+        self.0.get(key)
+    }
+
+    pub fn entry(&mut self, key: ValidatorId) -> Entry<'_, ValidatorId, BigNum> {
+        self.0.entry(key)
+    }
+
+    pub fn insert(&mut self, key: ValidatorId, value: BigNum) -> Option<BigNum> {
+        self.0.insert(key, value)
+    }
+}
+
+impl FromIterator<(ValidatorId, BigNum)> for BalancesMap {
+    fn from_iter<I: IntoIterator<Item = (ValidatorId, BigNum)>>(iter: I) -> Self {
+        // @TODO: Is there better way to do this?
+        let btree_map: BTreeMap<ValidatorId, BigNum> = iter.into_iter().collect();
+
+        BalancesMap(btree_map)
+    }
+}
+
+impl Serialize for BalancesMap {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(self.0.len()))?;
+
+        for (key, big_num) in self.0.iter() {
+            map.serialize_entry(&key.to_hex_prefix_string(), big_num)?;
+        }
+        map.end()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::util::tests::prep_db::IDS;
+    use crate::BigNum;
+
+    #[test]
+    fn test_balances_map_serialization() {
+        let data = vec![
+            (IDS["leader"].clone(), BigNum::from(50_u64)),
+            (IDS["follower"].clone(), BigNum::from(100_u64)),
+        ];
+
+        let balances_map: BalancesMap = data.into_iter().collect();
+
+        let actual_json = serde_json::to_string(&balances_map).expect("Should serialize it");
+        // should be all lowercase!
+        let expected_json = r#"{"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");
+
+        assert_eq!(balances_map, balances_map_from_json);
+    }
+}

primitives/src/lib.rs

@@ -55,3 +55,11 @@ impl error::Error for DomainError {
         None
     }
 }
+
+/// Trait that creates a String which is `0x` prefixed and encodes the bytes by `eth_checksum`
+pub trait ToETHChecksum: AsRef<[u8]> {
+    fn to_checksum(&self) -> String {
+        // checksum replaces `0x` prefix and adds one itself
+        eth_checksum::checksum(&hex::encode(self.as_ref()))
+    }
+}

primitives/src/sentry.rs

@@ -32,7 +32,7 @@ pub struct ApproveStateValidatorMessage {
 pub enum Event {
     #[serde(rename_all = "camelCase")]
     Impression {
-        publisher: String,
+        publisher: ValidatorId,
         ad_unit: Option<String>,
     },
     Click {
@@ -74,8 +74,8 @@ pub struct EventAggregate {
 #[serde(rename_all = "camelCase")]
 pub struct AggregateEvents {
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub event_counts: Option<HashMap<String, BigNum>>,
-    pub event_payouts: HashMap<String, BigNum>,
+    pub event_counts: Option<HashMap<ValidatorId, BigNum>>,
+    pub event_payouts: HashMap<ValidatorId, BigNum>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

primitives/src/validator.rs

@@ -1,9 +1,9 @@
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, Serializer};
 use serde_hex::{SerHex, StrictPfx};
 use std::fmt;
 
-use crate::{BalancesMap, BigNum, DomainError};
+use crate::{BalancesMap, BigNum, DomainError, ToETHChecksum};
 use std::convert::TryFrom;
 
 #[derive(Debug)]
@@ -14,7 +14,7 @@ pub enum ValidatorError {
     InvalidTransition,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[serde(transparent)]
 pub struct ValidatorId(#[serde(with = "SerHex::<StrictPfx>")] [u8; 20]);
 
@@ -23,12 +23,26 @@ impl ValidatorId {
         &self.0
     }
 
+    /// To Hex non-`0x` prefixed string without **Checksum**ing the string
     pub fn to_hex_non_prefix_string(&self) -> String {
         hex::encode(self.0)
     }
 
-    pub fn to_hex_checksummed_string(&self) -> String {
-        eth_checksum::checksum(&format!("0x{}", self.to_hex_non_prefix_string()))
+    /// To Hex `0x` prefixed string **without** __Checksum__ing the string
+    pub fn to_hex_prefix_string(&self) -> String {
+        format!("0x{}", self.to_hex_non_prefix_string())
+    }
+}
+
+impl ToETHChecksum for ValidatorId {}
+
+impl Serialize for ValidatorId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let checksum = self.to_checksum();
+        serializer.serialize_str(&checksum)
     }
 }
 
@@ -79,7 +93,7 @@ impl TryFrom<&String> for ValidatorId {
 
 impl fmt::Display for ValidatorId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", format!("0x{}", self.to_hex_non_prefix_string()))
+        write!(f, "{}", self.to_checksum())
     }
 }
 
@@ -207,3 +221,19 @@ pub mod postgres {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn validator_id_is_checksummed_when_serialized() {
+        let validator_id_checksum_str = "0xce07CbB7e054514D590a0262C93070D838bFBA2e";
+
+        let validator_id =
+            ValidatorId::try_from(validator_id_checksum_str).expect("Valid string was provided");
+        let actual_json = serde_json::to_string(&validator_id).expect("Should serialize");
+        let expected_json = format!(r#""{}""#, validator_id_checksum_str);
+        assert_eq!(expected_json, actual_json);
+    }
+}

sentry/src/access.rs

@@ -188,10 +188,11 @@ mod test {
 
         channel
     }
+
     fn get_impression_events(count: i8) -> Vec<Event> {
         (0..count)
             .map(|_| Event::Impression {
-                publisher: "working".to_string(),
+                publisher: IDS["publisher2"].clone(),
                 ad_unit: None,
             })
             .collect()