changes: switch to bitreq from chunked_transfer

we changed the http layer from the manual tcpstream client
implementation to bitreq, this change lets us rely on bitreq for
http request formatting, sockets, HTTP parsing, chunked bodies,
pooling, and async support instead of having to manually implement
them.

cargo.toml: we added bitreq 0.3 and updates the rest-client and
rpc-client feature wiring to depend on bitreq. A tokio feature is
also enabled to allow bitreq async support and pipelining.

http.rs: The old HttpEndpoint builder and all manual TCP/socket
timeout logic are dropped along with the manual GET/POST
construction and response parsing. The client API now uses base_url
and get/post return Result with a typed HttpClientError instead of
std::io::Result. HttpClientError splits transport failures
(bitreq::Error), non-2xx HTTP responses (HttpError), and response
decoding issues (std::io::Error).

rest.rs and rpc.rs: HttpEndpoint and the Mutex<Option<HttpClient>>
caching pattern are removed and both clients now own an HttpClient
directly using base_url. rpc.rs also adds RpcClientError so we can
represent HTTP failures, JSON-RPC errors from the server, and
malformed responses instead of just giving out std::io::Error.

convert.rs: it maps HttpClientError and RpcClientError into
BlockSourceError with this retry classification: transport errors
and HTTP 5xx are transient, HTTP 4xx and invalid data are
persistent, and RPC errors are treated as transient.

Author: Apostlex0

lightning-block-sync/Cargo.toml

@@ -16,15 +16,16 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-rest-client = [ "serde_json", "chunked_transfer" ]
-rpc-client = [ "serde_json", "chunked_transfer" ]
+rest-client = [ "serde_json", "dep:bitreq" ]
+rpc-client = [ "serde_json", "dep:bitreq" ]
+tokio = [ "dep:tokio", "bitreq?/async" ]
 
 [dependencies]
 bitcoin = "0.32.2"
 lightning = { version = "0.3.0", path = "../lightning" }
 tokio = { version = "1.35", features = [ "io-util", "net", "time", "rt" ], optional = true }
 serde_json = { version = "1.0", optional = true }
-chunked_transfer = { version = "1.4", optional = true }
+bitreq = { version = "0.3", default-features = false, features = ["std"], optional = true }
 
 [dev-dependencies]
 lightning = { version = "0.3.0", path = "../lightning", features = ["_test_utils"] }

lightning-block-sync/src/convert.rs

@@ -1,4 +1,6 @@
-use crate::http::{BinaryResponse, JsonResponse};
+use crate::http::{BinaryResponse, HttpClientError, JsonResponse};
+#[cfg(feature = "rpc-client")]
+use crate::rpc::RpcClientError;
 use crate::utils::hex_to_work;
 use crate::{BlockHeaderData, BlockSourceError};
 
@@ -35,6 +37,64 @@ impl From<io::Error> for BlockSourceError {
 	}
 }
 
+/// Conversion from `HttpClientError` into `BlockSourceError`.
+impl From<HttpClientError> for BlockSourceError {
+	fn from(e: HttpClientError) -> BlockSourceError {
+		match e {
+			// Transport errors (connection, timeout, etc.) are transient
+			HttpClientError::Transport(err) => {
+				BlockSourceError::transient(HttpClientError::Transport(err))
+			},
+			// 5xx errors are transient (server issues), others are persistent (client errors)
+			HttpClientError::Http(http_err) => {
+				if (500..600).contains(&http_err.status_code) {
+					BlockSourceError::transient(HttpClientError::Http(http_err))
+				} else {
+					BlockSourceError::persistent(HttpClientError::Http(http_err))
+				}
+			},
+			// Delegate to existing From<io::Error> implementation
+			HttpClientError::Io(io_err) => BlockSourceError::from(io_err),
+		}
+	}
+}
+
+/// Conversion from `RpcClientError` into `BlockSourceError`.
+#[cfg(feature = "rpc-client")]
+impl From<RpcClientError> for BlockSourceError {
+	fn from(e: RpcClientError) -> BlockSourceError {
+		match e {
+			RpcClientError::Http(http_err) => match http_err {
+				// Transport errors (connection, timeout, etc.) are transient
+				HttpClientError::Transport(err) => BlockSourceError::transient(
+					RpcClientError::Http(HttpClientError::Transport(err)),
+				),
+				// 5xx errors are transient (server issues), others are persistent (client errors)
+				HttpClientError::Http(http) => {
+					if (500..600).contains(&http.status_code) {
+						BlockSourceError::transient(RpcClientError::Http(HttpClientError::Http(
+							http,
+						)))
+					} else {
+						BlockSourceError::persistent(RpcClientError::Http(HttpClientError::Http(
+							http,
+						)))
+					}
+				},
+				HttpClientError::Io(io_err) => BlockSourceError::from(io_err),
+			},
+			// RPC errors (e.g. "block not found") are transient
+			RpcClientError::Rpc(rpc_err) => {
+				BlockSourceError::transient(RpcClientError::Rpc(rpc_err))
+			},
+			// Malformed response data is persistent
+			RpcClientError::InvalidData(msg) => {
+				BlockSourceError::persistent(RpcClientError::InvalidData(msg))
+			},
+		}
+	}
+}
+
 /// Parses binary data as a block.
 impl TryInto<Block> for BinaryResponse {
 	type Error = io::Error;