the rest of todos

Author: simzzz

Cargo.lock

@@ -10,7 +10,7 @@ use ethsign::{KeyFile, Signature};
 use primitives::{Address, BigNum, Chain, ChainId, ChainOf, Channel, Config, ValidatorId};
 
 use super::{
-    error::{Error, EwtSigningError, KeystoreError, VerifyError},
+    error::{Error, KeystoreError, VerifyError, OutpaceError},
     ewt::{self, Payload},
     to_ethereum_signed, Electrum, LockedWallet, UnlockedWallet, WalletState, IDENTITY_ABI,
     OUTPACE_ABI,
@@ -282,8 +282,7 @@ impl Unlocked for Ethereum<UnlockedWallet> {
             .state
             .wallet
             .sign(&message)
-            // TODO: This is not entirely true, we do not sign an Ethereum Web Token but Outpace state_root
-            .map_err(|err| EwtSigningError::SigningMessage(err.to_string()))?;
+            .map_err(|err| OutpaceError::SignStateroot(err.to_string()))?;
 
         Ok(format!("0x{}", hex::encode(wallet_sign.to_electrum())))
     }

adapter/src/ethereum/client.rs

@@ -22,6 +22,7 @@ impl From<Error> for AdapterError {
             err @ Error::ContractInitialization(..) => AdapterError::adapter(err),
             err @ Error::ContractQuerying(..) => AdapterError::adapter(err),
             err @ Error::VerifyAddress(..) => AdapterError::adapter(err),
+            err @ Error::OutpaceError( .. ) => AdapterError::adapter(err),
             err @ Error::AuthenticationTokenNotIntendedForUs { .. } => {
                 AdapterError::authentication(err)
             }
@@ -74,6 +75,8 @@ pub enum Error {
     },
     #[error("Insufficient privilege")]
     InsufficientAuthorizationPrivilege,
+    #[error("Outpace contract error: {0}")]
+    OutpaceError(#[from] OutpaceError),
 }
 
 #[derive(Debug, Error)]
@@ -123,6 +126,12 @@ pub enum EwtSigningError {
     DecodingHexSignature(#[from] hex::FromHexError),
 }
 
+#[derive(Debug, Error)]
+pub enum OutpaceError {
+    #[error("Error while signing outpace contract: {0}")]
+    SignStateroot(String),
+}
+
 #[derive(Debug, Error)]
 pub enum EwtVerifyError {
     #[error("The Ethereum Web Token header is invalid")]
@@ -142,12 +151,18 @@ pub enum EwtVerifyError {
     /// or if Signature V component is not in "Electrum" notation (`< 27`).
     #[error("Error when decoding token signature")]
     InvalidSignature,
+    #[error("Payload error: {0}")]
+    Payload(#[from] PayloadError)
+}
+
+#[derive(Debug, Error)]
+pub enum PayloadError {
     #[error("Payload decoding: {0}")]
-    PayloadDecoding(#[source] base64::DecodeError),
+    Decoding(#[source] base64::DecodeError),
     #[error("Payload deserialization: {0}")]
-    PayloadDeserialization(#[from] serde_json::Error),
+    Deserialization(#[from] serde_json::Error),
     #[error("Payload is not a valid UTF-8 string: {0}")]
-    PayloadUtf8(#[from] std::str::Utf8Error),
+    Utf8(#[from] std::str::Utf8Error),
 }
 
 #[cfg(test)]

adapter/src/ethereum/error.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use web3::signing::keccak256;
 
 use super::{
-    error::{EwtSigningError, EwtVerifyError},
+    error::{EwtSigningError, EwtVerifyError, PayloadError},
     to_ethereum_signed, Electrum,
 };
 
@@ -54,14 +54,13 @@ pub struct Payload {
 
 impl Payload {
     /// Decodes the [`Payload`] from a base64 encoded json string
-    // TODO: replace with own error?
-    pub fn base64_decode(encoded_json: &str) -> Result<Self, EwtVerifyError> {
+    pub fn base64_decode(encoded_json: &str) -> Result<Self, PayloadError> {
         let base64_decode = base64::decode_config(encoded_json, base64::URL_SAFE_NO_PAD)
-            .map_err(EwtVerifyError::PayloadDecoding)?;
+            .map_err(PayloadError::Decoding)?;
 
-        let json = std::str::from_utf8(&base64_decode).map_err(EwtVerifyError::PayloadUtf8)?;
+        let json = std::str::from_utf8(&base64_decode).map_err(PayloadError::Utf8)?;
 
-        serde_json::from_str(json).map_err(EwtVerifyError::PayloadDeserialization)
+        serde_json::from_str(json).map_err(PayloadError::Deserialization)
     }
 }
 

adapter/src/ethereum/ewt.rs

@@ -156,7 +156,6 @@ pub fn get_unit_html_with_events(
         let body =
             serde_json::to_string(&events_body).expect("It should always serialize EventBody");
 
-        // TODO: check whether the JSON body with `''` quotes executes correctly!
         let fetch_opts = format!("var fetchOpts = {{ method: 'POST', headers: {{ 'content-type': 'application/json' }}, body: {body} }};");
 
         let validators: String = validators

adview-manager/src/helpers.rs

@@ -83,8 +83,6 @@ required-features = ["test-util"]
 # (De)Serialization
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-# TODO: Remove once we change `ChannelId` Serialize impl
-serde-hex = "0.1"
 serde_millis = "0.1"
 # Used prefixes on field for targeting::Input, and `campaign::Active`
 serde_with = "2"
@@ -106,7 +104,7 @@ ethereum-types = "0.13"
 parse-display = "0.5"
 # CID & multihash / multibase
 cid = "0.8"
-hex = "0.4"
+hex = { version = "0.4", features = ["serde"] }
 merkletree = "0.10"
 tiny-keccak = { version = "2", features = ["keccak"] }
 url = { version = "2", features = ["serde"] }

primitives/Cargo.toml

@@ -99,7 +99,6 @@ pub struct Time {
     /// - a timestamp in milliseconds
     /// **Note:** [`DateHour`] rules should be uphold, this means that passed values should always be rounded to hours
     /// And it should not contain **minutes**, **seconds** or **nanoseconds**
-    // TODO: Either Timestamp (number) or DateTime (string) de/serialization
     pub start: DateHour<Utc>,
     /// The End [`DateHour`] which will fetch `analytics_time <= end` and should be after Start [`DateHour`]!
     pub end: Option<DateHour<Utc>>,

primitives/src/analytics/query.rs

@@ -2,19 +2,17 @@ use std::{fmt, ops::Deref, str::FromStr};
 
 use ethereum_types::U256;
 
-use serde::{Deserialize, Deserializer, Serialize};
-use serde_hex::{SerHex, StrictPfx};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use hex::{FromHex, FromHexError};
 
-use crate::{Address, Validator, ValidatorId};
+use crate::{Address, Validator, ValidatorId, ToHex};
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Hash)]
+#[derive(Deserialize, PartialEq, Eq, Copy, Clone, Hash)]
 #[serde(transparent)]
 pub struct ChannelId(
     #[serde(
         deserialize_with = "deserialize_channel_id",
-        serialize_with = "SerHex::<StrictPfx>::serialize"
     )]
     [u8; 32],
 );
@@ -39,6 +37,15 @@ where
     validate_channel_id(&channel_id).map_err(serde::de::Error::custom)
 }
 
+impl Serialize for ChannelId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.0.to_hex_prefixed())
+    }
+}
+
 fn validate_channel_id(s: &str) -> Result<[u8; 32], FromHexError> {
     // strip `0x` prefix
     let hex = s.strip_prefix("0x").unwrap_or(s);

primitives/src/channel.rs

@@ -347,7 +347,6 @@ pub mod tests_postgres {
             let manager =
                 deadpool_postgres::Manager::from_config(config, NoTls, self.manager_config.clone());
 
-            // TODO: Fix error mapping
             let pool = deadpool_postgres::Pool::builder(manager)
                 .max_size(15)
                 .build()