@devlab.group/agent-commerce 1.4.1 → 1.6.0

package/dist/x402.js

@@ -1,48 +1,11 @@
-import { assertPayToIsNotDevAddress, resolveX402Deployment, assertDevKeyIsLocalOnly, describeDeploymentMode } from './chunk-NWIQLJNU.js';
-export { SUPPORTED_NETWORK_IDS } from './chunk-NWIQLJNU.js';
-import { CommerceError, systemClock, NOOP_LOGGER, PACKAGE_VERSION } from './chunk-ZEGFLRGV.js';
-import { PaymentRequirementsV2Schema, PaymentPayloadV2Schema } from '@x402/core/schemas';
-import { getAddress, toHex, isAddress, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, encodeAbiParameters, keccak256, ContractFunctionRevertedError, ContractFunctionExecutionError } from 'viem';
+import { chainIdFromCaip2 } from './chunk-ATTWSFQP.js';
+export { createX402PaymentProvider, createX402PaymentProvider as x402 } from './chunk-ATTWSFQP.js';
+export { SUPPORTED_NETWORK_IDS } from './chunk-74BSEXB5.js';
+import { CommerceError } from './chunk-IVJC5YLE.js';
+import { PaymentRequirementsV2Schema } from '@x402/core/schemas';
+import { getAddress, toHex } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { x402Facilitator } from '@x402/core/facilitator';
-import { HTTPFacilitatorClient } from '@x402/core/http';
-import { isEIP3009Payload, toFacilitatorEvmSigner } from '@x402/evm';
-import { registerExactEvmScheme } from '@x402/evm/exact/facilitator';
 
