Update proto buf to use the newest format

Cargo.toml

@@ -55,7 +55,7 @@ cdk-payment-processor = { path = "./crates/cdk-payment-processor", default-featu
 cdk-mint-rpc = { path = "./crates/cdk-mint-rpc", version = "=0.9.2" }
 cdk-redb = { path = "./crates/cdk-redb", default-features = true, version = "=0.9.2" }
 cdk-sqlite = { path = "./crates/cdk-sqlite", default-features = true, version = "=0.9.2" }
-cdk-signatory = { path = "./crates/cdk-signatory", version = "=0.9.2" }
+cdk-signatory = { path = "./crates/cdk-signatory", version = "=0.9.2", default-features = false }
 clap = { version = "4.5.31", features = ["derive"] }
 ciborium = { version = "0.2.2", default-features = false, features = ["std"] }
 cbor-diag = "0.1.12"

crates/cdk-mintd/src/config.rs

@@ -30,8 +30,12 @@ impl std::fmt::Debug for Info {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // Use a fallback approach that won't panic
         let mnemonic_display = {
-            let hash = sha256::Hash::hash(self.mnemonic.clone().into_bytes().as_ref());
-            format!("<hashed: {hash}>")
+            if let Some(mnemonic) = self.mnemonic.as_ref() {
+                let hash = sha256::Hash::hash(mnemonic.as_bytes());
+                format!("<hashed: {hash}>")
+            } else {
+                format!("<url: {}>", self.signatory_url.clone().unwrap_or_default())
+            }
         };
 
         f.debug_struct("Info")

crates/cdk-signatory/proto/signatory.proto

@@ -2,167 +2,167 @@ syntax = "proto3";
 
 package signatory;
 
-/// TODO: research about the stream, to notify when RotateKeyset is triggered.
 service Signatory {
-  rpc BlindSign (BlindedMessages) returns (BlindSignResponse);
-
-  rpc VerifyProofs (Proofs) returns (BooleanResponse);
-
-  rpc Keysets (EmptyRequest) returns (KeysResponse);
+  rpc BlindSign(BlindedMessages) returns (BlindSignResponse);
+  rpc VerifyProofs(Proofs) returns (BooleanResponse);
+  // returns all the keysets for the mint
+  rpc Keysets(EmptyRequest) returns (KeysResponse);
+  // rotates the keysets
+  rpc RotateKeyset(RotationRequest) returns (KeyRotationResponse);
+}
 
-  rpc RotateKeyset (RotationRequest) returns (KeyRotationResponse);
+enum Operation {
+  OPERATION_UNSPECIFIED = 0;
+  OPERATION_MINT = 1;
+  OPERATION_MELT = 2;
+  OPERATION_SWAP = 3;
 }
 
 message BlindSignResponse {
-    oneof result {
-        BlindSignatures sigs  = 1;
-        Error error = 2;
-    }
+  Error error = 1;
+  BlindSignatures sigs = 2;
 }
 
 message BlindedMessages {
-    repeated BlindedMessage blinded_messages = 1;
+  repeated BlindedMessage blinded_messages = 1;
+  Operation operation = 2;
+  string correlation_id = 3;
 }
 
 // Represents a blinded message
 message BlindedMessage {
-    uint64 amount = 1;
-    string keyset_id = 2;
-    bytes blinded_secret = 3;
+  uint64 amount = 1;
+  string keyset_id = 2;
+  bytes blinded_secret = 3;
 }
 
 message BooleanResponse {
-    oneof result {
-        bool success  = 1;
-        Error error = 2;
-    }
+  Error error = 1;
+  bool success = 2;
 }
 
 message KeyRotationResponse {
-    oneof result {
-        KeySet keyset  = 1;
-        Error error = 2;
-    }
+  Error error = 1;
+  KeySet keyset = 2;
 }
 
 message KeysResponse {
-    oneof result {
-        SignatoryKeysets keysets = 1;
-        Error error = 2;
-    }
+  Error error = 1;
+  SignatoryKeysets keysets = 2;
 }
 
 message SignatoryKeysets {
-    bytes pubkey = 1;
-    repeated KeySet keysets = 2;
+  bytes pubkey = 1;
+  repeated KeySet keysets = 2;
 }
 
 message KeySet {
-    string id = 1;
-    CurrencyUnit unit = 2;
-    bool active = 3;
-    uint64 input_fee_ppk = 4;
-    Keys keys = 5;
+  string id = 1;
+  CurrencyUnit unit = 2;
+  bool active = 3;
+  uint64 input_fee_ppk = 4;
+  Keys keys = 5;
 }
 
 message Keys {
-    map<uint64, bytes> keys = 1;
+  map<uint64, bytes> keys = 1;
 }
 
 message RotationRequest {
-    CurrencyUnit unit  = 1;
-    uint64 input_fee_ppk  = 2;
-    uint64 max_order = 3;
+  CurrencyUnit unit = 1;
+  uint64 input_fee_ppk = 2;
+  uint32 max_order = 3;
 }
 
 enum CurrencyUnitType {
-    SAT = 0;
-    MSAT = 1;
-    USD = 2;
-    EUR = 3;
-    AUTH = 4;
+  CURRENCY_UNIT_TYPE_UNSPECIFIED = 0;
+  CURRENCY_UNIT_TYPE_SAT = 1;
+  CURRENCY_UNIT_TYPE_MSAT = 2;
+  CURRENCY_UNIT_TYPE_USD = 3;
+  CURRENCY_UNIT_TYPE_EUR = 4;
+  CURRENCY_UNIT_TYPE_AUTH = 5;
 }
 
 message CurrencyUnit {
-    oneof currency_unit {
-        CurrencyUnitType unit = 1;
-        string custom_unit = 2;
-    }
+  oneof currency_unit {
+    CurrencyUnitType unit = 1;
+    string custom_unit = 2;
+  }
 }
 
 message Proofs {
-    repeated Proof proof = 1;
+  repeated Proof proof = 1;
+  Operation operation = 3;
+  string correlation_id = 4;
 }
 
 message Proof {
-    uint64 amount = 1;
-    string keyset_id = 2;
-    bytes secret = 3;
-    bytes C = 4;
+  uint64 amount = 1;
+  string keyset_id = 2;
+  bytes secret = 3;
+  bytes c = 4;
 }
 
 message ProofDLEQ {
-    bytes e = 1;
-    bytes s = 2;
-    bytes r = 3;
+  bytes e = 1;
+  bytes s = 2;
+  bytes r = 3;
 }
 
 message SigningResponse {
-    oneof result {
-        BlindSignatures blind_signatures = 1;
-        Error error = 2;
-    }
+  Error error = 1;
+  BlindSignatures blind_signatures = 2;
 }
 message BlindSignatures {
-    repeated BlindSignature blind_signatures = 1;
+  repeated BlindSignature blind_signatures = 1;
 }
 
 message BlindSignature {
-    uint64 amount = 1;
-    string keyset_id = 2;
-    bytes blinded_secret = 3;
-    optional BlindSignatureDLEQ dleq = 4;
+  uint64 amount = 1;
+  string keyset_id = 2;
+  bytes blinded_secret = 3;
+  optional BlindSignatureDLEQ dleq = 4;
 }
 
 message BlindSignatureDLEQ {
-    bytes e = 1;
-    bytes s = 2;
+  bytes e = 1;
+  bytes s = 2;
 }
 
 // Witness type
 message Witness {
-    oneof witness_type {
-        P2PKWitness p2pk_witness = 1;
-        HTLCWitness htlc_witness = 2;
-    }
+  oneof witness_type {
+    P2PKWitness p2pk_witness = 1;
+    HTLCWitness htlc_witness = 2;
+  }
 }
 
 // P2PKWitness type
 message P2PKWitness {
-    // List of signatures
-    repeated string signatures = 1;
+  // List of signatures
+  repeated string signatures = 1;
 }
 
 // HTLCWitness type
 message HTLCWitness {
-    // Preimage
-    string preimage = 1;
-    // List of signatures
-    repeated string signatures = 2;
+  // Preimage
+  string preimage = 1;
+  // List of signatures
+  repeated string signatures = 2;
 }
 
 enum ErrorCode {
-    UNKNOWN = 0;
-    AMOUNT_OUTSIDE_LIMIT = 1;
-    DUPLICATE_INPUTS_PROVIDED = 2;
-    DUPLICATE_OUTPUTS_PROVIDED = 3;
-    KEYSET_NOT_KNOWN = 4;
-    KEYSET_INACTIVE = 5;
-    MINTING_DISABLED = 6;
-    COULD_NOT_ROTATE_KEYSET = 7;
-    INVALID_PROOF = 8;
-    INVALID_BLIND_MESSAGE = 9;
-    UNIT_NOT_SUPPORTED = 10;
+  ERROR_CODE_UNSPECIFIED = 0;
+  ERROR_CODE_AMOUNT_OUTSIDE_LIMIT = 1;
+  ERROR_CODE_DUPLICATE_INPUTS_PROVIDED = 2;
+  ERROR_CODE_DUPLICATE_OUTPUTS_PROVIDED = 3;
+  ERROR_CODE_KEYSET_NOT_KNOWN = 4;
+  ERROR_CODE_KEYSET_INACTIVE = 5;
+  ERROR_CODE_MINTING_DISABLED = 6;
+  ERROR_CODE_COULD_NOT_ROTATE_KEYSET = 7;
+  ERROR_CODE_INVALID_PROOF = 8;
+  ERROR_CODE_INVALID_BLIND_MESSAGE = 9;
+  ERROR_CODE_UNIT_NOT_SUPPORTED = 10;
 }
 
 message Error {

crates/cdk-signatory/src/db_signatory.rs

@@ -22,6 +22,7 @@ use crate::signatory::{RotateKeyArguments, Signatory, SignatoryKeySet, Signatory
 pub struct DbSignatory {
     keysets: RwLock<HashMap<Id, (MintKeySetInfo, MintKeySet)>>,
     active_keysets: RwLock<HashMap<CurrencyUnit, Id>>,
+    /// TODO: Merge localstore with auth_localstore (use the same db). It makes sense in CDK but not here.
     localstore: Arc<dyn database::MintKeysDatabase<Err = database::Error> + Send + Sync>,
     auth_localstore:
         Option<Arc<dyn database::MintAuthDatabase<Err = database::Error> + Send + Sync>>,

crates/cdk-signatory/src/main.rs

@@ -1,11 +1,11 @@
 #[cfg(not(target_arch = "wasm32"))]
 mod cli {
     use std::collections::HashMap;
-    use std::fs;
     use std::net::SocketAddr;
     use std::path::PathBuf;
     use std::str::FromStr;
     use std::sync::Arc;
+    use std::{env, fs};
 
     use anyhow::{bail, Result};
     use bip39::rand::{thread_rng, Rng};
@@ -22,6 +22,7 @@ mod cli {
     use tracing_subscriber::EnvFilter;
 
     const DEFAULT_WORK_DIR: &str = ".cdk-signatory";
+    const ENV_MNEMONIC: &str = "CDK_MINTD_MNEMONIC";
 
     /// Simple CLI application to interact with cashu
     #[derive(Parser)]
@@ -48,6 +49,7 @@ mod cli {
         listen_port: u32,
         #[arg(long, short)]
         certs: Option<String>,
+        /// Supported units with the format of name,fee and max_order
         #[arg(long, short, default_value = "sat,0,32")]
         units: Vec<String>,
     }
@@ -74,7 +76,7 @@ mod cli {
 
         let sqlx_filter = "sqlx=warn,hyper_util=warn,reqwest=warn";
 
-        let env_filter = EnvFilter::new(format!("{},{}", default_filter, sqlx_filter));
+        let env_filter = EnvFilter::new(format!("{default_filter},{sqlx_filter}"));
 
         // Parse input
         tracing_subscriber::fmt().with_env_filter(env_filter).init();
@@ -136,21 +138,25 @@ mod cli {
 
         let seed_path = work_dir.join("seed");
 
-        let mnemonic = match fs::metadata(seed_path.clone()) {
-            Ok(_) => {
-                let contents = fs::read_to_string(seed_path.clone())?;
-                Mnemonic::from_str(&contents)?
-            }
-            Err(_e) => {
-                let mut rng = thread_rng();
-                let random_bytes: [u8; 32] = rng.gen();
+        let mnemonic = if let Ok(mnemonic) = env::var(ENV_MNEMONIC) {
+            Mnemonic::from_str(&mnemonic)?
+        } else {
+            match fs::metadata(seed_path.clone()) {
+                Ok(_) => {
+                    let contents = fs::read_to_string(seed_path.clone())?;
+                    Mnemonic::from_str(&contents)?
+                }
+                Err(_e) => {
+                    let mut rng = thread_rng();
+                    let random_bytes: [u8; 32] = rng.gen();
 
-                let mnemonic = Mnemonic::from_entropy(&random_bytes)?;
-                tracing::info!("Creating new seed");
+                    let mnemonic = Mnemonic::from_entropy(&random_bytes)?;
+                    tracing::info!("Creating new seed");
 
-                fs::write(seed_path, mnemonic.to_string())?;
+                    fs::write(seed_path, mnemonic.to_string())?;
 
-                mnemonic
+                    mnemonic
+                }
             }
         };
         let seed = mnemonic.to_seed_normalized("");

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

@@ -4,7 +4,6 @@ use cdk_common::error::Error;
 use cdk_common::{BlindSignature, BlindedMessage, Proof};
 use tonic::transport::{Certificate, Channel, ClientTlsConfig, Identity};
 
-use super::{blind_sign_response, boolean_response, key_rotation_response, keys_response};
 use crate::proto::signatory_client::SignatoryClient;
 use crate::signatory::{RotateKeyArguments, Signatory, SignatoryKeySet, SignatoryKeysets};
 
@@ -67,6 +66,27 @@ impl SignatoryRpcClient {
     }
 }
 
+macro_rules! handle_error {
+    ($x:expr, $y:ident, scalar) => {{
+        let mut obj = $x.into_inner();
+        if let Some(err) = obj.error.take() {
+            return Err(err.into());
+        }
+
+        obj.$y
+    }};
+    ($x:expr, $y:ident) => {{
+        let mut obj = $x.into_inner();
+        if let Some(err) = obj.error.take() {
+            return Err(err.into());
+        }
+
+        obj.$y
+            .take()
+            .ok_or(Error::Custom("Internal error".to_owned()))?
+    }};
+}
+
 #[async_trait::async_trait]
 impl Signatory for SignatoryRpcClient {
     fn name(&self) -> String {
@@ -79,6 +99,8 @@ impl Signatory for SignatoryRpcClient {
                 .into_iter()
                 .map(|blind_message| blind_message.into())
                 .collect(),
+            operation: super::Operation::Unspecified.into(),
+            correlation_id: "".to_owned(),
         };
 
         self.client
@@ -86,18 +108,11 @@ impl Signatory for SignatoryRpcClient {
             .blind_sign(req)
             .await
             .map(|response| {
-                match response
-                    .into_inner()
-                    .result
-                    .ok_or(Error::Custom("Internal error".to_owned()))?
-                {
-                    blind_sign_response::Result::Sigs(sigs) => sigs
-                        .blind_signatures
-                        .into_iter()
-                        .map(|blinded_signature| blinded_signature.try_into())
-                        .collect(),
-                    blind_sign_response::Result::Error(err) => Err(err.into()),
-                }
+                handle_error!(response, sigs)
+                    .blind_signatures
+                    .into_iter()
+                    .map(|blinded_signature| blinded_signature.try_into())
+                    .collect()
             })
             .map_err(|e| Error::Custom(e.to_string()))?
     }
@@ -109,19 +124,10 @@ impl Signatory for SignatoryRpcClient {
             .verify_proofs(req)
             .await
             .map(|response| {
-                match response
-                    .into_inner()
-                    .result
-                    .ok_or(Error::Custom("Internal error".to_owned()))?
-                {
-                    boolean_response::Result::Success(bool) => {
-                        if bool {
-                            Ok(())
-                        } else {
-                            Err(Error::SignatureMissingOrInvalid)
-                        }
-                    }
-                    boolean_response::Result::Error(err) => Err(err.into()),
+                if handle_error!(response, success, scalar) {
+                    Ok(())
+                } else {
+                    Err(Error::SignatureMissingOrInvalid)
                 }
             })
             .map_err(|e| Error::Custom(e.to_string()))?
@@ -132,16 +138,7 @@ impl Signatory for SignatoryRpcClient {
             .clone()
             .keysets(super::EmptyRequest {})
             .await
-            .map(|response| {
-                match response
-                    .into_inner()
-                    .result
-                    .ok_or(Error::Custom("Internal error".to_owned()))?
-                {
-                    keys_response::Result::Keysets(keyset) => keyset.try_into(),
-                    keys_response::Result::Error(err) => Err(err.into()),
-                }
-            })
+            .map(|response| handle_error!(response, keysets).try_into())
             .map_err(|e| Error::Custom(e.to_string()))?
     }
 
@@ -151,16 +148,7 @@ impl Signatory for SignatoryRpcClient {
             .clone()
             .rotate_keyset(req)
             .await
-            .map(|response| {
-                match response
-                    .into_inner()
-                    .result
-                    .ok_or(Error::Custom("Internal error".to_owned()))?
-                {
-                    key_rotation_response::Result::Keyset(keyset) => keyset.try_into(),
-                    key_rotation_response::Result::Error(err) => Err(err.into()),
-                }
-            })
+            .map(|response| handle_error!(response, keyset).try_into())
             .map_err(|e| Error::Custom(e.to_string()))?
     }
 }

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

@@ -25,6 +25,7 @@ impl From<crate::signatory::SignatoryKeysets> for SignatoryKeysets {
 }
 
 impl TryInto<crate::signatory::SignatoryKeysets> for SignatoryKeysets {
+    /// TODO: Make sure that all type Error here are cdk_common::Error
     type Error = cdk_common::Error;
 
     fn try_into(self) -> Result<crate::signatory::SignatoryKeysets, Self::Error> {
@@ -90,7 +91,7 @@ impl From<cdk_common::Error> for Error {
             cdk_common::Error::DuplicateOutputs => ErrorCode::DuplicateInputsProvided,
             cdk_common::Error::UnknownKeySet => ErrorCode::KeysetNotKnown,
             cdk_common::Error::InactiveKeyset => ErrorCode::KeysetInactive,
-            _ => ErrorCode::Unknown,
+            _ => ErrorCode::Unspecified,
         };
 
         Error {
@@ -103,8 +104,13 @@ impl From<cdk_common::Error> for Error {
 impl From<Error> for cdk_common::Error {
     fn from(val: Error) -> Self {
         match val.code.try_into().expect("valid code") {
+            ErrorCode::AmountOutsideLimit => {
+                cdk_common::Error::AmountError(cdk_common::amount::Error::AmountOverflow)
+            }
             ErrorCode::DuplicateInputsProvided => cdk_common::Error::DuplicateInputs,
-            ErrorCode::Unknown => cdk_common::Error::Custom(val.detail),
+            ErrorCode::KeysetNotKnown => cdk_common::Error::UnknownKeySet,
+            ErrorCode::KeysetInactive => cdk_common::Error::InactiveKeyset,
+            ErrorCode::Unspecified => cdk_common::Error::Custom(val.detail),
             _ => todo!(),
         }
     }
@@ -144,6 +150,8 @@ impl From<Vec<cdk_common::Proof>> for Proofs {
     fn from(value: Vec<cdk_common::Proof>) -> Self {
         Proofs {
             proof: value.into_iter().map(|x| x.into()).collect(),
+            operation: Operation::Unspecified.into(),
+            correlation_id: "".to_owned(),
         }
     }
 }
@@ -353,6 +361,9 @@ impl TryInto<cashu::CurrencyUnit> for CurrencyUnit {
                 CurrencyUnitType::Usd => Ok(cashu::CurrencyUnit::Usd),
                 CurrencyUnitType::Eur => Ok(cashu::CurrencyUnit::Eur),
                 CurrencyUnitType::Auth => Ok(cashu::CurrencyUnit::Auth),
+                CurrencyUnitType::Unspecified => {
+                    Err(Status::invalid_argument("Current unit is not specified"))
+                }
             },
             Some(currency_unit::CurrencyUnit::CustomUnit(name)) => {
                 Ok(cashu::CurrencyUnit::Custom(name))

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

@@ -4,7 +4,6 @@ use std::path::Path;
 use tonic::transport::{Certificate, Identity, Server, ServerTlsConfig};
 use tonic::{Request, Response, Status};
 
-use super::{boolean_response, key_rotation_response, keys_response, BooleanResponse};
 use crate::proto::{self, signatory_server};
 use crate::signatory::Signatory;
 
@@ -36,20 +35,22 @@ where
             )
             .await
         {
-            Ok(blind_signatures) => {
-                proto::blind_sign_response::Result::Sigs(proto::BlindSignatures {
+            Ok(blind_signatures) => proto::BlindSignResponse {
+                sigs: Some(proto::BlindSignatures {
                     blind_signatures: blind_signatures
                         .into_iter()
                         .map(|blind_sign| blind_sign.into())
                         .collect(),
-                })
-            }
-            Err(err) => proto::blind_sign_response::Result::Error(err.into()),
+                }),
+                ..Default::default()
+            },
+            Err(err) => proto::BlindSignResponse {
+                error: Some(err.into()),
+                ..Default::default()
+            },
         };
 
-        Ok(Response::new(proto::BlindSignResponse {
-            result: Some(result),
-        }))
+        Ok(Response::new(result))
     }
 
     async fn verify_proofs(
@@ -68,15 +69,22 @@ where
             )
             .await
         {
-            Ok(()) => boolean_response::Result::Success(true),
-
-            Err(cdk_common::Error::DHKE(_)) => boolean_response::Result::Success(false),
-            Err(err) => boolean_response::Result::Error(err.into()),
+            Ok(()) => proto::BooleanResponse {
+                success: true,
+                ..Default::default()
+            },
+
+            Err(cdk_common::Error::DHKE(_)) => proto::BooleanResponse {
+                success: false,
+                ..Default::default()
+            },
+            Err(err) => proto::BooleanResponse {
+                error: Some(err.into()),
+                ..Default::default()
+            },
         };
 
-        Ok(Response::new(BooleanResponse {
-            result: Some(result),
-        }))
+        Ok(Response::new(result))
     }
 
     async fn keysets(
@@ -84,13 +92,17 @@ where
         _request: Request<proto::EmptyRequest>,
     ) -> Result<Response<proto::KeysResponse>, Status> {
         let result = match self.inner.keysets().await {
-            Ok(result) => keys_response::Result::Keysets(result.into()),
-            Err(err) => keys_response::Result::Error(err.into()),
+            Ok(result) => proto::KeysResponse {
+                keysets: Some(result.into()),
+                ..Default::default()
+            },
+            Err(err) => proto::KeysResponse {
+                error: Some(err.into()),
+                ..Default::default()
+            },
         };
 
-        Ok(Response::new(proto::KeysResponse {
-            result: Some(result),
-        }))
+        Ok(Response::new(result))
     }
 
     async fn rotate_keyset(
@@ -102,13 +114,17 @@ where
             .rotate_keyset(request.into_inner().try_into()?)
             .await
         {
-            Ok(result) => key_rotation_response::Result::Keyset(result.into()),
-            Err(err) => key_rotation_response::Result::Error(err.into()),
+            Ok(result) => proto::KeyRotationResponse {
+                keyset: Some(result.into()),
+                ..Default::default()
+            },
+            Err(err) => proto::KeyRotationResponse {
+                error: Some(err.into()),
+                ..Default::default()
+            },
         };
 
-        Ok(Response::new(proto::KeyRotationResponse {
-            result: Some(mint_keyset_info),
-        }))
+        Ok(Response::new(mint_keyset_info))
     }
 }
 

crates/cdk-signatory/src/signatory.rs

@@ -36,6 +36,8 @@ impl From<CurrencyUnit> for KeysetIdentifier {
 /// RotateKeyArguments
 ///
 /// This struct is used to pass the arguments to the rotate_keyset function
+///
+/// TODO: Change argument to accept a vector of Amount instead of max_order.
 #[derive(Debug, Clone)]
 pub struct RotateKeyArguments {
     /// Unit