formalize and decouple XMTP attributes from did:ethr

Author: insipx

lib/src/types.rs

@@ -4,6 +4,7 @@
 mod did_parser;
 mod did_url;
 mod ethr;
+mod xmtp;
 
 use serde::{Deserialize, Serialize};
 use std::fmt;
@@ -12,6 +13,7 @@ use url::Url;
 pub use did_parser::*;
 pub use did_url::*;
 pub use ethr::*;
+pub use xmtp::*;
 
 /// The ethereum null addresss
 pub const NULL_ADDRESS: &str = "0x0000000000000000000000000000000000000000";
@@ -191,26 +193,11 @@ impl From<KeyType> for String {
     }
 }
 
-/// Any extra key-specific metadata that could be ascribed to the key
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Serialize, Deserialize)]
-pub enum KeyMetadata {
-    Installation,
-}
-
-impl fmt::Display for KeyMetadata {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            KeyMetadata::Installation => write!(f, "inst"),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum KeyPurpose {
     VerificationKey,
     SignatureAuthentication,
     Encryption,
-    Xmtp,
 }
 
 impl fmt::Display for KeyPurpose {
@@ -219,7 +206,6 @@ impl fmt::Display for KeyPurpose {
             KeyPurpose::VerificationKey => write!(f, "veriKey"),
             KeyPurpose::SignatureAuthentication => write!(f, "sigAuth"),
             KeyPurpose::Encryption => write!(f, "enc"),
-            KeyPurpose::Xmtp => write!(f, "xmtp"),
         }
     }
 }
@@ -236,28 +222,22 @@ pub enum Attribute {
     PublicKey(PublicKey),
     Service(ServiceType),
     Other(String),
+    Xmtp(XmtpAttribute),
 }
 
 impl fmt::Display for Attribute {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Attribute::PublicKey(key) => {
-                if let Some(metadata) = key.metadata {
-                    write!(
-                        f,
-                        "did/pub/{}/{}/{}/{}",
-                        key.key_type, key.purpose, metadata, key.encoding
-                    )
-                } else {
-                    write!(
-                        f,
-                        "did/pub/{}/{}/{}",
-                        key.key_type, key.purpose, key.encoding
-                    )
-                }
+                write!(
+                    f,
+                    "did/pub/{}/{}/{}",
+                    key.key_type, key.purpose, key.encoding
+                )
             }
             Attribute::Service(service) => write!(f, "did/svc/{}", service),
             Attribute::Other(other) => write!(f, "{}", other),
+            Attribute::Xmtp(xmtp) => write!(f, "xmtp/{}/{}", xmtp.purpose, xmtp.encoding),
         }
     }
 }
