feat: mint connector http headers (#1602)

crates/cdk/examples/mint-token-bolt12-with-custom-http.rs

@@ -56,12 +56,22 @@ impl HttpTransport for CustomHttp {
         panic!("Not supported");
     }
 
-    async fn http_get<R>(&self, url: Url, _auth: Option<AuthToken>) -> Result<R, Error>
+    async fn http_get_with_headers<R>(
+        &self,
+        url: Url,
+        _auth: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
+    ) -> Result<R, Error>
     where
         R: DeserializeOwned,
     {
-        self.agent
-            .get(url.as_str())
+        let mut request = self.agent.get(url.as_str());
+
+        for (key, value) in custom_headers {
+            request = request.header(*key, *value);
+        }
+
+        request
             .call()
             .map_err(|e| Error::HttpError(None, e.to_string()))?
             .body_mut()
@@ -70,18 +80,24 @@ impl HttpTransport for CustomHttp {
     }
 
     /// HTTP Post request
-    async fn http_post<P, R>(
+    async fn http_post_with_headers<P, R>(
         &self,
         url: Url,
         _auth_token: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
         payload: &P,
     ) -> Result<R, Error>
     where
         P: Serialize + ?Sized + Send + Sync,
         R: DeserializeOwned,
     {
-        self.agent
-            .post(url.as_str())
+        let mut request = self.agent.post(url.as_str());
+
+        for (key, value) in custom_headers {
+            request = request.header(*key, *value);
+        }
+
+        request
             .send_json(payload)
             .map_err(|e| Error::HttpError(None, e.to_string()))?
             .body_mut()

crates/cdk/src/wallet/mint_connector/http_client.rs

@@ -116,6 +116,7 @@ where
         method: nut19::Method,
         path: nut19::Path,
         auth_token: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
         payload: &P,
     ) -> Result<R, Error>
     where
@@ -151,8 +152,16 @@ where
             };
 
             let result = match method {
-                nut19::Method::Get => transport.http_get(url, auth_token.clone()).await,
-                nut19::Method::Post => transport.http_post(url, auth_token.clone(), payload).await,
+                nut19::Method::Get => {
+                    transport
+                        .http_get_with_headers(url, auth_token.clone(), custom_headers)
+                        .await
+                }
+                nut19::Method::Post => {
+                    transport
+                        .http_post_with_headers(url, auth_token.clone(), custom_headers, payload)
+                        .await
+                }
             };
 
             if result.is_ok() {
@@ -310,7 +319,7 @@ where
             PaymentMethod::Custom(m) => nut19::Path::custom_mint(m),
         };
 
-        self.retriable_http_request(nut19::Method::Post, path, auth_token, &request)
+        self.retriable_http_request(nut19::Method::Post, path, auth_token, &[], &request)
             .await
     }
 
@@ -375,7 +384,7 @@ where
             PaymentMethod::Custom(m) => nut19::Path::custom_melt(m),
         };
 
-        self.retriable_http_request(nut19::Method::Post, path, auth_token, &request)
+        self.retriable_http_request(nut19::Method::Post, path, auth_token, &[], &request)
             .await
     }
 
@@ -388,6 +397,7 @@ where
             nut19::Method::Post,
             nut19::Path::Swap,
             auth_token,
+            &[],
             &swap_request,
         )
         .await

crates/cdk/src/wallet/mint_connector/transport.rs

@@ -38,6 +38,19 @@ pub trait Transport: Default + Send + Sync + Debug + Clone {
         auth: Option<cdk_common::AuthToken>,
     ) -> Result<R, super::Error>
     where
+        R: serde::de::DeserializeOwned,
+    {
+        self.http_get_with_headers(url, auth, &[]).await
+    }
+
+    /// HTTP Get request with custom headers
+    async fn http_get_with_headers<R>(
+        &self,
+        url: url::Url,
+        auth: Option<cdk_common::AuthToken>,
+        custom_headers: &[(&str, &str)],
+    ) -> Result<R, super::Error>
+    where
         R: serde::de::DeserializeOwned;
 
     /// HTTP Post request
@@ -49,6 +62,22 @@ pub trait Transport: Default + Send + Sync + Debug + Clone {
     ) -> Result<R, super::Error>
     where
         P: serde::Serialize + ?Sized + Send + Sync,
