feat(router): cache ledger clients

Signed-off-by: Flavio Caetano Garcia <flavio.garcia@serpro.gov.br>

Author: flaviocgarcia78

README.md

@@ -79,7 +79,7 @@ _Resources_ section. The [Docker for Mac](https://docs.docker.com/docker-for-mac
 
 ## Managing smart contracts
 
-See [README.md](/smart_contracts/README.md).
+See [README.md](./smart_contracts/README.md).
 
 ## Client library
 

vdr/src/client/ledger_router.rs

@@ -1,4 +1,7 @@
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
 
 use crate::{
     client::LedgerClient,
@@ -28,7 +31,7 @@ impl Default for LedgerMode {
 #[derive(Debug)]
 pub enum LedgerResult {
     /// A fully initialized LedgerClient
-    Client(LedgerClient),
+    Client(Arc<LedgerClient>),
     /// A configuration-only LedgerClientConfig
     Config(LedgerClientConfig),
 }
@@ -67,6 +70,8 @@ pub struct LedgerRouter {
     configs: HashMap<String, LedgerClientConfig>,
     default_network: String,
     mode: LedgerMode,
+    // cache thread-safe
+    clients: Arc<Mutex<HashMap<String, Arc<LedgerClient>>>>,
 }
 
 impl LedgerRouter {
@@ -88,6 +93,7 @@ impl LedgerRouter {
             configs,
             default_network: default_network.unwrap_or(DEFAULT_NETWORK).to_string(),
             mode: mode.unwrap_or_default(),
+            clients: Arc::new(Mutex::new(HashMap::new())),
         }
     }
 
@@ -101,10 +107,15 @@ impl LedgerRouter {
     pub fn get_ledger_for_identifier(&self, identifier: &str) -> VdrResult<LedgerResult> {
         let network = Self::extract_network(identifier)?;
 
-        let config = self
+        let (resolved_network, config) = self
             .configs
             .get(&network)
-            .or_else(|| self.configs.get(&self.default_network))
+            .map(|c| (network.clone(), c))
+            .or_else(|| {
+                self.configs
+                    .get(&self.default_network)
+                    .map(|c| (self.default_network.clone(), c))
+            })
             .ok_or_else(|| {
                 VdrError::RouterConfigError(format!(
                     "Ledger for network '{}' not configured and no default network defined",
@@ -114,13 +125,23 @@ impl LedgerRouter {
 
         match self.mode {
             LedgerMode::LedgerClient => {
-                let client = LedgerClient::new(
+                // cache lookup
+                let mut cache = self.clients.lock().unwrap();
+
+                if let Some(client) = cache.get(&resolved_network).cloned() {
+                    return Ok(LedgerResult::Client(client));
+                }
+
+                let client = Arc::new(LedgerClient::new(
                     config.chain_id,
                     &config.rpc_node,
                     &config.contract_configs,
                     config.network.as_deref(),
                     config.quorum_config.as_ref(),
-                )?;
+                )?);
+
+                cache.insert(resolved_network.clone(), client.clone());
+
                 Ok(LedgerResult::Client(client))
             }
             LedgerMode::ConfigOnly => Ok(LedgerResult::Config(config.clone())),
@@ -151,14 +172,20 @@ impl LedgerRouter {
             )));
         }
 
-        match parts.len() {
-            3 => Ok(DEFAULT_NETWORK.to_string()),
-            n if n >= 4 => Ok(parts[2].to_string()),
-            _ => Err(VdrError::RouterConfigError(format!(
-                "Invalid did:ethr format: {}",
-                identifier
-            ))),
+        if parts.len() == 3 {
+            return Ok(DEFAULT_NETWORK.to_string());
         }
+
+        if parts.len() >= 4 {
+            return parts.get(2).map(|s| s.to_string()).ok_or_else(|| {
+                VdrError::RouterConfigError(format!("Invalid did:ethr format: {}", identifier))
+            });
+        }
+
+        Err(VdrError::RouterConfigError(format!(
+            "Invalid did:ethr format: {}",
+            identifier
+        )))
     }
 
     /// Submits a transaction to a ledger based on its identifier
@@ -194,16 +221,14 @@ impl LedgerRouter {
         }
 
         let mut results = HashMap::new();
-        for (network, config) in self.configs.iter() {
-            let client = LedgerClient::new(
-                config.chain_id,
-                &config.rpc_node,
-                &config.contract_configs,
-                config.network.as_deref(),
-                config.quorum_config.as_ref(),
-            )?;
-            let ping_status = client.ping().await?;
-            results.insert(network.clone(), ping_status);
+        for (network, _) in self.configs.iter() {
+            match self.get_ledger_for_identifier(&format!("did:ethr:{}:0x0", network))? {
+                LedgerResult::Client(client) => {
+                    let ping_status = client.ping().await?;
+                    results.insert(network.clone(), ping_status);
+                }
+                _ => {}
+            }
         }
         Ok(results)
     }
@@ -304,4 +329,10 @@ mod tests {
             LedgerResult::Config(_) => panic!("Expected LedgerResult::Client, got Config"),
         }
     }
+
+    #[test]
+    fn test_invalid_did_format() {
+        let err = LedgerRouter::extract_network("invalid").unwrap_err();
+        assert!(matches!(err, VdrError::RouterConfigError(_)));
+    }
 }

vdr/uniffi/src/ffi/client.rs

@@ -1,6 +1,7 @@
 // Copyright (c) 2024 DSR Corporation, Denver, Colorado.
 // https://www.dsr-corporation.com
 // SPDX-License-Identifier: Apache-2.0
+use std::sync::Arc;
 
 use crate::{
     ffi::{
@@ -15,7 +16,7 @@ use indy_besu_vdr::{ContractConfig as ContractConfig_, LedgerClient as LedgerCli
 
 #[derive(uniffi::Object)]
 pub struct LedgerClient {
-    pub client: LedgerClient_,
+    pub client: Arc<LedgerClient_>,
 }
 
 #[uniffi::export(async_runtime = "tokio")]
@@ -33,13 +34,13 @@ impl LedgerClient {
             .map(ContractConfig::into)
             .collect();
         let quorum_config = quorum_config.map(QuorumConfig::into);
-        let client = LedgerClient_::new(
+        let client = Arc::new(LedgerClient_::new(
             chain_id,
             &node_address,
             &contract_configs,
             network.as_deref(),
             quorum_config.as_ref(),
-        )?;
+        )?);
         Ok(LedgerClient { client })
     }
 

vdr/uniffi/src/ffi/ledger_router.rs

@@ -103,7 +103,7 @@ impl LedgerRouter {
             ledgers.insert(network_name, ledger_config);
         }
 
-        let default_network = default_network_name.unwrap_or_else(|| "default".to_string());
+        let default_network = default_network_name.unwrap_or_else(|| DEFAULT_NETWORK.to_string());
 
         // Initialize the underlying LedgerRouter (client mode)
         let router = LedgerRouter_::new(
@@ -131,9 +131,9 @@ impl LedgerRouter {
         let ledger_result = self.router.get_ledger_for_identifier(identifier)?;
 
         let client = match ledger_result {
-            LedgerResult::Client(c) => c,
+            LedgerResult::Client(c) => c.clone(),
             LedgerResult::Config(_) => {
-                return Err(VdrError::ClientInvalidResponse {
+                return Err(VdrError::RouterConfigError {
                     msg: "Expected LedgerClient but got config".to_string(),
                 });
             }

vdr/wrappers/python/demo/test-multiledger.py

@@ -75,7 +75,7 @@ async def demo():
     status = await router.ping_all()
     for ledger_name, ping_status in status.items():
         s = ping_status.status
-        # tenta pegar o nome do enum, senão imprime o próprio objeto
+        # Try to get the enum name; otherwise fallback to the object itself
         status_name = getattr(s, "name", str(s))
         print(f"  {ledger_name}: {{'status': '{status_name}'}}")
 
@@ -95,7 +95,7 @@ async def demo():
     receipt = await client.get_receipt(txn_hash)
     print(' Transaction receipt: ' + receipt)
 
-    print("3. Resolve DID Document:" +network1)
+    print("3. Resolve DID Document:" +network2)
     client = router.get_ledger_for_identifier(did)
     print("Router Return:" +client.network())
     resolved_did_doc = await DidResolver.resolve_did(client, did, None)