@@ -309,7 +289,6 @@ impl From<KeyEncoding> for String {
 pub struct PublicKey {
     pub key_type: KeyType,
     pub purpose: KeyPurpose,
-    pub metadata: Option<KeyMetadata>,
     pub encoding: KeyEncoding,
 }
 
@@ -483,19 +462,19 @@ mod test {
             let bytes: [u8; 32] = parsed.into();
             assert_eq!(String::from_utf8_lossy(&bytes), attribute);
         };
-        t("did/pub/Ed25519/xmtp/inst/base58");
+        t("xmtp/installation/base58        ");
+        t("xmtp/installation/hex           ");
+        t("xmtp/installation/base64        ");
+        t("did/pub/Ed25519/veriKey/base58  ");
+        t("did/pub/Secp256k1/veriKey/base64");
         t("did/svc/MessagingService        ");
-        t("did/pub/Secp256k1/xmtp/inst/hex ");
-        t("did/pub/RSA/xmtp/inst/hex       ");
-        t("did/pub/Ed25519/xmtp/inst/base64");
     }
 
     #[test]
     fn test_attribute_to_string() {
         let attr = Attribute::PublicKey(PublicKey {
             key_type: KeyType::Ed25519VerificationKey2020,
             purpose: KeyPurpose::VerificationKey,
-            metadata: None,
             encoding: KeyEncoding::Base58,
         });
         assert_eq!(attr.to_string(), "did/pub/Ed25519/veriKey/base58");

lib/src/types/did_parser.rs

@@ -81,10 +81,7 @@ peg::parser! {
             = kt:(secp256k1() / ed25519() / rsa() / x25519() ) { kt }
 
         rule key_purpose() -> KeyPurpose
-            = i("veriKey") { KeyPurpose::VerificationKey } / "sigAuth" { KeyPurpose::SignatureAuthentication } / "enc" { KeyPurpose::Encryption } / "xmtp" { KeyPurpose::Xmtp }
-
-        rule key_metadata() -> KeyMetadata
-            = i("inst") { KeyMetadata::Installation }
+            = i("veriKey") { KeyPurpose::VerificationKey } / "sigAuth" { KeyPurpose::SignatureAuthentication } / "enc" { KeyPurpose::Encryption }
 
         rule encoding() -> KeyEncoding
             = i("hex") { KeyEncoding::Hex } / "base64" { KeyEncoding::Base64 } / "base58" { KeyEncoding::Base58 }
@@ -98,24 +95,30 @@ peg::parser! {
         rule service() -> ServiceType
             = padding() "did/svc/" svc:(messaging_service() / other_service()) padding()  { svc }
 
-        rule public_key() -> (KeyType, KeyPurpose, Option<KeyMetadata>, KeyEncoding)
-            = padding() "did/pub/" kt:key_type() "/" kp:key_purpose() "/" me:metadata_and_encoding() padding() {
-                (kt, kp, me.0, me.1)
+        rule public_key() -> (KeyType, KeyPurpose, KeyEncoding)
+            = padding() "did/pub/" kt:key_type() "/" kp:key_purpose() "/" enc:encoding() padding() {
+                (kt, kp, enc)
             }
 
-        rule metadata_and_encoding() -> (Option<KeyMetadata>, KeyEncoding)
-            = km:key_metadata() "/" enc:encoding() { (Some(km), enc) } / enc:encoding() { (None, enc) }
+        rule xmtp_purpose() -> XmtpKeyPurpose
+            = "installation" { XmtpKeyPurpose::Installation }
+
+        rule xmtp() -> Attribute
+            = padding() "xmtp/" xmtp:xmtp_purpose() "/" enc:encoding() padding() { Attribute::Xmtp(XmtpAttribute { purpose: xmtp, encoding: enc })}
+
+        rule ethr() -> Attribute
+            = pk:public_key() {
+                let key = PublicKey { key_type: pk.0, purpose: pk.1, encoding: pk.2 };
+                Attribute::PublicKey(key)
+            }
+            / svc:service() { Attribute::Service(svc) }
 
         /// Parses the DID attribute name value
         ///
         /// Parses the `did/pub/(Secp256k1|RSA|Ed25519|X25519)/(veriKey|sigAuth|enc|xmtp)/(hex|base64|base58)` part of a DID attribute name for adding a public key,
         /// or the `did/svc/[ServiceName]` part for adding a service
         pub rule attribute() -> Attribute
-            = pk:public_key() {
-                let key = PublicKey { key_type: pk.0, purpose: pk.1, metadata: pk.2, encoding: pk.3 };
-                Attribute::PublicKey(key)
-            }
-            / svc:service() { Attribute::Service(svc) }
+            = x:xmtp() { x } / e:ethr() { e }
         }
 }
 
@@ -186,12 +189,6 @@ mod tests {
             "did/pub/X25519/enc/hex",
             "did/pub/X25519/enc/base64",
             "did/pub/X25519/enc/base58",
-            "did/pub/ed25519/xmtp/inst/hex",
-            "did/pub/x25519/xmtp/inst/hex",
-            "did/pub/Secp256k1/xmtp/inst/hex",
-            "did/pub/RSA/xmtp/inst/hex",
-            "did/pub/ed25519/xmtp/inst/base64",
-            "did/pub/ed25519/xmtp/inst/base58",
             "did/svc/MessagingService",
         ];
 
@@ -201,6 +198,47 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_did_xmtp_attribute_parser() {
+        let keys = [
+            "xmtp/installation/hex",
+            "xmtp/installation/base58",
+            "xmtp/installation/base64",
+        ];
+
+        for key in keys {
+            let parsed = parse_attribute(key);
+            assert!(parsed.is_ok(), "Failed to parse key: {}", key);
+        }
+    }
+
+    #[test]
+    fn test_xmtp_attribute_parses() {
+        assert_eq!(
+            parse_attribute("xmtp/installation/hex"),
+            Ok(Attribute::Xmtp(XmtpAttribute {
+                purpose: XmtpKeyPurpose::Installation,
+                encoding: KeyEncoding::Hex
+            }))
+        );
+
+        assert_eq!(
+            parse_attribute("xmtp/installation/base64"),
+            Ok(Attribute::Xmtp(XmtpAttribute {
+                purpose: XmtpKeyPurpose::Installation,
+                encoding: KeyEncoding::Base64,
+            }))
+        );
+
+        assert_eq!(
+            parse_attribute("xmtp/installation/base58"),
+            Ok(Attribute::Xmtp(XmtpAttribute {
+                purpose: XmtpKeyPurpose::Installation,
+                encoding: KeyEncoding::Base58
+            }))
+        );
+    }
+
     #[test]
     fn test_ethr_method_parser() {
         let parsed =