uvd-x402-sdk 2.74.0 → 2.76.0

package/dist/backend/index.d.mts

@@ -1,5 +1,210 @@
-import { S as SigningWalletAdapter } from '../wallet-w7BnImDG.mjs';
-import { e as X402Header, X as X402Version, f as X402PayloadData } from '../index-DeJMYEKC.mjs';
+import { S as SigningWalletAdapter } from '../wallet-0cX9Pw2F.mjs';
+import { x as X402Header, Q as X402Version, G as X402PayloadData } from '../index-ZH10otHE.mjs';
+
+/**
+ * Reading a facilitator refusal as DATA instead of prose.
+ *
+ * # Why this file exists
+ *
+ * `402` and `503` say opposite things and the SDK used to collapse both into
+ * `success: false` plus an English sentence.
+ *
+ * - **402** means the payment was REJECTED. The credential is spent; sign a new
+ *   authorization.
+ * - **503** means NO VERDICT WAS REACHED. Nothing was rejected and nothing was
+ *   executed; retry the SAME credential.
+ *
+ * Turning a 503 into a 402 makes the buyer sign and send a second payment for a
+ * money movement that was never refused — they pay twice. That is the most
+ * expensive mistake this SDK can make, so every facilitator edge now reports the
+ * status, the facilitator's own `reason`, and whether the request may be
+ * replayed.
+ *
+ * # The writer lease
+ *
+ * The facilitator serialises every EVM write through the one process that holds
+ * the EVM writer lease, because they all spend gas from the same EOA and the
+ * nonce for it is allocated in memory. A task that does not hold the lease
+ * forwards the request to the one that does; when it cannot, it answers
+ * `503` + `Retry-After: 5` + `{"error": "...", "reason": "<why>"}`.
+ *
+ * The five reasons do NOT share retry semantics, which is the whole point of
+ * surfacing them:
+ *
+ * | reason                     | did the write run? | replay? |
+ * |----------------------------|--------------------|---------|
+ * | `holder_unknown`           | no                 | yes     |
+ * | `forwarding_disabled`      | no                 | yes     |
+ * | `forwarded_but_not_writer` | no                 | yes     |
+ * | `body_unreadable`          | no                 | yes     |
+ * | `forward_failed`           | **maybe**          | **no**  |
+ *
+ * `forward_failed` is emitted after the forward was attempted: the holder may
+ * have executed the write and the response been lost on the way back. It is a
+ * timeout wearing a status code. Replaying a `/register` on it is exactly the
+ * sequence that once minted five duplicate agents — reconcile with
+ * `GET /identity/{network}/owner/{recipient}` or `getRegisterStatus` instead.
+ *
+ * Source of the shape: x402-rs `src/handlers.rs` `writer_lease_unavailable()`
+ * and `require_writer_lease()`.
+ */
+/**
+ * A `reason` the facilitator attaches to a writer-lease 503.
+ *
+ * Typed as a union for discrimination but never used to VALIDATE: the fields
+ * that carry it are plain `string`, so a reason added on the server does not
+ * break compilation here.
+ */
+type WriterLeaseReason = 'holder_unknown' | 'forwarding_disabled' | 'forwarded_but_not_writer' | 'body_unreadable' | 'forward_failed';
+/** Every writer-lease reason the facilitator emits today. */
+declare const WRITER_LEASE_REASONS: readonly WriterLeaseReason[];
+/**
+ * The reasons returned BEFORE the write is handed to anyone.
+ *
+ * The facilitator refuses these in its router, so the request provably did not
+ * execute and re-sending the identical body is safe — including a mint.
+ */
+declare const REPLAYABLE_LEASE_REASONS: readonly WriterLeaseReason[];
+/**
+ * The reason that is ambiguous: the write may already have happened.
+ *
+ * Still `retryable` — the credential was not rejected — but never replayed
+ * automatically. Resolve it by reading state, not by re-POSTing.
+ */
+declare const AMBIGUOUS_LEASE_REASONS: readonly WriterLeaseReason[];
+/**
+ * Ceiling, in seconds, on how long an automatic retry will wait.
+ *
+ * `Retry-After` is a hint from a server that may be misconfigured. Honouring a
+ * literal `Retry-After: 3600` would hang the caller's request for an hour
+ * inside a function documented as returning promptly, so the header is honoured
+ * only up to this bound.
+ */
+declare const MAX_RETRY_AFTER_SECONDS = 15;
+/** Wait used when a 503 carries no usable `Retry-After`. */
+declare const DEFAULT_RETRY_AFTER_SECONDS = 5;
+/** How many EXTRA attempts a retryable facilitator refusal gets by default. */
+declare const DEFAULT_FACILITATOR_RETRIES = 2;
+/**
+ * A non-2xx answer from the facilitator, kept structured.
+ *
+ * `error` is byte-identical to the string this SDK has always produced, so
+ * callers matching on it keep working; everything else is new and optional.
+ */
+interface FacilitatorErrorInfo {
+    /** Legacy flattened message: `Facilitator error: <status> - <body>`. */
+    error: string;
+    /** HTTP status the facilitator answered with. */
+    status: number;
+    /** The facilitator's own `reason`, when the body carried one. */
+    reason?: string;
+    /**
+     * Seconds to wait before retrying, already clamped to
+     * {@link MAX_RETRY_AFTER_SECONDS}. Absent when the answer is not retryable.
+     */
+    retryAfterSeconds?: number;
+    /**
+     * The request reached no verdict; the credential is untouched and the SAME
+     * request may be sent again. Never surface this as a payment rejection.
+     */
+    retryable: boolean;
+    /**
+     * The facilitator NAMED a reason that proves it executed nothing, so an
+     * automatic replay cannot double-write.
+     *
+     * False for `forward_failed`, whose write may already have landed, and false
+     * for an unattributed 5xx from a proxy — "something in front answered" is not
+     * evidence that nothing ran.
+     */
+    safeToReplay: boolean;
+    /** Raw response body, for logs. */
+    body: string;
+}
+/** Fields every facilitator response type gained so a 503 stops looking terminal. */
+interface FacilitatorFailureFields {
+    /** HTTP status, when the failure was transport-level rather than a verdict. */
+    status?: number;
+    /** The facilitator's `reason` for the refusal (see {@link WriterLeaseReason}). */
+    reason?: string;
+    /** True when the same request may be sent again without re-signing anything. */
+    retryable?: boolean;
+    /** Seconds to wait before retrying, clamped to {@link MAX_RETRY_AFTER_SECONDS}. */
+    retryAfterSeconds?: number;
+    /** True when the facilitator provably executed nothing. */
+    safeToReplay?: boolean;
+}
+/** A 503/429 that carries a reason known to be pre-execution. */
+declare function isReplayableLeaseReason(reason?: string): boolean;
+/** A 503 whose write may already have run. Reconcile, do not re-POST. */
+declare function isAmbiguousLeaseReason(reason?: string): boolean;
+/**
+ * Read `Retry-After` and clamp it.
+ *
+ * Tolerates a `Response`-shaped object with no `headers` at all: test doubles
+ * and non-standard fetch polyfills routinely omit it, and throwing there would
+ * turn a readable refusal into an unreadable crash.
+ */
+declare function parseRetryAfterSeconds(response: {
+    headers?: {
+        get?: (name: string) => string | null;
+    };
+}): number | undefined;
+/**
+ * Turn a non-2xx facilitator response into {@link FacilitatorErrorInfo}.
+ *
+ * Reads the body exactly once. The `error` string keeps the historical format
+ * verbatim; reformatting it would break callers that match on it.
+ */
+declare function readFacilitatorError(response: {
+    status: number;
+    text: () => Promise<string>;
+    headers?: {
+        get?: (name: string) => string | null;
+    };
+}): Promise<FacilitatorErrorInfo>;
+/**
+ * Copy the failure fields off one response onto another.
+ *
+ * Used where a wrapper returns its own shape: without this the wrapper flattens
+ * a `503` back into a bare failure and reintroduces, one level up, exactly the
+ * ambiguity the fields exist to remove.
+ */
+declare function carryFailureFields(source: FacilitatorFailureFields): FacilitatorFailureFields;
+/** Options for {@link facilitatorFetch}. */
+interface FacilitatorFetchOptions {
+    /** Abort the request after this many milliseconds. */
+    timeoutMs: number;
+    /** Extra attempts after the first. Default {@link DEFAULT_FACILITATOR_RETRIES}. */
+    retries?: number;
+    /**
+     * Whether this particular refusal may be replayed.
+     *
+     * Default: only when the facilitator proved it executed nothing
+     * (`info.safeToReplay`). Pass a stricter predicate on paths where even a
+     * proven-safe replay is unwanted.
+     */
+    canReplay?: (info: FacilitatorErrorInfo) => boolean;
+    /** Injected for tests. */
+    fetchImpl?: typeof fetch;
+    /** Injected for tests, so a retry does not really sleep. */
+    sleepImpl?: (ms: number) => Promise<void>;
+}
+/**
+ * POST/GET the facilitator, replaying a refusal that provably executed nothing.
+ *
+ * Returns the response plus, when it was not ok, the structured refusal — the
+ * body has already been consumed to build it, so callers must not read it
+ * again.
+ *
+ * Network errors and timeouts still THROW, exactly as before: callers already
+ * have `catch` blocks that turn them into `{ success: false }`, and an
+ * `AbortError` on the escrow paths triggers an on-chain reconciliation that
+ * must keep firing.
+ */
+declare function facilitatorFetch(url: string, init: RequestInit, options: FacilitatorFetchOptions): Promise<{
+    response: Response;
+    error?: FacilitatorErrorInfo;
+}>;
 
 /**
  * Payment requirements sent to the facilitator
@@ -47,8 +252,16 @@ interface SettleRequest {
 /**
  * Verify response from the facilitator
  */
