Merge branch 'dev' into cfg-route

Author: elpiel

adapter/src/dummy.rs

@@ -70,7 +70,7 @@ impl Adapter for DummyAdapter {
         }
     }
 
-    fn session_from_token(&mut self, token: &str) -> AdapterResult<Session> {
+    fn session_from_token(&self, token: &str) -> AdapterResult<Session> {
         let identity = self
             .authorization_tokens
             .iter()

adapter/src/ethereum.rs

@@ -38,8 +38,6 @@ pub struct EthereumAdapter {
     keystore_json: Value,
     keystore_pwd: Password,
     config: Config,
-    // Auth tokens that we have verified (tokenId => session)
-    session_tokens: HashMap<String, Session>,
     // Auth tokens that we've generated to authenticate with someone (address => token)
     authorization_tokens: HashMap<String, String>,
     wallet: Option<SafeAccount>,
@@ -72,7 +70,6 @@ impl EthereumAdapter {
             address,
             keystore_json,
             keystore_pwd: opts.keystore_pwd.into(),
-            session_tokens: HashMap::new(),
             authorization_tokens: HashMap::new(),
             wallet: None,
             config: config.to_owned(),
@@ -164,15 +161,11 @@ impl Adapter for EthereumAdapter {
         Ok(true)
     }
 
-    fn session_from_token(&mut self, token: &str) -> AdapterResult<Session> {
+    /// Creates a `Session` from a provided Token by calling the Contract.
+    /// Does **not** cache the (`Token`, `Session`) pair.
+    fn session_from_token(&self, token: &str) -> AdapterResult<Session> {
         if token.len() < 16 {
-            return Err(AdapterError::Failed("invaild token id".to_string()));
-        }
-
-        let token_id = token[token.len() - 16..].to_string();
-
-        if let Some(token) = self.session_tokens.get(&token_id) {
-            return Ok(token.to_owned());
+            return Err(AdapterError::Failed("invalid token id".to_string()));
         }
 
         let parts: Vec<&str> = token.split('.').collect();
@@ -204,7 +197,7 @@ impl Adapter for EthereumAdapter {
                 let contract = get_contract(&self.config, contract_address, &IDENTITY_ABI)
                     .map_err(|_| map_error("failed to init identity contract"))?;
 
-                let priviledge_level: U256 = contract
+                let privilege_level: U256 = contract
                     .query(
                         "privileges",
                         verified.from.to_string(),
@@ -215,7 +208,7 @@ impl Adapter for EthereumAdapter {
                     .wait()
                     .map_err(|_| map_error("failed query priviledge level on contract"))?;
 
-                if priviledge_level == *PRIVILEGE_LEVEL_NONE {
+                if privilege_level == *PRIVILEGE_LEVEL_NONE {
                     return Err(AdapterError::Authorization(
                         "insufficient privilege".to_string(),
                     ));
@@ -231,7 +224,6 @@ impl Adapter for EthereumAdapter {
             },
         };
 
-        self.session_tokens.insert(token_id, sess.clone());
         Ok(sess)
     }
 

primitives/src/adapter.rs

@@ -81,7 +81,7 @@ pub trait Adapter: ChannelValidator + Send + Clone + Debug {
     fn validate_channel(&self, channel: &Channel) -> AdapterResult<bool>;
 
     /// Get user session from token
-    fn session_from_token(&mut self, token: &str) -> AdapterResult<Session>;
+    fn session_from_token(&self, token: &str) -> AdapterResult<Session>;
 
     /// Gets authentication for specific validator
     fn get_auth(&mut self, validator_id: &ValidatorId) -> AdapterResult<String>;

primitives/src/channel.rs

@@ -70,8 +70,8 @@ pub struct ChannelSpec {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(transparent)]
-pub struct SpecValidators([ValidatorDesc; 2]);
+/// A (leader, follower) tuple
+pub struct SpecValidators(ValidatorDesc, ValidatorDesc);
 
 pub enum SpecValidator<'a> {
     Leader(&'a ValidatorDesc),
@@ -94,15 +94,15 @@ impl<'a> SpecValidator<'a> {
 
 impl SpecValidators {
     pub fn new(leader: ValidatorDesc, follower: ValidatorDesc) -> Self {
-        Self([leader, follower])
+        Self(leader, follower)
     }
 
     pub fn leader(&self) -> &ValidatorDesc {
-        &self.0[0]
+        &self.0
     }
 
     pub fn follower(&self) -> &ValidatorDesc {
-        &self.0[1]
+        &self.1
     }
 
     pub fn find(&self, validator_id: &ValidatorId) -> SpecValidator<'_> {
@@ -116,12 +116,13 @@ impl SpecValidators {
     }
 }
 
-impl From<[ValidatorDesc; 2]> for SpecValidators {
-    fn from(slice: [ValidatorDesc; 2]) -> Self {
-        Self(slice)
+impl From<(ValidatorDesc, ValidatorDesc)> for SpecValidators {
+    fn from((leader, follower): (ValidatorDesc, ValidatorDesc)) -> Self {
+        Self(leader, follower)
     }
 }
 
+/// Fixed size iterator of 2, as we need an iterator in couple of occasions
 impl<'a> IntoIterator for &'a SpecValidators {
     type Item = &'a ValidatorDesc;
     type IntoIter = ::std::vec::IntoIter<Self::Item>;

primitives/src/lib.rs

@@ -15,7 +15,15 @@ pub mod market_channel;
 pub mod merkle_tree;
 pub mod sentry;
 pub mod targeting_tag;
-pub mod util;
+pub mod util {
+    pub mod tests {
+        pub mod prep_db;
+        pub mod time;
+    }
+
+    pub mod logging;
+    pub mod serde;
+}
 pub mod validator;
 
 pub use self::ad_unit::AdUnit;

primitives/src/merkle_tree.rs

@@ -53,16 +53,19 @@ impl Algorithm<MerkleItem> for KeccakAlgorithm {
     }
 
     fn node(&mut self, left: MerkleItem, right: MerkleItem, _height: usize) -> MerkleItem {
-        let left_vec: Vec<u8> = left.to_vec();
-        let right_vec: Vec<u8> = right.to_vec();
-
-        let mut node_vec = vec![left_vec, right_vec];
-        node_vec.sort();
-
-        let flatten_node_vec: Vec<u8> = node_vec.into_iter().flatten().collect();
+        // This is a check for odd number of leaves items
+        // left == right since the right is a duplicate of left
+        // return the item unencoded as the JS impl
+        if left == right {
+            left
+        } else {
+            let mut node_vec = vec![left.to_vec(), right.to_vec()];
+            node_vec.sort();
 
-        self.write(&flatten_node_vec);
-        self.hash()
+            let flatten_node_vec: Vec<u8> = node_vec.into_iter().flatten().collect();
+            self.write(&flatten_node_vec);
+            self.hash()
+        }
     }
 }
 
@@ -183,4 +186,36 @@ mod test {
 
         assert_eq!(verify, true, "should verify proof successfully");
     }
+
+    #[test]
+    fn it_generates_correct_merkle_tree_with_odd_leaves() {
+        let h1 = <[u8; 32]>::from_hex(
+            "13c21db99584c9bb3e9ad98061f6ca39364049b328b74822be6303a4da18014d",
+        )
+        .unwrap();
+        let h2 = <[u8; 32]>::from_hex(
+            "b1bea7b8b58cd47d475bfe07dbe6df33f50f7a76957c51cebe8254257542fd7d",
+        )
+        .unwrap();
+
+        let h3 = <[u8; 32]>::from_hex(
+            "c455ef23d4db0091e1e25ef5d652a2832a1fc4fa82b8e66c290a692836e0cbe6",
+        )
+        .unwrap();
+
+        // odd leaves
+        let top = MerkleTree::new(&[h1, h2, h3]);
+
+        let root = hex::encode(&top.root());
+
+        assert_eq!(
+            root, "e68ea33571084e5dea276b089a10fa7be9d59accf3d7838c0d9b050bf72634a1",
+            "should generate the correct root"
+        );
+
+        let proof = top.proof(0);
+        let verify = top.verify(proof);
+
+        assert_eq!(verify, true, "should verify proof successfully");
+    }
 }