Merge branch 'aip-61-adex-v5' into analytics-routes

Author: elpiel

Cargo.lock

@@ -10,4 +10,4 @@ members = [
 ]
 
 [patch.crates-io]
-postgres-types = { git = "https://github.com/elpiel/rust-postgres", branch = "from-T-for-boxed-dyn-ToSql"}
+postgres-types = { git = "https://github.com/elpiel/rust-postgres", branch = "boxed-dyn-ToSql"}

Cargo.toml

@@ -1,48 +1,45 @@
 [package]
 name = "adapter"
-version = "0.1.0"
+version = "0.2.0"
 authors = [
   "Ambire <[email protected]>",
   "Lachezar Lechev <[email protected]>",
-  "Omidiora Samuel <[email protected]>",
+  "Samparsky <[email protected]>",
 ]
 edition = "2021"
+license = "AGPL-3.0"
+
 
 [features]
 
+# Enables testing untilites for working with Ganache.
 test-util = ["primitives/test-util"]
 
 [dependencies]
 primitives = { path = "../primitives" }
-# Time handling
-chrono = "0.4"
-# To/From Hex
-hex = "0.4"
-serde = { version = "^1.0", features = ['derive'] }
-serde_json = "1.0"
-serde-hex = "0.1.0"
-# Ethereum
+
+# For Ethereum client
 web3 = { version = "0.17", features = ["http-tls", "signing"] }
-eth_checksum = "0.1"
-tiny-keccak = "1.5"
 ethstore = { git = "https://github.com/openethereum/openethereum", tag = "v3.1.1-rc.1" }
 create2 = "0.0.2"
 
-# API client
-reqwest = { version = "0.11", features = ["json"] }
+# For Dummy client
+dashmap = "4.0"
 
-sha2 = "0.9"
-base64 = "0.13"
-once_cell = "^1.8"
-thiserror = "^1"
-# Futures
-futures = "0.3"
 async-trait = "0.1"
+thiserror = "1"
 
-# Dummy adapter
-dashmap = "4.0"
+# Time handling
+chrono = "0.4"
+serde = { version = "^1.0", features = ["derive"] }
+serde_json = "1.0"
+hex = "0.4"
+base64 = "0.13"
+once_cell = "^1.8"
+# Macro for easier derive of Display & FromStr
+parse-display = "^0.5.0"
 
 [dev-dependencies]
 byteorder = "^1.4"
 tokio = { version = "^1", features = ["macros", "rt-multi-thread"] }
-wiremock = "0.5"
+pretty_assertions = "1"

adapter/Cargo.toml

@@ -12,6 +12,10 @@ dependencies = [
   "ganache-down",
 ]
 
