@devlab.group/agent-commerce 0.1.0-alpha.0

package/dist/x402.js

@@ -0,0 +1,650 @@
+import { CommerceError, systemClock, NOOP_LOGGER, PACKAGE_VERSION } from './chunk-CZ6ZDAYD.js';
+import { getAddress, toHex, isAddress, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, encodeAbiParameters, keccak256, ContractFunctionRevertedError, ContractFunctionExecutionError } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { encodePayment } from 'x402/schemes';
+import { getNetworkId } from 'x402/shared';
+import { PaymentRequirementsSchema, PaymentPayloadSchema } from 'x402/types';
+import { verify, settle } from 'x402/facilitator';
+
+var TRANSFER_WITH_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var DEFAULT_VALID_AFTER_SKEW_SECONDS = 600;
+async function createPaymentProof(options) {
+  const requirements = PaymentRequirementsSchema.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"
+    );
+  }
+  const account = privateKeyToAccount(options.buyerPrivateKey);
+  void options.rpcUrl;
+  const chainId = getNetworkId(requirements.network);
+  const nonce = options.overrides?.nonce ?? randomNonce();
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const validAfter = options.overrides?.validAfter ?? nowSeconds - DEFAULT_VALID_AFTER_SKEW_SECONDS;
+  const validBefore = options.overrides?.validBefore ?? nowSeconds + requirements.maxTimeoutSeconds;
+  const to = getAddress(options.overrides?.payTo ?? requirements.payTo);
+  const value = BigInt(options.overrides?.value ?? requirements.maxAmountRequired);
+  const signature = await account.signTypedData({
+    domain: {
+      name: requirements.extra["name"],
+      version: requirements.extra["version"],
+      chainId,
+      verifyingContract: getAddress(requirements.asset)
+    },
+    types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: account.address,
+      to,
+      value,
+      validAfter: BigInt(validAfter),
+      validBefore: BigInt(validBefore),
+      nonce
+    }
+  });
+  const payload = {
+    x402Version: 1,
+    scheme: "exact",
+    network: requirements.network,
+    payload: {
+      signature,
+      authorization: {
+        from: account.address,
+        to,
+        value: value.toString(),
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      }
+    }
+  };
+  return encodePayment(payload);
+}
+function randomNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  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 LOCAL_CHAIN_ID = 84532;
+function buildLocalChain(rpcUrl) {
+  return {
+    id: LOCAL_CHAIN_ID,
+    name: "agent-commerce-local",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+      default: { http: [rpcUrl] }
+    }
+  };
+}
+function createLocalPublicClient(rpcUrl, timeoutMs) {
+  return createPublicClient({
+    chain: buildLocalChain(rpcUrl),
+    transport: http(rpcUrl, timeoutMs !== void 0 ? { timeout: timeoutMs } : void 0)
+  });
+}
+function createLocalFacilitatorClient(rpcUrl, signerPrivateKey) {
+  const chain = buildLocalChain(rpcUrl);
+  const account = privateKeyToAccount(signerPrivateKey);
+  return createWalletClient({
+    account,
+    chain,
+    transport: http(rpcUrl)
+  }).extend(publicActions);
+}
+
+// src/payments/x402/local-chain/accounts.ts
+var ANVIL_WELL_KNOWN_ACCOUNTS = [
+  {
+    address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+    privateKey: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+  },
+  {
+    address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+    privateKey: "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+  },
+  {
+    address: "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+    privateKey: "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a"
+  }
+];
+
+// src/payments/x402/dev-key-guard.ts
+var WELL_KNOWN_DEV_KEYS = new Set(
+  ANVIL_WELL_KNOWN_ACCOUNTS.map((a) => a.privateKey.toLowerCase())
+);
+var WELL_KNOWN_DEV_ADDRESSES = new Set(
+  ANVIL_WELL_KNOWN_ACCOUNTS.map((a) => a.address.toLowerCase())
+);
+var PRIVATE_KEY_SHAPE = /^0x[0-9a-fA-F]{64}$/;
+function isWellKnownDevKey(privateKey) {
+  return WELL_KNOWN_DEV_KEYS.has(privateKey.toLowerCase());
+}
+function isWellKnownDevAddress(address) {
+  return WELL_KNOWN_DEV_ADDRESSES.has(address.toLowerCase());
+}
+function isLikelyLocalOrPrivateHost(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h === "127.0.0.1" || h === "::1") return true;
+  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^192\.168\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (!h.includes(".") && !h.includes(":")) return true;
+  return false;
+}
+function parseHostnameOrThrow(rpcUrl) {
+  try {
+    return new URL(rpcUrl).hostname;
+  } catch (cause) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `x402 provider: rpcUrl "${rpcUrl}" is not a valid URL`,
+      { cause }
+    );
+  }
+}
+function assertDevKeyIsLocalOnly(rpcUrl, signerPrivateKey) {
+  if (!PRIVATE_KEY_SHAPE.test(signerPrivateKey)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      'x402 provider: facilitator.signerPrivateKey is not a well-formed private key (expected "0x" followed by exactly 64 hex characters).'
+    );
+  }
+  if (!isWellKnownDevKey(signerPrivateKey)) return;
+  const hostname = parseHostnameOrThrow(rpcUrl);
+  if (!isLikelyLocalOrPrivateHost(hostname)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `x402 provider: facilitator.signerPrivateKey is a well-known Anvil development key, but rpcUrl "${rpcUrl}" does not look like a local/private chain. A public dev key must never sign against a public network \u2014 it is instantly drainable and can grief real settlements via nonce exhaustion. Use a real facilitator key for any non-local RPC, or point rpcUrl at your local/dev chain.`
+    );
+  }
+}
+function assertPayToIsNotDevAddress(rpcUrl, payTo) {
+  if (!isWellKnownDevAddress(payTo)) return;
+  const hostname = parseHostnameOrThrow(rpcUrl);
+  if (!isLikelyLocalOrPrivateHost(hostname)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `x402 provider: "payTo" (${payTo}) is a well-known Anvil development address, but rpcUrl "${rpcUrl}" does not look like a local/private chain. The private key behind that address is public knowledge, so any revenue settled to it is immediately spendable by anyone. Set "payTo" to your own merchant wallet for any non-local RPC, or point rpcUrl at your local/dev chain.`
+    );
+  }
+}
+function decodePaymentSubmission(payloadBase64) {
+  let json;
+  try {
+    const decoded = Buffer.from(payloadBase64, "base64").toString("utf8");
+    json = JSON.parse(decoded);
+  } catch {
+    return void 0;
+  }
+  const result = PaymentPayloadSchema.safeParse(json);
+  return result.success ? result.data : void 0;
+}
+function isExactEvmPayload(payload) {
+  return payload.scheme === "exact" && typeof payload.payload === "object" && payload.payload !== null && "authorization" in payload.payload && "signature" in payload.payload;
+}
+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_PROTOCOL_VERSION = "1";
+var DEFAULT_MAX_TIMEOUT_SECONDS = 60;
+var DEFAULT_MIME_TYPE = "application/json";
+var HEALTH_TIMEOUT_MS = 4e3;
+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`
+    );
+  }
+  let facilitatorClient;
+  if (options.facilitator.mode === "local") {
+    assertDevKeyIsLocalOnly(options.rpcUrl, options.facilitator.signerPrivateKey);
+    try {
+      facilitatorClient = 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 }
+      );
+    }
+  }
+  const publicClient = createLocalPublicClient(options.rpcUrl);
+  const healthPublicClient = createLocalPublicClient(options.rpcUrl, HEALTH_TIMEOUT_MS);
+  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@1.2.0 scheme=exact family=evm",
+    capabilities: ["exact-evm", "local-facilitator", "eip-3009"],
+    status: "stable",
+    unsupported: ["svm", "deferred scheme", "remote facilitator"]
+  };
+  async function createRequirement(context) {
+    const maxAmountRequired = parseCanonicalAmount(
+      context.amount,
+      options.assetDecimals
+    ).toString();
+    const requirements = {
+      scheme: "exact",
+      // options.network is a canonical free-form string (frozen contract); the
+      // x402 SDK's Network union is checked against the live chain in health()
+      // and by verify()'s own network-mismatch guard.
+      network: options.network,
+      maxAmountRequired,
+      // Descriptive metadata only: `resource` is not part of the EIP-3009
+      // authorisation the buyer signs (`from`/`to`/`value`/`validAfter`/
+      // `validBefore`/`nonce`), nothing verifies against it, and the replay
+      // key is keyed on the authorisation rather than on this string. It is
+      // still what a facilitator, wallet or buyer agent logs and shows, so it
+      // carries `network` and `payTo` — both already public in this same
+      // challenge — to stay unambiguous across the wider x402 ecosystem,
+      // where the `agent-commerce` authority alone is not reserved to us.
+      resource: `resource://agent-commerce/${encodeURIComponent(options.network)}/${options.payTo}/resources/${encodeURIComponent(context.resource.id)}`,
+      description: context.resource.description ?? context.resource.name,
+      mimeType: DEFAULT_MIME_TYPE,
+      payTo: options.payTo,
+      maxTimeoutSeconds,
+      asset: options.asset,
+      // REQUIRED.name/version explicitly means
+      // the facilitator never needs an on-chain version() call to build the
+      // EIP-712 domain, so verification stays deterministic even against a
+      // token that has no on-chain version() (it doesn't matter here since
+      // MockUSDC has one, but this is what makes the domain unambiguous).
+      extra: { name: options.assetName, version: options.assetVersion }
+    };
+    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]
+      }
+    };
+  }
+  async function verify$1(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 (!isExactEvmPayload(payload)) {
+      return rejected("unsupported_scheme");
+    }
+    const { authorization } = payload.payload;
+    if (!isAddress(authorization.from) || !isAddress(authorization.to)) {
+      return rejected("malformed_payment_payload");
+    }
+    if (payload.network !== options.network) {
+      return rejected("wrong_network");
+    }
+    if (getAddress(authorization.to) !== getAddress(options.payTo)) {
+      return rejected("wrong_recipient");
+    }
+    let authorizedValue;
+    let maxRequired;
+    try {
+      authorizedValue = BigInt(authorization.value);
+      maxRequired = BigInt(requirements.maxAmountRequired);
+    } catch {
+      return rejected("malformed_payment_payload");
+    }
+    if (authorizedValue < maxRequired) {
+      return rejected("wrong_amount");
+    }
+    let sdkResult;
+    try {
+      sdkResult = await verify(
+        publicClient,
+        payload,
+        requirements
+      );
+    } catch (err) {
+      if (isProviderUnavailableError(err)) {
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "x402 provider: RPC unreachable during verify()",
+          {
+            cause: err
+          }
+        );
+      }
+      logger.warn({ err: describeError(err) }, "x402 verify(): unexpected SDK error");
+      return rejected("unexpected_verify_error");
+    }
+    if (!sdkResult.isValid) {
+      return rejected(sdkResult.invalidReason ?? "invalid_payment");
+    }
+    const replayKey = computeReplayKey({
+      chainId: getNetworkId(payload.network),
+      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.network,
+      asset: getAddress(requirements.asset),
+      replayKey
+    };
+  }
+  async function settle$1(context) {
+    const { requirement, submission, verification } = context;
+    if (verification.status !== "verified") {
+      throw new CommerceError(
+        "PAYMENT_INVALID",
+        "x402 provider: settle() called without a successful verify()"
+      );
+    }
+    if (options.facilitator.mode !== "local" || facilitatorClient === void 0) {
+      throw new CommerceError(
+        "PROTOCOL_UNSUPPORTED",
+        'x402 provider: remote facilitator settlement is not implemented in v0.1.0-alpha; only { mode: "local" } is supported'
+      );
+    }
+    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"
+      );
+    }
+    let broadcastTxHash;
+    const settlementClient = {
+      ...facilitatorClient,
+      waitForTransactionReceipt: (args) => {
+        broadcastTxHash = args.hash;
+        return facilitatorClient.waitForTransactionReceipt(args);
+      }
+    };
+    let sdkResult;
+    try {
+      sdkResult = await settle(
+        settlementClient,
+        payload,
+        requirements
+      );
+    } catch (err) {
+      if (isProviderUnavailableError(err)) {
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "x402 provider: RPC unreachable during settle()",
+          {
+            cause: err,
+            ...broadcastTxHash !== void 0 ? { details: { transactionHash: broadcastTxHash } } : {}
+          }
+        );
+      }
+      const rejectionReason = isOnChainRevertError(err) ? "transaction_reverted" : "unexpected_settle_error";
+      logger.warn(
+        { err: describeError(err), rejectionReason },
+        "x402 settle(): settlement transaction failed"
+      );
+      return {
+        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
+      };
+    }
+    if (!sdkResult.success) {
+      return {
+        status: "rejected",
+        provider: "x402",
+        amount: verification.amount,
+        currency: requirement.currency,
+        network: sdkResult.network,
+        ...verification.asset !== void 0 ? { asset: verification.asset } : {},
+        ...sdkResult.payer !== void 0 ? { payer: sdkResult.payer } : {},
+        ...verification.replayKey !== void 0 ? { replayKey: verification.replayKey } : {},
+        rejectionReason: sdkResult.errorReason ?? "settlement_failed"
+      };
+    }
+    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 !== LOCAL_CHAIN_ID) {
+        return {
+          status: "fail",
+          detail: `RPC at ${options.rpcUrl} reports chain id ${chainId}, expected ${LOCAL_CHAIN_ID}`,
+          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 (options.facilitator.mode === "remote") {
+        return {
+          status: "warn",
+          detail: "RPC and asset are reachable; remote facilitator mode is not implemented in v0.1.0-alpha",
+          checkedAt,
+          durationMs: clock.monotonicMs() - startedAt
+        };
+      }
+      const isAnvil = await probeIsAnvilNode(healthPublicClient);
+      if (!isAnvil) {
+        return {
+          status: "fail",
+          detail: `RPC at ${options.rpcUrl} reports chain id ${LOCAL_CHAIN_ID} 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: `RPC ${options.rpcUrl} reachable, chain id ${LOCAL_CHAIN_ID}, 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: verify$1,
+    settle: settle$1,
+    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 };
+//# sourceMappingURL=x402.js.map
+//# sourceMappingURL=x402.js.map