refactor!: build Request's with authorization

- add `AuthProvider` as public type.
- add new `.with_auth()` method to `Request`, it sets the
  `authorization` token, if any.
- update `.call()` and `.batch_call()` to use the newly added
  `.with_auth()`, instead of updating request's authorization field
  directly.
- update `authorization` field in `Request` to private.

Author: oleonardolima

src/lib.rs

@@ -58,5 +58,5 @@ pub mod utils;
 pub use api::ElectrumApi;
 pub use batch::Batch;
 pub use client::*;
-pub use config::{Config, ConfigBuilder, Socks5Config};
+pub use config::{AuthProvider, Config, ConfigBuilder, Socks5Config};
 pub use types::*;

src/raw_client.rs

@@ -764,11 +764,13 @@ impl<S: Read + Write> RawClient<S> {
         let (sender, receiver) = channel();
         self.waiting_map.lock()?.insert(req.id, sender);
 
-        // Apply authorization token if provider is set
-        let mut req = req;
-        if let Some(provider) = &self.auth_provider {
-            req.authorization = provider();
-        }
+        // apply `authorization` token into `Request`, if any.
+        let authorization = self
+            .auth_provider
+            .as_ref()
+            .and_then(|auth_provider| auth_provider());
+
+        let req = req.with_auth(authorization);
 
         let mut raw = serde_json::to_vec(&req)?;
         trace!("==> {}", String::from_utf8_lossy(&raw));
@@ -887,19 +889,20 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
 
         // Add our listener to the map before we send the request
 
-        for (index, (method, params)) in batch.iter().enumerate() {
-            let mut req = Request::new_id(
+        for (method, params) in batch.iter() {
+            // if there's an `auth_provider` available, it should get the `authorization`, if any.
+            // it'll be set into into `Request`.
+            let authorization = self
+                .auth_provider
+                .as_ref()
+                .and_then(|auth_provider| auth_provider());
+
+            let req = Request::new_id(
                 self.last_id.fetch_add(1, Ordering::SeqCst),
                 method,
                 params.to_vec(),
-            );
-
-            // Servers expect auth token only in the first request in batched requests
-            if index == 0 {
-                if let Some(provider) = &self.auth_provider {
-                    req.authorization = provider();
-                }
-            }
+            )
+            .with_auth(authorization);
 
             // Add distinct channel to each request so when we remove our request id (and sender) from the waiting_map
             // we can be sure that the response gets sent to the correct channel in self.recv

src/types.rs

@@ -71,13 +71,14 @@ pub struct Request<'a> {
     pub method: &'a str,
     /// The request parameters
     pub params: Vec<Param>,
-    /// Optional authorization token (e.g., JWT Bearer token)
+
+    /// Authorization token (e.g. `"Bearer <token>"`) included in the JSON-RPC request, if any.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub authorization: Option<String>,
+    authorization: Option<String>,
 }
 
 impl<'a> Request<'a> {
-    /// Creates a new request with a default id
+    /// Creates a new [`Request`] with a default `id`.
     fn new(method: &'a str, params: Vec<Param>) -> Self {
         Self {
             id: 0,
@@ -88,13 +89,19 @@ impl<'a> Request<'a> {
         }
     }
 
-    /// Creates a new request with a user-specified id
+    /// Creates a new [`Request`] with a user-specified `id`.
     pub fn new_id(id: usize, method: &'a str, params: Vec<Param>) -> Self {
         let mut instance = Self::new(method, params);
         instance.id = id;
 
         instance
     }
+
+    /// Sets the `authorization` token for this [`Request`].
+    pub fn with_auth(mut self, authorization: Option<String>) -> Self {
+        self.authorization = authorization;
+        self
+    }
 }
 
 #[doc(hidden)]