+[tasks.test]
+# run tests in release because of slow unlock time of Ethereum adapter (i.e. keystore decryption)
+args = ["test", "--release", "--all-features"]
+
 [tasks.ganache-up]
 script = '''
 docker-compose -f ../docker-compose.harness.yml up --renew-anon-volumes -d ganache \

adapter/Makefile.toml

@@ -0,0 +1,145 @@
+use crate::primitives::*;
+use async_trait::async_trait;
+use std::{marker::PhantomData, sync::Arc};
+
+use crate::{
+    client::{Locked, Unlockable, Unlocked},
+    Error,
+};
+
+pub(crate) mod state {
+    #[derive(Debug, Clone, Copy)]
+    /// The `Locked` state of the [`crate::Adapter`].
+    /// See [`crate::client::Locked`]
+    pub struct LockedState;
+
+    /// The `Unlocked` state of the [`crate::Adapter`].
+    /// See [`crate::client::Unlocked`]
+    #[derive(Debug, Clone, Copy)]
+    pub struct UnlockedState;
+}
+
+#[derive(Debug)]
+/// The [`Adapter`] struct and it's states.
+///
+/// Used for communication with the underlying client implementation.
+///
+/// # Available adapters
+///
+/// 2 Adapters are available in this crate:
+/// - Ethereum
+///   - [`crate::ethereum::LockedAdapter`] and [`crate::ethereum::UnlockedAdapter`]
+///   - Client implementation [`crate::Ethereum`] for chains compatible with EVM.
+/// - Dummy
+///   - [`crate::dummy::Adapter`] and it's client implementation [`crate::Dummy`] for testing.
+pub struct Adapter<C, S = state::LockedState> {
+    /// client in a specific state - Locked or Unlocked
+    pub client: Arc<C>,
+    _state: PhantomData<S>,
+}
+
+impl<C, S: Clone> Clone for Adapter<C, S> {
+    fn clone(&self) -> Self {
+        Self {
+            client: self.client.clone(),
+            _state: self._state,
+        }
+    }
+}
+
+impl<C: Locked> Adapter<C> {
+    /// Create a new [`Adapter`] in [`Locked`] state using a [`Locked`].
+    pub fn new(client: C) -> Adapter<C, state::LockedState> {
+        Adapter {
+            client: Arc::new(client),
+            _state: PhantomData::default(),
+        }
+    }
+}
+
+impl<C: Unlocked> Adapter<C, state::LockedState> {
+    /// Create a new [`Adapter`] in [`state::UnlockedState`] state using an [`Unlocked`] client.
+    pub fn with_unlocked(client: C) -> Adapter<C, state::UnlockedState> {
+        Adapter {
+            client: Arc::new(client),
+            _state: PhantomData::default(),
+        }
+    }
+}
+
+impl<C> Adapter<C, state::LockedState>
+where
+    C: Locked + Unlockable,
+    <C::Unlocked as Locked>::Error: Into<Error>,
+    C::Error: Into<Error>,
+{
+    pub fn unlock(self) -> Result<Adapter<C::Unlocked, state::UnlockedState>, Error> {
+        let unlocked = self.client.unlock().map_err(Into::into)?;
+
+        Ok(Adapter {
+            client: Arc::new(unlocked),
+            _state: PhantomData::default(),
+        })
+    }
+}
+
+#[async_trait]
+impl<C> Unlocked for Adapter<C, state::UnlockedState>
+where
+    C: Unlocked + Sync + Send,
+    C::Error: Into<Error>,
+{
+    fn sign(&self, state_root: &str) -> Result<String, Error> {
+        self.client.sign(state_root).map_err(Into::into)
+    }
+
+    fn get_auth(&self, intended_for: ValidatorId) -> Result<String, Error> {
+        self.client.get_auth(intended_for).map_err(Into::into)
+    }
+}
+
+#[async_trait]
+impl<C, S> Locked for Adapter<C, S>
+where
+    C: Locked + Sync + Send,
+    C::Error: Into<Error>,
+    S: Sync + Send,
+{
+    type Error = Error;
+    /// Get Adapter whoami
+    fn whoami(&self) -> ValidatorId {
+        self.client.whoami()
+    }
+
+    /// Verify, based on the signature & state_root, that the signer is the same
+    fn verify(
+        &self,
+        signer: ValidatorId,
+        state_root: &str,
+        signature: &str,
+    ) -> Result<bool, Error> {
+        self.client
+            .verify(signer, state_root, signature)
+            .map_err(Into::into)
+    }
+
+    /// Creates a `Session` from a provided Token by calling the Contract.
+    /// Does **not** cache the (`Token`, [`Session`]) pair.
+    async fn session_from_token(&self, token: &str) -> Result<Session, Error> {
+        self.client
+            .session_from_token(token)
+            .await
+            .map_err(Into::into)
+    }
+
+    async fn get_deposit(
+        &self,
+        channel: &Channel,
+        depositor_address: Address,
+    ) -> Result<Deposit, Error> {
+        self.client
+            .get_deposit(channel, depositor_address)
+            .await
+            .map_err(Into::into)
+    }
+}

adapter/src/adapter.rs

@@ -0,0 +1,69 @@
+//! The Client traits that define the actions for each state.
+//!
+//! - [`Locked`]
+//! - [`Unlocked`]
+//! - [`Unlockable`]
+
+use crate::primitives::{Deposit, Session};
+use async_trait::async_trait;
+use primitives::{Address, Channel, ValidatorId};
+
+#[async_trait]
+/// Available methods for Locked clients.
+pub trait Locked: Sync + Send {
+    type Error: std::error::Error + Into<crate::Error> + 'static;
+
+    /// Get Adapter whoami
+    fn whoami(&self) -> ValidatorId;
+
+    /// Verify, based on the signature & state_root, that the signer is the same
+    fn verify(
+        &self,
+        signer: ValidatorId,
+        state_root: &str,
+        signature: &str,
+    ) -> Result<bool, Self::Error>;
+
+    /// Creates a `Session` from a provided Token by calling the Contract.
+    /// Does **not** cache the (`Token`, `Session`) pair.
+    async fn session_from_token(&self, token: &str) -> Result<Session, Self::Error>;
+
+    async fn get_deposit(
+        &self,
+        channel: &Channel,
+        depositor_address: Address,
+    ) -> Result<Deposit, Self::Error>;
+
+    // fn unlock(
+    //     &self,
+    // ) -> Result<
+    //     <Self as Unlockable>::Unlocked,
+    //     <<Self as Unlockable>::Unlocked as Locked>::Error,
+    // >
+    // where
+    //     Self: Unlockable,
+    // {
+    //     <Self as Unlockable>::unlock(self)
+    // }
+}
+
+/// Available methods for Unlocked clients.
+/// Unlocked clients should also implement [`Locked`].
+#[async_trait]
+pub trait Unlocked: Locked {
+    // requires Unlocked
+    fn sign(&self, state_root: &str) -> Result<String, Self::Error>;
+
+    // requires Unlocked
+    fn get_auth(&self, intended_for: ValidatorId) -> Result<String, Self::Error>;
+}
+
+/// A client that can be `unlock()`ed
+/// and implements both [`Locked`] & [`Unlocked`].
+///
+/// **Note:** A possibly expensive operation as it might result in cloning
+pub trait Unlockable {
+    type Unlocked: Unlocked;
+
+    fn unlock(&self) -> Result<Self::Unlocked, <Self::Unlocked as Locked>::Error>;
+}