changes: switch to bitreq from chunked_transfer

diff --git a/lightning-block-sync/Cargo.toml b/lightning-block-sync/Cargo.toml
index 97f1999..d8d71da 100644
--- a/lightning-block-sync/Cargo.toml
+++ b/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"] }
diff --git a/lightning-block-sync/src/convert.rs b/lightning-block-sync/src/convert.rs
index a31b329..47c7586 100644
--- a/lightning-block-sync/src/convert.rs
+++ b/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;
diff --git a/lightning-block-sync/src/http.rs b/lightning-block-sync/src/http.rs
index 0fb82b4..29cc425 100644
--- a/lightning-block-sync/src/http.rs
+++ b/lightning-block-sync/src/http.rs
@@ -1,399 +1,164 @@
 //! Simple HTTP implementation which supports both async and traditional execution environments
 //! with minimal dependencies. This is used as the basis for REST and RPC clients.
 
-use chunked_transfer;
 use serde_json;
 
-use std::convert::TryFrom;
-use std::fmt;
-#[cfg(not(feature = "tokio"))]
-use std::io::Write;
-use std::net::{SocketAddr, ToSocketAddrs};
-use std::time::Duration;
-
-#[cfg(feature = "tokio")]
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt};
 #[cfg(feature = "tokio")]
-use tokio::net::TcpStream;
+use bitreq::RequestExt;
 
-#[cfg(not(feature = "tokio"))]
-use std::io::BufRead;
-use std::io::Read;
-#[cfg(not(feature = "tokio"))]
-use std::net::TcpStream;
-
-/// Timeout for operations on TCP streams.
-const TCP_STREAM_TIMEOUT: Duration = Duration::from_secs(5);
-
-/// Timeout for reading the first byte of a response. This is separate from the general read
-/// timeout as it is not uncommon for Bitcoin Core to be blocked waiting on UTXO cache flushes for
-/// upwards of 10 minutes on slow devices (e.g. RPis with SSDs over USB). Note that we always retry
-/// once when we time out, so the maximum time we allow Bitcoin Core to block for is twice this
-/// value.
-const TCP_STREAM_RESPONSE_TIMEOUT: Duration = Duration::from_secs(300);
+use std::convert::TryFrom;
+use std::fmt;
 
-/// Maximum HTTP message header size in bytes.
-const MAX_HTTP_MESSAGE_HEADER_SIZE: usize = 8192;
+/// Timeout for requests in seconds. This is set to a high value as it is not uncommon for Bitcoin
+/// Core to be blocked waiting on UTXO cache flushes for upwards of 10 minutes on slow devices
+/// (e.g. RPis with SSDs over USB).
+const TCP_STREAM_RESPONSE_TIMEOUT: u64 = 300;
 
 /// Maximum HTTP message body size in bytes. Enough for a hex-encoded block in JSON format and any
 /// overhead for HTTP chunked transfer encoding.
 const MAX_HTTP_MESSAGE_BODY_SIZE: usize = 2 * 4_000_000 + 32_000;
 
-/// Endpoint for interacting with an HTTP-based API.
+/// Error type for HTTP client operations.
 #[derive(Debug)]
