@parallel-protocol/x402 0.7.1 → 0.8.1

package/dist/{chunk-AENXD4OC.js → chunk-GXPUE3ES.js}

@@ -1,4 +1,4 @@
-import { X402_ERROR_CODES, X402RuntimeError, X402ConfigError, isPriceRejection } from './chunk-AFRDHGDT.js';
+import { X402_ERROR_CODES, X402ConfigError, X402RuntimeError, isPriceRejection } from './chunk-QAECRSWF.js';
 import { getTokenDecimals as getTokenDecimals$1 } from '@parallel-protocol/chains';
 import { z } from 'zod';
 
@@ -127,8 +127,18 @@ var priceSchema = z.union([
     "Price must be a string, a bigint or a function of the request"
   )
 ]);
+var LOCAL_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isFacilitatorUrl(value) {
+  if (!URL.canParse(value)) return false;
+  const { protocol, hostname } = new URL(value);
+  return protocol === "https:" || protocol === "http:" && LOCAL_HOSTNAMES.has(hostname);
+}
+var facilitatorUrlSchema = z.string().refine(
+  isFacilitatorUrl,
+  "The facilitator URL must use https (plain http only on localhost, 127.0.0.1 or [::1])"
+);
 var facilitatorConfigSchema = z.object({
-  url: z.string().refine((v) => URL.canParse(v), "Invalid facilitator URL"),
+  url: facilitatorUrlSchema,
   apiKey: z.string().optional()
 });
 var UPTO_MAX_TIMEOUT_SECONDS = 3600;
