@inflowpayai/x402 0.5.0

package/dist/index.d.cts

@@ -0,0 +1,571 @@
+export { h as generatePaymentId, v as validatePaymentId } from './payment-identifier-BNYznClf.cjs';
+import { ResourceInfo } from '@x402/core/types';
+export { ResourceInfo, VerifyResponse } from '@x402/core/types';
+
+/**
+ * X402 protocol version emitted on every outbound SDK request and required on every inbound response. Responses
+ * advertising a different version are rejected at the boundary with {@link X402VersionMismatchError}.
+ */
+declare const X402_VERSION: 2;
+/**
+ * V2 spec header names. Emitted verbatim on the write path; read via {@link readHeader} (case-insensitive). Header
+ * values use the standard base64 alphabet (`A-Z`, `a-z`, `0-9`, `+`, `/`) with `=` padding — not base64url.
+ */
+declare const HEADERS: {
+    readonly PAYMENT_REQUIRED: "PAYMENT-REQUIRED";
+    readonly PAYMENT_RESPONSE: "PAYMENT-RESPONSE";
+    readonly PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE";
+};
+/**
+ * Payment-scheme identifiers carried in `PaymentRequirements.scheme` and `PaymentPayload.accepted.scheme`.
+ *
+ * `INSTRUMENT` is a reserved value: it is present in the type union for forward compatibility, and the SDK rejects it
+ * at runtime with a typed error if reached.
+ */
+declare const SCHEMES: {
+    readonly BALANCE: "balance";
+    readonly EXACT: "exact";
+    readonly INSTRUMENT: "instrument";
+};
+/**
+ * Canonical Permit2Proxy and Permit2 addresses. Identical on every supported EVM chain (CREATE2-deployed). Use for the
+ * buyer-side verification fallback when `PaymentRequirements.extra.permit2Proxy` is absent.
+ */
+declare const CONTRACTS: {
+    readonly PERMIT2_PROXY: "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
+    readonly PERMIT2: "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+};
+/**
+ * Reserved network identifiers. CAIP-2 shaped `<namespace>:<reference>`. Only InFlow's internal ledger is enumerated;
+ * on-chain network ids (`eip155:8453`, `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`, …) are sourced at runtime from
+ * `X402ConfigResponse.assets[*].network` and `wallets[*].network`.
+ */
+declare const NETWORKS: {
+    readonly INFLOW: "inflow:1";
+};
+/** Well-known keys read from `PaymentRequirements.extra` and `PaymentMethodInfo.extra`. */
+declare const EXTRA_KEYS: {
+    readonly ASSET_TRANSFER_METHOD: "assetTransferMethod";
+    readonly FEE_PAYER: "feePayer";
+    readonly NAME: "name";
+    readonly PERMIT2_PROXY: "permit2Proxy";
+    readonly VERSION: "version";
+};
+/** Well-known keys read from `PaymentPayload.payload`. */
+declare const PAYLOAD_KEYS: {
+    readonly TRANSACTION_ID: "transactionId";
+};
+/** Values that can appear in `PaymentRequirements.extra.assetTransferMethod`. */
+declare const ASSET_TRANSFER_METHODS: {
+    readonly EIP3009: "eip3009";
+    readonly PERMIT2: "permit2";
+    readonly SOLANA: "solana";
+};
+/**
+ * Header bag accepted by {@link readHeader}. Covers WHATWG `Headers`, Node's `IncomingHttpHeaders`-style records (where
+ * values may be string arrays or undefined), and plain string-valued records.
+ */
+type HeaderBag = Headers | Record<string, string | readonly string[] | undefined>;
+/**
+ * Read a single header value case-insensitively. Returns `undefined` when the header is absent. For Node-style headers
+ * whose value is an array, returns the first element.
+ *
+ * @param headers - The header bag to read from.
+ * @param name - The header name. Matched case-insensitively against the keys in `headers`.
+ * @returns The header value, or `undefined` if missing.
+ */
+declare function readHeader(headers: HeaderBag, name: string): string | undefined;
+
+/** Public InFlow environments addressable by the SDK without an explicit `baseUrl` override. */
+type Environment = 'production' | 'sandbox';
+/** Options consumed by {@link resolveBaseUrl}. */
+interface ResolveBaseUrlOptions {
+    /** Selects one of the public environments. Defaults to `'production'`. */
+    environment?: Environment;
+    /** Override the environment-derived URL entirely. Trailing slashes are stripped. Takes precedence over `environment`. */
+    baseUrl?: string;
+}
+/**
+ * Resolve the InFlow API base URL the SDK will issue requests against.
+ *
+ * @param options - {@link ResolveBaseUrlOptions}. `baseUrl` wins over `environment`. With neither set, falls back to the
+ *   production URL.
+ * @returns The base URL with any trailing slashes stripped, suitable for appending request paths.
+ */
+declare function resolveBaseUrl(options?: ResolveBaseUrlOptions): string;
+
+/**
+ * Constructor parameters for {@link InflowApiError}. Every field except `message` corresponds to an attribute carried on
+ * the resulting error instance.
+ */
+interface InflowApiErrorInit {
+    /**
+     * Application-level error code extracted from the response body's `code` field. Falls back to `'UNEXPECTED_ERROR'`
+     * when the body did not carry a code. Specific values consumers may branch on include `INSUFFICIENT_FUNDS`,
+     * `PARAMETER_REQUIRED`, `PARAMETER_INVALID`, `BLOCKCHAIN_NOT_FOUND`, and `USER_NOT_FOUND`.
+     */
+    code: string;
+    /** HTTP status of the failing response. */
+    httpStatus: number;
+    /** Endpoint path (relative to the base URL) that produced the failure. */
+    endpoint: string;
+    /**
+     * Server-issued correlation ID, read from `X-Request-Id` on the response. `undefined` when the server did not emit
+     * one.
+     */
+    requestId?: string;
+    /** Underlying error (e.g. a `fetch` rejection) when this wraps another. */
+    cause?: unknown;
+    /** Parsed JSON body when the response was JSON; raw text otherwise. */
+    body?: unknown;
+    /** Response headers with sensitive entries (`authorization`, `cookie`, `set-cookie`, `x-api-key`) stripped. */
+    headers?: Headers | Record<string, string | readonly string[] | undefined>;
+}
+/**
+ * Error thrown by every {@link InflowHttpClient} call on a non-2xx response. Carries the server-issued correlation ID
+ * when available and the (sanitized) response body and headers for diagnostics.
+ */
+declare class InflowApiError extends Error {
+    /** {@inheritDoc InflowApiErrorInit.code} */
+    readonly code: string;
+    /** {@inheritDoc InflowApiErrorInit.httpStatus} */
+    readonly httpStatus: number;
+    /** {@inheritDoc InflowApiErrorInit.endpoint} */
+    readonly endpoint: string;
+    /** {@inheritDoc InflowApiErrorInit.requestId} */
+    readonly requestId?: string;
+    /** {@inheritDoc InflowApiErrorInit.body} */
+    readonly body?: unknown;
+    /** {@inheritDoc InflowApiErrorInit.headers} */
+    readonly headers?: Readonly<Record<string, string>>;
+    /**
+     * @param message - Human-readable message. Callers should prefer the factory {@link InflowApiError.from} which
+     *   composes a standard message shape including endpoint, status, code, and request ID.
+     * @param init - Structured fields carried on the resulting instance.
+     */
+    constructor(message: string, init: InflowApiErrorInit);
+    /**
+     * Compose an {@link InflowApiError} with a standard message shape.
+     *
+     * Format: `[<requestId>] <endpoint>: <httpStatus> <code> — <bodyMessage>`, where `<requestId>` is omitted when
+     * missing and `<bodyMessage>` falls back to a generic `request failed` when the body had no `message` field.
+     */
+    static from(init: InflowApiErrorInit): InflowApiError;
+}
+/**
+ * Thrown when a response advertises an `x402Version` other than the SDK's supported version ({@link X402_VERSION} = 2).
+ * The SDK does not attempt version negotiation: only V2 is supported and any other value is a hard error so consumers
+ * see the mismatch at the boundary instead of as a silent decode failure deeper in.
+ */
+declare class X402VersionMismatchError extends Error {
+    /** Version reported by the server (or `unknown` when the field was absent). */
+    readonly receivedVersion: number | 'unknown';
+    /** Endpoint or context that produced the mismatched payload. */
+    readonly endpoint: string;
+    /**
+     * @param receivedVersion - The `x402Version` value the response carried, or the string `'unknown'` when the field was
+     *   missing or not a number.
+     * @param endpoint - The endpoint path or context the SDK was processing when it saw the version field, used in the
+     *   generated message.
+     */
+    constructor(receivedVersion: number | 'unknown', endpoint: string);
+}
+
+/**
+ * Options accepted by {@link InflowHttpClient}'s constructor and shared by higher-level facilitator and signer clients
+ * in the seller and buyer packages.
+ */
+interface InflowClientOptions {
+    /** InFlow API key sent on every request as `X-API-KEY`. */
+    apiKey: string;
+    /** Selects one of the public environments. Defaults to `'production'`. */
+    environment?: Environment;
+    /** Override the environment-derived URL. Takes precedence over `environment`. */
+    baseUrl?: string;
+    /**
+     * Per-request timeout, milliseconds. Defaults to 30 000. The timer covers the whole `fetch` plus body read; on expiry
+     * the request is aborted and an `InflowApiError` with `code: 'TIMEOUT'` is thrown.
+     */
+    timeoutMs?: number;
+    /**
+     * Optional `fetch` implementation. Defaults to `globalThis.fetch`. Useful for routing through a corporate proxy,
+     * attaching OpenTelemetry instrumentation, or stubbing at the SDK boundary in tests. The injected function must
+     * conform to the WHATWG fetch API.
+     */
+    fetch?: typeof fetch;
+}
+/**
+ * Options accepted by {@link InflowHttpClient} when constructed without an API key. Only used by the seller-side
+ * `createUnauthenticatedInflowFacilitator` factory; buyer-side flows and the seller client never construct anonymous
+ * transports. Sends no `X-API-KEY` header on outbound requests.
+ */
+interface InflowAnonymousClientOptions {
+    /** Marker field — must be omitted or `undefined`. */
+    apiKey?: undefined;
+    /** Selects one of the public environments. Defaults to `'production'`. */
+    environment?: Environment;
+    /** Override the environment-derived URL. Takes precedence over `environment`. */
+    baseUrl?: string;
+    /** Per-request timeout, milliseconds. Defaults to 30 000. */
+    timeoutMs?: number;
+    /** Optional `fetch` implementation. Defaults to `globalThis.fetch`. */
+    fetch?: typeof fetch;
+}
+/** Per-call overrides accepted by {@link InflowHttpClient}'s request methods. */
+interface RequestOptions {
+    /**
+     * Maximum retry attempts on transient failures (HTTP 429, 502, 503, 504, and network errors). Capped at 3. Pass `0`
+     * to disable retries — used by the buyer signer's polling loop, where the outer poller controls retry semantics.
+     */
+    retries?: number;
+    /** Override the client-level `timeoutMs` for this call. */
+    timeoutMs?: number;
+    /** Additional headers merged on top of the SDK's standard headers. */
+    headers?: Record<string, string>;
+    /**
+     * AbortSignal for caller-driven cancellation. Composes with the request-internal timeout signal; whichever fires
+     * first aborts the request.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * HTTP client used by every other package in this monorepo to talk to `api.inflowpay.ai`. Carries `apiKey` injection,
+ * retry on transient statuses (429, 502, 503, 504) with exponential backoff capped at three attempts, request timeout,
+ * JSON parsing, and error mapping into {@link InflowApiError}.
+ *
+ * Construct one instance per `(apiKey, environment)` pair and share it across requests.
+ */
+declare class InflowHttpClient {
+    /** Resolved base URL (no trailing slash). */
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private readonly defaultTimeoutMs;
+    private readonly fetchImpl;
+    /**
+     * @param options - {@link InflowClientOptions} or {@link InflowAnonymousClientOptions}. The authed form requires
+     *   `apiKey` to be a non-empty string; the anonymous form omits it entirely and sends no `X-API-KEY` header.
+     *   Anonymous mode is used only by `createUnauthenticatedInflowFacilitator` in `@inflowpayai/x402-seller`.
+     * @throws {Error} When `apiKey` is present but empty. (Server-side codes are mapped to {@link InflowApiError}; this is
+     *   a local precondition failure.)
+     */
+    constructor(options: InflowClientOptions | InflowAnonymousClientOptions);
+    /**
+     * Issue a `GET` to `path` (relative to {@link InflowHttpClient.baseUrl}) and parse the JSON body.
+     *
+     * @typeParam T - Expected shape of the parsed body. Not validated at runtime; callers are responsible for narrowing.
+     * @param path - Path including leading slash, e.g. `'/v1/x402/config'`.
+     * @param options - Per-call overrides.
+     * @returns Parsed JSON body cast to `T`.
+     * @throws {@link InflowApiError} On any non-2xx response or terminal network error.
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Issue a `POST` to `path` with a JSON body and parse the JSON response.
+     *
+     * @typeParam T - Expected shape of the parsed body.
+     * @param path - Path including leading slash.
+     * @param body - Value serialized via `JSON.stringify`. Pass `undefined` to send an empty body.
+     * @param options - Per-call overrides.
+     * @returns Parsed JSON body cast to `T`.
+     * @throws {@link InflowApiError} On any non-2xx response or terminal network error.
+     */
+    post<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Lower-level entry point. Prefer {@link InflowHttpClient.get} / {@link InflowHttpClient.post} unless the verb is one
+     * neither covers.
+     *
+     * @typeParam T - Expected shape of the parsed body.
+     * @param method - HTTP verb.
+     * @param path - Path including leading slash.
+     * @param body - Optional value serialized via `JSON.stringify`.
+     * @param options - Per-call overrides.
+     * @returns Parsed JSON body cast to `T`.
+     */
+    request<T>(method: string, path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    private sendOnce;
+}
+
+/**
+ * Payment-scheme identifier carried on the wire. `'exact'` covers EIP-3009 and Permit2 EVM transfers as well as non-EVM
+ * signed transfers; `'balance'` covers InFlow internal balance transfers; `'instrument'` is reserved.
+ *
+ * The `(string & {})` branch keeps editor autocomplete focused on the known values while still accepting any string at
+ * runtime, so consumers can interoperate with future schemes the SDK hasn't yet enumerated.
+ */
+type PaymentScheme = 'exact' | 'balance' | 'instrument' | (string & {});
+/** Funding-source type carried in `instrument`-scheme payloads and extras. Reserved for future use. */
+type InstrumentType = 'card' | 'bank' | (string & {});
+/**
+ * A single entry in `PaymentRequired.accepts[]`. Describes one acceptable way for a buyer to pay the protected
+ * resource: a scheme, a network, the payee address, the asset (when applicable), the atomic-unit amount, and
+ * scheme-specific extras.
+ */
+interface PaymentRequirements {
+    /** Payment scheme — `'exact'`, `'balance'`, or `'instrument'`. */
+    scheme: PaymentScheme;
+    /**
+     * CAIP-2 network identifier. `'eip155:8453'` and `'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'` for blockchain networks;
+     * `'inflow:1'` for InFlow's internal ledger (balance and reserved instrument schemes).
+     */
+    network: string;
+    /** On-chain contract address or mint. Empty string when not applicable. */
+    asset: string;
+    /** Amount in atomic units of `asset` (or the method's own decimal scale). */
+    amount: string;
+    /** Recipient — wallet address for blockchain schemes, seller UUID for balance/instrument. */
+    payTo: string;
+    /** Maximum lifetime (seconds) the requirement is valid for. */
+    maxTimeoutSeconds: number;
+    /**
+     * Scheme-specific extras (EIP-712 domain, asset transfer method, fee payer, etc.). Optional on the wire — the server
+     * omits it when no extras apply (e.g. some `balance`-scheme entries). Use the typed accessors in
+     * `@inflowpayai/x402/extras` for safe reads under `noUncheckedIndexedAccess`.
+     */
+    extra?: Record<string, unknown>;
+}
+/** The 402-response body. Sent by the seller as a base64 JSON encoding in the `PAYMENT-REQUIRED` header. */
+interface PaymentRequired {
+    /** Protocol version — always `2`. */
+    x402Version: number;
+    /** Optional human-readable error context attached by the seller. */
+    error?: string;
+    /** Information about the protected resource. */
+    resource: ResourceInfo;
+    /** The set of acceptable payment options. The buyer chooses one. */
+    accepts: PaymentRequirements[];
+    /** Per-response extension declarations, keyed by extension name. */
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Inner payload shape for the `'balance'` scheme. Balance payments are not cryptographically signed because settlement
+ * is an internal ledger transfer rather than a verifiable on-chain action.
+ */
+interface BalancePayloadData {
+    /** InFlow transaction UUID — the only field carried on the wire. */
+    transactionId: string;
+}
+/**
+ * EIP-3009 (`transferWithAuthorization`) wire shape of the `'exact'` scheme. The Permit2 variant lives on
+ * {@link Permit2PayloadData}.
+ */
+interface ExactPayloadData {
+    /** EIP-3009 `TransferWithAuthorization` typed-data message. */
+    authorization: {
+        /** Payer address; signs `authorization`. */
+        from: string;
+        /** Recipient (the seller's `payTo`). */
+        to: string;
+        /** Atomic-unit amount (decimal string). */
+        value: string;
+        /** Unix-seconds lower bound for facilitator submission. */
+        validAfter: string;
+        /** Unix-seconds upper bound (matches `maxTimeoutSeconds`). */
+        validBefore: string;
+        /** 32-byte hex; the payer must not have used it before. */
+        nonce: string;
+    };
+    /** 65-byte EIP-712 ECDSA signature over `authorization`. */
+    signature: string;
+}
+/** Inner payload shape for the `'instrument'` scheme. Reserved. */
+interface InstrumentPayloadData {
+    transactionId: string;
+    signature: string;
+    instrumentId?: string;
+    instrumentType?: InstrumentType;
+}
+/**
+ * Permit2 variant of the `'exact'` scheme inner payload. See the [x402 EVM exact scheme
+ * spec](https://github.com/coinbase/x402/blob/main/specs/schemes/exact/scheme_exact_evm.md). `spender` must be the
+ * canonical x402ExactPermit2Proxy (see {@link CONTRACTS}); the InFlow facilitator rejects custom spenders.
+ */
+interface Permit2PayloadData {
+    signature: string;
+    permit2Authorization: {
+        permitted: {
+            token: string;
+            amount: string;
+        };
+        from: string;
+        spender: string;
+        nonce: string;
+        deadline: string;
+        witness: {
+            to: string;
+            validAfter: string;
+            extra: string;
+        };
+    };
+}
+/**
+ * Discriminated union of known inner-payload shapes. The catch-all `Record<string, unknown>` branch keeps the type open
+ * for forward- compatible schemes the SDK hasn't yet enumerated.
+ */
+type InflowPaymentPayloadData = BalancePayloadData | ExactPayloadData | Permit2PayloadData | InstrumentPayloadData | Record<string, unknown>;
+/**
+ * The signed payment envelope a buyer sends to the seller in the `PAYMENT-SIGNATURE` header (base64 JSON). Narrow on
+ * `accepted.scheme` to discriminate `payload`.
+ */
+interface InflowPaymentPayload {
+    /** Protocol version — always `2`. */
+    x402Version: number;
+    /** The {@link PaymentRequirements} the buyer chose. */
+    accepted: PaymentRequirements;
+    /** Scheme-specific signed (or pseudo-signed) inner payload. */
+    payload: InflowPaymentPayloadData;
+    /** Per-payload extension data, keyed by extension name. */
+    extensions?: Record<string, unknown>;
+    /** Optional resource info echoed back by the buyer. */
+    resource?: ResourceInfo;
+}
+/** Narrows to the `'balance'` scheme branch. */
+declare function isBalancePayload(p: InflowPaymentPayload): p is InflowPaymentPayload & {
+    payload: BalancePayloadData;
+};
+/**
+ * Narrows to the EIP-3009 variant of the `'exact'` scheme. The two `'exact'` variants split on transfer method — use
+ * alongside {@link isPermit2Payload}.
+ */
+declare function isExactPayload(p: InflowPaymentPayload): p is InflowPaymentPayload & {
+    payload: ExactPayloadData;
+};
+/**
+ * Narrows to the Permit2 variant of the `'exact'` scheme. The two `'exact'` variants split on transfer method — use
+ * alongside {@link isExactPayload}.
+ */
+declare function isPermit2Payload(p: InflowPaymentPayload): p is InflowPaymentPayload & {
+    payload: Permit2PayloadData;
+};
+/** Narrows to the reserved `'instrument'` scheme branch. Returns `false` for all production traffic today. */
+declare function isInstrumentPayload(p: InflowPaymentPayload): p is InflowPaymentPayload & {
+    payload: InstrumentPayloadData;
+};
+/**
+ * Settlement-result envelope returned by the facilitator after a settle call. `network` is CAIP-2 for blockchain
+ * settlements and `'inflow:1'` for balance settlements.
+ *
+ * `transaction` is always present: a non-empty on-chain hash (or settlement reference for `'balance'`) on success, the
+ * empty string on failure. Check `success` before treating the value as a real reference.
+ */
+interface SettleResponse {
+    success: boolean;
+    errorReason?: string;
+    errorMessage?: string;
+    payer?: string;
+    /** On-chain hash on success, empty string on failure. Always present. */
+    transaction: string;
+    network: string;
+    amount?: string;
+    /** Per-extension entries returned by the facilitator. */
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Per-`(scheme, network)` capability advertised by a facilitator. The optional `extra` map carries scheme- or
+ * operator-specific metadata; the SDK does not interpret it.
+ */
+interface X402SupportedKind {
+    network: string;
+    scheme: PaymentScheme;
+    x402Version: number;
+    extra?: Record<string, unknown>;
+}
+/**
+ * Facilitator-wide capability response. Returned by `GET /v1/x402/supported`.
+ *
+ * `signers` carries the operator wallet addresses that sign settlement on the facilitator side, used by sellers for
+ * trust verification of the settlement source. `extensions` enumerates the facilitator-wide extension names so
+ * `inflowAccepts` can dispatch to the right handlers.
+ */
+interface X402FacilitatorSupportedResponse {
+    kinds: X402SupportedKind[];
+    extensions?: string[];
+    signers?: Record<string, string[]>;
+}
+/**
+ * Buyer-facing capability response. Returned by `GET /v1/transactions/x402-supported`. Deliberately narrower than
+ * {@link X402FacilitatorSupportedResponse}: facilitator-wide extension declarations and operator signer addresses have
+ * no actionable meaning on the buyer side and are intentionally omitted.
+ */
+interface X402BuyerSupportedResponse {
+    kinds: X402SupportedKind[];
+}
+/**
+ * On-chain asset metadata, per `(blockchain, currency)` pair. Read from `X402ConfigResponse.assets[]` by
+ * `inflowAccepts` when constructing `'exact'`-scheme entries.
+ */
+interface X402AssetInfo {
+    /**
+     * Default transfer method for this asset. `'eip3009'` and `'permit2'` for EVM assets; `'solana'` for Solana. The
+     * `(string & {})` branch leaves room for forward-compatible methods the SDK hasn't enumerated yet (e.g.
+     * `'erc7710'`).
+     */
+    assetTransferMethod?: 'eip3009' | 'permit2' | 'solana' | (string & {});
+    /** Contract address (EVM) or mint (Solana). */
+    assetId: string;
+    /** Blockchain enum name as serialized in the config response. Opaque to the SDK. */
+    blockchain: string;
+    /** Currency code — e.g. `'USDC'`, `'USDT'`, `'PYUSD'`. */
+    currency: string;
+    /** On-chain decimal places for this asset (e.g. `6` for USDC on Base). */
+    decimals: number;
+    /** CAIP-2 network identifier (e.g. `'eip155:8453'`). Opaque to the SDK. */
+    network: string;
+    /**
+     * Permit2 spender address the facilitator will sign settlements through. Present on EVM assets that support Permit2;
+     * absent when the canonical x402ExactPermit2Proxy isn't deployed on the chain. Buyers should verify this equals
+     * {@link CONTRACTS.PERMIT2_PROXY} before signing.
+     */
+    permit2Proxy?: string;
+    /** EIP-712 domain name. Present only for EVM assets. */
+    tokenName?: string;
+    /** EIP-712 domain version. Present only for EVM assets. */
+    tokenVersion?: string;
+}
+/**
+ * Receiving-wallet metadata, per blockchain. Read from `X402ConfigResponse.wallets[]` by `inflowAccepts` to fill the
+ * `payTo` field on `'exact'`-scheme entries.
+ */
+interface X402WalletInfo {
+    /** Chain-native address (EVM hex or Solana base58); used as `payTo` on `'exact'` entries. */
+    address: string;
+    /** Blockchain enum name — joins to `X402AssetInfo.blockchain`. Opaque to the SDK. */
+    blockchain: string;
+    /** Solana-only fee-payer address. */
+    feePayer?: string;
+    /** CAIP-2 network identifier (e.g. `'eip155:8453'`); matches `X402AssetInfo.network`. */
+    network: string;
+}
+/**
+ * Non-blockchain payment method metadata. Read from `X402ConfigResponse.paymentMethods[]` by `inflowAccepts` when
+ * constructing `'balance'` and (reserved) `'instrument'` entries.
+ */
+interface PaymentMethodInfo {
+    /** Scheme this method handles — `'balance'` today, `'instrument'` reserved. */
+    scheme: PaymentScheme;
+    /** Network identifier for the method. `'inflow:1'` for `'balance'`; CAIP-2 for any future on-chain method. */
+    network: string;
+    /** Recipient identifier — the seller UUID for `'balance'` / `'instrument'`. */
+    payTo: string;
+    /** Per-method decimal scale. */
+    decimals: number;
+    /** Method-specific extras. Optional on the wire. */
+    extra?: Record<string, unknown>;
+}
+/**
+ * Stateless seller config response. Returned by `GET /v1/x402/config`. The seller middleware consumes this to construct
+ * `PaymentRequired.accepts[]` at request time without per-route hard-coding.
+ */
+interface X402ConfigResponse {
+    /** Per-`(blockchain, currency)` on-chain asset metadata. */
+    assets: X402AssetInfo[];
+    /** Non-blockchain methods — `'balance'` and (reserved) `'instrument'`. */
+    paymentMethods: PaymentMethodInfo[];
+    /** Seller UUID — also the `payTo` value for non-blockchain schemes. */
+    sellerId: string;
+    /** Facilitator capabilities mirrored on the seller's config response. */
+    supported: X402SupportedKind[];
+    /** Per-blockchain receiving wallets. */
+    wallets: X402WalletInfo[];
+}
+
+export { ASSET_TRANSFER_METHODS, type BalancePayloadData, CONTRACTS, EXTRA_KEYS, type Environment, type ExactPayloadData, HEADERS, type HeaderBag, type InflowAnonymousClientOptions, InflowApiError, type InflowApiErrorInit, type InflowClientOptions, InflowHttpClient, type InflowPaymentPayload, type InflowPaymentPayloadData, type InstrumentPayloadData, type InstrumentType, NETWORKS, PAYLOAD_KEYS, type PaymentMethodInfo, type PaymentRequired, type PaymentRequirements, type PaymentScheme, type Permit2PayloadData, type RequestOptions, type ResolveBaseUrlOptions, SCHEMES, type SettleResponse, type X402AssetInfo, type X402BuyerSupportedResponse, type X402ConfigResponse, type X402FacilitatorSupportedResponse, type X402SupportedKind, X402VersionMismatchError, type X402WalletInfo, X402_VERSION, isBalancePayload, isExactPayload, isInstrumentPayload, isPermit2Payload, readHeader, resolveBaseUrl };