Merge pull request #271 from samparsky/fix-route-discrepancies

Fix route discrepancies

Author: elpiel

adapter/src/ethereum.rs

@@ -472,8 +472,8 @@ mod test {
         let expected_response =
             "0x625fd46f82c4cfd135ea6a8534e85dbf50beb157046dce59d2e97aacdf4e38381d1513c0e6f002b2f05c05458038b187754ff38cc0658dfc9ba854cccfb6e13e1b";
         let message = "2bdeafae53940669daa6f519373f686c";
-        let response = eth_adapter.sign(message).expect("failed to sign message");
-        assert_eq!(expected_response, response, "invalid signature");
+        let signature = eth_adapter.sign(message).expect("failed to sign message");
+        assert_eq!(expected_response, signature, "invalid signature");
 
         // Verify
         let signature =
@@ -487,6 +487,18 @@ mod test {
             )
             .expect("Failed to verify signatures");
 
+        let sig1 = "0x9fa5852041b9818021323aff8260624fd6998c52c95d9ad5036e0db6f2bf2b2d48a188ec1d638581ff56b0a2ecceca6d3880fc65030558bd8f68b154e7ebf80f1b";
+        let msg = "1648231285e69677531ffe70719f67a07f3d4393b8425a5a1c84b0c72434c77b";
+
+        let verify2 = eth_adapter
+            .verify(
+                &ValidatorId::try_from("ce07CbB7e054514D590a0262C93070D838bFBA2e")
+                    .expect("Failed to parse id"),
+                msg,
+                &sig1,
+            )
+            .expect("Failed to verify signatures");
+
         assert_eq!(verify, true, "invalid signature verification");
     }
 

primitives/src/adapter.rs

@@ -31,7 +31,7 @@ impl fmt::Display for AdapterError {
             AdapterError::Authorization(error) => write!(f, "Authorization error: {}", error),
             AdapterError::Configuration(error) => write!(f, "Configuration error: {}", error),
             AdapterError::Signature(error) => write!(f, "Signature error: {}", error),
-            AdapterError::InvalidChannel(error) => write!(f, "Invalid Channel error: {}", error),
+            AdapterError::InvalidChannel(error) => write!(f, "{}", error),
             AdapterError::Failed(error) => write!(f, "error: {}", error),
         }
     }

primitives/src/channel.rs

@@ -3,7 +3,7 @@ use std::fmt;
 
 use chrono::serde::{ts_milliseconds, ts_milliseconds_option, ts_seconds};
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_hex::{SerHex, StrictPfx};
 
 use crate::big_num::BigNum;
@@ -13,7 +13,25 @@ use std::ops::Deref;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Copy, Clone, Hash)]
 #[serde(transparent)]
-pub struct ChannelId(#[serde(with = "SerHex::<StrictPfx>")] [u8; 32]);
+pub struct ChannelId(
+    #[serde(
+        deserialize_with = "channel_id_from_str",
+        serialize_with = "SerHex::<StrictPfx>::serialize"
+    )]
+    [u8; 32],
+);
+
+fn channel_id_from_str<'de, D>(deserializer: D) -> Result<[u8; 32], D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let channel_id = String::deserialize(deserializer)?;
+    if channel_id.is_empty() || channel_id.len() != 66 {
+        return Err(serde::de::Error::custom("invalid channel id".to_string()));
+    }
+
+    <[u8; 32] as FromHex>::from_hex(&channel_id[2..]).map_err(serde::de::Error::custom)
+}
 
 impl Deref for ChannelId {
     type Target = [u8];
@@ -72,7 +90,9 @@ pub struct Pricing {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "UPPERCASE")]
 pub struct PricingBounds {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub impression: Option<Pricing>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub click: Option<Pricing>,
 }
 
