Update Dockerfile Rust version and fix Ethereum Adapter

Author: elpiel

Cargo.lock

@@ -1,6 +1,6 @@
-FROM rust:1.40 as builder
+FROM rust:1.45.2 as builder
 
-MAINTAINER dev@adex.network
+LABEL maintainer="dev@adex.network"
 
 WORKDIR /usr/src/app
 

Dockerfile

@@ -14,13 +14,10 @@ serde = { version = "^1.0", features = ['derive'] }
 serde_json = "1.0"
 serde-hex = "0.1.0"
 # Ethereum
-web3 = { git = "https://github.com/samparsky/rust-web3" }
+web3 = { git = "https://github.com/elpiel/rust-web3", branch = "export-ethabi" }
 eth_checksum = "0.1.1"
-ethabi = { git = "https://github.com/samparsky/ethabi", branch = "graph-patches" }
 tiny-keccak = "1.5"
-parity-crypto = { version = "0.5.0", features = ["publickey"] }
-ethstore = { version = "0.2.1", git = "https://github.com/paritytech/parity-ethereum"}
-ethkey = { version = "0.4.0", git = "https://github.com/paritytech/parity-ethereum"}
+ethstore = { git = "https://github.com/elpiel/openethereum", branch = "remove-dir-depenedency-for-ethstore" }
 # API client
 reqwest = { version = "0.10", features = ["json"] }
 

adapter/Cargo.toml

@@ -2,14 +2,12 @@ use crate::EthereumChannel;
 use async_trait::async_trait;
 use chrono::Utc;
 use error::*;
