Add support for undecodable credentials

core/conversations/src/conversation/group_v2.rs

@@ -465,7 +465,6 @@ impl GroupV2Convo {
                     convo_id: self.convo_id.clone(),
                     content: Some(Content {
                         bytes: cm.message.clone(),
-                        // D
                         encoded_credential: cred,
                     }),
                 })

core/conversations/src/conversation/privatev1.rs

@@ -197,7 +197,7 @@ impl PrivateV1Convo {
     fn handle_content(&self, bytes: Bytes) -> Content {
         Content {
             bytes: bytes.into(),
-            encoded_credential: vec![114, 114],
+            encoded_credential: vec![],
         }
     }
 

crates/client/src/client.rs

@@ -313,9 +313,12 @@ fn convo_events(outcome: ConvoOutcome) -> Vec<Event> {
     let ConvoOutcome { convo_id, content } = outcome;
     content
         .map(|c| {
-            let data = hex::decode(c.encoded_credential).unwrap();
+            if let Ok(data) = hex::decode(c.encoded_credential) {
-            let delegate_cred = DelegateCredential::from(data);
+                if let Ok(delegate_cred) = DelegateCredential::try_from(data) {
-            println!("{:?}", delegate_cred);
+                    println!("{:?}", delegate_cred);
+                    // TODO: Integration Point
+                }
+            }
 
             Event::MessageReceived {
                 convo_id: Arc::from(convo_id),

crates/client/src/delegate.rs

@@ -100,9 +100,13 @@ impl From<DelegateCredential> for Vec<u8> {
     }
 }
 
-impl From<Vec<u8>> for DelegateCredential {
+impl TryFrom<Vec<u8>> for DelegateCredential {
-    fn from(value: Vec<u8>) -> Self {
+    type Error = ClientError;
-        assert_eq!(&value[..2], &[0x23, 0x23], "invalid magic bytes");
+
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        if value.get(..2) != Some(&[0x23, 0x23]) {
+            return Err(ClientError::BadlyFormedCredential);
+        }
         let mut delegate_id = None;
         let mut account_addr = None;
         let mut i = 2;
@@ -110,26 +114,33 @@ impl From<Vec<u8>> for DelegateCredential {
             let tag = value[i];
             let len = value[i + 1] as usize;
             i += 2;
-            let v = &value[i..i + len];
+            let v = value
+                .get(i..i + len)
+                .ok_or(ClientError::BadlyFormedCredential)?;
             i += len;
             match tag {
                 DelegateCredential::TAG_DELEGATE_ID => {
-                    let bytes: &[u8; 32] = v.try_into().expect("invalid delegate_id length");
+                    let bytes: &[u8; 32] = v
+                        .try_into()
+                        .map_err(|_| ClientError::BadlyFormedCredential)?;
                     delegate_id = Some(
-                        Ed25519VerifyingKey::from_bytes(bytes).expect("invalid verifying key"),
+                        Ed25519VerifyingKey::from_bytes(bytes)
+                            .map_err(|_| ClientError::BadlyFormedCredential)?,
                     );
                 }
                 DelegateCredential::TAG_ACCOUNT_ADDR => {
-                    account_addr =
+                    account_addr = Some(
-                        Some(String::from_utf8(v.to_vec()).expect("invalid account_addr utf8"));
+                        String::from_utf8(v.to_vec())
+                            .map_err(|_| ClientError::BadlyFormedCredential)?,
+                    );
                 }
                 _ => {}
             }
         }
-        Self {
+        Ok(Self {
-            delegate_id: delegate_id.expect("missing delegate_id TLV field"),
+            delegate_id: delegate_id.ok_or(ClientError::BadlyFormedCredential)?,
             account_addr,
-        }
+        })
     }
 }
 
@@ -143,8 +154,8 @@ impl TryFrom<IdentId> for DelegateCredential {
     type Error = ClientError;
 
     fn try_from(value: IdentId) -> Result<Self, Self::Error> {
-        Ok(hex::decode(value.as_str())
+        hex::decode(value.as_str())
-            .map_err(|e| ClientError::BadlyFormedCredential)?
+            .map_err(|_| ClientError::BadlyFormedCredential)?
-            .into())
+            .try_into()
     }
 }