Merge pull request #244 from AdExNetwork/issue-243-contrafactual-accounts

Issue #243 contrafactual accounts

Author: samparsky

Cargo.lock

@@ -21,6 +21,9 @@ tiny-keccak = "1.5"
 parity-crypto = { version = "0.4.2", features = ["publickey"] }
 ethstore = { version = "0.2.1", git = "https://github.com/elpiel/parity-ethereum"}
 ethkey = { version = "0.4.0", git = "https://github.com/elpiel/parity-ethereum"}
+# API client
+reqwest = { version = "0.10", features = ["json"] }
+
 sha2 = "0.8.0"
 base64 = "0.10.1"
 lazy_static = "1.4.0"

adapter/Cargo.toml

@@ -5,6 +5,7 @@ use ethkey::Password;
 use ethstore::SafeAccount;
 use futures::compat::Future01CompatExt;
 use futures::future::{BoxFuture, FutureExt};
+use futures::TryFutureExt;
 use lazy_static::lazy_static;
 use parity_crypto::publickey::{
     public_to_address, recover, verify_address, Address, Message, Signature,
@@ -15,8 +16,8 @@ use primitives::{
     config::Config,
     Channel, ToETHChecksum, ValidatorId,
 };
+use reqwest::Client;
 use serde::{Deserialize, Serialize};
-use serde_hex::{SerHexOpt, StrictPfx};
 use serde_json::Value;
 use std::convert::TryFrom;
 use std::error::Error;
@@ -34,10 +35,8 @@ use web3::{
 lazy_static! {
     static ref ADEXCORE_ABI: &'static [u8] =
         include_bytes!("../../lib/protocol-eth/abi/AdExCore.json");
-    static ref IDENTITY_ABI: &'static [u8] =
-        include_bytes!("../../lib/protocol-eth/abi/Identity.json");
     static ref CHANNEL_STATE_ACTIVE: U256 = 1.into();
-    static ref PRIVILEGE_LEVEL_NONE: U256 = 0.into();
+    static ref PRIVILEGE_LEVEL_NONE: u8 = 0;
 }
 
 #[derive(Debug, Clone)]
@@ -49,6 +48,7 @@ pub struct EthereumAdapter {
     wallet: Option<SafeAccount>,
     event_loop: Arc<EventLoopHandle>,
     web3: Web3<Http>,
+    relayer: RelayerClient,
 }
 
 // Enables EthereumAdapter to be able to
@@ -78,6 +78,8 @@ impl EthereumAdapter {
             .map_err(|_| map_error("failed to init http transport"))?;
         let event_loop = Arc::new(eloop);
         let web3 = web3::Web3::new(transport);
+        let relayer = RelayerClient::new(&config.ethereum_adapter_relayer)
+            .map_err(|_| map_error("Client for Relayer couldn't be built"))?;
 
         Ok(Self {
             address,
@@ -87,6 +89,7 @@ impl EthereumAdapter {
             config: config.to_owned(),
             event_loop,
             web3,
+            relayer,
         })
     }
 }
@@ -219,32 +222,20 @@ impl Adapter for EthereumAdapter {
 
             let sess = match &verified.payload.identity {
                 Some(identity) => {
-                    let contract_address: Address = identity.into();
-                    let contract =
-                        Contract::from_json(self.web3.eth(), contract_address, &IDENTITY_ABI)
-                            .map_err(|_| map_error("failed to init identity contract"))?;
-
-                    let privilege_level: U256 = contract
-                        .query(
-                            "privileges",
-                            (Token::Address(Address::from_slice(verified.from.inner())),),
-                            None,
-                            Options::default(),
-                            None,
-                        )
-                        .compat()
-                        .await
-                        .map_err(|_| map_error("failed query priviledge level on contract"))?;
-
-                    if privilege_level == *PRIVILEGE_LEVEL_NONE {
+                    if self
+                        .relayer
+                        .has_privileges(&verified.from, identity)
+                        .await?
+                    {
+                        Session {
+                            era: verified.payload.era,
+                            uid: identity.to_owned(),
+                        }
+                    } else {
                         return Err(AdapterError::Authorization(
                             "insufficient privilege".to_string(),
                         ));
                     }
-                    Session {
-                        era: verified.payload.era,
-                        uid: identity.into(),
-                    }
                 }
                 None => Session {
                     era: verified.payload.era,
@@ -276,6 +267,53 @@ impl Adapter for EthereumAdapter {
     }
 }
 
+#[derive(Debug, Clone)]
+struct RelayerClient {
+    client: Client,
+    relayer_url: String,
+}
+
+impl RelayerClient {
+    pub fn new(relayer_url: &str) -> Result<Self, reqwest::Error> {
+        let client = Client::builder().build()?;
+
+        Ok(Self {
+            relayer_url: relayer_url.to_string(),
+            client,
+        })
+    }
+
+    /// Checks whether there are any privileges (i.e. > 0)
+    pub async fn has_privileges(
+        &self,
+        from: &ValidatorId,
+        identity: &ValidatorId,
+    ) -> Result<bool, AdapterError> {
+        use reqwest::Response;
+        use std::collections::HashMap;
+
+        let relay_url = format!(
+            "{}/identity/by-owner/{}",
+            self.relayer_url,
+            from.to_checksum()
+        );
+
+        let identities_owned: HashMap<ValidatorId, u8> = self
+            .client
+            .get(&relay_url)
+            .send()
+            .and_then(|res: Response| res.json())
+            .await
+            .map_err(|_| map_error("Fetching privileges failed"))?;
+
+        let has_privileges = identities_owned
+            .get(identity)
+            .map_or(false, |privileges| *privileges > 0);
+
+        Ok(has_privileges)
+    }
+}
+
 fn hash_message(message: &str) -> [u8; 32] {
     let eth = "\x19Ethereum Signed Message:\n";
     let message_length = message.len();
@@ -301,12 +339,8 @@ pub struct Payload {
     pub id: String,
     pub era: i64,
     pub address: String,
-    #[serde(
-        default,
-        skip_serializing_if = "Option::is_none",
-        with = "SerHexOpt::<StrictPfx>"
-    )]
-    pub identity: Option<[u8; 20]>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ValidatorId>,
 }
 
 #[derive(Clone, Debug)]
@@ -377,7 +411,7 @@ pub fn ewt_verify(
     let payload: Payload = serde_json::from_str(&payload_string)?;
 
     let verified_payload = VerifyPayload {
-        from: ValidatorId::try_from(&format!("{:?}", address))?,
+        from: ValidatorId::from(address.as_fixed_bytes()),
         payload,
     };
 
@@ -482,6 +516,33 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    #[ignore]
+    async fn test_session_from_token() {
+        use primitives::ToETHChecksum;
+        let identity = ValidatorId::try_from("0x5B04DBc513F90CaAFAa09307Ad5e3C65EB4b26F0").unwrap();
+
+        let mut eth_adapter = setup_eth_adapter(None);
+        eth_adapter.unlock().expect("should unlock eth adapter");
+        let wallet = eth_adapter.wallet.clone();
+
+        let era = Utc::now().timestamp_millis() as f64 / 60000.0;
+        let payload = Payload {
+            id: eth_adapter.whoami().to_checksum(),
+            era: era.floor() as i64,
+            identity: Some(identity.clone()),
+            address: eth_adapter.whoami().to_checksum(),
+        };
+
+        let token = ewt_sign(&wallet.unwrap(), &eth_adapter.keystore_pwd, &payload)
+            .map_err(|_| map_error("Failed to sign token"))
+            .unwrap();
+
+        let session: Session = eth_adapter.session_from_token(&token).await.unwrap();
+
+        assert_eq!(session.uid, identity);
+    }
+
     #[tokio::test]
     async fn should_validate_valid_channel_properly() {
         let (_eloop, http) =
@@ -604,13 +665,10 @@ mod test {
             .await
             .expect("open channel");
 
-        let contract_addr = <[u8; 20]>::from_hex(&format!("{:?}", adex_contract.address())[2..])
-            .expect("failed to deserialize contract addr");
-
+        let contract_addr = adex_contract.address().to_fixed_bytes();
         let channel_id = eth_channel.hash(&contract_addr).expect("hash hex");
         // set id to proper id
-        valid_channel.id = ChannelId::from_hex(hex::encode(channel_id))
-            .expect("prep_db: failed to deserialize channel id");
+        valid_channel.id = ChannelId::from(channel_id);
 
         // eth adapter
         let mut eth_adapter = setup_eth_adapter(Some(contract_addr));
@@ -623,68 +681,4 @@ mod test {
 
         assert_eq!(result, true, "should validate valid channel correctly");
     }
-
-    #[tokio::test]
-    async fn should_generate_session_from_token_with_identity() {
-        // setup test payload
-        let mut eth_adapter = setup_eth_adapter(None);
-        eth_adapter.unlock().expect("should unlock eth adapter");
-
-        // part of address used in initializing ganache-cli
-        let leader_account: Address = "Df08F82De32B8d460adbE8D72043E3a7e25A3B39"
-            .parse()
-            .expect("failed to parse leader account");
-
-        let eth_adapter_address: Address = eth_adapter
-            .whoami()
-            .to_hex_non_prefix_string()
-            .parse()
-            .expect("failed to parse eth adapter address");
-
-        let identity_bytecode = include_str!("../test/resources/identitybytecode.json");
-
-        // deploy identity contract
-        let identity_contract = Contract::deploy(eth_adapter.web3.eth(), &IDENTITY_ABI)
-            .expect("invalid token token contract")
-            .confirmations(0)
-            .options(Options::with(|opt| {
-                opt.gas_price = Some(1.into());
-                opt.gas = Some(6_721_975.into());
-            }))
-            .execute(
-                identity_bytecode,
-                (
-                    Token::Array(vec![Token::Address(eth_adapter_address)]),
-                    Token::Array(vec![Token::Uint(1.into())]),
-                ),
-                leader_account,
-            )
-            .expect("Correct parameters are passed to the constructor.")
-            .compat()
-            .await
-            .expect("failed to initialize identity contract");
-
-        // identity contract address
-        let identity = <[u8; 20]>::from_hex(&format!("{:?}", identity_contract.address())[2..])
-            .expect("failed to deserialize address");
-
-        let payload = Payload {
-            id: eth_adapter.whoami().to_checksum(),
-            era: 100_000,
-            address: format!("{:?}", leader_account),
-            identity: Some(identity),
-        };
-
-        let wallet = eth_adapter.wallet.clone();
-        let response = ewt_sign(&wallet.unwrap(), &eth_adapter.keystore_pwd, &payload)
-            .expect("failed to generate ewt signature");
-
-        // verify since its with identity
-        let session = eth_adapter
-            .session_from_token(&response)
-            .await
-            .expect("failed generate session");
-
-        assert_eq!(session.uid.inner(), &identity);
-    }
 }

adapter/src/ethereum.rs

@@ -1,4 +1,6 @@
-max_channels=512
+# Maximum number of channels to return per request
+max_channels = 512
+
 channels_find_limit = 200
 wait_time = 500
 
@@ -15,11 +17,12 @@ list_timeout = 5000
 fetch_timeout = 5000
 validator_tick_timeout = 5000
 
-ip_rate_limit = {type='ip', timeframe=20000}
-sid_rate_limit = {type='sid', timeframe=20000}
+ip_rate_limit = { type = 'ip', timeframe = 20000 }
+sid_rate_limit = { type = 'sid', timeframe = 20000 }
 
 ethereum_core_address = '0x333420fc6a897356e69b62417cd17ff012177d2b'
 ethereum_network = 'http://localhost:8545'
+ethereum_adapter_relayer = 'https://goerli-relayer.adex.network'
 
 creators_whitelist = []
 minimal_deposit = "0"

docs/config/dev.toml

@@ -17,13 +17,14 @@ list_timeout = 10000
 fetch_timeout = 10000
 validator_tick_timeout = 10000
 
-ip_rate_limit = { type = "ip", timeframe = 20000 }
-sid_rate_limit = { type = "sid", timeframe = 0 }
+ip_rate_limit = { type = 'ip', timeframe = 20000 }
+sid_rate_limit = { type = 'sid', timeframe = 0 }
 ethereum_core_address = '0x333420fc6a897356e69b62417cd17ff012177d2b'
 ethereum_network = 'http://localhost:8545'
-token_address_whitelist = ['0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359']
+ethereum_adapter_relayer = 'https://relayer.adex.network'
 
 creators_whitelist = []
 minimal_deposit = "0"
 minimal_fee = "0"
+token_address_whitelist = ['0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359']
 validators_whitelist = []

docs/config/prod.toml

@@ -40,6 +40,7 @@ pub struct Config {
     #[serde(with = "SerHex::<StrictPfx>")]
     pub ethereum_core_address: [u8; 20],
     pub ethereum_network: String,
+    pub ethereum_adapter_relayer: String,
     pub validators_whitelist: Vec<ValidatorId>,
 }
 

primitives/src/config.rs

@@ -63,3 +63,5 @@ pub trait ToETHChecksum: AsRef<[u8]> {
         eth_checksum::checksum(&hex::encode(self.as_ref()))
     }
 }
+
+impl ToETHChecksum for &[u8; 20] {}