-pub struct HttpEndpoint {
-	host: String,
-	port: Option<u16>,
-	path: String,
+pub enum HttpClientError {
+	/// transport-level error (connection, timeout, protocol parsing, etc.)
+	Transport(bitreq::Error),
+	/// HTTP error response (non-2xx status code)
+	Http(HttpError),
+	/// Response parsing/conversion error
+	Io(std::io::Error),
 }
 
-impl HttpEndpoint {
-	/// Creates an endpoint for the given host and default HTTP port.
-	pub fn for_host(host: String) -> Self {
-		Self { host, port: None, path: String::from("/") }
-	}
-
-	/// Specifies a port to use with the endpoint.
-	pub fn with_port(mut self, port: u16) -> Self {
-		self.port = Some(port);
-		self
-	}
-
-	/// Specifies a path to use with the endpoint.
-	pub fn with_path(mut self, path: String) -> Self {
-		self.path = path;
-		self
-	}
-
-	/// Returns the endpoint host.
-	pub fn host(&self) -> &str {
-		&self.host
+impl std::error::Error for HttpClientError {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		match self {
+			HttpClientError::Transport(e) => Some(e),
+			HttpClientError::Http(e) => Some(e),
+			HttpClientError::Io(e) => Some(e),
+		}
 	}
+}
 
-	/// Returns the endpoint port.
-	pub fn port(&self) -> u16 {
-		match self.port {
-			None => 80,
-			Some(port) => port,
+impl fmt::Display for HttpClientError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			HttpClientError::Transport(e) => write!(f, "transport error: {}", e),
+			HttpClientError::Http(e) => write!(f, "HTTP error: {}", e),
+			HttpClientError::Io(e) => write!(f, "Response parsing/conversion error: {}", e),
 		}
 	}
+}
 
-	/// Returns the endpoint path.
-	pub fn path(&self) -> &str {
-		&self.path
+impl From<std::io::Error> for HttpClientError {
+	fn from(e: std::io::Error) -> Self {
+		HttpClientError::Io(e)
 	}
 }
 
-impl<'a> std::net::ToSocketAddrs for &'a HttpEndpoint {
-	type Iter = <(&'a str, u16) as std::net::ToSocketAddrs>::Iter;
+impl From<bitreq::Error> for HttpClientError {
+	fn from(e: bitreq::Error) -> Self {
+		HttpClientError::Transport(e)
+	}
+}
 
-	fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
-		(self.host(), self.port()).to_socket_addrs()
+impl From<HttpError> for HttpClientError {
+	fn from(e: HttpError) -> Self {
+		HttpClientError::Http(e)
 	}
 }
 
+/// Maximum number of cached connections in the connection pool.
+#[cfg(feature = "tokio")]
+const MAX_CONNECTIONS: usize = 10;
+
 /// Client for making HTTP requests.
 pub(crate) struct HttpClient {
-	address: SocketAddr,
-	stream: TcpStream,
+	base_url: String,
+	#[cfg(feature = "tokio")]
+	client: bitreq::Client,
 }
 
 impl HttpClient {
-	/// Opens a connection to an HTTP endpoint.
-	pub fn connect<E: ToSocketAddrs>(endpoint: E) -> std::io::Result<Self> {
-		let address = match endpoint.to_socket_addrs()?.next() {
-			None => {
-				return Err(std::io::Error::new(
-					std::io::ErrorKind::InvalidInput,
-					"could not resolve to any addresses",
-				));
-			},
-			Some(address) => address,
-		};
-		let stream = std::net::TcpStream::connect_timeout(&address, TCP_STREAM_TIMEOUT)?;
-		stream.set_read_timeout(Some(TCP_STREAM_TIMEOUT))?;
-		stream.set_write_timeout(Some(TCP_STREAM_TIMEOUT))?;
-
-		#[cfg(feature = "tokio")]
-		let stream = {
-			stream.set_nonblocking(true)?;
-			TcpStream::from_std(stream)?
-		};
-
-		Ok(Self { address, stream })
+	/// Creates a new HTTP client for the given base URL.
+	///
+	/// The base URL should include the scheme, host, and port (e.g., "http://127.0.0.1:8332").
+	/// DNS resolution is deferred until the first request is made.
+	pub fn new(base_url: String) -> Self {
+		Self {
+			base_url,
+			#[cfg(feature = "tokio")]
+			client: bitreq::Client::new(MAX_CONNECTIONS),
+		}
 	}
 
-	/// Sends a `GET` request for a resource identified by `uri` at the `host`.
+	/// Sends a `GET` request for a resource identified by `uri`.
 	///
 	/// Returns the response body in `F` format.
 	#[allow(dead_code)]
-	pub async fn get<F>(&mut self, uri: &str, host: &str) -> std::io::Result<F>
+	pub async fn get<F>(&self, uri: &str) -> Result<F, HttpClientError>
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error>,
 	{
-		let request = format!(
-			"GET {} HTTP/1.1\r\n\
-			 Host: {}\r\n\
-			 Connection: keep-alive\r\n\
-			 \r\n",
-			uri, host
-		);
-		let response_body = self.send_request_with_retry(&request).await?;
-		F::try_from(response_body)
+		let url = format!("{}{}", self.base_url, uri);
+		let request = bitreq::get(url)
+			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT)
+			.with_max_body_size(Some(MAX_HTTP_MESSAGE_BODY_SIZE));
+		#[cfg(feature = "tokio")]
+		let request = request.with_pipelining();
+		let response_body = self.send_request(request).await?;
+		F::try_from(response_body).map_err(HttpClientError::Io)
 	}
 
-	/// Sends a `POST` request for a resource identified by `uri` at the `host` using the given HTTP
+	/// Sends a `POST` request for a resource identified by `uri` using the given HTTP
 	/// authentication credentials.
 	///
 	/// The request body consists of the provided JSON `content`. Returns the response body in `F`
 	/// format.
 	#[allow(dead_code)]
 	pub async fn post<F>(
-		&mut self, uri: &str, host: &str, auth: &str, content: serde_json::Value,
-	) -> std::io::Result<F>
+		&self, uri: &str, auth: &str, content: serde_json::Value,
+	) -> Result<F, HttpClientError>
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error>,
 	{
-		let content = content.to_string();
-		let request = format!(
-			"POST {} HTTP/1.1\r\n\
-			 Host: {}\r\n\
-			 Authorization: {}\r\n\
-			 Connection: keep-alive\r\n\
-			 Content-Type: application/json\r\n\
-			 Content-Length: {}\r\n\
-			 \r\n\
-			 {}",
-			uri,
-			host,
-			auth,
-			content.len(),
-			content
-		);
-		let response_body = self.send_request_with_retry(&request).await?;
-		F::try_from(response_body)
-	}
-
-	/// Sends an HTTP request message and reads the response, returning its body. Attempts to
-	/// reconnect and retry if the connection has been closed.
-	async fn send_request_with_retry(&mut self, request: &str) -> std::io::Result<Vec<u8>> {
-		match self.send_request(request).await {
-			Ok(bytes) => Ok(bytes),
-			Err(_) => {
-				// Reconnect and retry on fail. This can happen if the connection was closed after
-				// the keep-alive limits are reached, or generally if the request timed out due to
-				// Bitcoin Core being stuck on a long-running operation or its RPC queue being
-				// full.
-				// Block 100ms before retrying the request as in many cases the source of the error
-				// may be persistent for some time.
-				#[cfg(feature = "tokio")]
-				tokio::time::sleep(Duration::from_millis(100)).await;
-				#[cfg(not(feature = "tokio"))]
-				std::thread::sleep(Duration::from_millis(100));
-				*self = Self::connect(self.address)?;
-				self.send_request(request).await
-			},
-		}
-	}
-
-	/// Sends an HTTP request message and reads the response, returning its body.
-	async fn send_request(&mut self, request: &str) -> std::io::Result<Vec<u8>> {
-		self.write_request(request).await?;
-		self.read_response().await
-	}
-
-	/// Writes an HTTP request message.
-	async fn write_request(&mut self, request: &str) -> std::io::Result<()> {
+		let url = format!("{}{}", self.base_url, uri);
+		let request = bitreq::post(url)
+			.with_header("Authorization", auth)
+			.with_header("Content-Type", "application/json")
+			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT)
+			.with_max_body_size(Some(MAX_HTTP_MESSAGE_BODY_SIZE))
+			.with_body(content.to_string());
 		#[cfg(feature = "tokio")]
-		{
-			self.stream.write_all(request.as_bytes()).await?;
-			self.stream.flush().await
-		}
-		#[cfg(not(feature = "tokio"))]
-		{
-			self.stream.write_all(request.as_bytes())?;
-			self.stream.flush()
-		}
+		let request = request.with_pipelining();
+		let response_body = self.send_request(request).await?;
+		F::try_from(response_body).map_err(HttpClientError::Io)
 	}
 
-	/// Reads an HTTP response message.
-	async fn read_response(&mut self) -> std::io::Result<Vec<u8>> {
-		#[cfg(feature = "tokio")]
-		let stream = self.stream.split().0;
-		#[cfg(not(feature = "tokio"))]
-		let stream = std::io::Read::by_ref(&mut self.stream);
-
-		let limited_stream = stream.take(MAX_HTTP_MESSAGE_HEADER_SIZE as u64);
-
+	/// Sends an HTTP request message and reads the response, returning its body.
+	async fn send_request(&self, request: bitreq::Request) -> Result<Vec<u8>, HttpClientError> {
 		#[cfg(feature = "tokio")]
-		let mut reader = tokio::io::BufReader::new(limited_stream);
+		let response = request.send_async_with_client(&self.client).await?;
 		#[cfg(not(feature = "tokio"))]
-		let mut reader = std::io::BufReader::new(limited_stream);
-
-		macro_rules! read_line {
-			() => {
-				read_line!(0)
-			};
-			($retry_count: expr) => {{
-				let mut line = String::new();
-				let mut timeout_count: u64 = 0;
-				let bytes_read = loop {
-					#[cfg(feature = "tokio")]
-					let read_res = reader.read_line(&mut line).await;
-					#[cfg(not(feature = "tokio"))]
-					let read_res = reader.read_line(&mut line);
-					match read_res {
-						Ok(bytes_read) => break bytes_read,
-						Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
-							timeout_count += 1;
-							if timeout_count > $retry_count {
-								return Err(e);
-							} else {
-								continue;
-							}
-						},
-						Err(e) => return Err(e),
-					}
-				};
-
-				match bytes_read {
-					0 => None,
-					_ => {
-						// Remove trailing CRLF
-						if line.ends_with('\n') {
-							line.pop();
-							if line.ends_with('\r') {
-								line.pop();
-							}
-						}
-						Some(line)
-					},
-				}
-			}};
-		}
+		let response = request.send()?;
 
-		// Read and parse status line
-		// Note that we allow retrying a few times to reach TCP_STREAM_RESPONSE_TIMEOUT.
-		let status_line =
-			read_line!(TCP_STREAM_RESPONSE_TIMEOUT.as_secs() / TCP_STREAM_TIMEOUT.as_secs())
-				.ok_or(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "no status line"))?;
-		let status = HttpStatus::parse(&status_line)?;
-
-		// Read and parse relevant headers
-		let mut message_length = HttpMessageLength::Empty;
-		loop {
-			let line = read_line!()
-				.ok_or(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "no headers"))?;
-			if line.is_empty() {
-				break;
-			}
+		let status_code = response.status_code;
+		let body = response.into_bytes();
 
-			let header = HttpHeader::parse(&line)?;
-			if header.has_name("Content-Length") {
-				let length = header
-					.value
-					.parse()
-					.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
-				if let HttpMessageLength::Empty = message_length {
-					message_length = HttpMessageLength::ContentLength(length);
-				}
-				continue;
-			}
-
-			if header.has_name("Transfer-Encoding") {
-				message_length = HttpMessageLength::TransferEncoding(header.value.into());
-				continue;
-			}
+		if !(200..300).contains(&status_code) {
+			return Err(HttpError { status_code, contents: body }.into());
 		}
 
-		// Read message body
-		let read_limit = MAX_HTTP_MESSAGE_BODY_SIZE - reader.buffer().len();
-		reader.get_mut().set_limit(read_limit as u64);
-		let contents = match message_length {
-			HttpMessageLength::Empty => Vec::new(),
-			HttpMessageLength::ContentLength(length) => {
-				if length == 0 || length > MAX_HTTP_MESSAGE_BODY_SIZE {
-					return Err(std::io::Error::new(
-						std::io::ErrorKind::InvalidData,
-						format!("invalid response length: {} bytes", length),
-					));
-				} else {
-					let mut content = vec![0; length];
-					#[cfg(feature = "tokio")]
-					reader.read_exact(&mut content[..]).await?;
-					#[cfg(not(feature = "tokio"))]
-					reader.read_exact(&mut content[..])?;
-					content
-				}
-			},
-			HttpMessageLength::TransferEncoding(coding) => {
-				if !coding.eq_ignore_ascii_case("chunked") {
-					return Err(std::io::Error::new(
-						std::io::ErrorKind::InvalidInput,
-						"unsupported transfer coding",
-					));
-				} else {
-					let mut content = Vec::new();
-					#[cfg(feature = "tokio")]
-					{
-						// Since chunked_transfer doesn't have an async interface, only use it to
-						// determine the size of each chunk to read.
-						//
-						// TODO: Replace with an async interface when available.
-						// https://github.com/frewsxcv/rust-chunked-transfer/issues/7
-						loop {
-							// Read the chunk header which contains the chunk size.
-							let mut chunk_header = String::new();
-							reader.read_line(&mut chunk_header).await?;
-							if chunk_header == "0\r\n" {
-								// Read the terminator chunk since the decoder consumes the CRLF
-								// immediately when this chunk is encountered.
-								reader.read_line(&mut chunk_header).await?;
-							}
-
-							// Decode the chunk header to obtain the chunk size.
-							let mut buffer = Vec::new();
-							let mut decoder =
-								chunked_transfer::Decoder::new(chunk_header.as_bytes());
-							decoder.read_to_end(&mut buffer)?;
-
-							// Read the chunk body.
-							let chunk_size = match decoder.remaining_chunks_size() {
-								None => break,
-								Some(chunk_size) => chunk_size,
-							};
-							let chunk_offset = content.len();
-							content.resize(chunk_offset + chunk_size + "\r\n".len(), 0);
-							reader.read_exact(&mut content[chunk_offset..]).await?;
-							content.resize(chunk_offset + chunk_size, 0);
-						}
-						content
-					}
-					#[cfg(not(feature = "tokio"))]
-					{
-						let mut decoder = chunked_transfer::Decoder::new(reader);
-						decoder.read_to_end(&mut content)?;
-						content
-					}
-				}
-			},
-		};
-
-		if !status.is_ok() {
-			// TODO: Handle 3xx redirection responses.
-			let error = HttpError { status_code: status.code.to_string(), contents };
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, error));
-		}
-
-		Ok(contents)
+		Ok(body)
 	}
 }
 
 /// HTTP error consisting of a status code and body contents.
 #[derive(Debug)]
