Struct HttpClient 

pub struct HttpClient {
    pub client: Client,
    pub base_url: Url,
    /* private fields */
}

Shared HTTP client with base URL, optional rate limiter, and retry config.

This is the common structure used by all API clients to hold the configured reqwest client, base URL, and rate-limiting state.

Fields

client: Client

The underlying reqwest HTTP client

base_url: Url

Base URL for API requests

Implementations

impl HttpClient

pub fn with_base_url(&self, base_url: &str) -> Result<Self, ApiError>

Clone this client, pointed at a different base URL.

The underlying reqwest client (and so its connection pool), rate limiter, retry config, and concurrency limiter are all shared with the original. Use this to reach a sibling API host that should share the same transport configuration and request budget — several Polymarket APIs live on their own subdomains but are consumed by one client.

Sharing the concurrency limiter is deliberate: the limit exists to keep Cloudflare from seeing a burst from this process, and that is a per-process concern rather than a per-host one.

Path prefixes are ignored

Request paths are absolute (/user-pnl), and resolving an absolute path against a base replaces the base’s path entirely. So a prefix in base_url is silently dropped, with or without a trailing slash:

http://host          + /user-pnl -> http://host/user-pnl
http://host/proxy    + /user-pnl -> http://host/user-pnl   (prefix gone)
http://host/proxy/   + /user-pnl -> http://host/user-pnl   (prefix gone)

Point this at a scheme, host, and port — not at a sub-path. Fronting the API with a path-prefixed reverse proxy is not supported.

pub async fn acquire_rate_limit(&self, path: &str, method: Option<&Method>)

Await rate limiter for the given endpoint path + method.

pub async fn acquire_concurrency(&self) -> Option<OwnedSemaphorePermit>

Acquire a concurrency permit, if a limiter is configured.

The returned permit must be held until the HTTP response has been received. Dropping the permit releases the concurrency slot. Returns None when no concurrency limit is set.

pub fn should_retry( &self, status: StatusCode, attempt: u32, retry_after: Option<&str>, ) -> Option<Duration>

Check if a response should be retried; returns backoff duration if yes.

Retries two statuses, both of which upstream documents as “retry with exponential backoff”:

• 429 Too Many Requests — rate limited.
• 425 Too Early — Polymarket’s matching engine is restarting. It returns this with no body, so nothing was processed.

Deliberately narrow: 5xx is not retried here. It is retriable in the ApiError::is_retriable sense, but a 5xx can mean the request was partially applied, and this loop resends non-idempotent writes. The two statuses above are safe because neither reaches the matching engine — and for order placement the resent body is byte-identical, so the order hash is unchanged and the venue rejects a genuine double-submit as a duplicate. Callers wanting broader retry semantics should drive them from ApiError::is_retriable with their own idempotency judgement.

When retry_after is Some, the server-provided delay is used instead of the client-computed exponential backoff (clamped to max_backoff_ms).

pub async fn get_bytes( &self, path: &str, query: &[(String, String)], ) -> Result<Vec<u8>, ApiError>

GET a URL and return the raw response body as bytes.

Use this for endpoints that return non-JSON payloads (e.g. application/zip downloads). Applies the same rate-limiting, concurrency gating, and should_retry behavior as the JSON-oriented Request helper.

Non-2xx responses are mapped to ApiError via ApiError::from_response.

Errors

Returns ApiError on URL-join failure, network errors, or non-2xx responses.

Trait Implementations

impl Clone for HttpClient

fn clone(&self) -> HttpClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.