-interface VerifyResponse {
+interface VerifyResponse extends FacilitatorFailureFields {
     isValid: boolean;
+    /**
+     * Why the payment is not valid.
+     *
+     * Read `retryable` before showing this to anyone. When `retryable` is true the
+     * facilitator reached NO VERDICT -- it did not reject the payment, so this
+     * string is a transport diagnosis, not a rejection, and re-signing on it makes
+     * the buyer pay twice.
+     */
     invalidReason?: string;
     payer?: string;
     network?: string;
@@ -56,11 +269,17 @@ interface VerifyResponse {
 /**
  * Settle response from the facilitator
  */
-interface SettleResponse {
+interface SettleResponse extends FacilitatorFailureFields {
     success: boolean;
     transactionHash?: string;
     network?: string;
-    /** Transport-level failure (unreachable facilitator, non-2xx, timeout). */
+    /**
+     * Transport-level failure (unreachable facilitator, non-2xx, timeout).
+     *
+     * `success: false` with `retryable: true` is NOT a rejected payment. The
+     * authorization is untouched and the same one must be resent; treating it as
+     * a refusal and asking for a new signature charges the buyer twice.
+     */
     error?: string;
     /**
      * The facilitator's own reason when it settled nothing — e.g. a transfer that
@@ -357,6 +576,15 @@ interface FacilitatorClientOptions {
      * Set explicitly to override per-network auto-detection.
      */
     timeout?: number;
+    /**
+     * Extra attempts after the first when the facilitator answers a refusal it
+     * proved it did not execute (`safeToReplay`). Default 2; `0` disables.
+     *
+     * Only ever spent on `429` and on a `503` naming a pre-execution writer-lease
+     * reason. An ambiguous `forward_failed` -- whose write may already have landed
+     * -- is never replayed here, at any setting.
+     */
+    retries?: number;
 }
 /**
  * Client for interacting with the x402 facilitator API
@@ -382,6 +610,7 @@ declare class FacilitatorClient {
     private readonly baseUrl;
     private readonly timeout;
     private readonly explicitTimeout;
+    private readonly retries;
     constructor(options?: FacilitatorClientOptions);
     /**
      * Get timeout for a specific network, using per-chain defaults when no explicit timeout was set.
@@ -422,7 +651,7 @@ declare class FacilitatorClient {
         settled: boolean;
         transactionHash?: string;
         error?: string;
-    }>;
+    } & FacilitatorFailureFields>;
     /**
      * Check if the facilitator is healthy
      *
@@ -645,37 +874,6 @@ interface HonoMiddlewareOptions extends PaymentMiddlewareOptions {
     /** Custom requirement resolver for ambiguous multi-accept flows */
     resolveRequirement?: PaymentRequirementResolver;
 }
-/**
- * Create a Hono-compatible middleware for x402 payments.
- *
- * Handles the x402 payment flow:
- * 1. Returns 402 with payment requirements if no X-PAYMENT header
- * 2. Verifies the payment with the facilitator
- * 3. Optionally settles before the handler when settlementStrategy is set
- * 4. Passes control to the next handler on success
- *
- * @param options - Middleware options with facilitator URL and payment accepts
- * @returns Hono middleware function
- *
- * @example
- * ```ts
- * import { createHonoMiddleware } from 'uvd-x402-sdk';
- *
- * const paywall = createHonoMiddleware({
- *   accepts: [{
- *     network: 'skale-base',
- *     asset: '0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20',
- *     amount: '1000000',
- *     payTo: '0xYourWallet',
- *     extra: { name: 'Bridged USDC (SKALE Bridge)', version: '2' },
- *   }],
- * });
- *
- * app.get('/api/premium', paywall, (c) => {
- *   return c.json({ message: 'Premium content!' });
- * });
- * ```
- */
 declare function createHonoMiddleware(options: HonoMiddlewareOptions): (c: {
     req: {
         header: (name: string) => string | undefined;
@@ -683,6 +881,8 @@ declare function createHonoMiddleware(options: HonoMiddlewareOptions): (c: {
     };
     json: (body: unknown, status?: number) => unknown;
     set?: (key: string, value: unknown) => void;
+    /** Hono's response-header setter. Optional so older context doubles still fit. */
+    header?: (name: string, value: string) => void;
 }, next: () => Promise<void>) => Promise<unknown>;
 /**
  * Maximum length of the free-text `q` filter.
@@ -1744,7 +1944,7 @@ interface FeedbackRequest {
 /**
  * Feedback response from POST /feedback
  */
-interface FeedbackResponse {
+interface FeedbackResponse extends FacilitatorFailureFields {
     /** Whether the feedback was successfully submitted */
     success: boolean;
     /** Transaction hash of the feedback submission */
@@ -1774,11 +1974,42 @@ declare class Erc8004LookupError extends Error {
     readonly status: number;
     /** Raw response body, for debugging */
     readonly body: string;
-    constructor(message: string, status: number, body: string);
+    /**
+     * `Retry-After`, already clamped, when the facilitator sent one.
+     *
+     * Optional so every existing three-argument construction keeps compiling; it
+     * falls back to the default wait rather than to zero, because a caller that
+     * retries instantly on a 503 is the load that caused it.
+     */
+    private readonly retryAfterHint;
+    constructor(message: string, status: number, body: string, retryAfterSeconds?: number);
     /** The address genuinely owns no agent on this network. */
     get notFound(): boolean;
-    /** The lookup reached no verdict. Retry; never read as "owns nothing". */
+    /**
+     * The lookup reached no verdict. Retry; never read as "owns nothing".
+     *
+     * `502` and `504` join `503` and `429` here: a gateway that answered on the
+     * facilitator's behalf is exactly as silent about the agent's existence, and
+     * reading either as absence has the same consequence -- a duplicate mint.
+     */
     get retryable(): boolean;
+    /**
+     * The facilitator's own `reason`, when the body carried one.
+     *
+     * On a WRITE route this is the writer-lease reason and it decides whether the
+     * request may be re-sent; see {@link isReplayableLeaseReason}.
+     */
+    get reason(): string | undefined;
+    /**
+     * The facilitator NAMED a reason proving it executed nothing.
+     *
+     * False for `forward_failed` and for every unattributed 5xx: "something
+     * answered" is not evidence that nothing ran. On `/register`, replaying when
+     * this is false is the sequence that minted five duplicate agents.
+     */
+    get safeToReplay(): boolean;
+    /** Seconds to wait before retrying, clamped. Absent when not retryable. */
+    get retryAfterSeconds(): number | undefined;
 }
 /**
  * ATOM Engine reputation analytics (Solana only).
@@ -1851,7 +2082,7 @@ interface RegisterAgentRequest {
 /**
  * Response from POST /register
  */
-interface RegisterAgentResponse {
+interface RegisterAgentResponse extends FacilitatorFailureFields {
     /** Whether registration succeeded */
     success: boolean;
     /** The newly assigned agent ID (EVM: tokenId number, Solana: base58 pubkey string) */
@@ -1972,6 +2203,12 @@ interface Erc8004ClientOptions {
     baseUrl?: string;
     /** Request timeout in milliseconds (default: 30000) */
     timeout?: number;
+    /**
+     * Extra attempts after the first, spent only on a refusal the facilitator
+     * proved it did not execute. Default 2; `0` disables. An ambiguous
+     * `forward_failed` is never replayed at any setting.
+     */
+    retries?: number;
 }
 /**
  * Client for ERC-8004 Trustless Agents API
@@ -2013,7 +2250,21 @@ interface Erc8004ClientOptions {
 declare class Erc8004Client {
     private readonly baseUrl;
     private readonly timeout;
+    private readonly retries;
     constructor(options?: Erc8004ClientOptions);
+    /**
+     * POST a write route, keeping a refusal readable.
+     *
+     * Every ERC-8004 write goes through the facilitator's EVM writer lease, so
+     * every one of them can answer `503` + `reason`. Flattened to a string, those
+     * are indistinguishable from "the registry rejected your feedback" — and on
+     * `/register` the wrong reading re-POSTs a mint that may already have landed,
+     * which is precisely how five duplicate agents were once created.
+     *
+     * A refusal the facilitator proved it did not execute is replayed
+     * automatically (`safeToReplay`); `forward_failed` never is.
+     */
+    private writeJson;
     /**
      * Get agent identity from the Identity Registry
      *
@@ -2489,10 +2740,19 @@ interface AdvancedAuthorizationResult {
 /**
  * Result of an on-chain transaction (release, refund, charge).
  */
-interface AdvancedTransactionResult {
+interface AdvancedTransactionResult extends FacilitatorFailureFields {
     success: boolean;
     transactionHash?: string;
     gasUsed?: number;
+    /**
+     * Why it failed.
+     *
+     * On the gasless (`*ViaFacilitator`) paths, check `retryable` first: a
+     * facilitator that could not hand the write to its lease holder rejected
+     * nothing on-chain, and the escrow is exactly as it was. Reporting that as a
+     * failed refund is how funds get written off while they are still sitting in
+     * escrow, recoverable.
+     */
     error?: string;
 }
 /**
@@ -2583,6 +2843,11 @@ interface AdvancedEscrowClientOptions {
      * ```
      */
     wallet?: SigningWalletAdapter;
+    /**
+     * Extra attempts on the gasless facilitator paths when the facilitator proved
+     * it executed nothing. Default 2; `0` disables.
+     */
+    retries?: number;
 }
 /**
  * Minimal PaymentOperator ABI for the 4 on-chain functions.
@@ -2644,6 +2909,7 @@ declare class AdvancedEscrowClient {
     private chainId;
     private gasLimit;
     private readonly timeout;
+    private readonly retries;
     private contracts;
     private signer;
     private walletAdapter;
@@ -2751,23 +3017,53 @@ declare class AdvancedEscrowClient {
      */
     releaseViaFacilitator(paymentInfo: AdvancedPaymentInfo, amount?: string): Promise<AdvancedTransactionResult>;
     /**
-     * GASLESS REFUND: Refund escrowed funds via the facilitator.
+     * GASLESS REFUND: return escrowed funds to the payer via the facilitator.
      *
-     * Instead of calling the PaymentOperator contract directly (which requires
-     * gas), this sends a refundInEscrow request to the facilitator, which
-     * submits the transaction on your behalf.
+     * Sends `action: "refundInEscrow"` to `POST /settle`; the facilitator's
+     * PaymentOperator calls `AuthCaptureEscrow.partialVoid`.
+     *
+     * # This is how an EXPIRED escrow is recovered
+     *
+     * A widely repeated claim — including in this SDK's own comments until now —
+     * says that once `authorizationExpiry` passes, only the payer's `reclaim()`
+     * can move the funds. **That is false, and believing it has left real money
+     * stranded.**
+     *
+     * Read the contract (`AuthCaptureEscrow.sol`):
+     *
+     * - `partialVoid` is `onlySender(paymentInfo.operator)` — the operator is the
+     *   FACILITATOR, not the payer — it sends the tokens **to the payer**, and it
+     *   **does not check `authorizationExpiry` at all**. It works before expiry
+     *   and after it, and the payer never has to appear.
+     * - `reclaim` is `onlySender(paymentInfo.payer)` and only after expiry. It is
+     *   a payer's self-service escape hatch, which is why this facilitator does
+     *   not expose it — **not** the only way out.
+     *
+     * So a release that reverted with `AfterAuthorizationExpiry` is recoverable
+     * from here, with no gas and no cooperation from the payer. Get the amount
+     * from {@link queryEscrowState}'s `capturableAmount`.
+     *
+     * # A refusal that is not a refusal
+     *
+     * Check `retryable` before writing an escrow off. A `503` means the
+     * facilitator never reached the chain — the escrow is untouched and the same
+     * request should be sent again.
      *
      * @param paymentInfo - PaymentInfo from the authorize step
-     * @param amount - Amount to refund in atomic units (defaults to maxAmount)
+     * @param amount - Amount to refund in atomic units (defaults to maxAmount).
+     *   For a stuck escrow pass `capturableAmount` from {@link queryEscrowState}.
      * @returns Transaction result from the facilitator
      *
-     * @example
+     * @example Recovering an escrow whose release window already closed
      * ```typescript
-     * const pi = client.buildPaymentInfo('0xWorker...', '5000000', 'standard');
-     * await client.authorize(pi);
-     * // Task cancelled...
-     * const result = await client.refundViaFacilitator(pi);
-     * console.log(result.transactionHash);
+     * const state = await client.queryEscrowState(pi);
+     * if (state.capturableAmount !== '0') {
+     *   // No payer needed, no gas, and expiry is irrelevant to partialVoid.
+     *   const result = await client.refundViaFacilitator(pi, state.capturableAmount);
+     *   if (!result.success && result.retryable) {
+     *     // No verdict was reached. The funds are still there; send it again.
+     *   }
+     * }
      * ```
      */
     refundViaFacilitator(paymentInfo: AdvancedPaymentInfo, amount?: string): Promise<AdvancedTransactionResult>;
@@ -2838,4 +3134,4 @@ declare class AdvancedEscrowClient {
     private sendViaAdapter;
 }
 
-export { type AdvancedAuthorizationResult, AdvancedEscrowClient, type AdvancedEscrowClientOptions, type AdvancedEscrowContracts, type AdvancedEscrowTaskTier, type AdvancedPaymentInfo, type AdvancedTransactionResult, type AgentId, type AgentIdentity, type AgentRegistration, type AgentRegistrationFile, type AgentService, type AtomStats, BASE_MAINNET_CONTRACTS, BazaarClient, type BazaarClientOptions, type BazaarDiscoverOptions, type BazaarDiscoverResponse, type BazaarRegisterOptions, type BazaarResource, type CreateEscrowOptions, DEPOSIT_LIMIT_USDC, type DiscoveryAccepts, type DiscoveryCuration, type DiscoveryHealth, type DiscoveryHealthStatus, type DiscoveryListOptions, type DiscoveryPagination, type DiscoveryRegisterOptions, type DiscoveryResource, type DiscoveryResponse, type DiscoverySource, type DiscoveryStats, type DiscoveryTier, type Dispute, type DisputeOutcome, ERC8004_CONTRACTS, ERC8004_EXTENSION_ID, ESCROW_CONTRACTS, ESCROW_TIMEOUT_MS, Erc8004Client, type Erc8004ClientOptions, Erc8004LookupError, type Erc8004Network, EscrowClient, type EscrowClientOptions, type EscrowPayment, type EscrowStateResponse, type EscrowStatus, FacilitatorClient, type FacilitatorClientOptions, type FeedbackEntry, type FeedbackParams, type FeedbackRequest, type FeedbackResponse, HEALTH_FILTERS, type HonoMiddlewareOptions, type IdentityByOwnerResponse, type IdentityMetadataResponse, type IdentityTotalSupplyResponse, MAX_SEARCH_LEN, type MetadataEntryParam, OPERATOR_ABI, OPERATOR_ABI_CREATE3, PAYMENT_INFO_TYPEHASH, type PaymentAcceptance, type PaymentMiddlewareOptions, type PaymentPayloadV2, type PaymentRequirementResolver, type PaymentRequirements, type PaymentRequirementsOptions, type PaymentRequirementsV2, type PrepareRelayFeedbackRequest, type PrepareRelayFeedbackResponse, type PrepareRelayResponseRequest, type ProofOfPayment, RELAYED_FEEDBACK_NETWORKS, type RefundRequest, type RefundStatus, type RegisterAgentRequest, type RegisterAgentResponse, type RegisterJobResponse, type RegisterJobStatus, RegistrationPendingError, type RelayAuthorizationParams, type ReputationResponse, type ReputationSummary, type RequestRefundOptions, type ResourceInfoV2, type SettleRequest, type SettleRequestV2, type SettleResponse, type SettleResponseWithProof, type SubmitRelayFeedbackRequest, type SubmitRelayResponseRequest, TIER_FILTERS, TIER_TIMINGS, USDC_DOMAIN_NAME, type VerifiedPaymentState, type VerifyRequest, type VerifyRequestV2, type VerifyResponse, X402_CORS_HEADERS, X402_HEADER_NAMES, ZERO_ADDRESS, buildErc8004PaymentRequirements, buildPaymentRequirements, buildSettleRequest, buildSettleRequestV2, buildVerifyRequest, buildVerifyRequestV2, canRefundEscrow, canReleaseEscrow, create402Response, createHonoMiddleware, createPaymentMiddleware, epochToDate, escrowTimeRemaining, extractPaymentFromHeaders, getCorsHeaders, getEscrowContractsByChainId, getEscrowSupportedChainIds, isAlive, isEscrowExpired, isEscrowSupportedOnChain, isRegisterJobTerminal, parsePaymentHeader, supportsRelayedFeedback, wireNetwork };
+export { AMBIGUOUS_LEASE_REASONS, type AdvancedAuthorizationResult, AdvancedEscrowClient, type AdvancedEscrowClientOptions, type AdvancedEscrowContracts, type AdvancedEscrowTaskTier, type AdvancedPaymentInfo, type AdvancedTransactionResult, type AgentId, type AgentIdentity, type AgentRegistration, type AgentRegistrationFile, type AgentService, type AtomStats, BASE_MAINNET_CONTRACTS, BazaarClient, type BazaarClientOptions, type BazaarDiscoverOptions, type BazaarDiscoverResponse, type BazaarRegisterOptions, type BazaarResource, type CreateEscrowOptions, DEFAULT_FACILITATOR_RETRIES, DEFAULT_RETRY_AFTER_SECONDS, DEPOSIT_LIMIT_USDC, type DiscoveryAccepts, type DiscoveryCuration, type DiscoveryHealth, type DiscoveryHealthStatus, type DiscoveryListOptions, type DiscoveryPagination, type DiscoveryRegisterOptions, type DiscoveryResource, type DiscoveryResponse, type DiscoverySource, type DiscoveryStats, type DiscoveryTier, type Dispute, type DisputeOutcome, ERC8004_CONTRACTS, ERC8004_EXTENSION_ID, ESCROW_CONTRACTS, ESCROW_TIMEOUT_MS, Erc8004Client, type Erc8004ClientOptions, Erc8004LookupError, type Erc8004Network, EscrowClient, type EscrowClientOptions, type EscrowPayment, type EscrowStateResponse, type EscrowStatus, FacilitatorClient, type FacilitatorClientOptions, type FacilitatorErrorInfo, type FacilitatorFailureFields, type FacilitatorFetchOptions, type FeedbackEntry, type FeedbackParams, type FeedbackRequest, type FeedbackResponse, HEALTH_FILTERS, type HonoMiddlewareOptions, type IdentityByOwnerResponse, type IdentityMetadataResponse, type IdentityTotalSupplyResponse, MAX_RETRY_AFTER_SECONDS, MAX_SEARCH_LEN, type MetadataEntryParam, OPERATOR_ABI, OPERATOR_ABI_CREATE3, PAYMENT_INFO_TYPEHASH, type PaymentAcceptance, type PaymentMiddlewareOptions, type PaymentPayloadV2, type PaymentRequirementResolver, type PaymentRequirements, type PaymentRequirementsOptions, type PaymentRequirementsV2, type PrepareRelayFeedbackRequest, type PrepareRelayFeedbackResponse, type PrepareRelayResponseRequest, type ProofOfPayment, RELAYED_FEEDBACK_NETWORKS, REPLAYABLE_LEASE_REASONS, type RefundRequest, type RefundStatus, type RegisterAgentRequest, type RegisterAgentResponse, type RegisterJobResponse, type RegisterJobStatus, RegistrationPendingError, type RelayAuthorizationParams, type ReputationResponse, type ReputationSummary, type RequestRefundOptions, type ResourceInfoV2, type SettleRequest, type SettleRequestV2, type SettleResponse, type SettleResponseWithProof, type SubmitRelayFeedbackRequest, type SubmitRelayResponseRequest, TIER_FILTERS, TIER_TIMINGS, USDC_DOMAIN_NAME, type VerifiedPaymentState, type VerifyRequest, type VerifyRequestV2, type VerifyResponse, WRITER_LEASE_REASONS, type WriterLeaseReason, X402_CORS_HEADERS, X402_HEADER_NAMES, ZERO_ADDRESS, buildErc8004PaymentRequirements, buildPaymentRequirements, buildSettleRequest, buildSettleRequestV2, buildVerifyRequest, buildVerifyRequestV2, canRefundEscrow, canReleaseEscrow, carryFailureFields, create402Response, createHonoMiddleware, createPaymentMiddleware, epochToDate, escrowTimeRemaining, extractPaymentFromHeaders, facilitatorFetch, getCorsHeaders, getEscrowContractsByChainId, getEscrowSupportedChainIds, isAlive, isAmbiguousLeaseReason, isEscrowExpired, isEscrowSupportedOnChain, isRegisterJobTerminal, isReplayableLeaseReason, parsePaymentHeader, parseRetryAfterSeconds, readFacilitatorError, supportsRelayedFeedback, wireNetwork };