fix: make adapter options enum and tryfrom channel to ethchannel

Author: samparsky

adapter/src/dummy.rs

@@ -1,7 +1,7 @@
 use primitives::adapter::{Adapter, AdapterError, AdapterOptions, AdapterResult, Session};
 use primitives::channel_validator::ChannelValidator;
 use primitives::config::Config;
-use primitives::{Channel, ValidatorDesc};
+use primitives::Channel;
 use std::collections::HashMap;
 
 #[derive(Debug, Clone)]
@@ -22,17 +22,18 @@ impl Adapter for DummyAdapter {
     type Output = DummyAdapter;
 
     fn init(opts: AdapterOptions, config: &Config) -> AdapterResult<DummyAdapter> {
-        let (identity, authorization_tokens, session_tokens) =
-            match (opts.dummy_identity, opts.dummy_auth, opts.dummy_auth_tokens) {
-                (Some(identity), Some(authorization_tokens), Some(session_tokens)) => {
-                    (identity, authorization_tokens, session_tokens)
-                }
-                (_, _, _) => {
-                    return Err(AdapterError::Configuration(
-                        "dummy_identity, dummy_auth, dummy_auth_tokens required".to_string(),
-                    ))
-                }
-            };
+        let (identity, authorization_tokens, session_tokens) = match opts {
+            AdapterOptions::DummAdapter {
+                dummy_identity,
+                dummy_auth,
+                dummy_auth_tokens,
+            } => (dummy_identity, dummy_auth, dummy_auth_tokens),
+            _ => {
+                return Err(AdapterError::Configuration(
+                    "dummy_identity, dummy_auth, dummy_auth_tokens required".to_string(),
+                ))
+            }
+        };
 
         Ok(Self {
             identity,

adapter/src/ethereum.rs

@@ -7,11 +7,12 @@ use primitives::{
     adapter::{Adapter, AdapterError, AdapterOptions, AdapterResult, Session},
     channel_validator::ChannelValidator,
     config::Config,
-    Channel, ValidatorDesc,
+    Channel,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
+use std::convert::TryFrom;
 use std::error::Error;
 use std::fs;
 use tiny_keccak::Keccak;
@@ -52,9 +53,11 @@ impl Adapter for EthereumAdapter {
     type Output = EthereumAdapter;
 
     fn init(opts: AdapterOptions, config: &Config) -> AdapterResult<EthereumAdapter> {
-        let (keystore_file, keystore_pwd) = match (opts.keystore_file, opts.keystore_pwd) {
-            (Some(file), Some(pwd)) => (file, pwd),
-            (_, _) => {
+        let (keystore_file, keystore_pwd) = match opts {
+            AdapterOptions::EthereumAdapter(keystore_opts) => {
+                (keystore_opts.keystore_file, keystore_opts.keystore_pwd)
+            }
+            _ => {
                 return Err(AdapterError::Configuration(
                     "Missing keystore json file or password".to_string(),
                 ))
@@ -139,7 +142,19 @@ impl Adapter for EthereumAdapter {
     }
 
     fn validate_channel(&self, channel: &Channel) -> AdapterResult<bool> {
-        let eth_channel: EthereumChannel = channel.into();
+        if check_validator_id_checksum(channel) {
+            return Err(AdapterError::Configuration(
+                "channel.validators: all addresses are checksummed".to_string(),
+            ));
+        }
+        // check if channel is valid
+        if let Err(e) = EthereumAdapter::is_channel_valid(&self.config, channel) {
+            return Err(AdapterError::InvalidChannel(e.to_string()));
+        }
+
+        let eth_channel = EthereumChannel::try_from(channel)
+            .map_err(|e| AdapterError::InvalidChannel(e.to_string()))?;
+
         let channel_id = eth_channel
             .hash_hex(&self.config.ethereum_core_address)
             .map_err(|_| map_error("Failed to hash the channel id"))?;
@@ -150,15 +165,6 @@ impl Adapter for EthereumAdapter {
             ));
         }
 
-        if check_validator_id_checksum(channel) {
-            return Err(AdapterError::Configuration(
-                "channel.validators: all addresses are checksummed".to_string(),
-            ));
-        }
-        // check if channel is valid
-        if let Err(error) = EthereumAdapter::is_channel_valid(&self.config, channel) {
-            return Err(AdapterError::InvalidChannel(error.to_string()));
-        }
         // query the blockchain for the channel status
         let contract_address = Address::from_slice(self.config.ethereum_core_address.as_bytes());
         let contract = get_contract(&self.config, contract_address, &ADEXCORE_ABI)
@@ -399,17 +405,16 @@ pub fn ewt_verify(
 #[cfg(test)]
 mod test {
     use super::*;
+    use primitives::adapter::KeystoreOptions;
     use primitives::config::configuration;
 
     fn setup_eth_adapter() -> EthereumAdapter {
         let config = configuration("development", None).expect("failed parse config");
-        let adapter_options = AdapterOptions {
-            keystore_file: Some("./test/resources/keystore.json".to_string()),
-            keystore_pwd: Some("adexvalidator".to_string()),
-            dummy_identity: None,
-            dummy_auth: None,
-            dummy_auth_tokens: None,
+        let keystore_options = KeystoreOptions {
+            keystore_file: "./test/resources/keystore.json".to_string(),
+            keystore_pwd: "adexvalidator".to_string(),
         };
+        let adapter_options = AdapterOptions::EthereumAdapter(keystore_options);
 
         EthereumAdapter::init(adapter_options, &config).expect("should init ethereum adapter")
     }

adapter/src/lib.rs

@@ -4,10 +4,11 @@ use chrono::{DateTime, Utc};
 use ethabi::encode;
 use ethabi::param_type::ParamType;
 use ethabi::token::{LenientTokenizer, StrictTokenizer, Tokenizer};
+use primitives::channel::ChannelError;
 use primitives::BigNum;
 use primitives::Channel;
 use sha2::{Digest, Sha256};
-use std::convert::From;
+use std::convert::TryFrom;
 use tiny_keccak::Keccak;
 
 pub use self::dummy::DummyAdapter;
@@ -66,9 +67,12 @@ pub struct EthereumChannel {
     pub spec: String,
 }
 
-impl From<&Channel> for EthereumChannel {
-    fn from(channel: &Channel) -> Self {
-        let spec = serde_json::to_string(&channel.spec).expect("Failed to serialize channel spec");
+impl TryFrom<&Channel> for EthereumChannel {
+    type Error = ChannelError;
+
+    fn try_from(channel: &Channel) -> Result<Self, Self::Error> {
+        let spec = serde_json::to_string(&channel.spec)
+            .map_err(|e| ChannelError::InvalidArgument(e.to_string()))?;
 
         let mut hash = Sha256::new();
         hash.input(spec);
@@ -101,16 +105,44 @@ impl EthereumChannel {
         valid_until: DateTime<Utc>,
         validators: Vec<String>,
         spec: &str,
-    ) -> Self {
-        // @TODO some validation
-        Self {
+    ) -> Result<Self, ChannelError> {
+        // check creator addres
+        if creator != eth_checksum::checksum(creator) {
+            return Err(ChannelError::InvalidArgument(
+                "Invalid creator address".into(),
+            ));
+        }
+
+        if token_addr != eth_checksum::checksum(token_addr) {
+            return Err(ChannelError::InvalidArgument(
+                "invalid token addresss".into(),
+            ));
+        }
+
+        if let Err(_) = BigNum::try_from(token_amount) {
+            return Err(ChannelError::InvalidArgument("invalid token amount".into()));
+        }
+
+        if spec.len() != 32 {
+            return Err(ChannelError::InvalidArgument(
+                "32 len string expected".into(),
+            ));
+        }
+
+        if validators.iter().any(|v| *v != eth_checksum::checksum(v)) {
+            return Err(ChannelError::InvalidArgument(
+                "invalid validator address: must start with a 0x and be 42 characters long".into(),
+            ));
+        }
+
+        Ok(Self {
             creator: creator.to_owned(),
             token_addr: token_addr.to_owned(),
             token_amount: token_amount.to_owned(),
             valid_until: valid_until.timestamp(),
             validators: format!("[{}]", validators.join(",")),
             spec: spec.to_owned(),
-        }
+        })
     }
 
     pub fn hash(&self, contract_addr: &str) -> Result<[u8; 32], Box<dyn Error>> {

primitives/src/adapter.rs

@@ -34,12 +34,19 @@ impl fmt::Display for AdapterError {
 }
 
 #[derive(Debug, Clone)]
-pub struct AdapterOptions {
-    pub dummy_identity: Option<String>,
-    pub dummy_auth: Option<HashMap<String, String>>,
-    pub dummy_auth_tokens: Option<HashMap<String, String>>,
-    pub keystore_file: Option<String>,
-    pub keystore_pwd: Option<String>,
+pub enum AdapterOptions {
+    DummAdapter {
+        dummy_identity: String,
+        dummy_auth: HashMap<String, String>,
+        dummy_auth_tokens: HashMap<String, String>,
+    },
+    EthereumAdapter(KeystoreOptions),
+}
+
+#[derive(Debug, Clone)]
+pub struct KeystoreOptions {
+    pub keystore_file: String,
+    pub keystore_pwd: String,
 }
 
 #[derive(Debug, Clone)]

validator_worker/src/lib.rs

@@ -56,12 +56,10 @@ mod test {
     use std::sync::{Arc, RwLock};
 
     fn setup_iface(channel: &Channel) -> SentryApi<DummyAdapter> {
-        let adapter_options = AdapterOptions {
-            dummy_identity: Some(IDS["leader"].clone()),
-            dummy_auth: Some(IDS.clone()),
-            dummy_auth_tokens: Some(AUTH.clone()),
-            keystore_file: None,
-            keystore_pwd: None,
+        let adapter_options = AdapterOptions::DummAdapter {
+            dummy_identity: IDS["leader"].clone(),
+            dummy_auth: IDS.clone(),
+            dummy_auth_tokens: AUTH.clone(),
         };
         let config = configuration("development", None).expect("Dev config should be available");
         let dummy_adapter = DummyAdapter::init(adapter_options, &config).expect("init adadpter");

validator_worker/src/main.rs

@@ -5,8 +5,9 @@
 use clap::{App, Arg};
 
 use adapter::{AdapterTypes, DummyAdapter, EthereumAdapter};
-use primitives::adapter::{Adapter, AdapterOptions};
+use primitives::adapter::{Adapter, AdapterOptions, KeystoreOptions};
 use primitives::config::{configuration, Config};
+use primitives::util::tests::prep_db::{AUTH, IDS};
 
 fn main() {
     let cli = App::new("Validator worker")
@@ -60,30 +61,25 @@ fn main() {
 
     let adapter = match cli.value_of("adapter").unwrap() {
         "ethereum" => {
-            let keystore_file = cli.value_of("keystoreFile").unwrap();
-            let keystore_pwd = std::env::var("KEYSTORE_PWD").unwrap();
-
-            let options = AdapterOptions {
-                keystore_file: Some(keystore_file.to_string()),
-                keystore_pwd: Some(keystore_pwd),
-                dummy_identity: None,
-                dummy_auth: None,
-                dummy_auth_tokens: None,
+            let keystore_file = cli
+                .value_of("keystoreFile")
+                .expect("unable to get keystore file");
+            let keystore_pwd = std::env::var("KEYSTORE_PWD").expect("unable to get keystore pwd");
+            let keystore_options = KeystoreOptions {
+                keystore_file: keystore_file.to_string(),
+                keystore_pwd,
             };
+            let options = AdapterOptions::EthereumAdapter(keystore_options);
             AdapterTypes::EthereumAdapter(Box::new(
                 EthereumAdapter::init(options, &config).expect("failed to init adapter"),
             ))
         }
         "dummy" => {
             let dummy_identity = cli.value_of("dummyIdentity").unwrap();
-            let options = AdapterOptions {
-                dummy_identity: Some(dummy_identity.to_string()),
-                // this should be prefilled using fixtures
-                //
-                dummy_auth: None,
-                dummy_auth_tokens: None,
-                keystore_file: None,
-                keystore_pwd: None,
+            let options = AdapterOptions::DummAdapter {
+                dummy_identity: dummy_identity.to_string(),
+                dummy_auth: IDS.clone(),
+                dummy_auth_tokens: AUTH.clone(),
             };
             AdapterTypes::DummyAdapter(Box::new(
                 DummyAdapter::init(options, &config).expect("failed to init adapter"),