Merge branch 'dev' into supermarket-changes

Author: elpiel

Cargo.lock

@@ -225,12 +225,12 @@ mod test {
             .expect("The timestamp should be able to be converted to u64");
         BigEndian::write_uint(&mut timestamp_buf[26..], n, 6);
 
-        let merkle_tree = MerkleTree::new(&[timestamp_buf]);
+        let merkle_tree = MerkleTree::new(&[timestamp_buf]).expect("Should instantiate");
 
         let channel_id = "061d5e2a67d0a9a10f1c732bca12a676d83f79663a396f7d87b3e30b9b411088";
 
         let state_root = get_signable_state_root(
-            &hex::decode(&channel_id).expect("fialed"),
+            &hex::decode(&channel_id).expect("failed"),
             &merkle_tree.root(),
         )
         .expect("Should get state_root");

adapter/src/lib.rs

@@ -20,6 +20,7 @@ slog = { version = "^2.5.2" , features = ["max_level_trace"] }
 slog-term = "^2.4.2"
 slog-async = "^2.3.0"
 # Domain
+thiserror = "^1.0"
 chrono = { version = "0.4", features = ["serde"] }
 time = "0.1.42"
 hex = "0.3.2"

primitives/Cargo.toml

@@ -44,6 +44,10 @@ impl BalancesMap {
         self.0.insert(key, value)
     }
 
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }

primitives/src/balances_map.rs

@@ -1,14 +1,19 @@
-use merkletree::hash::Algorithm;
-use merkletree::merkle;
-use merkletree::merkle::VecStore;
-use merkletree::proof::Proof;
+use merkletree::{hash::Algorithm, merkle, merkle::VecStore, proof::Proof};
+use std::fmt;
 use std::hash::Hasher;
 use std::iter::FromIterator;
+use thiserror::Error;
 use tiny_keccak::Keccak;
 
 #[derive(Clone)]
 struct KeccakAlgorithm(Keccak);
 
