progress on client

Author: patrick-ogrady

Cargo.lock

@@ -12,6 +12,8 @@ documentation = "https://docs.rs/alto-client"
 
 [dependencies]
 alto-types = { workspace = true }
+commonware-codec = { workspace = true }
+commonware-consensus = { workspace = true }
 commonware-cryptography = { workspace = true }
 commonware-utils = { workspace = true }
 bytes =  { workspace = true }

client/Cargo.toml

@@ -1,6 +1,9 @@
 use crate::{Client, Error, IndexQuery, Query};
-use alto_types::{Block, Finalized, Kind, Notarized, Seed};
+use alto_types::{Block, Finalized, Kind, Notarized, NAMESPACE};
 use bytes::Bytes;
+use commonware_codec::DecodeExt;
+use commonware_consensus::threshold_simplex::types::{Seed, Viewable};
+use commonware_cryptography::Digestible;
 use futures::{channel::mpsc::unbounded, Stream, StreamExt};
 use tokio_tungstenite::{connect_async, tungstenite::Message as TMessage};
 
@@ -76,18 +79,21 @@ impl Client {
             return Err(Error::Failed(result.status()));
         }
         let bytes = result.bytes().await.map_err(Error::Reqwest)?;
-        let result = Seed::deserialize(Some(&self.public), &bytes).ok_or(Error::InvalidData)?;
+        let seed = Seed::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
+        if !seed.verify(NAMESPACE, self.public.as_ref()) {
+            return Err(Error::InvalidSignature);
+        }
 
         // Verify the seed matches the query
         match query {
             IndexQuery::Latest => {}
             IndexQuery::Index(index) => {
-                if result.view != index {
-                    return Err(Error::InvalidData);
+                if seed.view() != index {
+                    return Err(Error::UnexpectedResponse);
                 }
             }
         }
-        Ok(result)
+        Ok(seed)
     }
 
     pub async fn notarization_upload(&self, notarized: Bytes) -> Result<(), Error> {
@@ -116,19 +122,21 @@ impl Client {
             return Err(Error::Failed(result.status()));
         }
         let bytes = result.bytes().await.map_err(Error::Reqwest)?;
-        let result =
-            Notarized::deserialize(Some(&self.public), &bytes).ok_or(Error::InvalidData)?;
+        let notarized = Notarized::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
+        if !notarized.verify(self.public.as_ref()) {
+            return Err(Error::InvalidSignature);
+        }
 
         // Verify the notarization matches the query
         match query {
             IndexQuery::Latest => {}
             IndexQuery::Index(index) => {
-                if result.proof.view != index {
-                    return Err(Error::InvalidData);
+                if notarized.proof.view() != index {
+                    return Err(Error::UnexpectedResponse);
                 }
             }
         }
-        Ok(result)
+        Ok(notarized)
     }
 
     pub async fn finalization_upload(&self, finalized: Bytes) -> Result<(), Error> {
@@ -157,19 +165,21 @@ impl Client {
             return Err(Error::Failed(result.status()));
         }
         let bytes = result.bytes().await.map_err(Error::Reqwest)?;
-        let result =
-            Finalized::deserialize(Some(&self.public), &bytes).ok_or(Error::InvalidData)?;
+        let finalized = Finalized::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
+        if !finalized.verify(self.public.as_ref()) {
+            return Err(Error::InvalidSignature);
+        }
 
         // Verify the finalization matches the query
         match query {
             IndexQuery::Latest => {}
             IndexQuery::Index(index) => {
-                if result.proof.view != index {
-                    return Err(Error::InvalidData);
+                if finalized.proof.view() != index {
+                    return Err(Error::UnexpectedResponse);
                 }
             }
         }
-        Ok(result)
+        Ok(finalized)
     }
 
     pub async fn block_get(&self, query: Query) -> Result<Payload, Error> {
@@ -188,22 +198,26 @@ impl Client {
         // Verify the block matches the query
         let result = match query {
             Query::Latest => {
-                let result =
-                    Finalized::deserialize(Some(&self.public), &bytes).ok_or(Error::InvalidData)?;
+                let result = Finalized::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
+                if !result.verify(self.public.as_ref()) {
+                    return Err(Error::InvalidSignature);
+                }
                 Payload::Finalized(Box::new(result))
             }
             Query::Index(index) => {
-                let result =
-                    Finalized::deserialize(Some(&self.public), &bytes).ok_or(Error::InvalidData)?;
+                let result = Finalized::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
+                if !result.verify(self.public.as_ref()) {
+                    return Err(Error::InvalidSignature);
+                }
                 if result.block.height != index {
-                    return Err(Error::InvalidData);
+                    return Err(Error::UnexpectedResponse);
                 }
                 Payload::Finalized(Box::new(result))
             }
             Query::Digest(digest) => {
-                let result = Block::deserialize(&bytes).ok_or(Error::InvalidData)?;
+                let result = Block::decode(bytes.as_ref()).map_err(Error::InvalidData)?;
                 if result.digest() != digest {
-                    return Err(Error::InvalidData);
+                    return Err(Error::UnexpectedResponse);
                 }
                 Payload::Block(result)
             }

client/src/consensus.rs

@@ -47,8 +47,12 @@ pub enum Error {
     Tungstenite(#[from] tokio_tungstenite::tungstenite::Error),
     #[error("failed: {0}")]
     Failed(reqwest::StatusCode),
-    #[error("invalid data")]
-    InvalidData,
+    #[error("invalid data: {0}")]
+    InvalidData(#[from] commonware_codec::Error),
+    #[error("invalid signature")]
+    InvalidSignature,
+    #[error("unexpected response")]
+    UnexpectedResponse,
 }
 
 #[derive(Clone)]

client/src/lib.rs

@@ -3,12 +3,41 @@
 mod block;
 pub use block::{Block, Finalized, Notarized};
 mod consensus;
+use commonware_utils::hex;
 pub use consensus::leader_index;
 pub mod wasm;
 
-// We don't use functions here to guard against silent changes.
 pub const NAMESPACE: &[u8] = b"_ALTO";
 
+#[repr(u8)]
+pub enum Kind {
+    Seed = 0,
+    Notarization = 1,
+    Nullification = 2,
+    Finalization = 3,
+}
+
+impl Kind {
+    pub fn from_u8(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(Self::Seed),
+            1 => Some(Self::Notarization),
+            2 => Some(Self::Nullification),
+            3 => Some(Self::Finalization),
+            _ => None,
+        }
+    }
+
+    pub fn to_hex(&self) -> String {
+        match self {
+            Self::Seed => hex(&[0]),
+            Self::Notarization => hex(&[1]),
+            Self::Nullification => hex(&[2]),
+            Self::Finalization => hex(&[3]),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;