Fixed issue with active auth keyset

crates/cdk-signatory/proto/signatory.proto

@@ -7,8 +7,6 @@ service Signatory {
 
     rpc VerifyProof(Proof) returns (Empty);
 
-    rpc AuthKeysets(Empty) returns (VecSignatoryKeySet);
-
     rpc Keysets(Empty) returns (VecSignatoryKeySet);
 
     rpc RotateKeyset(RotateKeyArguments) returns (MintKeySetInfo);

crates/cdk-signatory/src/db_signatory.rs

@@ -144,13 +144,15 @@ impl DbSignatory {
         }
 
         if let Some(auth_db) = self.auth_localstore.clone() {
+            let active_auth_keyset = auth_db.get_active_keyset_id().await?;
             for mut info in auth_db.get_keyset_infos().await? {
                 let id = info.id;
                 let keyset = self.generate_keyset(&info);
                 if info.unit != CurrencyUnit::Auth {
                     continue;
                 }
-                info.active = db_active_keysets.get(&info.unit) == Some(&info.id);
+                info.active = active_auth_keyset == Some(info.id);
+                tracing::info!("Loading auth key from {} {:?}", id, info);
                 if info.active {
                     active_keysets.insert(info.unit.clone(), id);
                 }
@@ -211,26 +213,6 @@ impl Signatory for DbSignatory {
         Ok(())
     }
 
-    async fn auth_keysets(&self) -> Result<Option<Vec<SignatoryKeySet>>, Error> {
-        let keyset_id = self
-            .active_keysets
-            .read()
-            .await
-            .get(&CurrencyUnit::Auth)
-            .cloned()
-            .ok_or(Error::NoActiveKeyset)?;
-
-        let active_keyset = self
-            .keysets
-            .read()
-            .await
-            .get(&keyset_id)
-            .ok_or(Error::UnknownKeySet)?
-            .into();
-
-        Ok(Some(vec![active_keyset]))
-    }
-
     async fn keysets(&self) -> Result<Vec<SignatoryKeySet>, Error> {
         Ok(self
             .keysets

crates/cdk-signatory/src/proto/client.rs

@@ -41,28 +41,6 @@ impl Signatory for SignatoryRpcClient {
             .map_err(|e| Error::Custom(e.to_string()))?
     }
 
-    async fn auth_keysets(&self) -> Result<Option<Vec<SignatoryKeySet>>, Error> {
-        self.client
-            .clone()
-            .auth_keysets(super::Empty {})
-            .await
-            .map(|response| {
-                let response = response.into_inner();
-
-                if response.is_none == Some(true) {
-                    Ok(None)
-                } else {
-                    response
-                        .keysets
-                        .into_iter()
-                        .map(|x| x.try_into())
-                        .collect::<Result<Vec<SignatoryKeySet>, _>>()
-                        .map(Some)
-                }
-            })
-            .map_err(|e| Error::Custom(e.to_string()))?
-    }
-
     async fn keysets(&self) -> Result<Vec<SignatoryKeySet>, Error> {
         self.client
             .clone()

crates/cdk-signatory/src/proto/server.rs

@@ -41,28 +41,6 @@ where
         Ok(Response::new(proto::Empty {}))
     }
 
-    async fn auth_keysets(
-        &self,
-        _request: Request<proto::Empty>,
-    ) -> Result<Response<proto::VecSignatoryKeySet>, Status> {
-        let keys_response = self
-            .inner
-            .auth_keysets()
-            .await
-            .map_err(|e| Status::from_error(Box::new(e)))?;
-        Ok(Response::new(if let Some(keys_response) = keys_response {
-            proto::VecSignatoryKeySet {
-                keysets: keys_response.into_iter().map(|k| k.into()).collect(),
-                is_none: Some(false),
-            }
-        } else {
-            proto::VecSignatoryKeySet {
-                keysets: vec![],
-                is_none: Some(true),
-            }
-        }))
-    }
-
     async fn keysets(
         &self,
         _request: Request<proto::Empty>,

crates/cdk-signatory/src/service.rs

@@ -16,7 +16,6 @@ enum Request {
         ),
     ),
     VerifyProof((Proof, oneshot::Sender<Result<(), Error>>)),
-    AuthKeysets(oneshot::Sender<Result<Option<Vec<SignatoryKeySet>>, Error>>),
     Keysets(oneshot::Sender<Result<Vec<SignatoryKeySet>, Error>>),
     RotateKeyset(
         (
@@ -73,12 +72,6 @@ impl Service {
                         tracing::error!("Error sending response: {:?}", err);
                     }
                 }
-                Request::AuthKeysets(response) => {
-                    let output = handler.auth_keysets().await;
-                    if let Err(err) = response.send(output) {
-                        tracing::error!("Error sending response: {:?}", err);
-                    }
-                }
                 Request::Keysets(response) => {
                     let output = handler.keysets().await;
                     if let Err(err) = response.send(output) {
@@ -118,16 +111,6 @@ impl Signatory for Service {
         rx.await.map_err(|e| Error::RecvError(e.to_string()))?
     }
 
-    async fn auth_keysets(&self) -> Result<Option<Vec<SignatoryKeySet>>, Error> {
-        let (tx, rx) = oneshot::channel();
-        self.pipeline
-            .send(Request::AuthKeysets(tx))
-            .await
-            .map_err(|e| Error::SendError(e.to_string()))?;
-
-        rx.await.map_err(|e| Error::RecvError(e.to_string()))?
-    }
-
     async fn keysets(&self) -> Result<Vec<SignatoryKeySet>, Error> {
         let (tx, rx) = oneshot::channel();
         self.pipeline

crates/cdk-signatory/src/signatory.rs

@@ -66,9 +66,6 @@ impl From<&(MintKeySetInfo, MintKeySet)> for SignatoryKeySet {
 #[async_trait::async_trait]
 /// Signatory trait
 pub trait Signatory {
-    /// Get all the mint keysets for authentication
-    async fn auth_keysets(&self) -> Result<Option<Vec<SignatoryKeySet>>, Error>;
-
     /// Blind sign a message.
     ///
     /// The message can be for a coin or an auth token.

crates/cdk/src/mint/builder.rs

@@ -338,9 +338,15 @@ impl MintBuilder {
             signatory.clone()
         } else {
             let seed = self.seed.as_ref().ok_or(anyhow!("Mint seed not set"))?;
+            #[cfg(feature = "auth")]
+            let auth_localstore = self.auth_localstore.clone();
+
+            #[cfg(not(feature = "auth"))]
+            let auth_localstore = None;
+
             let in_memory_signatory = cdk_signatory::db_signatory::DbSignatory::new(
                 self.keystore.clone().ok_or(anyhow!("keystore not set"))?,
-                None,
+                auth_localstore,
                 seed,
                 self.supported_units.clone(),
                 HashMap::new(),

crates/cdk/src/mint/keysets/auth.rs

@@ -1,5 +1,6 @@
 //! Auth keyset functions
 
+use cdk_common::CurrencyUnit;
 use tracing::instrument;
 
 use crate::mint::{KeysResponse, KeysetResponse};
@@ -12,11 +13,11 @@ impl Mint {
     pub async fn auth_pubkeys(&self) -> Result<KeysResponse, Error> {
         let key = self
             .signatory
-            .auth_keysets()
+            .keysets()
             .await?
-            .ok_or(Error::AuthLocalstoreUndefined)?
-            .pop()
-            .ok_or(Error::AuthLocalstoreUndefined)?;
+            .into_iter()
+            .find(|key| key.info.unit == CurrencyUnit::Auth)
+            .ok_or(Error::NoActiveKeyset)?;
 
         Ok(KeysResponse {
             keysets: vec![key.key],
@@ -26,12 +27,20 @@ impl Mint {
     /// Return a list of auth keysets
     #[instrument(skip_all)]
     pub async fn auth_keysets(&self) -> Result<KeysetResponse, Error> {
-        self.signatory
-            .auth_keysets()
-            .await?
-            .map(|all_keysets| KeysetResponse {
-                keysets: all_keysets.into_iter().map(|k| k.info.into()).collect(),
-            })
-            .ok_or(Error::AuthLocalstoreUndefined)
+        Ok(KeysetResponse {
+            keysets: self
+                .signatory
+                .keysets()
+                .await?
+                .into_iter()
+                .filter_map(|key| {
+                    if key.info.unit == CurrencyUnit::Auth {
+                        Some(key.info.into())
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+        })
     }
 }