@devlab.group/agent-commerce 2.0.0 → 2.2.0

package/dist/chunk-RKBGCPCK.js

@@ -1,733 +0,0 @@
-import { assertPayToIsNotDevAddress, resolveX402Deployment, assertDevKeyIsLocalOnly, describeRpc, X402_DEFAULT_PAYMENT_FLOW, SETTLE_AFTER_BACKEND_METADATA_KEY, LOCAL_CHAIN_ID, describeDeploymentMode } from './chunk-TWRUNWDR.js';
-import { CommerceError, systemClock, NOOP_LOGGER, PACKAGE_VERSION, redactedErrorText } from './chunk-53WXXIPR.js';
-import { encodeAbiParameters, keccak256, isAddress, getAddress, formatUnits, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, BaseError, ContractFunctionRevertedError } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { x402Facilitator } from '@x402/core/facilitator';
-import { HTTPFacilitatorClient } from '@x402/core/http';
-import { SettleError, VerifyError } from '@x402/core/types';
-import { isEIP3009Payload, toFacilitatorEvmSigner } from '@x402/evm';
-import { registerExactEvmScheme } from '@x402/evm/exact/facilitator';
-import { PaymentPayloadV2Schema } from '@x402/core/schemas';
-
-// 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 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);
-}
-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
-      };
-    }
-  };
-}
-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 verdictFromVerifyError(err) {
-  if (err instanceof VerifyError && err.statusCode === 400 && typeof err.invalidReason === "string") {
-    return {
-      isValid: false,
-      invalidReason: err.invalidReason,
-      ...err.payer !== void 0 ? { payer: err.payer } : {}
-    };
-  }
-  throw err;
-}
-function verdictFromSettleError(err, network) {
-  if (err instanceof SettleError && err.statusCode === 400 && typeof err.errorReason === "string" && err.errorReason !== "" && !err.transaction) {
-    return {
-      success: false,
-      errorReason: err.errorReason,
-      transaction: "",
-      network: err.network ?? network,
-      ...err.payer !== void 0 ? { payer: err.payer } : {}
-    };
-  }
-  throw err;
-}
-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: 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).catch(verdictFromVerifyError)),
-        settle: (payload, requirements) => watch(
-          () => client.settle(payload, requirements).catch((err) => verdictFromSettleError(err, requirements.network))
-        ),
-        transportFailed: () => failed
-      };
-    },
-    async supported() {
-      const response = await client.getSupported();
-      return response.kinds;
-    }
-  };
-}
-function decodePaymentSubmission(payloadBase64) {
-  const json = decodeJson(payloadBase64);
-  if (json === void 0) return void 0;
-  const result = PaymentPayloadV2Schema.safeParse(json);
-  return result.success ? result.data : void 0;
-}
-function declaredX402Version(payloadBase64) {
-  const json = decodeJson(payloadBase64);
-  return typeof json === "object" && json !== null ? json["x402Version"] : void 0;
-}
-function withoutResource(payload) {
-  const { resource: _resource, ...rest } = payload;
-  return rest;
-}
-function decodeJson(payloadBase64) {
-  try {
-    return JSON.parse(Buffer.from(payloadBase64, "base64").toString("utf8"));
-  } catch {
-    return 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_VERSION = 2;
-var X402_PROTOCOL_VERSION = String(X402_VERSION);
-var DEFAULT_MAX_TIMEOUT_SECONDS = 60;
-var DEFAULT_MIME_TYPE = "application/json";
-var HEALTH_TIMEOUT_MS = 4e3;
-var SETTLEMENT_PENDING_REASON = "settlement_pending";
-var TRANSACTION_FAILED_REASON = "invalid_exact_evm_transaction_failed";
-var MAX_REASON_LENGTH = 64;
-var REASON_SHAPE = /^[a-z0-9_.-]+$/i;
-function sanitizeReason(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. 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 rpcOrigin = describeRpc(options.rpcUrl);
-  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_VERSION} scheme=exact family=eip155`,
-    capabilities: [
-      "exact-evm",
-      `${binding.kind}-facilitator`,
-      "eip-3009",
-      "caip-2",
-      `mode=${mode}`,
-      "authorization-flow",
-      "upfront-flow"
-    ],
-    status: "stable",
-    unsupported: [
-      "svm",
-      "permit2",
-      "upto scheme",
-      "batch-settlement scheme",
-      "auth-capture scheme"
-    ]
-  };
-  async function createRequirement(context) {
-    const amount = parseCanonicalAmount(context.amount, options.assetDecimals).toString();
-    const paymentFlow = options.resourcePaymentFlows?.[context.resource.id] ?? options.paymentFlow ?? X402_DEFAULT_PAYMENT_FLOW;
-    const requirements = {
-      scheme: "exact",
-      network,
-      asset: options.asset,
-      amount,
-      payTo: options.payTo,
-      maxTimeoutSeconds,
-      // `name`/`version` let the buyer and the facilitator build the same
-      // EIP-712 domain without calling `version()` on the token.
-      // `assetTransferMethod` names the one method this provider settles, so a
-      // conforming client never picks the `exact` scheme's Permit2 path.
-      // x402 requires an explicit non-default flow. Omit the default
-      // `authorization` flow here.
-      extra: {
-        name: options.assetName,
-        version: options.assetVersion,
-        assetTransferMethod: "eip3009",
-        ...paymentFlow === "upfront" ? { paymentFlow } : {}
-      }
-    };
-    const envelope = {
-      x402Version: X402_VERSION,
-      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
-      },
-      metadata: { [SETTLE_AFTER_BACKEND_METADATA_KEY]: paymentFlow === "authorization" }
-    };
-  }
-  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) {
-      const version = declaredX402Version(submission.payload);
-      return rejected(
-        typeof version === "number" && version !== X402_VERSION ? "invalid_x402_version" : "invalid_payload"
-      );
-    }
-    if (payload.x402Version !== X402_VERSION) {
-      return rejected("invalid_x402_version");
-    }
-    if (!isExactEvmPayload(payload)) {
-      return rejected("unsupported_scheme");
-    }
-    const { authorization } = payload.payload;
-    if (!isAddress(authorization.from) || !isAddress(authorization.to)) {
-      return rejected("invalid_payload");
-    }
-    if (payload.accepted.network !== options.network) {
-      return rejected("invalid_network");
-    }
-    const offeredUrl = requirement.challenge.envelope?.resource?.url;
-    if (!acceptedMatchesOffer(requirements, payload.accepted) || payload.resource !== void 0 && payload.resource.url !== offeredUrl) {
-      return rejected("invalid_payment_requirements");
-    }
-    if (getAddress(authorization.to) !== getAddress(options.payTo)) {
-      return rejected("invalid_exact_evm_payload_recipient_mismatch");
-    }
-    let authorizedValue;
-    let required;
-    try {
-      authorizedValue = BigInt(authorization.value);
-      required = BigInt(requirements.amount);
-    } catch {
-      return rejected("invalid_payload");
-    }
-    if (authorizedValue !== required) {
-      return rejected("invalid_exact_evm_payload_authorization_value_mismatch");
-    }
-    const scope = binding.open();
-    let sdkResult;
-    try {
-      sdkResult = await scope.verify(withoutResource(payload), requirements);
-    } catch (err) {
-      if (!isProviderUnavailableError(err) && !scope.transportFailed()) {
-        logger.warn({ err: redactedErrorText(err) }, "x402 verify(): unexpected SDK error");
-      }
-      throw new CommerceError(
-        "PAYMENT_PROVIDER_UNAVAILABLE",
-        `x402 provider: ${binding.kind} facilitator returned no verdict during verify()`,
-        { cause: err }
-      );
-    }
-    if (!sdkResult.isValid) {
-      if (scope.transportFailed()) {
-        if (sdkResult.invalidReason !== void 0) {
-          logger.debug(
-            { reportedReason: sdkResult.invalidReason },
-            "x402 verify(): local facilitator transport failure reason"
-          );
-        }
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          `x402 provider: ${binding.kind} facilitator unreachable during verify()`
-        );
-      }
-      if (sdkResult.invalidReason !== void 0) {
-        logger.debug(
-          { reportedReason: sdkResult.invalidReason },
-          "x402 verify(): facilitator rejection reason"
-        );
-      }
-      return rejected(sanitizeReason(sdkResult.invalidReason, "invalid_payment"));
-    }
-    const replayKey = computeReplayKey({
-      chainId: profile.chainId,
-      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: formatUnits(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(withoutResource(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: redactedErrorText(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: redactedErrorText(err), rejectionReason: "transaction_reverted" },
-        "x402 settle(): settlement transaction reverted on chain"
-      );
-      return rejectedSettlement("transaction_reverted");
-    }
-    if (!sdkResult.success) {
-      if (sdkResult.errorReason === TRANSACTION_FAILED_REASON && !/^0x[0-9a-f]{64}$/i.test(sdkResult.transaction)) {
-        logger.warn(
-          { reportedReason: sdkResult.errorReason },
-          "x402 settle(): the broadcast failed without a transaction hash; outcome unknown"
-        );
-        throw new CommerceError(
-          "PAYMENT_PROVIDER_UNAVAILABLE",
-          "x402 provider: settlement failed with an unclassified error; outcome unknown"
-        );
-      }
-      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(sanitizeReason(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(),
-      // `amount` is the display value; x402's settlement response reports base units
-      metadata: { amountBaseUnits: payload.payload.authorization.value }
-    };
-  }
-  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 ${rpcOrigin} 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_VERSION && kind.scheme === "exact" && kind.network === options.network
-        );
-        if (!supportsUs) {
-          return {
-            status: "fail",
-            detail: `Facilitator ${binding.describe} does not advertise x402 v${X402_VERSION} 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)}: RPC ${rpcOrigin} 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 ${rpcOrigin} reports chain id ${profile.chainId} but does not answer "anvil_nodeInfo", so 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)}: RPC ${rpcOrigin} 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: ${redactedErrorText(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 acceptedMatchesOffer(offered, accepted) {
-  const sameAddress = (a, b) => a.toLowerCase() === b.toLowerCase();
-  const offeredExtra = offered.extra ?? {};
-  const acceptedExtra = accepted.extra ?? {};
-  const flow = (extra) => extra["paymentFlow"] ?? X402_DEFAULT_PAYMENT_FLOW;
-  return accepted.scheme === offered.scheme && accepted.network === offered.network && accepted.amount === offered.amount && sameAddress(accepted.asset, offered.asset) && sameAddress(accepted.payTo, offered.payTo) && Object.entries(offeredExtra).every(([key, value]) => acceptedExtra[key] === value) && flow(acceptedExtra) === flow(offeredExtra);
-}
-function isOnChainRevertError(err) {
-  return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) !== null;
-}
-function isProviderUnavailableError(err) {
-  if (err instanceof HttpRequestError || err instanceof TimeoutError || err instanceof WaitForTransactionReceiptTimeoutError) {
-    return true;
-  }
-  const message = redactedErrorText(err).toLowerCase();
-  return message.includes("econnrefused") || message.includes("fetch failed") || message.includes("enotfound") || message.includes("etimedout") || message.includes("timed out") || message.includes("network error");
-}
-async function probeIsAnvilNode(client) {
-  const request = client.request;
-  try {
-    await request({ method: "anvil_nodeInfo", params: [] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export { DEFAULT_IDS, chainIdFromCaip2, computeReplayKey, createX402PaymentProvider, parseCanonicalAmount };
-//# sourceMappingURL=chunk-RKBGCPCK.js.map
-//# sourceMappingURL=chunk-RKBGCPCK.js.map