-pub(crate) struct HttpError {
-	pub(crate) status_code: String,
-	pub(crate) contents: Vec<u8>,
+pub struct HttpError {
+	/// The HTTP status code.
+	pub status_code: i32,
+	/// The response body contents.
+	pub contents: Vec<u8>,
 }
 
 impl std::error::Error for HttpError {}
@@ -405,94 +170,6 @@ impl fmt::Display for HttpError {
 	}
 }
 
-/// HTTP response status code as defined by [RFC 7231].
-///
-/// [RFC 7231]: https://tools.ietf.org/html/rfc7231#section-6
-struct HttpStatus<'a> {
-	code: &'a str,
-}
-
-impl<'a> HttpStatus<'a> {
-	/// Parses an HTTP status line as defined by [RFC 7230].
-	///
-	/// [RFC 7230]: https://tools.ietf.org/html/rfc7230#section-3.1.2
-	fn parse(line: &'a String) -> std::io::Result<HttpStatus<'a>> {
-		let mut tokens = line.splitn(3, ' ');
-
-		let http_version = tokens
-			.next()
-			.ok_or(std::io::Error::new(std::io::ErrorKind::InvalidData, "no HTTP-Version"))?;
-		if !http_version.eq_ignore_ascii_case("HTTP/1.1")
-			&& !http_version.eq_ignore_ascii_case("HTTP/1.0")
-		{
-			return Err(std::io::Error::new(
-				std::io::ErrorKind::InvalidData,
-				"invalid HTTP-Version",
-			));
-		}
-
-		let code = tokens
-			.next()
-			.ok_or(std::io::Error::new(std::io::ErrorKind::InvalidData, "no Status-Code"))?;
-		if code.len() != 3 || !code.chars().all(|c| c.is_ascii_digit()) {
-			return Err(std::io::Error::new(
-				std::io::ErrorKind::InvalidData,
-				"invalid Status-Code",
-			));
-		}
-
-		let _reason = tokens
-			.next()
-			.ok_or(std::io::Error::new(std::io::ErrorKind::InvalidData, "no Reason-Phrase"))?;
-
-		Ok(Self { code })
-	}
-
-	/// Returns whether the status is successful (i.e., 2xx status class).
-	fn is_ok(&self) -> bool {
-		self.code.starts_with('2')
-	}
-}
-
-/// HTTP response header as defined by [RFC 7231].
-///
-/// [RFC 7231]: https://tools.ietf.org/html/rfc7231#section-7
-struct HttpHeader<'a> {
-	name: &'a str,
-	value: &'a str,
-}
-
-impl<'a> HttpHeader<'a> {
-	/// Parses an HTTP header field as defined by [RFC 7230].
-	///
-	/// [RFC 7230]: https://tools.ietf.org/html/rfc7230#section-3.2
-	fn parse(line: &'a String) -> std::io::Result<HttpHeader<'a>> {
-		let mut tokens = line.splitn(2, ':');
-		let name = tokens
-			.next()
-			.ok_or(std::io::Error::new(std::io::ErrorKind::InvalidData, "no header name"))?;
-		let value = tokens
-			.next()
-			.ok_or(std::io::Error::new(std::io::ErrorKind::InvalidData, "no header value"))?
-			.trim_start();
-		Ok(Self { name, value })
-	}
-
-	/// Returns whether the header field has the given name.
-	fn has_name(&self, name: &str) -> bool {
-		self.name.eq_ignore_ascii_case(name)
-	}
-}
-
-/// HTTP message body length as defined by [RFC 7230].
-///
-/// [RFC 7230]: https://tools.ietf.org/html/rfc7230#section-3.3.3
-enum HttpMessageLength {
-	Empty,
-	ContentLength(usize),
-	TransferEncoding(String),
-}
-
 /// An HTTP response body in binary format.
 pub struct BinaryResponse(pub Vec<u8>);
 
@@ -517,82 +194,45 @@ impl TryFrom<Vec<u8>> for JsonResponse {
 	}
 }
 