+impl fmt::Debug for KeccakAlgorithm {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Keccak256 Algorithm")
+    }
+}
+
 impl KeccakAlgorithm {
     pub fn new() -> KeccakAlgorithm {
         KeccakAlgorithm(Keccak::new_keccak256())
@@ -72,39 +77,49 @@ impl Algorithm<MerkleItem> for KeccakAlgorithm {
 type ExternalMerkleTree =
     merkletree::merkle::MerkleTree<MerkleItem, KeccakAlgorithm, VecStore<MerkleItem>>;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 enum Tree {
     SingleItem(MerkleItem),
     MerkleTree(ExternalMerkleTree),
 }
 
+#[derive(Debug, Error, Eq, PartialEq)]
+pub enum Error {
+    #[error("No leaves were provided")]
+    ZeroLeaves,
+}
+
+#[derive(Debug)]
 pub struct MerkleTree {
     tree: Tree,
     root: MerkleItem,
 }
 
 impl MerkleTree {
-    pub fn new(data: &[MerkleItem]) -> MerkleTree {
+    pub fn new(data: &[MerkleItem]) -> Result<MerkleTree, Error> {
         let mut leaves: Vec<MerkleItem> = data.to_owned();
-
-        let tree: Tree = if leaves.len() == 1 {
-            Tree::SingleItem(leaves[0].to_owned())
-        } else {
-            // sort the merkle tree leaves
-            leaves.sort();
-            // remove duplicates
-            leaves.dedup_by(|a, b| a == b);
-
-            let merkletree = merkle::MerkleTree::from_iter(leaves);
-            Tree::MerkleTree(merkletree)
+        // sort the MerkleTree leaves
+        leaves.sort();
+        // remove duplicates **before** we check the leaves length
+        leaves.dedup_by(|a, b| a == b);
+
+        let tree = match leaves.len() {
+            0 => return Err(Error::ZeroLeaves),
+            // should never `panic!`, we have a single leaf after all
+            1 => Tree::SingleItem(leaves.remove(0)),
+            _ => {
+                let merkletree = merkle::MerkleTree::from_iter(leaves);
+
+                Tree::MerkleTree(merkletree)
+            }
         };
 
         let root: MerkleItem = match &tree {
             Tree::SingleItem(root) => root.to_owned(),
             Tree::MerkleTree(merkletree) => merkletree.root(),
         };
 
-        MerkleTree { tree, root }
+        Ok(MerkleTree { tree, root })
     }
 
     pub fn root(&self) -> MerkleItem {
@@ -134,6 +149,12 @@ mod test {
     use super::*;
     use hex::FromHex;
 
+    #[test]
+    fn it_returns_error_on_zero_leaves() {
+        let error = MerkleTree::new(&[]).expect_err("ZeroLeaves error expected");
+        assert_eq!(Error::ZeroLeaves, error);
+    }
+
     #[test]
     fn it_generates_correct_merkle_tree_that_correlates_with_js_impl() {
         let h1 = <[u8; 32]>::from_hex(
@@ -145,7 +166,7 @@ mod test {
         )
         .unwrap();
 
-        let top = MerkleTree::new(&[h1, h2]);
+        let top = MerkleTree::new(&[h1, h2]).expect("Should create MerkleTree");
 
         let root = hex::encode(&top.root());
 
@@ -172,7 +193,7 @@ mod test {
         .unwrap();
 
         // duplicate leaves
-        let top = MerkleTree::new(&[h1, h2, h2]);
+        let top = MerkleTree::new(&[h1, h2, h2]).expect("Should create MerkleTree");
 
         let root = hex::encode(&top.root());
 
@@ -204,7 +225,7 @@ mod test {
         .unwrap();
 
         // odd leaves
-        let top = MerkleTree::new(&[h1, h2, h3]);
+        let top = MerkleTree::new(&[h1, h2, h3]).expect("Should create MerkleTree");
 
         let root = hex::encode(&top.root());
 

primitives/src/merkle_tree.rs

@@ -6,6 +6,7 @@ use chrono::Utc;
 use std::collections::HashMap;
 
 pub use eval::*;
+use serde_json::Number;
 
 mod eval;
 
@@ -24,6 +25,7 @@ impl Input {
         let spec = &self.global.channel.spec;
 
         match key {
+            // AdView scope, accessible only on the AdView
             "adView.secondsSinceCampaignImpression" => self
                 .ad_view
                 .as_ref()
@@ -34,9 +36,22 @@ impl Input {
                 .as_ref()
                 .map(|ad_view| Value::Bool(ad_view.has_custom_preferences))
                 .ok_or(Error::UnknownVariable),
+            "adView.navigatorLanguage" => self
+                .ad_view
+                .as_ref()
+                .map(|ad_view| Value::String(ad_view.navigator_language.clone()))
+                .ok_or(Error::UnknownVariable),
+            // Global scope, accessible everywhere
             "adSlotId" => Ok(Value::String(self.global.ad_slot_id.clone())),
             "adSlotType" => Ok(Value::String(self.global.ad_slot_type.clone())),
             "publisherId" => Ok(Value::String(self.global.publisher_id.to_checksum())),
+            "country" => self
+                .global
+                .country
+                .clone()
+                .ok_or(Error::UnknownVariable)
+                .map(Value::String),
+            "eventType" => Ok(Value::String(self.global.event_type.clone())),
             "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
             "userAgentOS" => self
                 .global
@@ -50,7 +65,7 @@ impl Input {
                 .clone()
                 .map(Value::String)
                 .ok_or(Error::UnknownVariable),
-
+            // Global scope, accessible everywhere, campaign-dependant
             "adUnitId" => {
                 let ipfs = self
                     .global
@@ -112,6 +127,7 @@ impl Input {
 
                 Ok(Value::BigNum(earned))
             }
+            // adSlot scope, accessible on Supermarket and AdView
             "adSlot.categories" => self
                 .ad_slot
                 .as_ref()
@@ -213,6 +229,26 @@ pub struct Output {
     pub price: HashMap<String, BigNum>,
 }
 
+impl Output {
+    fn try_get(&self, key: &str) -> Result<Value, Error> {
+        match key {
+            "show" => Ok(Value::Bool(self.show)),
+            "boost" => {
+                let boost = Number::from_f64(self.boost).ok_or(Error::TypeError)?;
+                Ok(Value::Number(boost))
+            }
+            price_key if price_key.starts_with("price.") => {
+                let price = self
+                    .price
+                    .get(price_key.trim_start_matches("price."))
+                    .ok_or(Error::UnknownVariable)?;
+                Ok(Value::BigNum(price.clone()))
+            }
+            _ => Err(Error::UnknownVariable),
+        }
+    }
+}
+
 impl From<&Channel> for Output {
     fn from(channel: &Channel) -> Self {
         let price = match &channel.spec.pricing_bounds {
@@ -325,6 +361,26 @@ mod test {
         assert!(input.try_get("adSlot.alexaRank").is_ok());
     }
 
+    #[test]
+    fn test_try_get_of_output() {
+        let output = Output {
+            show: false,
+            boost: 5.5,
+            price: vec![("one".to_string(), 100.into())].into_iter().collect(),
+        };
+
+        assert_eq!(Ok(Value::Bool(false)), output.try_get("show"));
+        assert_eq!(
+            Ok(Value::Number(
+                Number::from_f64(5.5).expect("Should make a number")
+            )),
+            output.try_get("boost")
+        );
+        assert_eq!(Ok(Value::BigNum(100.into())), output.try_get("price.one"));
+        assert_eq!(Err(Error::UnknownVariable), output.try_get("price.unknown"));
+        assert_eq!(Err(Error::UnknownVariable), output.try_get("unknown"));
+    }
+
     #[test]
     fn test_output_from_channel() {
         use crate::channel::{Pricing, PricingBounds};