Fetch Key Packages Companion (#41)

* didUrl updates for query

* query map

* query pairs

* remove indexmap

* test coverage

* re-run coverage

* small tests

* fix assert_eq! -> assert!

Author: insipx

Cargo.lock

@@ -57,3 +57,29 @@ pub enum RegistrySignerError<M: Middleware> {
     #[error(transparent)]
     Wallet(#[from] WalletError),
 }
+
+/// General type error
+#[derive(Error, Debug)]
+pub enum TypeError {
+    #[error(transparent)]
+    HexConversion(#[from] hex::FromHexError),
+    #[error(transparent)]
+    Base58Conversion(#[from] bs58::decode::Error),
+    #[error(transparent)]
+    Base64Conversion(#[from] base64::DecodeError),
+}
+
+#[cfg(test)]
+mod tests {
+    use ethers::providers::{MockProvider, Provider};
+
+    use super::*;
+
+    #[test]
+    fn test_resolver_error() {
+        let err = ResolverError::<Provider<MockProvider>>::Middleware("test".to_string());
+        let err_obj: ErrorObjectOwned = err.into();
+        assert_eq!(err_obj.code(), -31000);
+        assert_eq!(err_obj.message(), "test");
+    }
+}

lib/src/error.rs

@@ -19,17 +19,21 @@ use crate::{
 
 /// A resolver for did:ethr that follows the steps outlined in the [spec](https://github.com/decentralized-identity/ethr-did-resolver/blob/master/doc/did-method-spec.md#read-resolve) in order to resolve a did:ethr identifier.
 pub struct Resolver<M> {
-    signer: Arc<M>,
     registry: DIDRegistry<M>,
 }
 
+impl<M> From<DIDRegistry<M>> for Resolver<M> {
+    fn from(registry: DIDRegistry<M>) -> Self {
+        Self { registry }
+    }
+}
+
 impl<M: Middleware + 'static> Resolver<M> {
     /// Instantiate a new did:ethr resolver
     pub async fn new(middleware: M, registry: Address) -> Result<Self, ResolverError<M>> {
-        let signer = Arc::new(middleware);
-        let registry = DIDRegistry::new(registry, signer.clone());
+        let registry = DIDRegistry::new(registry, middleware.into());
         log::debug!("Using deployed registry at {}", registry.address());
-        Ok(Self { signer, registry })
+        Ok(Self { registry })
     }
 
     /// Resolve a did:ethr identifier
@@ -131,12 +135,12 @@ impl<M: Middleware + 'static> Resolver<M> {
         base_document.account_address(&public_key)?;
 
         let current_block = self
-            .signer
+            .signer()
             .get_block_number()
             .await
             .map_err(|e| ResolverError::Middleware(e.to_string()))?;
         let current_block = self
-            .signer
+            .signer()
             .get_block(current_block)
             .await
             .map_err(|e| ResolverError::Middleware(e.to_string()))?;
@@ -182,7 +186,7 @@ impl<M: Middleware + 'static> Resolver<M> {
 
         // get the timestamp for the current_verison_id
         let current_version_timestamp = self
-            .signer
+            .signer()
             .get_block(current_version_id)
             .await
             .map_err(|e| ResolverError::Middleware(e.to_string()))?
@@ -196,7 +200,7 @@ impl<M: Middleware + 'static> Resolver<M> {
                 next_version_id: last_updated_did_version_id.map(|ver| ver.as_u64()),
                 next_update: match last_updated_did_version_id {
                     Some(ver) => self
-                        .signer
+                        .signer()
                         .get_block(ver)
                         .await
                         .map_err(|e| ResolverError::Middleware(e.to_string()))?
@@ -211,4 +215,21 @@ impl<M: Middleware + 'static> Resolver<M> {
         };
         Ok(resolution_result)
     }
+
+    fn signer(&self) -> Arc<M> {
+        self.registry.client()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_registry() {
+        let (provider, _) = ethers::providers::Provider::mocked();
+        let registry = DIDRegistry::new(Address::zero(), Arc::new(provider));
+        let resolver = Resolver::from(registry);
+        assert_eq!(resolver.registry.address(), Address::zero());
+    }
 }

lib/src/resolver.rs

@@ -66,3 +66,19 @@ impl From<RpcError> for ErrorObjectOwned {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rpc_error_conversion() {
+        let gen_error = H160::from_str("0xerror").unwrap_err();
+        let rpc_error = RpcError::from(gen_error);
+
+        let error_object = ErrorObjectOwned::from(rpc_error);
+
+        assert_eq!(error_object.code(), -31999);
+        assert_eq!(error_object.message(), "Invalid public key format");
+    }
+}

lib/src/rpc/methods.rs

@@ -6,6 +6,8 @@ mod did_url;
 mod ethr;
 mod xmtp;
 
+use crate::error::TypeError;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use url::Url;
@@ -120,23 +122,34 @@ pub enum VerificationMethodProperties {
         #[serde(rename = "publicKeyBase58")]
         public_key_base58: String,
     },
-    /// Public key as a Json-Web-Key
-    PublicKeyJwk {
-        #[serde(rename = "publicKeyJwk")]
-        public_key_jwk: String,
-    },
-    /// Public key in Multibase format
-    PublicKeyMultibase {
-        #[serde(rename = "publicKeyMultibase")]
-        public_key_multibase: String,
-    },
     /// Blockcahin account identitfier, case insensitive (does not support EIP-55)
     BlockchainAccountId {
         #[serde(rename = "blockchainAccountId")]
         blockchain_account_id: String,
     },
 }
 
+impl TryFrom<VerificationMethodProperties> for Vec<u8> {
+    type Error = TypeError;
+
+    fn try_from(prop: VerificationMethodProperties) -> Result<Vec<u8>, Self::Error> {
+        match prop {
+            VerificationMethodProperties::PublicKeyHex { public_key_hex } => {
+                Ok(hex::decode(public_key_hex)?)
+            }
+            VerificationMethodProperties::PublicKeyBase64 { public_key_base64 } => {
+                Ok(BASE64.decode(public_key_base64)?)
+            }
+            VerificationMethodProperties::PublicKeyBase58 { public_key_base58 } => {
+                Ok(bs58::decode(public_key_base58).into_vec()?)
+            }
+            VerificationMethodProperties::BlockchainAccountId {
+                blockchain_account_id,
+            } => Ok(hex::decode(blockchain_account_id)?),
+        }
+    }
+}
+
 /// Represents different types of services associated with a DID.
 /// Currently, only [`ServiceType::Messaging`] is directly supported
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
@@ -253,14 +266,20 @@ impl From<Attribute> for String {
 // will be cutoff.
 impl From<Attribute> for [u8; 32] {
     fn from(attribute: Attribute) -> [u8; 32] {
-        let mut attr_bytes: [u8; 32] = [b' '; 32];
-        let attr_string = attribute.to_string();
-        let length = std::cmp::min(attr_string.as_bytes().len(), 32);
-        attr_bytes[0..length].copy_from_slice(&attr_string.as_bytes()[0..length]);
-        attr_bytes
+        string_to_bytes32(attribute.to_string())
     }
 }
 
+// internal function to fill a [u8; 32] with bytes.
+// anything over 32 bytes will be cutoff.
+fn string_to_bytes32<S: AsRef<str>>(s: S) -> [u8; 32] {
+    let s = s.as_ref();
+    let mut attr_bytes: [u8; 32] = [b' '; 32];
+    let length = std::cmp::min(s.as_bytes().len(), 32);
+    attr_bytes[0..length].copy_from_slice(&s.as_bytes()[0..length]);
+    attr_bytes
+}
+
 /// Indicates the encoding of a key in a did:ethr attribute
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum KeyEncoding {
@@ -369,7 +388,7 @@ mod test {
               {
                 "controller": "did:ethr:mainnet:0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad",
                 "id": "did:ethr:mainnet:0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad",
-                "publicKeyMultibase": "0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad",
+                "blockchainAccountId": "0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad",
                 "type": "Ed25519VerificationKey2020"
               }
             ]
@@ -405,8 +424,8 @@ mod test {
                     .unwrap(),
                     verification_type: KeyType::Ed25519VerificationKey2020,
                     verification_properties: Some(
-                        VerificationMethodProperties::PublicKeyMultibase {
-                            public_key_multibase: "0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad"
+                        VerificationMethodProperties::BlockchainAccountId {
+                            blockchain_account_id: "0x6ceb0bf1f28ca4165d5c0a04f61dc733987ed6ad"
                                 .to_string(),
                         }
                     ),
@@ -545,4 +564,56 @@ mod test {
         let encoding = KeyEncoding::Base58;
         assert_eq!(String::from(encoding), "base58".to_string());
     }
+
+    #[test]
+    fn test_string_to_bytes32() {
+        let s = "xmtp/installation/base58";
+        let bytes: [u8; 32] = string_to_bytes32(s);
+        assert_eq!(
+            String::from_utf8_lossy(&bytes),
+            "xmtp/installation/base58        "
+        );
+
+        let s = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
+        let bytes: [u8; 32] = string_to_bytes32(s);
+        assert_eq!(
+            String::from_utf8_lossy(&bytes),
+            s.chars().take(32).collect::<String>()
+        );
+    }
+
+    #[test]
+    fn test_verification_method_properties_converts_to_bytes() {
+        let prop = VerificationMethodProperties::PublicKeyHex {
+            public_key_hex: "0000000000000000000000000000000000000000".to_string(),
+        };
+        let bytes: Vec<u8> = prop.try_into().unwrap();
+        assert_eq!(
+            bytes,
+            hex::decode("0000000000000000000000000000000000000000").unwrap()
+        );
+
+        let b64 = BASE64.encode("base64");
+        let prop = VerificationMethodProperties::PublicKeyBase64 {
+            public_key_base64: b64.clone(),
+        };
+        let bytes: Vec<u8> = prop.try_into().unwrap();
+        assert_eq!(bytes, BASE64.decode(b64).unwrap());
+
+        let b58 = bs58::encode("base58").into_string();
+        let prop = VerificationMethodProperties::PublicKeyBase58 {
+            public_key_base58: b58.clone(),
+        };
+        let bytes: Vec<u8> = prop.try_into().unwrap();
+        assert_eq!(bytes, bs58::decode(b58.clone()).into_vec().unwrap());
+
+        let prop = VerificationMethodProperties::BlockchainAccountId {
+            blockchain_account_id: "0000000000000000000000000000000000000000".to_string(),
+        };
+        let bytes: Vec<u8> = prop.try_into().unwrap();
+        assert_eq!(
+            bytes,
+            hex::decode("0000000000000000000000000000000000000000").unwrap()
+        );
+    }
 }

lib/src/types.rs

@@ -282,6 +282,13 @@ impl DidUrl {
         self.path.as_deref()
     }
 
+    pub fn contains_query(&self, key: String, value: String) -> bool {
+        self.query
+            .as_ref()
+            .map(|q| q.contains(&(key, value)))
+            .unwrap_or(false)
+    }
+
     pub fn query(&self) -> Option<&[(String, String)]> {
         self.query.as_deref()
     }
@@ -717,4 +724,25 @@ mod tests {
         assert_eq!(Network::from("sepolia"), Network::Sepolia);
         assert_eq!(Network::from("1a1"), Network::Other(0x1a1));
     }
+
+    #[test]
+    fn test_contains_query() {
+        let did_url = DidUrl::parse("did:ethr:mainnet:0x0000000000000000000000000000000000000000?meta=hi&username=&password=hunter2").unwrap();
+
+        assert!(did_url.contains_query("meta".into(), "hi".into()));
+        assert!(did_url.contains_query("username".into(), "".into()));
+        assert!(did_url.contains_query("password".into(), "hunter2".into()));
+        assert!(!did_url.contains_query("does".into(), "not exist".into()));
+
+        let did_url =
+            DidUrl::parse("did:ethr:mainnet:0x0000000000000000000000000000000000000000").unwrap();
+        assert!(!did_url.contains_query("no".into(), "queries".into()));
+    }
+
+    #[test]
+    fn test_network_to_string() {
+        assert_eq!(Network::Mainnet.to_string(), "mainnet");
+        assert_eq!(Network::Sepolia.to_string(), "sepolia");
+        assert_eq!(Network::Other(0x1a1).to_string(), "417");
+    }
 }

lib/src/types/did_url.rs

@@ -14,7 +14,7 @@
 //! *_NOTE:_* This format may be updated and changed according to the needs of the XMTP protocol. (currently
 //! in development)
 
-use super::{Attribute, EthrBuilder, KeyEncoding, KeyType, VerificationMethod};
+use super::{string_to_bytes32, Attribute, EthrBuilder, KeyEncoding, KeyType, VerificationMethod};
 use crate::error::EthrBuilderError;
 
 use std::fmt;
@@ -30,6 +30,12 @@ pub struct XmtpAttribute {
     pub encoding: KeyEncoding,
 }
 
+impl From<XmtpAttribute> for [u8; 32] {
+    fn from(attr: XmtpAttribute) -> Self {
+        string_to_bytes32(attr.to_string())
+    }
+}
+
 impl fmt::Display for XmtpAttribute {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "xmtp/{}/{}", self.purpose, self.encoding)
@@ -89,6 +95,7 @@ impl EthrBuilder {
             verification_type: KeyType::Ed25519VerificationKey2020,
             verification_properties: Self::encode_attribute_value(value, key.encoding)?,
         };
+
         match key.purpose {
             XmtpKeyPurpose::Installation => {
                 self.authentication.push(method.id.clone());
@@ -191,4 +198,17 @@ mod test {
         assert_eq!(purpose.to_string(), "installation");
         assert_eq!(String::from(purpose), "installation");
     }
+
+    #[test]
+    fn test_xmtp_attribute_bytes() {
+        let attr = XmtpAttribute {
+            purpose: XmtpKeyPurpose::Installation,
+            encoding: KeyEncoding::Hex,
+        };
+
+        assert_eq!(
+            b"xmtp/installation/hex           ".as_slice(),
+            <[u8; 32]>::from(attr)
+        );
+    }
 }