update client

Author: patrick-ogrady

client/src/consensus.rs

@@ -242,35 +242,61 @@ impl Client {
                         // Get kind
                         let kind = data[0];
                         let Some(kind) = Kind::from_u8(kind) else {
-                            let _ = sender.unbounded_send(Err(Error::InvalidData));
+                            let _ = sender.unbounded_send(Err(Error::UnexpectedResponse));
                             return;
                         };
                         let data = &data[1..];
 
                         // Deserialize the message
                         match kind {
                             Kind::Seed => {
-                                if let Some(seed) = Seed::deserialize(Some(&public), data) {
-                                    let _ = sender.unbounded_send(Ok(Message::Seed(seed)));
-                                } else {
-                                    let _ = sender.unbounded_send(Err(Error::InvalidData));
+                                let result = Seed::decode(data);
+                                match result {
+                                    Ok(seed) => {
+                                        if !seed.verify(NAMESPACE, public.as_ref()) {
+                                            let _ =
+                                                sender.unbounded_send(Err(Error::InvalidSignature));
+                                            return;
+                                        }
+                                        let _ = sender.unbounded_send(Ok(Message::Seed(seed)));
+                                    }
+                                    Err(e) => {
+                                        let _ = sender.unbounded_send(Err(Error::InvalidData(e)));
+                                    }
                                 }
                             }
                             Kind::Notarization => {
-                                if let Some(payload) = Notarized::deserialize(Some(&public), data) {
-                                    let _ =
-                                        sender.unbounded_send(Ok(Message::Notarization(payload)));
-                                } else {
-                                    let _ = sender.unbounded_send(Err(Error::InvalidData));
+                                let result = Notarized::decode(data);
+                                match result {
+                                    Ok(notarized) => {
+                                        if !notarized.verify(public.as_ref()) {
+                                            let _ =
+                                                sender.unbounded_send(Err(Error::InvalidSignature));
+                                            return;
+                                        }
+                                        let _ = sender
+                                            .unbounded_send(Ok(Message::Notarization(notarized)));
+                                    }
+                                    Err(e) => {
+                                        let _ = sender.unbounded_send(Err(Error::InvalidData(e)));
+                                    }
                                 }
                             }
-                            Kind::Nullification => {} // Ignore nullifications
                             Kind::Finalization => {
-                                if let Some(payload) = Finalized::deserialize(Some(&public), data) {
-                                    let _ =
-                                        sender.unbounded_send(Ok(Message::Finalization(payload)));
-                                } else {
-                                    let _ = sender.unbounded_send(Err(Error::InvalidData));
+                                let result = Finalized::decode(data);
+                                match result {
+                                    Ok(finalized) => {
+                                        if !finalized.verify(public.as_ref()) {
+                                            let _ =
+                                                sender.unbounded_send(Err(Error::InvalidSignature));
+                                            return;
+                                        }
+                                        let _ = sender
+                                            .unbounded_send(Ok(Message::Finalization(finalized)));
+                                    }
+                                    Err(e) => {
+                                        let _ = sender.unbounded_send(Err(Error::InvalidData(e)));
+                                    }
                                 }
                             }
                         }

types/src/lib.rs

@@ -13,17 +13,15 @@ pub const NAMESPACE: &[u8] = b"_ALTO";
 pub enum Kind {
     Seed = 0,
     Notarization = 1,
-    Nullification = 2,
-    Finalization = 3,
+    Finalization = 2,
 }
 
 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),
+            2 => Some(Self::Finalization),
             _ => None,
         }
     }
@@ -32,8 +30,7 @@ impl Kind {
         match self {
             Self::Seed => hex(&[0]),
             Self::Notarization => hex(&[1]),
-            Self::Nullification => hex(&[2]),
-            Self::Finalization => hex(&[3]),
+            Self::Finalization => hex(&[2]),
         }
     }
 }