-use ethabi::token::Token;
-use ethkey::Password;
-use ethstore::SafeAccount;
-use futures::{compat::Future01CompatExt, TryFutureExt};
-use lazy_static::lazy_static;
-use parity_crypto::publickey::{
-    public_to_address, recover, verify_address, Address, Message, Signature,
+use ethstore::{
+    ethkey::{public_to_address, recover, verify_address, Address, Message, Password, Signature},
+    SafeAccount,
 };
+use futures::TryFutureExt;
+use lazy_static::lazy_static;
 use primitives::{
     adapter::{Adapter, AdapterResult, Error as AdapterError, KeystoreOptions, Session},
     channel_validator::ChannelValidator,
@@ -21,13 +19,12 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::convert::TryFrom;
 use std::fs;
-use std::sync::Arc;
 use tiny_keccak::Keccak;
 use web3::{
+    contract::tokens::Tokenizable,
     contract::{Contract, Options},
-    transports::EventLoopHandle,
     transports::Http,
-    types::U256,
+    types::{H256, U256},
     Web3,
 };
 
@@ -46,7 +43,6 @@ pub struct EthereumAdapter {
     keystore_pwd: Password,
     config: Config,
     wallet: Option<SafeAccount>,
-    event_loop: Arc<EventLoopHandle>,
     web3: Web3<Http>,
     relayer: RelayerClient,
 }
@@ -70,9 +66,8 @@ impl EthereumAdapter {
 
         let address = ValidatorId::try_from(&address).map_err(KeystoreError::AddressInvalid)?;
 
-        let (eloop, transport) =
+        let transport =
             web3::transports::Http::new(&config.ethereum_network).map_err(Error::Web3)?;
-        let event_loop = Arc::new(eloop);
         let web3 = web3::Web3::new(transport);
         let relayer =
             RelayerClient::new(&config.ethereum_adapter_relayer).map_err(Error::RelayerClient)?;
@@ -83,7 +78,6 @@ impl EthereumAdapter {
             keystore_pwd: opts.keystore_pwd.into(),
             wallet: None,
             config: config.to_owned(),
-            event_loop,
             web3,
             relayer,
         })
@@ -115,7 +109,7 @@ impl Adapter for EthereumAdapter {
     fn sign(&self, state_root: &str) -> AdapterResult<String, Self::AdapterError> {
         if let Some(wallet) = &self.wallet {
             let state_root = hex::decode(state_root).map_err(VerifyError::StateRootDecoding)?;
-            let message = Message::from_slice(&hash_message(&state_root));
+            let message = Message::from(hash_message(&state_root));
             let wallet_sign = wallet
                 .sign(&self.keystore_pwd, &message)
                 .map_err(EwtSigningError::SigningMessage)?;
@@ -139,10 +133,10 @@ impl Adapter for EthereumAdapter {
             return Err(VerifyError::SignatureNotPrefixed.into());
         }
         let decoded_signature = hex::decode(&sig[2..]).map_err(VerifyError::SignatureDecoding)?;
-        let address = Address::from_slice(signer.inner());
+        let address = Address::from(*signer.inner());
         let signature = Signature::from_electrum(&decoded_signature);
         let state_root = hex::decode(state_root).map_err(VerifyError::StateRootDecoding)?;
-        let message = Message::from_slice(&hash_message(&state_root));
+        let message = Message::from(hash_message(&state_root));
 
         let verify_address = verify_address(&address, &signature, &message)
             .map_err(VerifyError::PublicKeyRecovery)?;
@@ -173,20 +167,21 @@ impl Adapter for EthereumAdapter {
             ));
         }
 
-        let contract_address: Address = self.config.ethereum_core_address.into();
-
-        let contract = Contract::from_json(self.web3.eth(), contract_address, &ADEXCORE_ABI)
-            .map_err(Error::ContractInitialization)?;
+        let contract = Contract::from_json(
+            self.web3.eth(),
+            self.config.ethereum_core_address.into(),
+            &ADEXCORE_ABI,
+        )
+        .map_err(Error::ContractInitialization)?;
 
         let channel_status: U256 = contract
             .query(
                 "states",
-                Token::FixedBytes(channel.id.as_ref().to_vec()),
+                H256(*channel.id).into_token(),
                 None,
                 Options::default(),
                 None,
             )
-            .compat()
             .await
             .map_err(Error::ContractQuerying)?;
 
@@ -382,7 +377,7 @@ pub fn ewt_sign(
         &serde_json::to_string(payload).map_err(EwtSigningError::PayloadSerialization)?,
         base64::URL_SAFE_NO_PAD,
     );
-    let message = Message::from_slice(&hash_message(
+    let message = Message::from(hash_message(
         &format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
     ));
     let signature: Signature = signer
@@ -404,7 +399,7 @@ pub fn ewt_verify(
     payload_encoded: &str,
     token: &str,
 ) -> Result<VerifyPayload, EwtVerifyError> {
-    let message = Message::from_slice(&hash_message(
+    let message = Message::from(hash_message(
         &format!("{}.{}", header_encoded, payload_encoded).as_bytes(),
     ));
 
@@ -424,7 +419,7 @@ pub fn ewt_verify(
         serde_json::from_str(&payload_string).map_err(EwtVerifyError::PayloadDeserialization)?;
 
     let verified_payload = VerifyPayload {
-        from: ValidatorId::from(address.as_fixed_bytes()),
+        from: ValidatorId::from(&address.0),
         payload,
     };
 
@@ -436,13 +431,13 @@ mod test {
     use super::*;
     use crate::EthereumChannel;
     use chrono::{Duration, Utc};
-    use ethabi::token::Token;
     use hex::FromHex;
     use primitives::adapter::KeystoreOptions;
     use primitives::config::configuration;
     use primitives::ChannelId;
     use primitives::{ChannelSpec, EventSubmission, SpecValidators, ValidatorDesc};
     use std::convert::TryFrom;
+    use web3::types::Address;
 
     fn setup_eth_adapter(contract_address: Option<[u8; 20]>) -> EthereumAdapter {
         let mut config = configuration("development", None).expect("failed parse config");
@@ -577,7 +572,7 @@ mod test {
 
     #[tokio::test]
     async fn should_validate_valid_channel_properly() {
-        let (_eloop, http) =
+        let http =
             web3::transports::Http::new("http://localhost:8545").expect("failed to init transport");
 
         let web3 = web3::Web3::new(http);
@@ -604,10 +599,8 @@ mod test {
                 opt.gas = Some(6_721_975.into());
             }))
             .execute(token_bytecode, (), leader_account)
-            .expect("Correct parameters are passed to the constructor.")
-            .compat()
             .await
-            .expect("failed to wait");
+            .expect("Correct parameters are passed to the constructor.");
 
         let adex_contract = Contract::deploy(web3.eth(), &ADEXCORE_ABI)
             .expect("invalid adex contract")
@@ -617,23 +610,17 @@ mod test {
                 opt.gas = Some(6_721_975.into());
             }))
             .execute(adex_bytecode, (), leader_account)
-            .expect("Correct parameters are passed to the constructor.")
-            .compat()
             .await
-            .expect("failed to init adex contract");
+            .expect("Correct parameters are passed to the constructor.");
 
         // contract call set balance
         token_contract
             .call(
                 "setBalanceTo",
-                (
-                    Token::Address(leader_account),
-                    Token::Uint(U256::from(2000 as u64)),
-                ),
+                (Address::from(leader_account), U256::from(2000_u64)),
                 leader_account,
                 Options::default(),
             )
-            .compat()
             .await
             .expect("Failed to set balance");
 
@@ -697,7 +684,6 @@ mod test {
                 leader_account,
                 Options::default(),
             )
-            .compat()
             .await
             .expect("open channel");
 

adapter/src/ethereum.rs

@@ -18,7 +18,7 @@ pub enum Error {
     /// Signing of the message failed
     SignMessage(EwtSigningError),
     VerifyMessage(EwtVerifyError),
-    ContractInitialization(ethabi::Error),
+    ContractInitialization(web3::ethabi::Error),
     ContractQuerying(web3::contract::Error),
     /// Error occurred during verification of Signature and/or StateRoot and/or Address
     VerifyAddress(VerifyError),
@@ -52,7 +52,7 @@ impl fmt::Display for Error {
 /// Error returned on `eth_adapter.verify()` when the combination of
 /// (signer, state_root, signature) **doesn't align**.
 pub enum VerifyError {
-    PublicKeyRecovery(parity_crypto::publickey::Error),
+    PublicKeyRecovery(ethstore::ethkey::Error),
     StateRootDecoding(hex::FromHexError),
     SignatureDecoding(hex::FromHexError),
     SignatureNotPrefixed,
@@ -150,7 +150,7 @@ impl From<EwtSigningError> for AdapterError<Error> {
 
 #[derive(Debug)]
 pub enum EwtVerifyError {
-    AddressRecovery(parity_crypto::publickey::Error),
+    AddressRecovery(ethstore::ethkey::Error),
     SignatureDecoding(base64::DecodeError),
     PayloadDecoding(base64::DecodeError),
     PayloadDeserialization(serde_json::Error),

adapter/src/ethereum/error.rs

@@ -5,16 +5,15 @@
 use std::error::Error;
 
 use chrono::{DateTime, Utc};
-use ethabi::encode;
-use ethabi::token::Token;
 use hex::FromHex;
-use primitives::channel::ChannelError;
-use primitives::BigNum;
-use primitives::{Channel, ValidatorId};
+use primitives::{channel::ChannelError, BigNum, Channel, ValidatorId};
 use sha2::{Digest, Sha256};
 use std::convert::TryFrom;
 use tiny_keccak::Keccak;
-use web3::types::{Address, U256};
+use web3::{
+    ethabi::{encode, token::Token},
+    types::{Address, U256},
+};
 
 pub use self::dummy::DummyAdapter;
 pub use self::ethereum::EthereumAdapter;

adapter/src/lib.rs

@@ -43,9 +43,9 @@ fn validate_channel_id(s: &str) -> Result<[u8; 32], FromHexError> {
 }
 
 impl Deref for ChannelId {
-    type Target = [u8];
+    type Target = [u8; 32];
 
-    fn deref(&self) -> &[u8] {
+    fn deref(&self) -> &[u8; 32] {
         &self.0
     }
 }
@@ -348,18 +348,21 @@ mod test {
         let prefixed_value = serde_json::Value::String(prefixed_string.clone());
 
         // Deserialization from JSON
-        let de_hex_json = serde_json::from_value::<ChannelId>(hex_value.clone())
+        let de_hex_json =
+            serde_json::from_value::<ChannelId>(hex_value.clone()).expect("Should deserialize");
+        let de_prefixed_json = serde_json::from_value::<ChannelId>(prefixed_value.clone())
             .expect("Should deserialize");
-        let de_prefixed_json =
-            serde_json::from_value::<ChannelId>(prefixed_value.clone()).expect("Should deserialize");
 
         assert_eq!(de_hex_json, expected_id);
         assert_eq!(de_prefixed_json, expected_id);
 
         // Serialization to JSON
         let actual_serialized = serde_json::to_value(expected_id).expect("Should Serialize");
         // we don't expect any capitalization
-        assert_eq!(actual_serialized, serde_json::Value::String(prefixed_string))
+        assert_eq!(
+            actual_serialized,
+            serde_json::Value::String(prefixed_string)
+        )
     }
 }
 

primitives/src/channel.rs

@@ -24,7 +24,7 @@ async fn send_heartbeat<A: Adapter + 'static>(
 
     let merkle_tree = MerkleTree::new(&[timestamp_buf])?;
 
-    let state_root_raw = get_signable_state_root(&iface.channel.id, &merkle_tree.root())?;
+    let state_root_raw = get_signable_state_root(iface.channel.id.as_ref(), &merkle_tree.root())?;
     let state_root = hex::encode(state_root_raw);
 
     let signature = iface.adapter.sign(&state_root)?;

validator_worker/src/heartbeat.rs

@@ -35,7 +35,7 @@ pub(crate) fn get_state_root_hash<A: Adapter + 'static>(
 
     let tree = MerkleTree::new(&elems)?;
     // keccak256(channelId, balanceRoot
-    get_signable_state_root(&iface.channel.id, &tree.root())
+    get_signable_state_root(iface.channel.id.as_ref(), &tree.root())
 }
 
 #[cfg(test)]