@@ -86,7 +106,8 @@ pub struct ChannelSpec {
     pub max_per_impression: BigNum,
     /// Minimum payment offered per impression
     pub min_per_impression: BigNum,
-    // Event pricing bounds
+    /// Event pricing bounds
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub pricing_bounds: Option<PricingBounds>,
     /// An array of TargetingTag (optional)
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
@@ -95,6 +116,7 @@ pub struct ChannelSpec {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub min_targeting_score: Option<f64>,
     /// EventSubmission object, applies to event submission (POST /channel/:id/events)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub event_submission: Option<EventSubmission>,
     /// A millisecond timestamp of when the campaign was created
     #[serde(
@@ -112,6 +134,7 @@ pub struct ChannelSpec {
     )]
     pub active_from: Option<DateTime<Utc>>,
     /// A random number to ensure the campaignSpec hash is unique
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub nonce: Option<BigNum>,
     /// A millisecond timestamp of when the campaign should enter a withdraw period
     /// (no longer accept any events other than CHANNEL_CLOSE)
@@ -232,17 +255,34 @@ pub enum ChannelError {
     /// which in terms means, that the adapter shouldn't handle this Channel
     AdapterNotIncluded,
     /// when `channel.valid_until` has passed (< now), the channel should be handled
-    PassedValidUntil,
+    InvalidValidUntil(String),
     UnlistedValidator,
     UnlistedCreator,
     UnlistedAsset,
     MinimumDepositNotMet,
     MinimumValidatorFeeNotMet,
+    FeeConstraintViolated,
 }
 
 impl fmt::Display for ChannelError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Channel error",)
+        match self {
+            ChannelError::InvalidArgument(error) => write!(f, "{}", error),
+            ChannelError::AdapterNotIncluded => write!(f, "channel is not validated by us"),
+            ChannelError::InvalidValidUntil(error) => write!(f, "{}", error),
+            ChannelError::UnlistedValidator => write!(f, "validators are not in the whitelist"),
+            ChannelError::UnlistedCreator => write!(f, "channel.creator is not whitelisted"),
+            ChannelError::UnlistedAsset => write!(f, "channel.depositAsset is not whitelisted"),
+            ChannelError::MinimumDepositNotMet => {
+                write!(f, "channel.depositAmount is less than MINIMAL_DEPOSIT")
+            }
+            ChannelError::MinimumValidatorFeeNotMet => {
+                write!(f, "channel validator fee is less than MINIMAL_FEE")
+            }
+            ChannelError::FeeConstraintViolated => {
+                write!(f, "total fees <= deposit: fee constraint violated")
+            }
+        }
     }
 }
 

primitives/src/channel_validator.rs

@@ -1,8 +1,10 @@
 use crate::channel::{Channel, ChannelError, SpecValidator, SpecValidators};
 use crate::config::Config;
+use crate::BigNum;
 use crate::ValidatorId;
 use chrono::Utc;
 use std::cmp::PartialEq;
