use async_trait::async_trait;
use serde_json::Value;
use std::time::Duration;
use super::json_rpc::{JsonRpcRequest, JsonRpcResponse};
use crate::error::SdkError;
#[async_trait]
pub trait Transport: Send + Sync {
async fn send(&self, method: &str, params: Value) -> Result<Value, SdkError>;
}
#[derive(Debug, Clone, Copy)]
pub struct RetryConfig {
pub max_retries: u32,
pub base_delay: Duration,
pub max_delay: Duration,
pub jitter_factor: f64,
}
impl Default for RetryConfig {
fn default() -> Self {
Self {
max_retries: 3,
base_delay: Duration::from_millis(100),
max_delay: Duration::from_secs(5),
jitter_factor: 0.25,
}
}
}
impl RetryConfig {
#[must_use]
pub const fn no_retry() -> Self {
Self {
max_retries: 0,
base_delay: Duration::from_millis(0),
max_delay: Duration::from_millis(0),
jitter_factor: 0.0,
}
}
fn delay_for(&self, attempt: u32) -> Duration {
let base = self.base_delay.as_millis() as f64;
let exp = base * 2_f64.powi(attempt as i32);
let capped = exp.min(self.max_delay.as_millis() as f64);
let jitter_low = capped * (1.0 - self.jitter_factor);
let jitter_high = capped * (1.0 + self.jitter_factor);
let sampled = jitter_low + rand::random::<f64>() * (jitter_high - jitter_low);
Duration::from_millis(sampled.max(0.0) as u64)
}
}
fn is_transient(err: &SdkError) -> bool {
matches!(err, SdkError::Connection(_))
|| matches!(err, SdkError::Rpc(msg) if msg.starts_with("HTTP 5"))
|| matches!(err, SdkError::Rpc(msg) if msg.starts_with("HTTP 429"))
}
fn parse_retry_after_secs(msg: &str) -> Option<u64> {
let after = msg.find("Wait for ")?;
let rest = &msg[after + "Wait for ".len()..];
let end = rest.find('s')?;
rest[..end].parse::<u64>().ok()
}
pub struct HttpTransport {
client: reqwest::Client,
url: String,
next_id: std::sync::atomic::AtomicU64,
retry: RetryConfig,
}
impl HttpTransport {
pub fn new(url: impl Into<String>) -> Result<Self, SdkError> {
let client = reqwest::Client::builder()
.pool_idle_timeout(std::time::Duration::from_secs(30))
.build()
.map_err(|e| SdkError::Connection(format!("reqwest client init: {e}")))?;
let url = url.into();
url::Url::parse(&url)
.map_err(|e| SdkError::InvalidArgument(format!("invalid RPC url: {e}")))?;
Ok(Self {
client,
url,
next_id: std::sync::atomic::AtomicU64::new(1),
retry: RetryConfig::default(),
})
}
#[must_use]
pub fn url(&self) -> &str {
&self.url
}
#[must_use]
pub fn with_retry_config(mut self, retry: RetryConfig) -> Self {
self.retry = retry;
self
}
#[must_use]
pub fn retry_config(&self) -> &RetryConfig {
&self.retry
}
fn next_request_id(&self) -> u64 {
self.next_id
.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
async fn send_once(&self, method: &str, params: Value) -> Result<Value, SdkError> {
let req = JsonRpcRequest::new(self.next_request_id(), method, params);
let http_resp = self
.client
.post(&self.url)
.json(&req)
.send()
.await
.map_err(|e| SdkError::Connection(format!("POST {}: {e}", self.url)))?;
let status = http_resp.status();
let body = http_resp
.text()
.await
.map_err(|e| SdkError::Connection(format!("read response body: {e}")))?;
if !status.is_success() {
return Err(SdkError::Rpc(format!("HTTP {status}: {body}")));
}
let resp: JsonRpcResponse = serde_json::from_str(&body).map_err(|e| {
SdkError::InvalidResponse(format!("decode envelope: {e}; body: {body}"))
})?;
resp.into_result()
}
}
const MAX_RETRY_AFTER_SECS: u64 = 60;
#[async_trait]
impl Transport for HttpTransport {
async fn send(&self, method: &str, params: Value) -> Result<Value, SdkError> {
let mut last_err: Option<SdkError> = None;
let mut server_hint_delay: Option<Duration> = None;
for attempt in 0..=self.retry.max_retries {
if attempt > 0 {
let delay = server_hint_delay
.take()
.unwrap_or_else(|| self.retry.delay_for(attempt - 1));
tokio::time::sleep(delay).await;
}
match self.send_once(method, params.clone()).await {
Ok(v) => return Ok(v),
Err(e) if is_transient(&e) => {
if let SdkError::Rpc(msg) = &e {
if let Some(secs) = parse_retry_after_secs(msg) {
let capped = secs.min(MAX_RETRY_AFTER_SECS);
server_hint_delay = Some(Duration::from_secs(capped));
}
}
last_err = Some(e);
continue;
}
Err(e) => return Err(e),
}
}
Err(last_err.unwrap_or_else(|| {
SdkError::Connection(format!(
"all {} retries exhausted on {method}",
self.retry.max_retries
))
}))
}
}
impl std::fmt::Debug for HttpTransport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HttpTransport")
.field("url", &self.url)
.field("retry", &self.retry)
.finish()
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
#[test]
fn rejects_invalid_url() {
assert!(HttpTransport::new("not a url").is_err());
}
#[test]
fn accepts_valid_url() {
let t = HttpTransport::new("http://127.0.0.1:9933").unwrap();
assert_eq!(t.url(), "http://127.0.0.1:9933");
}
#[test]
fn id_increments_per_request() {
let t = HttpTransport::new("http://127.0.0.1:9933").unwrap();
let a = t.next_request_id();
let b = t.next_request_id();
assert_eq!(b, a + 1);
}
#[test]
fn default_retry_config_has_3_retries() {
let t = HttpTransport::new("http://127.0.0.1:9933").unwrap();
assert_eq!(t.retry_config().max_retries, 3);
assert_eq!(t.retry_config().base_delay, Duration::from_millis(100));
assert_eq!(t.retry_config().max_delay, Duration::from_secs(5));
assert!((t.retry_config().jitter_factor - 0.25).abs() < 1e-9);
}
#[test]
fn no_retry_config_disables_retries() {
let cfg = RetryConfig::no_retry();
assert_eq!(cfg.max_retries, 0);
assert_eq!(cfg.base_delay, Duration::from_millis(0));
}
#[test]
fn with_retry_config_overrides_default() {
let custom = RetryConfig {
max_retries: 7,
base_delay: Duration::from_millis(25),
max_delay: Duration::from_secs(2),
jitter_factor: 0.5,
};
let t = HttpTransport::new("http://127.0.0.1:9933")
.unwrap()
.with_retry_config(custom);
assert_eq!(t.retry_config().max_retries, 7);
assert_eq!(t.retry_config().base_delay, Duration::from_millis(25));
}
#[test]
fn delay_grows_exponentially_within_cap() {
let cfg = RetryConfig {
max_retries: 5,
base_delay: Duration::from_millis(100),
max_delay: Duration::from_secs(5),
jitter_factor: 0.0, };
assert_eq!(cfg.delay_for(0), Duration::from_millis(100));
assert_eq!(cfg.delay_for(1), Duration::from_millis(200));
assert_eq!(cfg.delay_for(2), Duration::from_millis(400));
assert_eq!(cfg.delay_for(5), Duration::from_millis(3200));
assert_eq!(cfg.delay_for(6), Duration::from_millis(5000));
assert_eq!(cfg.delay_for(20), Duration::from_millis(5000));
}
#[test]
fn jittered_delay_stays_within_bounds() {
let cfg = RetryConfig {
max_retries: 5,
base_delay: Duration::from_millis(100),
max_delay: Duration::from_secs(5),
jitter_factor: 0.25,
};
for _ in 0..100 {
let d = cfg.delay_for(0);
assert!(
d >= Duration::from_millis(74) && d <= Duration::from_millis(126),
"delay {:?} outside jitter window [74..126]",
d
);
}
}
#[test]
fn is_transient_classifies_connection_as_retryable() {
assert!(is_transient(&SdkError::Connection("refused".into())));
}
#[test]
fn is_transient_classifies_5xx_as_retryable() {
assert!(is_transient(&SdkError::Rpc("HTTP 502: bad gateway".into())));
assert!(is_transient(&SdkError::Rpc(
"HTTP 503: service unavailable".into()
)));
}
#[test]
fn is_transient_classifies_4xx_as_non_retryable() {
assert!(!is_transient(&SdkError::Rpc("HTTP 404: not found".into())));
assert!(!is_transient(&SdkError::Rpc(
"HTTP 400: bad request".into()
)));
}
#[test]
fn is_transient_classifies_429_as_retryable() {
assert!(is_transient(&SdkError::Rpc(
"HTTP 429 Too Many Requests: Too Many Requests! Wait for 80s".into()
)));
assert!(is_transient(&SdkError::Rpc(
"HTTP 429: rate limited".into()
)));
}
#[test]
fn parse_retry_after_secs_extracts_engine_hint() {
assert_eq!(
parse_retry_after_secs("HTTP 429 Too Many Requests: Too Many Requests! Wait for 80s"),
Some(80)
);
assert_eq!(parse_retry_after_secs("HTTP 429: Wait for 1s"), Some(1));
assert_eq!(
parse_retry_after_secs("Wait for 9999s before retry"),
Some(9999)
);
}
#[test]
fn parse_retry_after_secs_handles_missing() {
assert_eq!(parse_retry_after_secs("HTTP 429: rate limited"), None);
assert_eq!(parse_retry_after_secs("HTTP 502: bad gateway"), None);
assert_eq!(parse_retry_after_secs(""), None);
assert_eq!(parse_retry_after_secs("Wait for s"), None);
assert_eq!(parse_retry_after_secs("Wait for abcs"), None);
}
const _: () = assert!(super::MAX_RETRY_AFTER_SECS <= 60);
#[test]
fn is_transient_classifies_chain_errors_as_non_retryable() {
assert!(!is_transient(&SdkError::InvalidArgument(
"nonce too low".into()
)));
assert!(!is_transient(&SdkError::InvalidResponse(
"malformed envelope".into()
)));
}
}