-var LOCAL_CHAIN_ID = 84532;
-function chainIdFromCaip2(network) {
-  const match = /^eip155:(\d+)$/.exec(network);
-  if (!match?.[1]) return void 0;
-  const chainId = Number(match[1]);
-  return Number.isSafeInteger(chainId) && chainId > 0 ? chainId : void 0;
-}
-function buildLocalChain(rpcUrl, chainId = LOCAL_CHAIN_ID) {
-  return {
-    id: chainId,
-    name: "agent-commerce-local",
-    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-    rpcUrls: {
-      default: { http: [rpcUrl] }
-    }
-  };
-}
-function createLocalPublicClient(rpcUrl, timeoutMs, chainId) {
-  return createPublicClient({
-    chain: buildLocalChain(rpcUrl, chainId),
-    transport: http(rpcUrl, { timeout: timeoutMs } )
-  });
-}
-function createLocalFacilitatorClient(rpcUrl, signerPrivateKey) {
-  const chain = buildLocalChain(rpcUrl);
-  const account = privateKeyToAccount(signerPrivateKey);
-  return createWalletClient({
-    account,
-    chain,
-    transport: http(rpcUrl)
-  }).extend(publicActions);
-}
-
-// src/payments/x402/client.ts
 var X402_VERSION = 2;
 var TRANSFER_WITH_AUTHORIZATION_TYPES = {
   TransferWithAuthorization: [
@@ -57,18 +20,19 @@ var TRANSFER_WITH_AUTHORIZATION_TYPES = {
 async function createPaymentProof(options) {
   const requirements = PaymentRequirementsV2Schema.parse(options.accepts);
   if (!requirements.extra || typeof requirements.extra["name"] !== "string" || typeof requirements.extra["version"] !== "string") {
-    throw new Error(
-      "createPaymentProof: payment requirement is missing extra.name/extra.version \u2014 cannot build the EIP-712 domain"
+    throw new CommerceError(
+      "INPUT_INVALID",
+      "createPaymentProof: payment requirement is missing extra.name/extra.version, so the EIP-712 domain cannot be built"
     );
   }
   const chainId = chainIdFromCaip2(requirements.network);
   if (chainId === void 0) {
-    throw new Error(
-      `createPaymentProof: network "${requirements.network}" is not a CAIP-2 eip155 identifier \u2014 cannot determine the chain id to sign against`
+    throw new CommerceError(
+      "INPUT_INVALID",
+      `createPaymentProof: network "${requirements.network}" is not a CAIP-2 eip155 identifier, so there is no chain id to sign against`
     );
   }
   const account = privateKeyToAccount(options.buyerPrivateKey);
-  void options.rpcUrl;
   const nonce = options.overrides?.nonce ?? randomNonce();
   const nowSeconds = Math.floor(Date.now() / 1e3);
   const validAfter = options.overrides?.validAfter ?? 0;
@@ -116,650 +80,6 @@ function randomNonce() {
   return toHex(bytes);
 }
 
-// src/payments/x402/amount.ts
-var DECIMAL_STRING_PATTERN = /^\d+(?:\.\d+)?$/;
-function parseCanonicalAmount(amount, decimals) {
-  if (!Number.isInteger(decimals) || decimals < 0) {
-    throw new CommerceError("INTERNAL_ERROR", `Invalid asset decimals: ${decimals}`);
-  }
-  if (!DECIMAL_STRING_PATTERN.test(amount)) {
-    throw new CommerceError(
-      "PAYMENT_INVALID",
-      `Amount "${amount}" is not a valid non-negative decimal string`,
-      {
-        details: { amount }
-      }
-    );
-  }
-  const [integerPart = "0", fractionPart = ""] = amount.split(".");
-  if (fractionPart.length > decimals) {
-    throw new CommerceError(
-      "PAYMENT_INVALID",
-      `Amount "${amount}" has more precision than the asset supports (${decimals} decimals)`,
-      { details: { amount, assetDecimals: decimals } }
-    );
-  }
-  const paddedFraction = fractionPart.padEnd(decimals, "0");
-  const combined = `${integerPart}${paddedFraction}`;
-  return BigInt(combined);
-}
-function formatCanonicalAmount(baseUnits, decimals) {
-  if (!Number.isInteger(decimals) || decimals < 0) {
-    throw new CommerceError("INTERNAL_ERROR", `Invalid asset decimals: ${decimals}`);
-  }
-  const negative = baseUnits < 0n;
-  const abs = negative ? -baseUnits : baseUnits;
-  const digits = abs.toString().padStart(decimals + 1, "0");
-  const integerPart = digits.slice(0, digits.length - decimals) || "0";
-  const fractionPart = digits.slice(digits.length - decimals).replace(/0+$/, "");
-  const sign = negative ? "-" : "";
-  return fractionPart.length > 0 ? `${sign}${integerPart}.${fractionPart}` : `${sign}${integerPart}`;
-}
-var SETTLEMENT_CONFIRMATION_TIMEOUT_MS = 6e4;
-function createLocalFacilitatorBinding(client, network, isTransportError) {
-  const build = () => {
-    let failed = false;
-    const watch = (promise) => promise.catch((err) => {
-      if (isTransportError(err)) failed = true;
-      throw err;
-    });
-    const signer = {
-      address: client.account.address,
-      readContract: (args) => watch(client.readContract(args)),
-      verifyTypedData: (args) => watch(client.verifyTypedData(args)),
-      writeContract: (args) => watch(client.writeContract(args)),
-      sendTransaction: (args) => watch(client.sendTransaction(args)),
-      waitForTransactionReceipt: (args) => watch(client.waitForTransactionReceipt(args)),
-      getCode: (args) => watch(client.getCode(args))
-    };
-    const facilitator = registerExactEvmScheme(new x402Facilitator(), {
-      signer: toFacilitatorEvmSigner(signer, {
-        confirmationTimeoutMs: SETTLEMENT_CONFIRMATION_TIMEOUT_MS
-      }),
-      networks: network
-    });
-    return { facilitator, failed: () => failed };
-  };
-  return {
-    kind: "local",
-    describe: "local (in-process)",
-    open() {
-      const { facilitator, failed } = build();
-      return {
-        verify: (payload, requirements) => facilitator.verify(payload, requirements),
-        settle: (payload, requirements) => facilitator.settle(payload, requirements),
-        transportFailed: failed
-      };
-    },
-    async supported() {
-      return build().facilitator.getSupported().kinds;
-    }
-  };
-}
-function cdpAuthHeaders(apiKeyId, apiKeySecret) {
-  const loading = import('@coinbase/x402').then(
-    (mod) => mod.createCdpAuthHeaders(apiKeyId, apiKeySecret),
-    (cause) => {
-      throw new CommerceError(
-        "CONFIG_INVALID",
-        'x402 provider: facilitator.auth.type is "cdp", which needs the optional peer "@coinbase/x402". Install it (npm install @coinbase/x402), or use a facilitator that accepts a static token with auth.type "bearer".',
-        { cause }
-      );
-    }
-  );
-  loading.catch(() => {
-  });
-  return async () => {
-    const create = await loading;
-    if (!create) {
-      throw new CommerceError(
-        "PAYMENT_PROVIDER_UNAVAILABLE",
-        "x402 provider: @coinbase/x402 returned no auth-header factory"
-      );
-    }
-    return await create();
-  };
-}
-function createRemoteFacilitatorBinding(options) {
-  const auth = options.auth;
-  let createAuthHeaders;
-  if (auth.type === "bearer") {
-    createAuthHeaders = async () => {
-      const headers = { Authorization: `Bearer ${auth.token}` };
-      return { verify: headers, settle: headers, supported: headers };
-    };
-  } else if (auth.type === "cdp") {
-    createAuthHeaders = cdpAuthHeaders(auth.apiKeyId, auth.apiKeySecret);
-  }
-  const client = new HTTPFacilitatorClient({
-    url: options.url,
-    timeoutMs: options.timeoutMs ?? SETTLEMENT_CONFIRMATION_TIMEOUT_MS,
-    ...createAuthHeaders ? { createAuthHeaders } : {}
-  });
-  return {
-    kind: "remote",
-    describe: `remote ${new URL(options.url).origin} (auth=${auth.type})`,
-    open() {
-      let failed = false;
-      const watch = async (call) => {
-        try {
-          return await call();
-        } catch (err) {
-          failed = true;
-          throw err;
-        }
-      };
-      return {
-        verify: (payload, requirements) => watch(() => client.verify(payload, requirements)),
-        settle: (payload, requirements) => watch(() => client.settle(payload, requirements)),
-        transportFailed: () => failed
-      };
-    },
-    async supported() {
-      const response = await client.getSupported();
-      return response.kinds;
-    }
-  };
-}
-function decodePaymentSubmission(payloadBase64) {
-  let json;
-  try {
-    const decoded = Buffer.from(payloadBase64, "base64").toString("utf8");
-    json = JSON.parse(decoded);
-  } catch {
-    return void 0;
-  }
-  const result = PaymentPayloadV2Schema.safeParse(json);
-  return result.success ? result.data : void 0;
-}
-function isExactEvmPayload(payload) {
-  return payload.accepted.scheme === "exact" && typeof payload.payload === "object" && payload.payload !== null && isEIP3009Payload(payload.payload) && typeof payload.payload.signature === "string";
-}
-function computeReplayKey(input) {
-  const encoded = encodeAbiParameters(
-    [{ type: "uint256" }, { type: "address" }, { type: "address" }, { type: "bytes32" }],
-    [BigInt(input.chainId), input.asset, input.from, input.nonce]
-  );
-  return keccak256(encoded);
-}
-
-// src/payments/x402/provider.ts
-var X402_VERSION2 = 2;
-var X402_PROTOCOL_VERSION = String(X402_VERSION2);
-var DEFAULT_MAX_TIMEOUT_SECONDS = 60;
-var DEFAULT_MIME_TYPE = "application/json";
-var HEALTH_TIMEOUT_MS = 4e3;
-var SETTLEMENT_PENDING_REASON = "settlement_pending";
-var MAX_REASON_LENGTH = 64;
-var REASON_SHAPE = /^[a-z0-9_.-]+$/i;
-function sanitiseReason(reason, fallback) {
-  if (reason === void 0) return fallback;
-  const trimmed = reason.trim();
-  if (trimmed.length === 0 || trimmed.length > MAX_REASON_LENGTH) return fallback;
-  return REASON_SHAPE.test(trimmed) ? trimmed : fallback;
-}
-var DEFAULT_IDS = {
-  next: (prefix) => `${prefix ? `${prefix}_` : ""}${crypto.randomUUID()}`
-};
-function createX402PaymentProvider(options) {
-  if (!isAddress(options.asset)) {
-    throw new CommerceError(
-      "CONFIG_INVALID",
-      `x402 provider: "asset" is not a valid EVM address: ${options.asset}`
-    );
-  }
-  if (!isAddress(options.payTo)) {
-    throw new CommerceError(
-      "CONFIG_INVALID",
-      `x402 provider: "payTo" is not a valid EVM address: ${options.payTo}`
-    );
-  }
-  assertPayToIsNotDevAddress(options.rpcUrl, options.payTo);
-  if (!Number.isInteger(options.assetDecimals) || options.assetDecimals < 0) {
-    throw new CommerceError(
-      "CONFIG_INVALID",
-      `x402 provider: "assetDecimals" must be a non-negative integer`
-    );
-  }
-  const { profile, mode } = resolveX402Deployment({
-    network: options.network,
-    payTo: options.payTo,
-    asset: options.asset,
-    assetName: options.assetName,
-    assetVersion: options.assetVersion,
-    facilitator: options.facilitator,
-    ...options.allowMainnet !== void 0 ? { allowMainnet: options.allowMainnet } : {},
-    ...options.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: options.allowUnauthenticatedFacilitator } : {}
-  });
-  const network = options.network;
-  let binding;
-  if (options.facilitator.mode === "local") {
-    assertDevKeyIsLocalOnly(options.rpcUrl, options.facilitator.signerPrivateKey);
-    let client;
-    try {
-      client = createLocalFacilitatorClient(
-        options.rpcUrl,
-        options.facilitator.signerPrivateKey
-      );
-    } catch (cause) {
-      throw new CommerceError(
-        "CONFIG_INVALID",
-        "x402 provider: could not construct a local facilitator signer from facilitator.signerPrivateKey \u2014 it must be a valid 32-byte hex private key",
-        { cause }
-      );
-    }
-    binding = createLocalFacilitatorBinding(client, network, isProviderUnavailableError);
-  } else {
-    binding = createRemoteFacilitatorBinding({
-      url: options.facilitator.url,
-      auth: options.facilitator.auth
-    });
-  }
-  const healthPublicClient = createLocalPublicClient(
-    options.rpcUrl,
-    HEALTH_TIMEOUT_MS,
-    profile.chainId
-  );
-  const clock = options.clock ?? systemClock;
-  const ids = options.ids ?? DEFAULT_IDS;
-  const logger = options.logger ?? NOOP_LOGGER;
-  const maxTimeoutSeconds = options.maxTimeoutSeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS;
-  const descriptor = {
-    name: "x402",
-    kind: "payment",
-    implementationVersion: PACKAGE_VERSION,
-    supportedSpec: `x402/v${X402_VERSION2} scheme=exact family=eip155`,
-    capabilities: [
-      "exact-evm",
-      `${binding.kind}-facilitator`,
-      "eip-3009",
-      "caip-2",
-      `mode=${mode}`
-    ],
-    status: "stable",
-    unsupported: [
-      "svm",
-      "permit2",
-      "upto scheme",
-      "per-request signed facilitator credentials (e.g. CDP JWT)"
-    ]
-  };
-  async function createRequirement(context) {
-    const amount = parseCanonicalAmount(context.amount, options.assetDecimals).toString();
-    const requirements = {
-      scheme: "exact",
-      network,
-      asset: options.asset,
-      amount,
-      payTo: options.payTo,
-      maxTimeoutSeconds,
-      // `name`/`version` are what let a buyer and the facilitator build the
-      // same EIP-712 domain without an on-chain `version()` call, so
-      // verification stays deterministic against a token that has none.
-      //
-      // `assetTransferMethod` is stated rather than left to default: x402 v2's
-      // `exact`/EVM scheme also has a Permit2 path, and a client that picked it
-      // would produce a payload this provider cannot settle. Declaring the one
-      // supported method turns that into a client-side non-choice instead of a
-      // server-side rejection.
-      extra: {
-        name: options.assetName,
-        version: options.assetVersion,
-        assetTransferMethod: "eip3009"
-      }
-    };
-    const envelope = {
-      x402Version: X402_VERSION2,
-      resource: {
-        url: `resource://agent-commerce/${encodeURIComponent(options.network)}/${options.payTo}/resources/${encodeURIComponent(context.resource.id)}`,
-        description: context.resource.description ?? context.resource.name,
-        mimeType: DEFAULT_MIME_TYPE
-      },
-      accepts: [requirements]
-    };
-    const expiresAt = new Date(clock.now().getTime() + maxTimeoutSeconds * 1e3).toISOString();
-    return {
-      id: ids.next("payreq"),
-      requestId: context.requestId,
-      resourceId: context.resource.id,
-      provider: "x402",
-      amount: context.amount,
-      currency: context.currency,
-      destination: options.payTo,
-      network: options.network,
-      asset: options.asset,
-      expiresAt,
-      challenge: {
-        provider: "x402",
-        version: X402_PROTOCOL_VERSION,
-        accepts: [requirements],
-        envelope
-      }
-    };
-  }
-  async function verify(context) {
-    const { requirement, submission } = context;
-    const rejected = (reason) => ({
-      status: "rejected",
-      provider: "x402",
-      amount: requirement.amount,
-      currency: requirement.currency,
-      ...requirement.network !== void 0 ? { network: requirement.network } : {},
-      ...requirement.asset !== void 0 ? { asset: requirement.asset } : {},
-      rejectionReason: reason
-    });
-    if (requirement.provider !== "x402" || requirement.challenge.provider !== "x402") {
-      return rejected("wrong_provider");
-    }
-    const requirements = requirement.challenge.accepts[0];
-    if (!requirements) {
-      return rejected("missing_payment_requirements");
-    }
-    if (requirement.expiresAt !== void 0 && Date.parse(requirement.expiresAt) < clock.now().getTime()) {
-      return rejected("requirement_expired");
-    }
-    if (!isAddress(requirements.asset) || getAddress(requirements.asset) !== getAddress(options.asset)) {
-      return rejected("wrong_asset");
-    }
-    const payload = decodePaymentSubmission(submission.payload);
-    if (!payload) {
-      return rejected("malformed_payment_payload");
-    }
-    if (payload.x402Version !== X402_VERSION2) {
-      return rejected("unsupported_x402_version");
-    }
-    if (!isExactEvmPayload(payload)) {
-      return rejected("unsupported_scheme");
-    }
-    const { authorization } = payload.payload;
-    if (!isAddress(authorization.from) || !isAddress(authorization.to)) {
-      return rejected("malformed_payment_payload");
-    }
-    if (payload.accepted.network !== options.network) {
-      return rejected("wrong_network");
-    }
-    if (getAddress(authorization.to) !== getAddress(options.payTo)) {
-      return rejected("wrong_recipient");
-    }
-    let authorizedValue;
-    let required;
-    try {
-      authorizedValue = BigInt(authorization.value);
-      required = BigInt(requirements.amount);
-    } catch {
-      return rejected("malformed_payment_payload");
-    }
-    if (authorizedValue !== required) {
-      return rejected("wrong_amount");
-    }
-    const scope = binding.open();
-    let sdkResult;
-    try {
-      sdkResult = await scope.verify(payload, requirements);
-    } catch (err) {
-      if (isProviderUnavailableError(err) || scope.transportFailed()) {
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          `x402 provider: ${binding.kind} facilitator unreachable during verify()`,
-          {
-            cause: err
-          }
-        );
-      }
-      logger.warn({ err: describeError(err) }, "x402 verify(): unexpected SDK error");
-      return rejected("unexpected_verify_error");
-    }
-    if (!sdkResult.isValid) {
-      if (scope.transportFailed()) {
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          `x402 provider: ${binding.kind} facilitator unreachable during verify()`,
-          { details: { reportedReason: sdkResult.invalidReason ?? "invalid_payment" } }
-        );
-      }
-      if (sdkResult.invalidReason !== void 0) {
-        logger.debug(
-          { reportedReason: sdkResult.invalidReason },
-          "x402 verify(): facilitator rejection reason"
-        );
-      }
-      return rejected(sanitiseReason(sdkResult.invalidReason, "invalid_payment"));
-    }
-    const payloadChainId = chainIdFromCaip2(payload.accepted.network);
-    if (payloadChainId === void 0) {
-      return rejected("wrong_network");
-    }
-    const replayKey = computeReplayKey({
-      chainId: payloadChainId,
-      asset: getAddress(requirements.asset),
-      from: getAddress(authorization.from),
-      nonce: authorization.nonce
-    });
-    return {
-      status: "verified",
-      provider: "x402",
-      payer: getAddress(authorization.from),
-      payee: getAddress(authorization.to),
-      amount: formatCanonicalAmount(authorizedValue, options.assetDecimals),
-      currency: requirement.currency,
-      network: payload.accepted.network,
-      asset: getAddress(requirements.asset),
-      replayKey
-    };
-  }
-  async function settle(context) {
-    const { requirement, submission, verification } = context;
-    if (verification.status !== "verified") {
-      throw new CommerceError(
-        "PAYMENT_INVALID",
-        "x402 provider: settle() called without a successful verify()"
-      );
-    }
-    const requirements = requirement.challenge.accepts[0];
-    if (!requirements) {
-      throw new CommerceError(
-        "PAYMENT_INVALID",
-        "x402 provider: settle() found no payment requirements to settle against"
-      );
-    }
-    const payload = decodePaymentSubmission(submission.payload);
-    if (!payload || !isExactEvmPayload(payload)) {
-      throw new CommerceError(
-        "PAYMENT_INVALID",
-        "x402 provider: settle() received an undecodable payment payload"
-      );
-    }
-    const rejectedSettlement = (rejectionReason) => ({
-      status: "rejected",
-      provider: "x402",
-      amount: verification.amount,
-      currency: requirement.currency,
-      ...verification.network !== void 0 ? { network: verification.network } : {},
-      ...verification.asset !== void 0 ? { asset: verification.asset } : {},
-      ...verification.replayKey !== void 0 ? { replayKey: verification.replayKey } : {},
-      rejectionReason
-    });
-    const scope = binding.open();
-    let sdkResult;
-    try {
-      sdkResult = await scope.settle(payload, requirements);
-    } catch (err) {
-      if (isProviderUnavailableError(err) || scope.transportFailed()) {
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          `x402 provider: ${binding.kind} facilitator unreachable during settle()`,
-          { cause: err }
-        );
-      }
-      if (!isOnChainRevertError(err)) {
-        logger.warn(
-          { err: describeError(err) },
-          "x402 settle(): settlement failed with an unclassified error; outcome unknown"
-        );
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          "x402 provider: settlement failed with an unclassified error; outcome unknown",
-          { cause: err }
-        );
-      }
-      logger.warn(
-        { err: describeError(err), rejectionReason: "transaction_reverted" },
-        "x402 settle(): settlement transaction reverted on chain"
-      );
-      return rejectedSettlement("transaction_reverted");
-    }
-    if (!sdkResult.success) {
-      if (sdkResult.errorReason === SETTLEMENT_PENDING_REASON || scope.transportFailed()) {
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          "x402 provider: settlement was broadcast but could not be confirmed",
-          {
-            ...sdkResult.transaction ? { details: { transactionHash: sdkResult.transaction } } : {}
-          }
-        );
-      }
-      if (sdkResult.errorReason !== void 0) {
-        logger.debug(
-          { reportedReason: sdkResult.errorReason },
-          "x402 settle(): facilitator failure reason"
-        );
-      }
-      return {
-        ...rejectedSettlement(sanitiseReason(sdkResult.errorReason, "settlement_failed")),
-        network: sdkResult.network,
-        ...sdkResult.payer !== void 0 ? { payer: sdkResult.payer } : {}
-      };
-    }
-    return {
-      status: "settled",
-      provider: "x402",
-      externalReference: sdkResult.transaction,
-      ...sdkResult.payer !== void 0 ? { payer: sdkResult.payer } : {},
-      payee: requirements.payTo,
-      amount: verification.amount,
-      currency: requirement.currency,
-      network: sdkResult.network,
-      ...verification.asset !== void 0 ? { asset: verification.asset } : {},
-      ...verification.replayKey !== void 0 ? { replayKey: verification.replayKey } : {},
-      settledAt: clock.nowIso()
-    };
-  }
-  async function computeHealth() {
-    const startedAt = clock.monotonicMs();
-    const checkedAt = clock.nowIso();
-    try {
-      const chainId = await healthPublicClient.getChainId();
-      if (chainId !== profile.chainId) {
-        return {
-          status: "fail",
-          detail: `RPC at ${options.rpcUrl} reports chain id ${chainId}, expected ${profile.chainId} (${profile.displayName})`,
-          checkedAt,
-          durationMs: clock.monotonicMs() - startedAt
-        };
-      }
-      const code = await healthPublicClient.getCode({ address: options.asset });
-      if (!code || code === "0x") {
-        return {
-          status: "fail",
-          detail: `No contract code found at configured asset address ${options.asset}`,
-          checkedAt,
-          durationMs: clock.monotonicMs() - startedAt
-        };
-      }
-      if (binding.kind === "remote") {
-        const kinds = await binding.supported();
-        const supportsUs = kinds.some(
-          (kind) => kind.x402Version === X402_VERSION2 && kind.scheme === "exact" && kind.network === options.network
-        );
-        if (!supportsUs) {
-          return {
-            status: "fail",
-            detail: `Facilitator ${binding.describe} does not advertise x402 v${X402_VERSION2} scheme=exact on ${options.network} (${profile.displayName}); no payment on this deployment can settle`,
-            checkedAt,
-            durationMs: clock.monotonicMs() - startedAt
-          };
-        }
-        return {
-          status: "pass",
-          detail: `${describeDeploymentMode(mode)} \u2014 RPC ${options.rpcUrl} reachable, chain id ${profile.chainId} (${profile.displayName}), asset ${options.asset} has code, facilitator ${binding.describe} supports exact/${options.network}`,
-          checkedAt,
-          durationMs: clock.monotonicMs() - startedAt
-        };
-      }
-      const isAnvil = await probeIsAnvilNode(healthPublicClient);
-      if (!isAnvil) {
-        return {
-          status: "fail",
-          detail: `RPC at ${options.rpcUrl} reports chain id ${profile.chainId} but does not answer "anvil_nodeInfo" \u2014 it does not look like a local Anvil dev node. Refusing to treat it as safe for a local-facilitator dev key.`,
-          checkedAt,
-          durationMs: clock.monotonicMs() - startedAt
-        };
-      }
-      return {
-        status: "pass",
-        detail: `${describeDeploymentMode(mode)} \u2014 RPC ${options.rpcUrl} reachable, chain id ${profile.chainId}, asset ${options.asset} has code, confirmed Anvil dev node`,
-        checkedAt,
-        durationMs: clock.monotonicMs() - startedAt
-      };
-    } catch (err) {
-      return {
-        status: "fail",
-        detail: `x402 health check failed: ${describeError(err)}`,
-        checkedAt,
-        durationMs: clock.monotonicMs() - startedAt
-      };
-    }
-  }
-  const HEALTH_CACHE_MS = 5e3;
-  let cachedHealth;
-  let inFlightHealth;
-  async function health() {
-    const now = clock.monotonicMs();
-    if (cachedHealth && now - cachedHealth.at < HEALTH_CACHE_MS) {
-      return cachedHealth.value;
-    }
-    if (inFlightHealth) return inFlightHealth;
-    inFlightHealth = computeHealth().then((value) => {
-      cachedHealth = { at: clock.monotonicMs(), value };
-      return value;
-    }).finally(() => {
-      inFlightHealth = void 0;
-    });
-    return inFlightHealth;
-  }
-  return {
-    name: "x402",
-    descriptor,
-    createRequirement,
-    verify,
-    settle,
-    health
-  };
-}
-function isOnChainRevertError(err) {
-  return err instanceof ContractFunctionRevertedError || err instanceof ContractFunctionExecutionError;
-}
-function isProviderUnavailableError(err) {
-  if (err instanceof HttpRequestError || err instanceof TimeoutError || err instanceof WaitForTransactionReceiptTimeoutError) {
-    return true;
-  }
-  const message = describeError(err).toLowerCase();
-  return message.includes("econnrefused") || message.includes("fetch failed") || message.includes("enotfound") || message.includes("etimedout") || message.includes("timed out") || message.includes("network error");
-}
-function describeError(err) {
-  if (err instanceof Error) return `${err.name}: ${err.message}`;
-  return String(err);
-}
-async function probeIsAnvilNode(client) {
-  const request = client.request;
-  try {
-    await request({ method: "anvil_nodeInfo", params: [] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export { createPaymentProof, createX402PaymentProvider, createX402PaymentProvider as x402 };
+export { createPaymentProof };
 //# sourceMappingURL=x402.js.map
 //# sourceMappingURL=x402.js.map