+use time::Duration;
 
 pub trait ChannelValidator {
     fn is_channel_valid(
@@ -17,7 +19,21 @@ pub trait ChannelValidator {
         };
 
         if channel.valid_until < Utc::now() {
-            return Err(ChannelError::PassedValidUntil);
+            return Err(ChannelError::InvalidValidUntil(
+                "channel.validUntil has passed".to_string(),
+            ));
+        }
+
+        if channel.valid_until > (Utc::now() + Duration::days(365)) {
+            return Err(ChannelError::InvalidValidUntil(
+                "channel.validUntil should not be greater than one year".to_string(),
+            ));
+        }
+
+        if channel.spec.withdraw_period_start > channel.valid_until {
+            return Err(ChannelError::InvalidValidUntil(
+                "channel withdrawPeriodStart is invalid".to_string(),
+            ));
         }
 
         if !all_validators_listed(&channel.spec.validators, &config.validators_whitelist) {
@@ -40,6 +56,17 @@ pub trait ChannelValidator {
             return Err(ChannelError::MinimumValidatorFeeNotMet);
         }
 
+        let total_validator_fee: BigNum = channel
+            .spec
+            .validators
+            .iter()
+            .map(|v| v.fee.clone())
+            .fold(BigNum::from(0), |acc, x| acc + x);
+
+        if total_validator_fee >= channel.deposit_amount {
+            return Err(ChannelError::FeeConstraintViolated);
+        }
+
         Ok(())
     }
 }

primitives/src/sentry.rs

@@ -160,6 +160,14 @@ pub struct EventAggregateResponse {
     pub events: Vec<EventAggregate>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ValidationErrorResponse {
+    pub status_code: u64,
+    pub message: String,
+    pub validation: Vec<String>,
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AdvancedAnalyticsResponse {

primitives/src/util/tests/prep_db.rs

@@ -36,7 +36,7 @@ lazy_static! {
         auth.insert("user".into(), "x8c9v1b2".into());
         auth.insert("publisher".into(), "testing".into());
         auth.insert("publisher2".into(), "testing2".into());
-        auth.insert("creator".into(), "0x033ed90e0fec3f3ea1c9b005c724d704501e0196".into());
+        auth.insert("creator".into(), "0x033Ed90e0FeC3F3ea1C9b005C724D704501e0196".into());
         auth.insert("tester".into(), "AUTH_awesomeTester".into());
 
         auth

primitives/src/validator.rs

@@ -1,6 +1,6 @@
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize, Serializer};
-use serde_hex::{SerHex, StrictPfx};
+use hex::FromHex;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 
 use crate::{BalancesMap, BigNum, DomainError, ToETHChecksum};
@@ -16,7 +16,27 @@ pub enum ValidatorError {
 
 #[derive(Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[serde(transparent)]
-pub struct ValidatorId(#[serde(with = "SerHex::<StrictPfx>")] [u8; 20]);
+pub struct ValidatorId(
+    #[serde(
+        deserialize_with = "validator_id_from_str",
+        serialize_with = "SerHex::<StrictPfx>::serialize"
+    )]
+    [u8; 20],
+);
+
+fn validator_id_from_str<'de, D>(deserializer: D) -> Result<[u8; 20], D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let validator_id = String::deserialize(deserializer)?;
+    if validator_id.is_empty() || validator_id.len() != 42 {
+        return Err(serde::de::Error::custom(
+            "invalid validator id length".to_string(),
+        ));
+    }
+
+    <[u8; 20] as FromHex>::from_hex(&validator_id[2..]).map_err(serde::de::Error::custom)
+}
 
 impl ValidatorId {
     pub fn inner(&self) -> &[u8; 20] {
@@ -61,11 +81,13 @@ impl AsRef<[u8]> for ValidatorId {
 impl TryFrom<&str> for ValidatorId {
     type Error = DomainError;
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let hex_value = if value.len() == 42 {
-            &value[2..]
-        } else {
-            value
-        };
+        let hex_value = match value {
+            value if value.len() == 42 => Ok(&value[2..]),
+            value if value.len() == 40 => Ok(value),
+            _ => Err(DomainError::InvalidArgument(
+                "invalid validator id length".to_string(),
+            )),
+        }?;
 
         let result = hex::decode(hex_value).map_err(|_| {
             DomainError::InvalidArgument("Failed to deserialize validator id".to_string())
@@ -101,6 +123,7 @@ impl fmt::Display for ValidatorId {
 #[serde(rename_all = "camelCase")]
 pub struct ValidatorDesc {
     pub id: ValidatorId,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub fee_addr: Option<ValidatorId>,
     pub url: String,
     pub fee: BigNum,

sentry/migrations/20190806011140_initial-tables/seed/up.sql

@@ -6,6 +6,6 @@ VALUES
     '0x033ed90e0fec3f3ea1c9b005c724d704501e0196', 
     '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359', 
     '1000',
-    to_timestamp(4102444800000),
+    to_timestamp(4102444800),
     '{"minPerImpression":"1","maxPerImpression":"10","pricingBounds":{"CLICK":{"min":"0","max":"0"}},"withdrawPeriodStart":4073414400000,"validators":[{"id":"0xce07CbB7e054514D590a0262C93070D838bFBA2e","url":"http://localhost:8005","fee":"100"},{"id":"0xC91763D7F14ac5c5dDfBCD012e0D2A61ab9bDED3","url":"http://localhost:8006","fee":"100"}]}'
 );