+        R: serde::de::DeserializeOwned,
+    {
+        self.http_post_with_headers(url, auth_token, &[], payload)
+            .await
+    }
+
+    /// HTTP Post request with custom headers
+    async fn http_post_with_headers<P, R>(
+        &self,
+        url: url::Url,
+        auth_token: Option<cdk_common::AuthToken>,
+        custom_headers: &[(&str, &str)],
+        payload: &P,
+    ) -> Result<R, super::Error>
+    where
+        P: serde::Serialize + ?Sized + Send + Sync,
         R: serde::de::DeserializeOwned;
 }
 
@@ -135,7 +164,12 @@ impl Transport for Async {
             .collect::<Vec<_>>())
     }
 
-    async fn http_get<R>(&self, url: Url, auth: Option<AuthToken>) -> Result<R, Error>
+    async fn http_get_with_headers<R>(
+        &self,
+        url: Url,
+        auth: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
+    ) -> Result<R, Error>
     where
         R: DeserializeOwned,
     {
@@ -146,6 +180,10 @@ impl Transport for Async {
             request = request.header(auth.header_key(), auth.to_string());
         }
 
+        for (key, value) in custom_headers {
+            request = request.header(*key, *value);
+        }
+
         let response = request
             .send()
             .await
@@ -163,10 +201,11 @@ impl Transport for Async {
         })
     }
 
-    async fn http_post<P, R>(
+    async fn http_post_with_headers<P, R>(
         &self,
         url: Url,
         auth_token: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
         payload: &P,
     ) -> Result<R, Error>
     where
@@ -180,6 +219,10 @@ impl Transport for Async {
             request = request.header(auth.header_key(), auth.to_string());
         }
 
+        for (key, value) in custom_headers {
+            request = request.header(*key, *value);
+        }
+
         let response = request
             .send()
             .await

crates/cdk/src/wallet/mint_connector/transport/tor_transport.rs

@@ -149,6 +149,7 @@ impl TorAsync {
         method: http::Method,
         url: Url,
         auth: Option<AuthToken>,
+        custom_headers: &[(&str, &str)],
         mut body: Option<Vec<u8>>,
     ) -> Result<R, Error>
     where
@@ -175,6 +176,10 @@ impl TorAsync {
         let mut builder = Request::builder().method(method).uri(uri);
         builder = builder.header(header::ACCEPT, "application/json");
 
+        for (key, value) in custom_headers {
+            builder = builder.header(*key, *value);
+        }
+
         let mut req = if let Some(b) = body.take() {
             builder
                 .header(http::header::CONTENT_TYPE, "application/json")
@@ -232,21 +237,24 @@ impl Transport for TorAsync {
         panic!("not supported with TorAsync transport");
     }
 
-    async fn http_get<R>(
+    async fn http_get_with_headers<R>(
         &self,
         url: url::Url,
         auth: Option<cdk_common::AuthToken>,
+        custom_headers: &[(&str, &str)],
     ) -> Result<R, super::super::Error>
     where
         R: serde::de::DeserializeOwned,
     {
-        self.request::<R>(Method::GET, url, auth, None).await
+        self.request::<R>(Method::GET, url, auth, custom_headers, None)
+            .await
     }
 
-    async fn http_post<P, R>(
+    async fn http_post_with_headers<P, R>(
         &self,
         url: url::Url,
         auth_token: Option<cdk_common::AuthToken>,
+        custom_headers: &[(&str, &str)],
         payload: &P,
     ) -> Result<R, super::super::Error>
     where
@@ -254,7 +262,7 @@ impl Transport for TorAsync {
         R: serde::de::DeserializeOwned,
     {
         let body = serde_json::to_vec(payload).map_err(|e| Error::Custom(e.to_string()))?;
-        self.request::<R>(Method::POST, url, auth_token, Some(body))
+        self.request::<R>(Method::POST, url, auth_token, custom_headers, Some(body))
             .await
     }
 
@@ -315,7 +323,7 @@ impl Transport for TorAsync {
         }
 
         let resp: DnsResp = self
-            .request::<DnsResp>(Method::GET, url, None, None::<Vec<u8>>)
+            .request::<DnsResp>(Method::GET, url, None, &[], None::<Vec<u8>>)
             .await?;
 
         let answers = resp.Answer.unwrap_or_default();