Merge #4: Use u32 for req ids to avoid overflow. Also add server.features method types.

7168a8c chore: bump version to 0.4 (志宇)
0957bb7 feat: Add `server.features` method types (志宇)
fbd8e79 feat!: Use u32 to avoid overflow (志宇)
22755f1 chore!: Bump MSRV to 1.70 (志宇)

Pull request description:

Top commit has no ACKs.

Tree-SHA512: 879c29929936046680bb963f611be6881155555da6106bf29ef5679df6b11fdf925c97ccc22e9060b7438092c4f3a21b14f487a9c7cfcf8618d750221ee1b6ce

Author: evanlinjin

Cargo.lock

@@ -1,10 +1,10 @@
 [package]
 name = "electrum_streaming_client"
-version = "0.3.0"
+version = "0.4.0"
 description = "Experimental but sane electrum client by @evanlinjin."
 license = "MIT OR Apache-2.0"
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.70"
 repository = "https://github.com/bitcoindevkit/electrum_streaming_client"
 documentation = "https://docs.rs/electrum_streaming_client"
 readme = "README.md"

Cargo.toml

@@ -68,7 +68,7 @@ impl AsyncClient {
         let mut incoming_stream =
             crate::io::ReadStreamer::new(futures::io::BufReader::new(reader)).fuse();
         let mut state = State::<AsyncPendingRequest>::new();
-        let mut next_id = 0_usize;
+        let mut next_id = 0_u32;
 
         let fut = async move {
             loop {
@@ -308,7 +308,7 @@ impl BlockingClient {
             Ok(())
         });
         let write_join = std::thread::spawn(move || -> std::io::Result<()> {
-            let mut next_id = 0_usize;
+            let mut next_id = 0_u32;
             for req in req_recv {
                 let raw_req = write_state.lock().unwrap().track_request(&mut next_id, req);
                 crate::io::blocking_write(&mut writer, raw_req)?;

src/client.rs

@@ -114,7 +114,7 @@ impl<R: std::io::BufRead> Iterator for ReadStreamer<R> {
             if let Err(err) = reader.read_until(b'\n', &mut self.buf) {
                 self.err = Some(err);
                 continue;
-            };
+            }
             if self._enqueue_from_buf() {
                 self.reader = Some(reader);
             }

src/io.rs

@@ -14,6 +14,7 @@ pub use batch_request::*;
 pub use hash_types::*;
 pub use pending_request::*;
 pub use request::Request;
+pub use serde_json;
 use serde_json::Value;
 pub use state::*;
 use std::fmt::Display;
@@ -183,7 +184,7 @@ pub struct RawResponse {
     pub version: Version,
 
     /// The ID that matches the request this response is answering.
-    pub id: usize,
+    pub id: u32,
 
     /// The result if the request succeeded, or the error object if it failed.
     #[serde(flatten, deserialize_with = "crate::custom_serde::result")]
@@ -214,7 +215,7 @@ pub struct RawRequest {
     pub jsonrpc: CowStr,
 
     /// The client-assigned request ID (used to correlate with responses).
-    pub id: usize,
+    pub id: u32,
 
     /// The method to be invoked (e.g., `"blockchain.headers.subscribe"`).
     pub method: CowStr,
@@ -227,14 +228,18 @@ impl RawRequest {
     /// Constructs a new JSON-RPC request with the given ID, method, and parameters.
     ///
     /// This sets the JSON-RPC version to `"2.0"`.
-    pub fn new(id: usize, method: CowStr, params: Vec<Value>) -> Self {
+    pub fn new(id: u32, method: CowStr, params: Vec<Value>) -> Self {
         Self {
             jsonrpc: JSONRPC_VERSION_2_0.into(),
             id,
             method,
             params,
         }
     }
+
+    pub fn from_request<Req: Request>(id: u32, req: Req) -> Self {
+        (id, req).into()
+    }
 }
 
 /// Represents either a single item or a batch of items.
@@ -275,6 +280,20 @@ impl<T> MaybeBatch<T> {
             }
         }
     }
+
+    pub fn map<T2>(self, f: impl Fn(T) -> T2) -> MaybeBatch<T2> {
+        match self {
+            MaybeBatch::Single(t) => MaybeBatch::Single(f(t)),
+            MaybeBatch::Batch(items) => MaybeBatch::Batch(items.into_iter().map(f).collect()),
+        }
+    }
+
+    pub fn map_into<T2>(self) -> MaybeBatch<T2>
+    where
+        T: Into<T2>,
+    {
+        self.map(Into::into)
+    }
 }
 
 impl<T> From<T> for MaybeBatch<T> {

src/lib.rs

@@ -288,3 +288,20 @@ gen_pending_request_types! {
     Ping,
     Custom
 }
+
+impl<A: PendingRequest> PendingRequest for Box<A> {
+    fn to_method_and_params(&self) -> MethodAndParams {
+        self.as_ref().to_method_and_params()
+    }
+
+    fn satisfy(
+        self,
+        raw_resp: serde_json::Value,
+    ) -> Result<Option<SatisfiedRequest>, serde_json::Error> {
+        (*self).satisfy(raw_resp)
+    }
+
+    fn satisfy_error(self, raw_error: serde_json::Value) -> Option<ErroredRequest> {
+        (*self).satisfy_error(raw_error)
+    }
+}

src/pending_request.rs

@@ -19,7 +19,8 @@
 use bitcoin::{consensus::Encodable, hex::DisplayHex, Script, Txid};
 
 use crate::{
-    response, CowStr, ElectrumScriptHash, ElectrumScriptStatus, MethodAndParams, ResponseError,
+    response, CowStr, ElectrumScriptHash, ElectrumScriptStatus, MethodAndParams, RawRequest,
+    ResponseError,
 };
 
 /// A trait representing a typed Electrum JSON-RPC request.
@@ -39,6 +40,16 @@ pub trait Request: Clone {
     fn to_method_and_params(&self) -> MethodAndParams;
 }
 
+impl<Req> From<(u32, Req)> for RawRequest
+where
+    Req: Request,
+{
+    fn from((id, req): (u32, Req)) -> Self {
+        let (method, params) = req.to_method_and_params();
+        RawRequest::new(id, method, params)
+    }
+}
+
 /// A dynamically constructed request for arbitrary Electrum methods.
 ///
 /// This type allows manual specification of the method name and parameters without needing a
@@ -613,6 +624,22 @@ impl Request for Banner {
     }
 }
 
+/// A request to return a list of features and services supported by the server.
+///
+/// This corresponds to the `"server.features"` Electrum RPC method.
+///
+/// See: <https://electrum-protocol.readthedocs.io/en/latest/protocol-methods.html#server-features>
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Features;
+
+impl Request for Features {
+    type Response = response::ServerFeatures;
+
+    fn to_method_and_params(&self) -> MethodAndParams {
+        ("server.features".into(), vec![])
+    }
+}
+
 /// A ping request to verify the connection to the Electrum server.
 ///
 /// This corresponds to the `"server.ping"` Electrum RPC method. It has no parameters and returns

src/request.rs

@@ -4,10 +4,12 @@
 //! Electrum JSON-RPC methods. These types are used to decode responses for specific request types
 //! defined in the [`crate::request`] module.
 
+use std::collections::HashMap;
+
 use bitcoin::{
     absolute,
     hashes::{Hash, HashEngine},
-    Amount,
+    Amount, BlockHash,
 };
 
 use crate::DoubleSHA;
@@ -278,3 +280,41 @@ pub struct FeePair {
     #[serde(deserialize_with = "crate::custom_serde::weight_from_vb")]
     pub weight: bitcoin::Weight,
 }
+
+/// Response to the `"server.features"` method.
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ServerFeatures {
+    /// Hosts.
+    pub hosts: HashMap<String, ServerHostValues>,
+
+    /// The hash of the genesis block.
+    ///
+    ///  This is used to detect if a peer is connected to one serving a different network.
+    pub genesis_hash: BlockHash,
+
+    /// The hash function the server uses for script hashing.
+    ///
+    /// The default is `"sha-256"`.
+    pub hash_function: String,
+
+    /// A string that identifies the server software.
+    pub server_version: String,
+
+    /// The max protocol version.
+    pub protocol_max: String,
+
+    /// The min protocol version.
+    pub protocol_min: String,
+
+    /// The pruning limit.
+    pub pruning: Option<u32>,
+}
+
+/// Server host values.
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ServerHostValues {
+    /// SSL Port.
+    pub ssl_port: Option<u16>,
+    /// TCP Port.
+    pub tcp_port: Option<u16>,
+}

src/response.rs

@@ -60,7 +60,7 @@ impl Event {
 /// previously tracked request.
 #[derive(Debug)]
 pub struct State<PReq: PendingRequest> {
-    pending: HashMap<usize, PReq>,
+    pending: HashMap<u32, PReq>,
 }
 
 impl<PReq: PendingRequest> Default for State<PReq> {
@@ -102,13 +102,13 @@ impl<PReq: PendingRequest> State<PReq> {
     ///
     /// Returns a [`MaybeBatch<RawRequest>`], preserving whether the input was a single request or a
     /// batch.
-    pub fn track_request<R>(&mut self, next_id: &mut usize, req: R) -> MaybeBatch<RawRequest>
+    pub fn track_request<R>(&mut self, next_id: &mut u32, req: R) -> MaybeBatch<RawRequest>
     where
         R: Into<MaybeBatch<PReq>>,
     {
         fn _add_request<PReq: PendingRequest>(
             state: &mut State<PReq>,
-            next_id: &mut usize,
+            next_id: &mut u32,
             req: PReq,
         ) -> RawRequest {
             let id = *next_id;
@@ -172,14 +172,14 @@ impl<PReq: PendingRequest> State<PReq> {
 #[derive(Debug)]
 pub enum ProcessError {
     /// A response was received for an unknown or untracked request ID.
-    MissingRequest(usize),
+    MissingRequest(u32),
 
     /// The server returned a successful response, but it could not be deserialized into the
     /// expected type.
     ///
     /// The `usize` is the request ID, and the `serde_json::Error` is the underlying deserialization
     /// failure.
-    CannotDeserializeResponse(usize, serde_json::Error),
+    CannotDeserializeResponse(u32, serde_json::Error),
 
     /// A server notification could not be deserialized into the expected notification type.
     ///