@@ -170,26 +180,32 @@ var facilitatorResponseSchema = z.discriminatedUnion("success", [
     chain: z.string(),
     gasSponsored: z.boolean(),
     networkId: z.string(),
-    amountSettled: z.string().optional()
+    amountSettled: z.string().optional(),
+    alreadySettled: z.boolean().optional()
   }),
   z.object({
     success: z.literal(false),
     error: z.object({
       code: z.string(),
       message: z.string(),
-      hint: z.string().optional()
+      hint: z.string().optional(),
+      status: z.number().optional(),
+      retryAfter: z.string().optional()
     })
   })
 ]);
 var verifyResponseSchema = z.object({
-  isValid: z.literal(true)
+  isValid: z.literal(true),
+  settleToken: z.string().min(1)
 });
 var settleSuccessSchema = z.object({
   txHash: txHashSchema,
   route: z.string(),
   gasSponsored: z.boolean(),
   // Metered routes: the amount actually charged (smallest unit).
-  amountSettled: z.string().optional()
+  amountSettled: z.string().optional(),
+  // The facilitator answered from a recorded outcome, nothing was broadcast.
+  alreadySettled: z.boolean().optional()
 });
 var settleErrorSchema = z.object({
   error: z.string(),
@@ -203,6 +219,29 @@ var settleResponseSchema = z.union([
 // src/client.ts
 var FACILITATOR_TIMEOUT_MS = 1e4;
 var SETTLE_TIMEOUT_MS = 6e4;
+var RETRY_AFTER_SHAPE = /^(?:\d{1,10}|[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT)$/;
+async function readErrorBody(response) {
+  const json = await response.json().catch(() => null);
+  if (typeof json !== "object" || json === null) return {};
+  const { error, message } = json;
+  return {
+    ...typeof error === "string" && { error },
+    ...typeof message === "string" && { message }
+  };
+}
+function retryAfterOf(response) {
+  const value = response.headers.get("retry-after");
+  return value !== null && RETRY_AFTER_SHAPE.test(value) ? value : void 0;
+}
+function throwIfRedirect(response) {
+  const redirected = response.type === "opaqueredirect" || response.status >= 300 && response.status < 400;
+  if (!redirected) return;
+  response.body?.cancel().catch(() => {
+  });
+  throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_UNAVAILABLE, {
+    status: response.status
+  });
+}
 function decodePaymentHeader(paymentHeader) {
   try {
     return decodeBase64(paymentHeader);
@@ -211,24 +250,43 @@ function decodePaymentHeader(paymentHeader) {
   }
 }
 var FacilitatorClient = class {
+  // Checked and kept when the client is built: a config changed afterwards
+  // does not move the calls elsewhere.
+  url;
+  apiKey;
   constructor(config) {
-    this.config = config;
+    const url = facilitatorUrlSchema.safeParse(config.url);
+    if (!url.success) {
+      throw new X402ConfigError(
+        url.error.issues[0]?.message ?? "Invalid facilitator URL",
+        url.error
+      );
+    }
+    this.url = new URL(url.data).href.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
   }
-  config;
   async verify(paymentHeader, paymentRequirements) {
     const paymentPayload = decodePaymentHeader(paymentHeader);
     let json;
     try {
-      const response = await fetch(`${this.config.url}/x402/verify`, {
+      const response = await fetch(`${this.url}/x402/verify`, {
         method: "POST",
         headers: this.buildHeaders(),
         body: JSON.stringify({ paymentPayload, paymentRequirements }),
+        redirect: "manual",
         signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
       });
+      throwIfRedirect(response);
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => null);
-        const code = errorBody?.error ?? X402_ERROR_CODES.FACILITATOR_UNAVAILABLE;
-        throw new X402RuntimeError(code);
+        const body = await readErrorBody(response);
+        throw new X402RuntimeError(
+          body.error ?? X402_ERROR_CODES.FACILITATOR_UNAVAILABLE,
+          {
+            detail: body.message,
+            status: response.status,
+            retryAfter: retryAfterOf(response)
+          }
+        );
       }
       json = await response.json();
     } catch (e) {
@@ -236,7 +294,8 @@ var FacilitatorClient = class {
       throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
     }
     try {
-      verifyResponseSchema.parse(json);
+      const { settleToken } = verifyResponseSchema.parse(json);
+      return { settleToken };
     } catch {
       throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
     }
@@ -245,28 +304,47 @@ var FacilitatorClient = class {
     const paymentPayload = decodePaymentHeader(paymentHeader);
     let json;
     try {
-      const response = await fetch(`${this.config.url}/x402/settle`, {
+      const response = await fetch(`${this.url}/x402/settle`, {
         method: "POST",
         headers: this.buildHeaders(),
-        // settleAmount only travels for metered routes — exact bodies are unchanged.
+        // settleAmount only travels for metered routes; the settle token
+        // travels whenever verify issued one.
         body: JSON.stringify({
           paymentPayload,
           paymentRequirements,
           ...options?.amount !== void 0 && {
             settleAmount: options.amount
+          },
+          ...options?.settleToken !== void 0 && {
+            settleToken: options.settleToken
           }
         }),
+        redirect: "manual",
         signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS)
       });
+      throwIfRedirect(response);
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => null);
-        const code = errorBody?.error ?? "SUBMISSION_FAILED";
-        const message = errorBody?.message ?? "Settlement failed";
-        return { success: false, error: { code, message } };
+        const body = await readErrorBody(response);
+        if (body.error === void 0 && response.status >= 500) {
+          throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+        }
+        const retryAfter = retryAfterOf(response);
+        return {
+          success: false,
+          error: {
+            code: body.error ?? "SUBMISSION_FAILED",
+            message: body.message ?? "Settlement failed",
+            status: response.status,
+            ...retryAfter !== void 0 && { retryAfter }
+          }
+        };
       }
       json = await response.json();
     } catch (e) {
       if (e instanceof X402RuntimeError) throw e;
+      if (e instanceof Error && e.name === "TimeoutError") {
+        throw new X402RuntimeError(X402_ERROR_CODES.SETTLE_TIMEOUT);
+      }
       throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
     }
     try {
@@ -281,7 +359,8 @@ var FacilitatorClient = class {
           networkId: toEip155Network(paymentRequirements.network),
           ...parsed.amountSettled !== void 0 && {
             amountSettled: parsed.amountSettled
-          }
+          },
+          ...parsed.alreadySettled && { alreadySettled: true }
         };
       }
       return {
@@ -292,16 +371,22 @@ var FacilitatorClient = class {
       throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
     }
   }
+  /**
+   * @deprecated The Parallel facilitator no longer serves `/x402/pay`, so this
+   * call fails with `FACILITATOR_UNAVAILABLE`. Use `verify`, then `settle`.
+   */
   async pay(paymentHeader) {
     const headers = this.buildHeaders();
     headers["X-PAYMENT"] = paymentHeader;
     let json;
     try {
-      const response = await fetch(`${this.config.url}/x402/pay`, {
+      const response = await fetch(`${this.url}/x402/pay`, {
         method: "POST",
         headers,
+        redirect: "manual",
         signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
       });
+      throwIfRedirect(response);
       if (!response.ok) {
         throw new X402RuntimeError(X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
       }
@@ -320,8 +405,8 @@ var FacilitatorClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (this.config.apiKey) {
-      headers["X-API-Key"] = this.config.apiKey;
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
     }
     return headers;
   }
@@ -379,10 +464,21 @@ async function resolvePrice(config, ctx) {
 }
 var SETTLE_AMOUNT_HEADER = "payment-settle-amount";
 var DEFAULT_MAX_TIMEOUT_SECONDS = 300;
+var SETTLEMENT_RESERVE_SECONDS = 120;
 function handlerTimeoutFor(config) {
   if ((config.scheme ?? "exact") !== "upto") return HANDLER_TIMEOUT_MS;
   const seconds = config.maxTimeoutSeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS;
-  return Math.max(HANDLER_TIMEOUT_MS, (seconds - 60) * 1e3);
+  return Math.max(
+    HANDLER_TIMEOUT_MS,
+    (seconds - SETTLEMENT_RESERVE_SECONDS) * 1e3
+  );
+}
+function jsonResult(status, body, headers = {}) {
+  return {
+    status,
+    headers: { "Content-Type": "application/json", ...headers },
+    body
+  };
 }
 function resolveSettleAmount(raw, maxAmount, decimals) {
   if (raw === void 0)
@@ -410,7 +506,10 @@ var INVALID_METER_RESPONSE = {
   message: "The route's meter function failed or returned something that is not an amount; the response was discarded and nothing was charged."
 };
 function invalidSettleAmountResponse(reason) {
-  return reason === "meter" ? INVALID_METER_RESPONSE : INVALID_SETTLE_AMOUNT_RESPONSE;
+  return jsonResult(
+    402,
+    reason === "meter" ? INVALID_METER_RESPONSE : INVALID_SETTLE_AMOUNT_RESPONSE
+  );
 }
 var AMOUNT_FORMAT = /^\d+(?:\.\d+)?$/;
 async function resolveCharge(verified, settleHeader, response) {
@@ -558,31 +657,46 @@ function buildFacilitatorRequirements(config, asset, price) {
     }
   };
 }
-function paymentRequiredResponse(url, config, resolvedTokens, price, error) {
+var CODE_SHAPE = /^[A-Z][A-Z0-9_]{2,63}$/;
+var MESSAGE_MAX_LENGTH = 300;
+function shapedCode(code) {
+  return typeof code === "string" && CODE_SHAPE.test(code) ? code : void 0;
+}
+function boundedMessage(message) {
+  if (typeof message !== "string") return void 0;
+  const oneLine = message.replace(/[\p{Cc}\p{Cf}]+/gu, " ").replace(/\s+/g, " ").trim();
+  if (!oneLine) return void 0;
+  const chars = Array.from(oneLine);
+  return chars.length > MESSAGE_MAX_LENGTH ? `${chars.slice(0, MESSAGE_MAX_LENGTH).join("")}\u2026` : oneLine;
+}
+function paymentRequiredResponse(url, config, resolvedTokens, price, refusal) {
   const paymentRequired = buildPaymentRequired(
     url,
     config,
     resolvedTokens,
     price
   );
-  if (error) paymentRequired.error = error;
-  return {
-    status: 402,
-    headers: {
-      "Content-Type": "application/json",
-      "payment-required": encodeBase64(paymentRequired),
-      "access-control-expose-headers": "payment-required"
-    },
-    body: paymentRequired
-  };
+  if (refusal) {
+    paymentRequired.error = shapedCode(refusal.code) ?? X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE;
+    const message = boundedMessage(refusal.detail);
+    if (message) paymentRequired.message = message;
+  }
+  return jsonResult(402, paymentRequired, {
+    "payment-required": encodeBase64(paymentRequired),
+    "access-control-expose-headers": "payment-required",
+    ...refusal?.retryAfter !== void 0 && {
+      "Retry-After": refusal.retryAfter
+    }
+  });
 }
 function createPaymentGate(config) {
-  try {
-    paymentMiddlewareConfigSchema.parse(config);
-  } catch (cause) {
+  const checked = paymentMiddlewareConfigSchema.safeParse(config);
+  if (!checked.success) {
+    const issue = checked.error.issues[0];
+    const where = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
     throw new X402ConfigError(
-      "Invalid paymentMiddleware config \u2014 check your routes, facilitator URL and payTo addresses",
-      cause
+      `Invalid paymentMiddleware config${where}: ${issue?.message ?? "check your routes, facilitator URL and payTo addresses"}`,
+      checked.error
     );
   }
   const client = new FacilitatorClient(config.facilitator);
@@ -630,10 +744,11 @@ function createPaymentGate(config) {
       asset,
       price
     );
+    let settleToken;
     try {
-      await client.verify(paymentHeader, requirements);
+      ({ settleToken } = await client.verify(paymentHeader, requirements));
     } catch (e) {
-      const code = e instanceof X402RuntimeError ? e.code : X402_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+      const refusal = e instanceof X402RuntimeError ? { code: e.code, detail: e.detail, retryAfter: e.retryAfter } : { code: X402_ERROR_CODES.FACILITATOR_UNAVAILABLE };
       return {
         type: "error",
         result: paymentRequiredResponse(
@@ -641,7 +756,7 @@ function createPaymentGate(config) {
           routeConfig,
           resolvedTokens,
           price,
-          code
+          refusal
         )
       };
     }
@@ -652,12 +767,71 @@ function createPaymentGate(config) {
       maxAmount: BigInt(requirements.maxAmountRequired),
       decimals: resolveDecimals(routeConfig, asset),
       handlerTimeoutMs: handlerTimeoutFor(routeConfig),
-      // Exact routes keep the historical two-argument client call.
-      settle: (options) => options ? client.settle(paymentHeader, requirements, options) : client.settle(paymentHeader, requirements),
+      settle: (options) => client.settle(paymentHeader, requirements, { ...options, settleToken }),
       ...routeConfig.meter && { meter: routeConfig.meter, request }
     };
   };
 }
+var UNKNOWN_SETTLEMENT_MESSAGE = "The payment could not be settled.";
+var MERCHANT_SETTLEMENT_MESSAGE = "The merchant could not complete the settlement of this payment. The payment was not taken: do not sign another payment for this request before checking with the merchant.";
+var AGENT_MESSAGES = {
+  [X402_ERROR_CODES.SETTLE_TIMEOUT]: "The facilitator did not confirm the settlement in time. The payment may still settle: do not sign another payment for this request before checking with the merchant.",
+  [X402_ERROR_CODES.FACILITATOR_UNAVAILABLE]: "The facilitator could not be reached to settle the payment. It may still have settled: do not sign another payment for this request before checking with the merchant.",
+  [X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE]: "The facilitator answered the settlement with an unexpected response. The payment may have settled: do not sign another payment for this request before checking with the merchant.",
+  SETTLE_IN_PROGRESS: "The facilitator is still settling this payment. Do not sign another payment for this request before checking with the merchant.",
+  RECEIPT_UNAVAILABLE: "The facilitator sent the transaction but could not read its confirmation. The payment may have settled: do not sign another payment for this request before checking with the merchant.",
+  SETTLE_TOKEN_INVALID: MERCHANT_SETTLEMENT_MESSAGE,
+  SETTLE_TOKEN_REQUIRED: MERCHANT_SETTLEMENT_MESSAGE,
+  AMOUNT_MISMATCH: "The facilitator settled a different amount than this request asked for. The response was not served: do not sign another payment for this request before checking with the merchant.",
+  UNKNOWN: UNKNOWN_SETTLEMENT_MESSAGE
+};
+function settlementFailure(code, failure) {
+  const reason = shapedCode(code) ?? "UNKNOWN";
+  return {
+    settled: false,
+    reason,
+    message: AGENT_MESSAGES[reason] ?? boundedMessage(failure?.message) ?? UNKNOWN_SETTLEMENT_MESSAGE,
+    ...failure?.retryAfter !== void 0 && {
+      retryAfter: failure.retryAfter
+    }
+  };
+}
+var RETRY_ONCE_CODES = /* @__PURE__ */ new Set([
+  X402_ERROR_CODES.SETTLE_TIMEOUT,
+  X402_ERROR_CODES.FACILITATOR_UNAVAILABLE
+]);
+async function settleVerified(verified, options) {
+  let response;
+  for (let attempt = 0; response === void 0; attempt++) {
+    try {
+      response = await verified.settle(options);
+    } catch (e) {
+      const code = e instanceof X402RuntimeError ? e.code : "UNKNOWN";
+      if (attempt > 0 || !RETRY_ONCE_CODES.has(code)) {
+        return settlementFailure(code);
+      }
+    }
+  }
+  if (!response.success) {
+    return settlementFailure(response.error.code, response.error);
+  }
+  if (options?.amount !== void 0 && response.amountSettled !== options.amount) {
+    return settlementFailure("AMOUNT_MISMATCH");
+  }
+  return { settled: true, confirmation: response };
+}
+function settlementFailureResponse(failure) {
+  const body = {
+    error: "PAYMENT_SETTLEMENT_FAILED",
+    reason: failure.reason,
+    message: failure.message
+  };
+  return jsonResult(402, body, {
+    ...failure.retryAfter !== void 0 && {
+      "Retry-After": failure.retryAfter
+    }
+  });
+}
 function createPaymentMiddleware(config) {
   const gate = createPaymentGate(config);
   return async (adapter) => {
@@ -687,11 +861,7 @@ function createPaymentMiddleware(config) {
         });
         if (resolved.kind === "invalid") {
           handlerResult.discardResponse();
-          return {
-            status: 402,
-            headers: { "Content-Type": "application/json" },
-            body: invalidSettleAmountResponse(resolved.reason)
-          };
+          return invalidSettleAmountResponse(resolved.reason);
         }
         if (resolved.kind === "skip") {
           handlerResult.sendResponse();
@@ -699,37 +869,23 @@ function createPaymentMiddleware(config) {
         }
         settleOptions = { amount: resolved.amount };
       }
-      let settled = false;
-      try {
-        const settleResponse = settleOptions ? await gateResult.settle(settleOptions) : await gateResult.settle();
-        if (settleResponse.success) {
-          handlerResult.setResponseHeader(
-            "payment-response",
-            encodeBase64(settleResponse)
-          );
-          handlerResult.setResponseHeader(
-            "access-control-expose-headers",
-            "payment-response"
-          );
-          settled = true;
-        }
-      } catch {
-      }
-      if (!settled) {
+      const outcome = await settleVerified(gateResult, settleOptions);
+      if (!outcome.settled) {
         handlerResult.discardResponse();
-        return {
-          status: 402,
-          headers: { "Content-Type": "application/json" },
-          body: {
-            error: "PAYMENT_SETTLEMENT_FAILED",
-            message: "Payment could not be confirmed after multiple attempts. Please retry."
-          }
-        };
+        return settlementFailureResponse(outcome);
       }
+      handlerResult.setResponseHeader(
+        "payment-response",
+        encodeBase64(outcome.confirmation)
+      );
+      handlerResult.setResponseHeader(
+        "access-control-expose-headers",
+        "payment-response"
+      );
     }
     handlerResult.sendResponse();
     return { pass: true, handlerRan: true };
   };
 }
 
-export { FacilitatorClient, HANDLER_TIMEOUT, PARALLEL_TOKENS, SETTLE_AMOUNT_HEADER, createPaymentGate, createPaymentMiddleware, encodeBase64, getDefaultAcceptedTokens, invalidSettleAmountResponse, isJsonContentType, jsonFromResponse, matchRoute, parseJsonBody, parsePrice, raceTimeout, resolveCharge, resolveSettleAmount, toEip155Network, validateAddress };
+export { FacilitatorClient, HANDLER_TIMEOUT, PARALLEL_TOKENS, SETTLE_AMOUNT_HEADER, createPaymentGate, createPaymentMiddleware, encodeBase64, getDefaultAcceptedTokens, invalidSettleAmountResponse, isJsonContentType, jsonFromResponse, matchRoute, parseJsonBody, parsePrice, raceTimeout, resolveCharge, resolveSettleAmount, settleVerified, settlementFailureResponse, toEip155Network, validateAddress };

package/dist/{chunk-JPMK5YBU.cjs → chunk-KZZY5LS6.cjs}

@@ -4,7 +4,9 @@
 var X402_ERROR_CODES = {
   FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE",
   FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE",
-  INVALID_PAYMENT: "INVALID_PAYMENT"
+  INVALID_PAYMENT: "INVALID_PAYMENT",
+  /** The facilitator did not answer a settle within the client's timeout: the payment may still settle. */
+  SETTLE_TIMEOUT: "SETTLE_TIMEOUT"
 };
 var X402ConfigError = class extends Error {
   constructor(message, cause) {
@@ -14,12 +16,21 @@ var X402ConfigError = class extends Error {
   }
 };
 var X402RuntimeError = class extends Error {
-  constructor(code) {
+  constructor(code, extra) {
     super(code);
     this.code = code;
     this.name = "X402RuntimeError";
+    if (extra?.detail !== void 0) this.detail = extra.detail;
+    if (extra?.status !== void 0) this.status = extra.status;
+    if (extra?.retryAfter !== void 0) this.retryAfter = extra.retryAfter;
   }
   code;
+  /** The facilitator's message for this code, when it answered with one. */
+  detail;
+  /** The facilitator's HTTP status, when the error comes from its answer. */
+  status;
+  /** The facilitator's `Retry-After` header, when it sent one. */
+  retryAfter;
 };
 var X402PriceRejectedError = class extends Error {
   constructor(code, message, status = 400) {

package/dist/{chunk-AFRDHGDT.js → chunk-QAECRSWF.js}

@@ -2,7 +2,9 @@
 var X402_ERROR_CODES = {
   FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE",
   FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE",
-  INVALID_PAYMENT: "INVALID_PAYMENT"
+  INVALID_PAYMENT: "INVALID_PAYMENT",
+  /** The facilitator did not answer a settle within the client's timeout: the payment may still settle. */
+  SETTLE_TIMEOUT: "SETTLE_TIMEOUT"
 };
 var X402ConfigError = class extends Error {
   constructor(message, cause) {
@@ -12,12 +14,21 @@ var X402ConfigError = class extends Error {
   }
 };
 var X402RuntimeError = class extends Error {
-  constructor(code) {
+  constructor(code, extra) {
     super(code);
     this.code = code;
     this.name = "X402RuntimeError";
+    if (extra?.detail !== void 0) this.detail = extra.detail;
+    if (extra?.status !== void 0) this.status = extra.status;
+    if (extra?.retryAfter !== void 0) this.retryAfter = extra.retryAfter;
   }
   code;
+  /** The facilitator's message for this code, when it answered with one. */
+  detail;
+  /** The facilitator's HTTP status, when the error comes from its answer. */
+  status;
+  /** The facilitator's `Retry-After` header, when it sent one. */
+  retryAfter;
 };
 var X402PriceRejectedError = class extends Error {
   constructor(code, message, status = 400) {