Add version_id support

Cargo.toml

@@ -33,6 +33,7 @@ rustc-hex= "2.1"
 peg = "0.8"
 dotenvy = "0.15.7"
 envy = "0.4.2"
+chrono = "0.4.27"
 
 [dev-dependencies]
 jsonrpsee = { version = "0.21", features = ["macros", "server", "client"] }

src/lib.rs

@@ -85,6 +85,7 @@ pub mod types;
 mod util;
 
 use serde::Deserialize;
+use std::process;
 use std::str::FromStr;
 
 use anyhow::Result;
@@ -130,13 +131,34 @@ fn default_provider() -> String {
 /// Entrypoint for the did:ethr Gateway
 pub async fn run() -> Result<()> {
     crate::util::init_logging();
-    dotenvy::dotenv()?;
-    let opts: DidEthGatewayApp = envy::from_env()?;
+    match dotenvy::dotenv() {
+        Ok(path) => {
+            // .env file successfully loaded.
+            log::debug!("Env file {} was loaded successfully", path.display());
+        }
+        Err(err) => {
+            // Error handling for the case where dotenv() fails
+            log::info!("Unable to load env file(s) : {err}");
+        }
+    }
+    let opts = envy::from_env::<DidEthGatewayApp>()?;
 
     let server = Server::builder().build(opts.address).await?;
     let addr = server.local_addr()?;
     let registry_address = Address::from_str(DID_ETH_REGISTRY)?;
-    let resolver = Resolver::new(opts.provider, registry_address).await?;
+    let provider = opts.provider.clone();
+    let resolver: Resolver = match Resolver::new(opts.provider, registry_address).await {
+        Ok(resolver) => resolver,
+        Err(err) => {
+            log::error!(
+                "Unable to create a resolver for provider {} and registry address {} : {})",
+                provider,
+                registry_address,
+                err
+            );
+            process::exit(-1);
+        }
+    };
     let handle = server.start(rpc::DidRegistryMethods::new(resolver).into_rpc());
 
     log::info!("Server Started at {addr}");

src/resolver.rs

@@ -10,10 +10,13 @@ use ethers::{
     providers::{Middleware, Ws},
     types::{Address, H160, H256, U256, U64},
 };
+
 use rand::{rngs::StdRng, SeedableRng};
 
 use self::did_registry::{DIDRegistry, DIDRegistryEvents};
-use crate::types::DidDocument;
+use crate::types::{
+    DidDocument, DidDocumentMetadata, DidResolutionMetadata, DidResolutionResult, EthrBuilder,
+};
 
 type ResolverSigner = SignerMiddleware<Provider<Ws>, LocalWallet>;
 
@@ -37,9 +40,15 @@ impl Resolver {
         Ok(Self { signer, registry })
     }
 
-    pub async fn resolve_did(&self, public_key: H160) -> Result<DidDocument> {
+    pub async fn resolve_did(
+        &self,
+        public_key: H160,
+        version_id: Option<U64>,
+    ) -> Result<DidResolutionResult> {
         let history = self.changelog(public_key).await?;
-        Ok(self.wrap_did_document(public_key, history).await?)
+        Ok(self
+            .wrap_did_resolution(public_key, version_id, history)
+            .await?)
     }
 
     async fn changelog(&self, public_key: H160) -> Result<Vec<(DIDRegistryEvents, LogMeta)>> {
@@ -79,56 +88,150 @@ impl Resolver {
         Ok(history)
     }
 
-    async fn wrap_did_document(
+    fn dispatch_event(
+        &self,
+        doc: &mut EthrBuilder,
+        public_key: H160,
+        event: DIDRegistryEvents,
+        meta: LogMeta,
+        deactivated: &mut bool,
+    ) {
+        let res = match event {
+            DIDRegistryEvents::DiddelegateChangedFilter(delegate_changed) => {
+                doc.delegate_event(delegate_changed)
+            }
+            DIDRegistryEvents::DidattributeChangedFilter(attribute_event) => {
+                doc.attribute_event(attribute_event)
+            }
+            DIDRegistryEvents::DidownerChangedFilter(owner_changed) => {
+                match doc.owner_event(owner_changed) {
+                    Err(err) => Err(err),
+                    Ok(v) => {
+                        *deactivated = v;
+                        Ok(())
+                    }
+                }
+            }
+        };
+
+        // if a did was set with the wrong format, for instance set-attribute was called with
+        // raw bytes instead of hex-encoded bytes, we don't want to cancel resolution of the
+        // rest of the DID
+        //
+        // TODO: Send this info as an extra json field to the caller apart from the DID Document
+        if let Err(e) = res {
+            log::error!(
+                    "Error while resolving for {} at event block={}, log index={}, incorrect format?: {}",
+                    public_key, meta.block_number, meta.log_index, e,
+                );
+        };
+    }
+
+    async fn wrap_did_resolution(
         &self,
         public_key: H160,
+        version_id: Option<U64>,
         history: Vec<(DIDRegistryEvents, LogMeta)>,
-    ) -> Result<DidDocument> {
+    ) -> Result<DidResolutionResult> {
         let mut base_document = DidDocument::ethr_builder();
         base_document.public_key(&public_key)?;
 
         let current_block = self.signer.get_block_number().await?;
         let current_block = self.signer.get_block(current_block).await?;
 
         let now = current_block.map(|b| b.timestamp).unwrap_or(U256::zero());
-        let mut version_id = U64::zero();
+        let mut current_version_id = U64::zero();
 
         base_document.now(now);
+        let mut last_updated_did_version_id: Option<U64> = { None };
+        let mut deactivated = false;
 
         for (event, meta) in history {
-            let LogMeta {
-                block_number,
-                log_index,
-                ..
-            } = meta;
-
-            if version_id < block_number {
-                version_id = block_number;
-            }
-
-            let res = match event {
-                DIDRegistryEvents::DiddelegateChangedFilter(delegate_changed) => {
-                    base_document.delegate_event(delegate_changed)
-                }
-                DIDRegistryEvents::DidattributeChangedFilter(attribute_event) => {
-                    base_document.attribute_event(attribute_event)
+            let LogMeta { block_number, .. } = meta;
+
+            if version_id.unwrap_or_default() > U64::zero() {
+                if meta.block_number <= version_id.unwrap_or_default() {
+                    // 1. delegate events
+                    Resolver::dispatch_event(
+                        &self,
+                        &mut base_document,
+                        public_key,
+                        event,
+                        meta,
+                        &mut deactivated,
+                    );
+                    // 2. set latest version
+                    if current_version_id < block_number {
+                        current_version_id = block_number;
+                    }
+                } else {
+                    // just update the next version before quitting.
+                    last_updated_did_version_id = Some(block_number);
+                    break;
                 }
-                DIDRegistryEvents::DidownerChangedFilter(owner_changed) => {
-                    base_document.owner_event(owner_changed)
+            } else {
+                // 1. delegate events
+                Resolver::dispatch_event(
+                    &self,
+                    &mut base_document,
+                    public_key,
+                    event,
+                    meta,
+                    &mut deactivated,
+                );
+                // 2. set latest version
+                if current_version_id < block_number {
+                    current_version_id = block_number;
                 }
             };
-
-            // if a did was set with the wrong format, for instance set-attribute was called with
-            // raw bytes instead of hex-encoded bytes, we don't want to cancel resolution of the
-            // rest of the DID
-            //
-            // TODO: Send this info as an extra json field to the caller apart from the DID Document
-            if let Err(e) = res {
-                log::error!(
-                        "Error while resolving for {public_key} at event block={block_number}, log index={log_index}, incorrect format?: {e}",
-                    );
-            };
         }
-        Ok(base_document.build())
+
+        // get the timestamp for the current_verison_id
+        let current_version_timestamp = match self.signer.get_block(current_version_id).await? {
+            Some(block) => {
+                if current_version_id != U64::zero() {
+                    Some::<String>(
+                        block
+                            .time()
+                            .unwrap_or_default()
+                            .format("%Y-%m-%dT%H:%M:%SZ")
+                            .to_string(),
+                    )
+                } else {
+                    None::<String>
+                }
+            }
+            None => None::<String>,
+        };
+
+        let resolution_result = DidResolutionResult {
+            document: base_document.build(),
+            metadata: Some(DidDocumentMetadata {
+                deactivated: deactivated,
+                version_id: current_version_id.as_u64(),
+                updated: current_version_timestamp,
+                next_version_id: match last_updated_did_version_id {
+                    Some(ver) => Some::<u64>(ver.as_u64()),
+                    None => None::<u64>,
+                },
+                next_update: match last_updated_did_version_id {
+                    Some(ver) => match self.signer.get_block(ver).await? {
+                        Some(block) => Some::<String>(
+                            block
+                                .time()
+                                .unwrap_or_default()
+                                .format("%Y-%m-%dT%H:%M:%SZ")
+                                .to_string(),
+                        ),
+                        None => None::<String>,
+                    },
+                    None => None::<String>,
+                },
+            }),
+            resolution_metadata: Some(DidResolutionMetadata {
+                content_type: "application/did+ld+json".to_string(),
+            }),
+        };
+        Ok(resolution_result)
     }
 }

src/rpc/api.rs

@@ -1,12 +1,16 @@
 //! Trait Interface Definitions for DID Registry JSON-RPC
 
-use crate::types::DidDocument;
+use crate::types::DidResolutionResult;
 
 use jsonrpsee::{proc_macros::rpc, types::ErrorObjectOwned};
 
 /// Decentralized Identifier JSON-RPC Interface Methods
 #[rpc(server, client, namespace = "did")]
 pub trait DidRegistry {
     #[method(name = "resolveDid")]
-    async fn resolve_did(&self, public_key: String) -> Result<DidDocument, ErrorObjectOwned>;
+    async fn resolve_did(
+        &self,
+        public_key: String,
+        version_id: Option<String>,
+    ) -> Result<DidResolutionResult, ErrorObjectOwned>;
 }