use std::fmt;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use url::Url;
use crate::{domain::Source, error::Error};
use super::RpcLimits;
#[derive(Clone)]
pub struct RpcEndpoint {
pub(crate) url: Url,
pub(crate) headers: HeaderMap,
}
impl RpcEndpoint {
pub fn new(endpoint: &str) -> Result<Self, Error> {
let explicit_scheme = endpoint.split_once("://").is_some_and(|(scheme, _)| {
scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
});
if !explicit_scheme
|| endpoint.contains('\\')
|| endpoint
.chars()
.any(|character| character.is_whitespace() || character.is_control())
{
return Err(Error::Configuration);
}
let url = Url::parse(endpoint).map_err(|_| Error::Configuration)?;
if !matches!(url.scheme(), "http" | "https")
|| url.host_str().is_none()
|| url.fragment().is_some()
{
return Err(Error::Configuration);
}
Ok(Self {
url,
headers: HeaderMap::new(),
})
}
pub fn with_header(mut self, name: &str, value: &str) -> Result<Self, Error> {
let name = HeaderName::from_bytes(name.as_bytes()).map_err(|_| Error::Configuration)?;
if matches!(
name.as_str(),
"host" | "content-type" | "content-length" | "transfer-encoding"
) {
return Err(Error::Configuration);
}
if name.as_str() == "authorization"
&& (!self.url.username().is_empty() || self.url.password().is_some())
{
return Err(Error::Configuration);
}
let mut value = HeaderValue::from_str(value).map_err(|_| Error::Configuration)?;
value.set_sensitive(true);
self.headers.insert(name, value);
Ok(self)
}
}
impl fmt::Debug for RpcEndpoint {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("RpcEndpoint { url: [REDACTED], headers: [REDACTED] }")
}
}
#[derive(Clone, Debug)]
pub struct HttpConfig {
endpoint: RpcEndpoint,
limits: RpcLimits,
provider_id: String,
}
impl HttpConfig {
pub fn new(
endpoint: RpcEndpoint,
limits: RpcLimits,
provider_id: impl Into<String>,
) -> Result<Self, Error> {
let provider_id = provider_id.into();
let _source = Source::new(&provider_id, "http", env!("CARGO_PKG_VERSION"))?;
Ok(Self {
endpoint,
limits,
provider_id,
})
}
#[must_use]
pub const fn endpoint(&self) -> &RpcEndpoint {
&self.endpoint
}
#[must_use]
pub const fn limits(&self) -> RpcLimits {
self.limits
}
#[must_use]
pub fn provider_id(&self) -> &str {
&self.provider_id
}
}