Struct X402Client 

pub struct X402Client<TSelector = FirstMatch> { /* private fields */ }

Available on crate feature client only.

HTTP middleware over a core PaymentClient.

Automatically handles 402 Payment Required by signing a payment and retrying once (or twice if on_payment_response signals recovery).

Implementations

impl X402Client<FirstMatch>

pub fn new() -> Self

Creates a new client with FirstMatch selection.

impl<TSelector> X402Client<TSelector>

pub const fn from_payment_client(inner: PaymentClient<TSelector>) -> Self

Builds from an existing core payment client.

pub const fn payment_client(&self) -> &PaymentClient<TSelector>

Returns a shared reference to the core payment client.

pub fn register<S>(self, scheme: S) -> Self

where S: SchemeClient + 'static,

Registers a scheme client.

pub fn with_selector<P: PaymentSelector>(self, selector: P) -> X402Client<P>

Sets a custom payment selector.

pub fn with_policy<P: PaymentPolicy + 'static>(self, policy: P) -> Self

Adds a payment policy.

pub fn with_hook(self, hook: impl ClientHooks + 'static) -> Self

Adds a client lifecycle hook (including on_payment_response).

impl<TSelector> X402Client<TSelector>

where TSelector: PaymentSelector,

pub async fn make_payment_headers( &self, res: Response, ) -> Result<HeaderMap, ClientError>

Creates Payment-Signature headers from a 402 response.

Errors

Parse, selection, signing, or before-hook abort.

pub async fn create_payment( &self, payment_required: &PaymentRequired, ) -> Result<CreatedPayment, ClientError>

Creates a payment for an already-parsed challenge.

Errors

Selection, signing, or before-hook abort.

impl<S> X402Client<S>

where Self: Middleware,

pub fn wrap(self, client: Client) -> ClientWithMiddleware

Wraps a reqwest Client with x402 payment middleware.

Returns a rqm::ClientWithMiddleware that automatically handles 402 Payment Required responses using registered scheme clients.

pub fn wrap_builder(self, client: Client) -> ClientBuilder

Wraps a reqwest Client and returns the middleware builder for further customization (e.g., adding more middleware).

Trait Implementations

impl Default for X402Client<FirstMatch>

fn default() -> Self

Returns the “default value” for a type.

impl<TSelector> Middleware for X402Client<TSelector>

where TSelector: PaymentSelector + Send + Sync + 'static,

fn handle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: Request, extensions: &'life1 mut Extensions, next: Next<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handles a request, automatically handling 402 responses.

When a 402 is received:

1. Extract requirements, create signed payment (hooks)
2. Retry with Payment-Signature
3. Dispatch on_payment_response on settle / corrective 402
4. If recovered, rebuild payment and retry once more