-#[cfg(test)]
-mod endpoint_tests {
-	use super::HttpEndpoint;
-
-	#[test]
-	fn with_default_port() {
-		let endpoint = HttpEndpoint::for_host("foo.com".into());
-		assert_eq!(endpoint.host(), "foo.com");
-		assert_eq!(endpoint.port(), 80);
-	}
-
-	#[test]
-	fn with_custom_port() {
-		let endpoint = HttpEndpoint::for_host("foo.com".into()).with_port(8080);
-		assert_eq!(endpoint.host(), "foo.com");
-		assert_eq!(endpoint.port(), 8080);
-	}
-
-	#[test]
-	fn with_uri_path() {
-		let endpoint = HttpEndpoint::for_host("foo.com".into()).with_path("/path".into());
-		assert_eq!(endpoint.host(), "foo.com");
-		assert_eq!(endpoint.path(), "/path");
-	}
-
-	#[test]
-	fn without_uri_path() {
-		let endpoint = HttpEndpoint::for_host("foo.com".into());
-		assert_eq!(endpoint.host(), "foo.com");
-		assert_eq!(endpoint.path(), "/");
-	}
-
-	#[test]
-	fn convert_to_socket_addrs() {
-		let endpoint = HttpEndpoint::for_host("localhost".into());
-		let host = endpoint.host();
-		let port = endpoint.port();
-
-		use std::net::ToSocketAddrs;
-		match (&endpoint).to_socket_addrs() {
-			Err(e) => panic!("Unexpected error: {:?}", e),
-			Ok(socket_addrs) => {
-				let mut std_addrs = (host, port).to_socket_addrs().unwrap();
-				for addr in socket_addrs {
-					assert_eq!(addr, std_addrs.next().unwrap());
-				}
-				assert!(std_addrs.next().is_none());
-			},
-		}
-	}
-}
-
 #[cfg(test)]
 pub(crate) mod client_tests {
 	use super::*;
-	use std::io::BufRead;
-	use std::io::Write;
+	use std::io::{BufRead, Read, Write};
+	use std::time::Duration;
 
 	/// Server for handling HTTP client requests with a stock response.
 	pub struct HttpServer {
 		address: std::net::SocketAddr,
-		handler: std::thread::JoinHandle<()>,
+		handler: Option<std::thread::JoinHandle<()>>,
 		shutdown: std::sync::Arc<std::sync::atomic::AtomicBool>,
 	}
 
+	impl Drop for HttpServer {
+		fn drop(&mut self) {
+			self.shutdown.store(true, std::sync::atomic::Ordering::SeqCst);
+			// Make a connection to unblock the listener's accept() call
+			let _ = std::net::TcpStream::connect(self.address);
+			if let Some(handler) = self.handler.take() {
+				let _ = handler.join();
+			}
+		}
+	}
+
 	/// Body of HTTP response messages.
 	pub enum MessageBody<T: ToString> {
 		Empty,
 		Content(T),
-		ChunkedContent(T),
 	}
 
 	impl HttpServer {
 		fn responding_with_body<T: ToString>(status: &str, body: MessageBody<T>) -> Self {
 			let response = match body {
-				MessageBody::Empty => format!("{}\r\n\r\n", status),
+				MessageBody::Empty => format!(
+					"{}\r\n\
+					 Content-Length: 0\r\n\
+					 \r\n",
+					status
+				),
 				MessageBody::Content(body) => {
 					let body = body.to_string();
 					format!(
@@ -605,22 +245,6 @@ pub(crate) mod client_tests {
 						body
 					)
 				},
-				MessageBody::ChunkedContent(body) => {
-					let mut chuncked_body = Vec::new();
-					{
-						use chunked_transfer::Encoder;
-						let mut encoder = Encoder::with_chunks_size(&mut chuncked_body, 8);
-						encoder.write_all(body.to_string().as_bytes()).unwrap();
-					}
-					format!(
-						"{}\r\n\
-						 Transfer-Encoding: chunked\r\n\
-						 \r\n\
-						 {}",
-						status,
-						String::from_utf8(chuncked_body).unwrap()
-					)
-				},
 			};
 			HttpServer::responding_with(response)
 		}
@@ -645,179 +269,90 @@ pub(crate) mod client_tests {
 			let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
 			let shutdown_signaled = std::sync::Arc::clone(&shutdown);
 			let handler = std::thread::spawn(move || {
+				let timeout = Duration::from_secs(5);
 				for stream in listener.incoming() {
-					let mut stream = stream.unwrap();
-					stream.set_write_timeout(Some(TCP_STREAM_TIMEOUT)).unwrap();
-
-					let lines_read = std::io::BufReader::new(&stream)
-						.lines()
-						.take_while(|line| !line.as_ref().unwrap().is_empty())
-						.count();
-					if lines_read == 0 {
-						continue;
+					if shutdown_signaled.load(std::sync::atomic::Ordering::SeqCst) {
+						return;
 					}
 
-					for chunk in response.as_bytes().chunks(16) {
+					let stream = stream.unwrap();
+					stream.set_write_timeout(Some(timeout)).unwrap();
+					stream.set_read_timeout(Some(timeout)).unwrap();
+
+					let mut reader = std::io::BufReader::new(stream);
+
+					// Handle multiple requests on the same connection (keep-alive)
+					loop {
 						if shutdown_signaled.load(std::sync::atomic::Ordering::SeqCst) {
 							return;
-						} else {
-							if let Err(_) = stream.write(chunk) {
+						}
+
+						// Read request headers
+						let mut lines_read = 0;
+						let mut content_length: usize = 0;
+						loop {
+							let mut line = String::new();
+							match reader.read_line(&mut line) {
+								Ok(0) => break, // eof
+								Ok(_) => {
+									if line == "\r\n" || line == "\n" {
+										break; // end of headers
+									}
+									// Parse content_length for POST body handling
+									if let Some(value) = line.strip_prefix("Content-Length:") {
+										content_length = value.trim().parse().unwrap_or(0);
+									}
+									lines_read += 1;
+								},
+								Err(_) => break, // Read error or timeout
+							}
+						}
+
+						if lines_read == 0 {
+							break; // No request received, connection closed
+						}
+
+						// Consume request body if present (needed for POST keep-alive)
+						if content_length > 0 {
+							let mut body = vec![0u8; content_length];
+							if reader.read_exact(&mut body).is_err() {
 								break;
 							}
-							if let Err(_) = stream.flush() {
+						}
+
+						// Send response
+						let stream = reader.get_mut();
+						let mut write_error = false;
+						for chunk in response.as_bytes().chunks(16) {
+							if shutdown_signaled.load(std::sync::atomic::Ordering::SeqCst) {
+								return;
+							}
+							if stream.write(chunk).is_err() || stream.flush().is_err() {
+								write_error = true;
 								break;
 							}
 						}
+						if write_error {
+							break;
+						}
 					}
 				}
 			});
 
-			Self { address, handler, shutdown }
-		}
-
-		fn shutdown(self) {
-			self.shutdown.store(true, std::sync::atomic::Ordering::SeqCst);
-			self.handler.join().unwrap();
-		}
-
-		pub fn endpoint(&self) -> HttpEndpoint {
-			HttpEndpoint::for_host(self.address.ip().to_string()).with_port(self.address.port())
-		}
-	}
-
-	#[test]
-	fn connect_to_unresolvable_host() {
-		match HttpClient::connect(("example.invalid", 80)) {
-			Err(e) => {
-				assert!(
-					e.to_string().contains("failed to lookup address information")
-						|| e.to_string().contains("No such host"),
-					"{:?}",
-					e
-				);
-			},
-			Ok(_) => panic!("Expected error"),
-		}
-	}
-
-	#[test]
-	fn connect_with_no_socket_address() {
-		match HttpClient::connect(&vec![][..]) {
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::InvalidInput),
-			Ok(_) => panic!("Expected error"),
-		}
-	}
-
-	#[test]
-	fn connect_with_unknown_server() {
-		// get an unused port by binding to port 0
-		let port = {
-			let t = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
-			t.local_addr().unwrap().port()
-		};
-
-		match HttpClient::connect(("::", port)) {
-			#[cfg(target_os = "windows")]
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::AddrNotAvailable),
-			#[cfg(not(target_os = "windows"))]
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::ConnectionRefused),
-			Ok(_) => panic!("Expected error"),
+			Self { address, handler: Some(handler), shutdown }
 		}
-	}
-
-	#[tokio::test]
-	async fn connect_with_valid_endpoint() {
-		let server = HttpServer::responding_with_ok::<String>(MessageBody::Empty);
 
-		match HttpClient::connect(&server.endpoint()) {
-			Err(e) => panic!("Unexpected error: {:?}", e),
-			Ok(_) => {},
+		pub fn endpoint(&self) -> String {
+			format!("http://{}:{}", self.address.ip(), self.address.port())
 		}
 	}
 
 	#[tokio::test]
-	async fn read_empty_message() {
-		let server = HttpServer::responding_with("".to_string());
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof);
-				assert_eq!(e.get_ref().unwrap().to_string(), "no status line");
-			},
-			Ok(_) => panic!("Expected error"),
-		}
-	}
-
-	#[tokio::test]
-	async fn read_incomplete_message() {
-		let server = HttpServer::responding_with("HTTP/1.1 200 OK".to_string());
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof);
-				assert_eq!(e.get_ref().unwrap().to_string(), "no headers");
-			},
-			Ok(_) => panic!("Expected error"),
-		}
-	}
-
-	#[tokio::test]
-	async fn read_too_large_message_headers() {
-		let response = format!(
-			"HTTP/1.1 302 Found\r\n\
-			 Location: {}\r\n\
-			 \r\n",
-			"Z".repeat(MAX_HTTP_MESSAGE_HEADER_SIZE)
-		);
-		let server = HttpServer::responding_with(response);
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof);
-				assert_eq!(e.get_ref().unwrap().to_string(), "no headers");
-			},
-			Ok(_) => panic!("Expected error"),
-		}
-	}
-
-	#[tokio::test]
-	async fn read_too_large_message_body() {
-		let body = "Z".repeat(MAX_HTTP_MESSAGE_BODY_SIZE + 1);
-		let server = HttpServer::responding_with_ok::<String>(MessageBody::Content(body));
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::InvalidData);
-				assert_eq!(
-					e.get_ref().unwrap().to_string(),
-					"invalid response length: 8032001 bytes"
-				);
-			},
-			Ok(_) => panic!("Expected error"),
-		}
-		server.shutdown();
-	}
-
-	#[tokio::test]
-	async fn read_message_with_unsupported_transfer_coding() {
-		let response = String::from(
-			"HTTP/1.1 200 OK\r\n\
-			 Transfer-Encoding: gzip\r\n\
-			 \r\n\
-			 foobar",
-		);
-		let server = HttpServer::responding_with(response);
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::InvalidInput);
-				assert_eq!(e.get_ref().unwrap().to_string(), "unsupported transfer coding");
-			},
+	async fn connect_with_invalid_host() {
+		let client = HttpClient::new("http://invalid.host.example:80".to_string());
+		match client.get::<JsonResponse>("/foo").await {
+			Err(HttpClientError::Transport(_)) => {},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -826,50 +361,25 @@ pub(crate) mod client_tests {
 	async fn read_error() {
 		let server = HttpServer::responding_with_server_error("foo");
 
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<JsonResponse>("/foo", "foo.com").await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::Other);
-				let http_error = e.into_inner().unwrap().downcast::<HttpError>().unwrap();
-				assert_eq!(http_error.status_code, "500");
+		let client = HttpClient::new(server.endpoint());
+		match client.get::<JsonResponse>("/foo").await {
+			Err(HttpClientError::Http(http_error)) => {
+				assert_eq!(http_error.status_code, 500);
 				assert_eq!(http_error.contents, "foo".as_bytes());
 			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
 
 	#[tokio::test]
-	async fn read_empty_message_body() {
-		let server = HttpServer::responding_with_ok::<String>(MessageBody::Empty);
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => panic!("Unexpected error: {:?}", e),
-			Ok(bytes) => assert_eq!(bytes.0, Vec::<u8>::new()),
-		}
-	}
-
-	#[tokio::test]
-	async fn read_message_body_with_length() {
+	async fn read_message_body() {
 		let body = "foo bar baz qux".repeat(32);
 		let content = MessageBody::Content(body.clone());
 		let server = HttpServer::responding_with_ok::<String>(content);
 
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
-			Err(e) => panic!("Unexpected error: {:?}", e),
-			Ok(bytes) => assert_eq!(bytes.0, body.as_bytes()),
-		}
-	}
-
-	#[tokio::test]
-	async fn read_chunked_message_body() {
-		let body = "foo bar baz qux".repeat(32);
-		let chunked_content = MessageBody::ChunkedContent(body.clone());
-		let server = HttpServer::responding_with_ok::<String>(chunked_content);
-
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
+		let client = HttpClient::new(server.endpoint());
+		match client.get::<BinaryResponse>("/foo").await {
 			Err(e) => panic!("Unexpected error: {:?}", e),
 			Ok(bytes) => assert_eq!(bytes.0, body.as_bytes()),
 		}
@@ -879,9 +389,9 @@ pub(crate) mod client_tests {
 	async fn reconnect_closed_connection() {
 		let server = HttpServer::responding_with_ok::<String>(MessageBody::Empty);
 
-		let mut client = HttpClient::connect(&server.endpoint()).unwrap();
-		assert!(client.get::<BinaryResponse>("/foo", "foo.com").await.is_ok());
-		match client.get::<BinaryResponse>("/foo", "foo.com").await {
+		let client = HttpClient::new(server.endpoint());
+		assert!(client.get::<BinaryResponse>("/foo").await.is_ok());
+		match client.get::<BinaryResponse>("/foo").await {
 			Err(e) => panic!("Unexpected error: {:?}", e),
 			Ok(bytes) => assert_eq!(bytes.0, Vec::<u8>::new()),
 		}
diff --git a/lightning-block-sync/src/rest.rs b/lightning-block-sync/src/rest.rs
index 619981b..0ea9389 100644
--- a/lightning-block-sync/src/rest.rs
+++ b/lightning-block-sync/src/rest.rs
@@ -3,7 +3,7 @@
 
 use crate::convert::GetUtxosResponse;
 use crate::gossip::UtxoSource;
-use crate::http::{BinaryResponse, HttpClient, HttpEndpoint, JsonResponse};
+use crate::http::{BinaryResponse, HttpClient, HttpClientError, JsonResponse};
 use crate::{BlockData, BlockHeaderData, BlockSource, BlockSourceResult};
 
 use bitcoin::hash_types::BlockHash;
@@ -12,38 +12,27 @@ use bitcoin::OutPoint;
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use std::future::Future;
-use std::sync::Mutex;
 
 /// A simple REST client for requesting resources using HTTP `GET`.
 pub struct RestClient {
-	endpoint: HttpEndpoint,
-	client: Mutex<Option<HttpClient>>,
+	client: HttpClient,
 }
 
 impl RestClient {
 	/// Creates a new REST client connected to the given endpoint.
 	///
-	/// The endpoint should contain the REST path component (e.g., http://127.0.0.1:8332/rest).
-	pub fn new(endpoint: HttpEndpoint) -> Self {
-		Self { endpoint, client: Mutex::new(None) }
+	/// The base URL should include the REST path component (e.g., "http://127.0.0.1:8332/rest").
+	pub fn new(base_url: String) -> Self {
+		Self { client: HttpClient::new(base_url) }
 	}
 
 	/// Requests a resource encoded in `F` format and interpreted as type `T`.
-	pub async fn request_resource<F, T>(&self, resource_path: &str) -> std::io::Result<T>
+	pub async fn request_resource<F, T>(&self, resource_path: &str) -> Result<T, HttpClientError>
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error> + TryInto<T, Error = std::io::Error>,
 	{
-		let host = format!("{}:{}", self.endpoint.host(), self.endpoint.port());
-		let uri = format!("{}/{}", self.endpoint.path().trim_end_matches("/"), resource_path);
-		let reserved_client = self.client.lock().unwrap().take();
-		let mut client = if let Some(client) = reserved_client {
-			client
-		} else {
-			HttpClient::connect(&self.endpoint)?
-		};
-		let res = client.get::<F>(&uri, &host).await?.try_into();
-		*self.client.lock().unwrap() = Some(client);
-		res
+		let uri = format!("/{}", resource_path);
+		self.client.get::<F>(&uri).await?.try_into().map_err(HttpClientError::Io)
 	}
 }
 
@@ -126,7 +115,8 @@ mod tests {
 		let client = RestClient::new(server.endpoint());
 
 		match client.request_resource::<BinaryResponse, u32>("/").await {
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::Other),
+			Err(HttpClientError::Http(e)) => assert_eq!(e.status_code, 404),
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -137,7 +127,8 @@ mod tests {
 		let client = RestClient::new(server.endpoint());
 
 		match client.request_resource::<BinaryResponse, u32>("/").await {
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::InvalidData),
+			Err(HttpClientError::Io(_)) => {},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
diff --git a/lightning-block-sync/src/rpc.rs b/lightning-block-sync/src/rpc.rs
index d851ba2..c81d7f2 100644
--- a/lightning-block-sync/src/rpc.rs
+++ b/lightning-block-sync/src/rpc.rs
@@ -2,14 +2,12 @@
 //! endpoint.
 
 use crate::gossip::UtxoSource;
-use crate::http::{HttpClient, HttpEndpoint, HttpError, JsonResponse};
+use crate::http::{HttpClient, HttpClientError, JsonResponse};
 use crate::{BlockData, BlockHeaderData, BlockSource, BlockSourceResult};
 
 use bitcoin::hash_types::BlockHash;
 use bitcoin::OutPoint;
 
-use std::sync::Mutex;
-
 use serde_json;
 
 use std::convert::TryFrom;
@@ -36,14 +34,56 @@ impl fmt::Display for RpcError {
 
 impl Error for RpcError {}
 
+/// Error type for RPC client operations.
+#[derive(Debug)]
+pub enum RpcClientError {
+	/// An HTTP client error (transport or HTTP error).
+	Http(HttpClientError),
+	/// An RPC error returned by the server.
+	Rpc(RpcError),
+	/// Invalid data in the response.
+	InvalidData(String),
+}
+
+impl std::error::Error for RpcClientError {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		match self {
+			RpcClientError::Http(e) => Some(e),
+			RpcClientError::Rpc(e) => Some(e),
+			RpcClientError::InvalidData(_) => None,
+		}
+	}
+}
+
+impl fmt::Display for RpcClientError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			RpcClientError::Http(e) => write!(f, "HTTP error: {}", e),
+			RpcClientError::Rpc(e) => write!(f, "{}", e),
+			RpcClientError::InvalidData(msg) => write!(f, "invalid data: {}", msg),
+		}
+	}
+}
+
+impl From<HttpClientError> for RpcClientError {
+	fn from(e: HttpClientError) -> Self {
+		RpcClientError::Http(e)
+	}
+}
+
+impl From<RpcError> for RpcClientError {
+	fn from(e: RpcError) -> Self {
+		RpcClientError::Rpc(e)
+	}
+}
+
 /// A simple RPC client for calling methods using HTTP `POST`.
 ///
 /// Implements [`BlockSource`] and may return an `Err` containing [`RpcError`]. See
 /// [`RpcClient::call_method`] for details.
 pub struct RpcClient {
 	basic_auth: String,
-	endpoint: HttpEndpoint,
-	client: Mutex<Option<HttpClient>>,
+	client: HttpClient,
 	id: AtomicUsize,
 }
 
@@ -51,85 +91,64 @@ impl RpcClient {
 	/// Creates a new RPC client connected to the given endpoint with the provided credentials. The
 	/// credentials should be a base64 encoding of a user name and password joined by a colon, as is
 	/// required for HTTP basic access authentication.
-	pub fn new(credentials: &str, endpoint: HttpEndpoint) -> Self {
+	///
+	/// The base URL should include the scheme, host, and port (e.g., "http://127.0.0.1:8332").
+	pub fn new(credentials: &str, base_url: String) -> Self {
 		Self {
 			basic_auth: "Basic ".to_string() + credentials,
-			endpoint,
-			client: Mutex::new(None),
+			client: HttpClient::new(base_url),
 			id: AtomicUsize::new(0),
 		}
 	}
 
 	/// Calls a method with the response encoded in JSON format and interpreted as type `T`.
-	///
-	/// When an `Err` is returned, [`std::io::Error::into_inner`] may contain an [`RpcError`] if
-	/// [`std::io::Error::kind`] is [`std::io::ErrorKind::Other`].
 	pub async fn call_method<T>(
 		&self, method: &str, params: &[serde_json::Value],
-	) -> std::io::Result<T>
+	) -> Result<T, RpcClientError>
 	where
 		JsonResponse: TryFrom<Vec<u8>, Error = std::io::Error> + TryInto<T, Error = std::io::Error>,
 	{
-		let host = format!("{}:{}", self.endpoint.host(), self.endpoint.port());
-		let uri = self.endpoint.path();
 		let content = serde_json::json!({
 			"method": method,
 			"params": params,
 			"id": &self.id.fetch_add(1, Ordering::AcqRel).to_string()
 		});
 
-		let reserved_client = self.client.lock().unwrap().take();
-		let mut client = if let Some(client) = reserved_client {
-			client
-		} else {
-			HttpClient::connect(&self.endpoint)?
-		};
-		let http_response =
-			client.post::<JsonResponse>(&uri, &host, &self.basic_auth, content).await;
-		*self.client.lock().unwrap() = Some(client);
+		let http_response = self.client.post::<JsonResponse>("/", &self.basic_auth, content).await;
 
 		let mut response = match http_response {
 			Ok(JsonResponse(response)) => response,
-			Err(e) if e.kind() == std::io::ErrorKind::Other => {
-				match e.get_ref().unwrap().downcast_ref::<HttpError>() {
-					Some(http_error) => match JsonResponse::try_from(http_error.contents.clone()) {
-						Ok(JsonResponse(response)) => response,
-						Err(_) => Err(e)?,
-					},
-					None => Err(e)?,
+			Err(HttpClientError::Http(http_error)) => {
+				// Try to parse the error body as JSON-RPC response
+				match JsonResponse::try_from(http_error.contents.clone()) {
+					Ok(JsonResponse(response)) => response,
+					Err(_) => return Err(HttpClientError::Http(http_error).into()),
 				}
 			},
-			Err(e) => Err(e)?,
+			Err(e) => return Err(e.into()),
 		};
 
 		if !response.is_object() {
-			return Err(std::io::Error::new(
-				std::io::ErrorKind::InvalidData,
-				"expected JSON object",
-			));
+			return Err(RpcClientError::InvalidData("expected JSON object".to_string()));
 		}
 
 		let error = &response["error"];
 		if !error.is_null() {
-			// TODO: Examine error code for a more precise std::io::ErrorKind.
 			let rpc_error = RpcError {
 				code: error["code"].as_i64().unwrap_or(-1),
 				message: error["message"].as_str().unwrap_or("unknown error").to_string(),
 			};
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, rpc_error));
+			return Err(rpc_error.into());
 		}
 
 		let result = match response.get_mut("result") {
 			Some(result) => result.take(),
-			None => {
-				return Err(std::io::Error::new(
-					std::io::ErrorKind::InvalidData,
-					"expected JSON result",
-				))
-			},
+			None => return Err(RpcClientError::InvalidData("expected JSON result".to_string())),
 		};
 
-		JsonResponse(result).try_into()
+		JsonResponse(result)
+			.try_into()
+			.map_err(|e: std::io::Error| RpcClientError::InvalidData(e.to_string()))
 	}
 }
 
@@ -212,7 +231,10 @@ mod tests {
 		let client = RpcClient::new(CREDENTIALS, server.endpoint());
 
 		match client.call_method::<u64>("getblockcount", &[]).await {
-			Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::Other),
+			Err(RpcClientError::Http(HttpClientError::Http(e))) => {
+				assert_eq!(e.status_code, 404);
+			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -224,10 +246,10 @@ mod tests {
 		let client = RpcClient::new(CREDENTIALS, server.endpoint());
 
 		match client.call_method::<u64>("getblockcount", &[]).await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::InvalidData);
-				assert_eq!(e.get_ref().unwrap().to_string(), "expected JSON object");
+			Err(RpcClientError::InvalidData(msg)) => {
+				assert_eq!(msg, "expected JSON object");
 			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -242,12 +264,11 @@ mod tests {
 
 		let invalid_block_hash = serde_json::json!("foo");
 		match client.call_method::<u64>("getblock", &[invalid_block_hash]).await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::Other);
-				let rpc_error: Box<RpcError> = e.into_inner().unwrap().downcast().unwrap();
+			Err(RpcClientError::Rpc(rpc_error)) => {
 				assert_eq!(rpc_error.code, -8);
 				assert_eq!(rpc_error.message, "invalid parameter");
 			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -259,10 +280,10 @@ mod tests {
 		let client = RpcClient::new(CREDENTIALS, server.endpoint());
 
 		match client.call_method::<u64>("getblockcount", &[]).await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::InvalidData);
-				assert_eq!(e.get_ref().unwrap().to_string(), "expected JSON result");
+			Err(RpcClientError::InvalidData(msg)) => {
+				assert_eq!(msg, "expected JSON result");
 			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}
@@ -274,10 +295,10 @@ mod tests {
 		let client = RpcClient::new(CREDENTIALS, server.endpoint());
 
 		match client.call_method::<u64>("getblockcount", &[]).await {
-			Err(e) => {
-				assert_eq!(e.kind(), std::io::ErrorKind::InvalidData);
-				assert_eq!(e.get_ref().unwrap().to_string(), "not a number");
+			Err(RpcClientError::InvalidData(msg)) => {
+				assert!(msg.contains("not a number"));
 			},
+			Err(e) => panic!("Unexpected error type: {:?}", e),
 			Ok(_) => panic!("Expected error"),
 		}
 	}