feat: cdk-cli cat login

Author: thesimplekid

crates/cashu/src/nuts/mod.rs

@@ -57,5 +57,5 @@ pub use nut14::HTLCWitness;
 pub use nut15::{Mpp, MppMethodSettings, Settings as NUT15Settings};
 pub use nut17::NotificationPayload;
 pub use nut18::{PaymentRequest, PaymentRequestPayload, Transport};
-pub use nutxx::{Method, ProtectedEndpoint, RoutePath};
+pub use nutxx::{Method, OidcClient, ProtectedEndpoint, RoutePath};
 pub use nutxx1::{AuthProof, AuthRequired, AuthToken, BlindAuthToken};

crates/cashu/src/nuts/nutxx/oidc.rs

@@ -5,7 +5,8 @@ use std::collections::HashMap;
 use jsonwebtoken::jwk::{AlgorithmParameters, JwkSet};
 use jsonwebtoken::{decode, decode_header, DecodingKey, Validation};
 use reqwest::Client;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use thiserror::Error;
 use tracing::instrument;
 
@@ -34,6 +35,7 @@ pub enum Error {
 pub struct OidcConfig {
     pub jwks_uri: String,
     pub issuer: String,
+    pub token_endpoint: String,
 }
 
 /// Http Client
@@ -43,6 +45,14 @@ pub struct OidcClient {
     openid_discovery: String,
 }
 
+#[derive(Debug, Clone, Serialize)]
+pub struct AccessTokenRequest {
+    pub grant_type: String,
+    pub client_id: String,
+    pub username: String,
+    pub password: String,
+}
+
 impl OidcClient {
     /// Create new [`OidcClient`]
     pub fn new(openid_discovery: String) -> Self {
@@ -116,4 +126,34 @@ impl OidcClient {
 
         Ok(())
     }
+
+    pub async fn get_access_token(
+        &self,
+        username: String,
+        password: String,
+    ) -> Result<String, Error> {
+        let token_url = self.get_oidc_config().await?.token_endpoint;
+
+        let request = AccessTokenRequest {
+            grant_type: "password".to_string(),
+            client_id: "cashu-client".to_string(),
+            username,
+            password,
+        };
+
+        let response: Value = self
+            .inner
+            .post(token_url)
+            .form(&request)
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        println!("{:?}", response);
+
+        let token = response.get("access_token").expect("access token");
+
+        Ok(token.to_string())
+    }
 }

crates/cdk-cli/src/main.rs

@@ -79,6 +79,8 @@ enum Commands {
     CreateRequest(sub_commands::create_request::CreateRequestSubCommand),
     /// Mint blind auth proofs
     MintBlindAuth(sub_commands::mint_blind_auth::MintBlindAuthSubCommand),
+    /// Cat login
+    CatLogin(sub_commands::cat_login::CatLoginSubCommand),
 }
 
 #[tokio::main]
@@ -239,5 +241,14 @@ async fn main() -> Result<()> {
             )
             .await
         }
+        Commands::CatLogin(sub_command_args) => {
+            sub_commands::cat_login::cat_login(
+                &multi_mint_wallet,
+                &mnemonic.to_seed_normalized(""),
+                localstore,
+                sub_command_args,
+            )
+            .await
+        }
     }
 }

crates/cdk-cli/src/sub_commands/cat_login.rs

@@ -0,0 +1,70 @@
+use std::str::FromStr;
+use std::sync::Arc;
+
+use anyhow::Result;
+use cdk::cdk_database::{Error, WalletDatabase};
+use cdk::mint_url::MintUrl;
+use cdk::nuts::nutxx::OidcClient;
+use cdk::nuts::CurrencyUnit;
+use cdk::wallet::types::WalletKey;
+use cdk::wallet::{MultiMintWallet, Wallet};
+use clap::Args;
+use serde::{Deserialize, Serialize};
+
+#[derive(Args, Serialize, Deserialize)]
+pub struct CatLoginSubCommand {
+    /// Mint url
+    mint_url: MintUrl,
+    /// Username
+    username: String,
+    /// Password
+    password: String,
+    /// Currency unit e.g. sat
+    #[arg(default_value = "sat")]
+    #[arg(short, long)]
+    unit: String,
+}
+
+pub async fn cat_login(
+    multi_mint_wallet: &MultiMintWallet,
+    seed: &[u8],
+    localstore: Arc<dyn WalletDatabase<Err = Error> + Sync + Send>,
+    sub_command_args: &CatLoginSubCommand,
+) -> Result<()> {
+    let mint_url = sub_command_args.mint_url.clone();
+    let unit = CurrencyUnit::from_str(&sub_command_args.unit)?;
+
+    let wallet = match multi_mint_wallet
+        .get_wallet(&WalletKey::new(mint_url.clone(), unit.clone()))
+        .await
+    {
+        Some(wallet) => wallet.clone(),
+        None => {
+            let wallet = Wallet::new(&mint_url.to_string(), unit, localstore, seed, None, None)?;
+
+            multi_mint_wallet.add_wallet(wallet.clone()).await;
+            wallet
+        }
+    };
+
+    let mint_info = wallet.get_mint_info().await?.expect("Mint info not found");
+
+    let openid_discovery = mint_info
+        .nuts
+        .nutxx
+        .expect("Nutxx definded")
+        .openid_discovery;
+
+    let oidc_client = OidcClient::new(openid_discovery);
+
+    let access_token = oidc_client
+        .get_access_token(
+            sub_command_args.username.clone(),
+            sub_command_args.password.clone(),
+        )
+        .await?;
+
+    println!("access_token: {}", access_token);
+
+    Ok(())
+}

crates/cdk-cli/src/sub_commands/mod.rs

@@ -1,5 +1,6 @@
 pub mod balance;
 pub mod burn;
+pub mod cat_login;
 pub mod check_spent;
 pub mod create_request;
 pub mod decode_request;

crates/cdk-sqlite/src/mint/mod.rs

@@ -1234,7 +1234,7 @@ fn sqlite_row_to_keyset_info(row: SqliteRow) -> Result<MintKeySetInfo, Error> {
     let row_valid_to: Option<i64> = row.try_get("valid_to").map_err(Error::from)?;
     let row_derivation_path: String = row.try_get("derivation_path").map_err(Error::from)?;
     let row_max_order: u8 = row.try_get("max_order").map_err(Error::from)?;
-    let row_keyset_ppk: Option<i64> = row.try_get("input_fee_ppk").map_err(Error::from)?;
+    let row_keyset_ppk: Option<i64> = row.try_get("input_fee_ppk").ok();
     let row_derivation_path_index: Option<i64> =
         row.try_get("derivation_path_index").map_err(Error::from)?;
 

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

@@ -8,8 +8,6 @@ use super::{
 use crate::dhke::{sign_message, verify_message};
 use crate::Amount;
 
-pub mod auth_database;
-
 impl Mint {
     /// Check if and what kind of auth is required for a method
     pub fn protected(&self, method: &ProtectedEndpoint) -> Option<AuthRequired> {