@devlab.group/agent-commerce 2.0.0 → 2.2.0

package/dist/cli/chunk-KLX2YZDG.js

@@ -0,0 +1,1400 @@
+import { assertPayToIsNotDevAddress, resolveX402Deployment, assertDevKeyIsLocalOnly, describeRpc, x402OfferName } from './chunk-NSPPEF5M.js';
+import { findX402Network, normalizeAddress, X402_DEFAULT_PAYMENT_FLOW, REUSE_REJECTED_AUTHORIZATION_METADATA_KEY, SETTLE_AFTER_BACKEND_METADATA_KEY, sameAddress, LOCAL_CHAIN_ID, isTransactionReference, isEvmAddress, describeDeploymentMode } from './chunk-7JNYFUT3.js';
+import { computeReplayKey, computePermit2ReplayKey } from './chunk-OSTCU6ZK.js';
+import { PACKAGE_VERSION } from './chunk-FRMLWGSS.js';
+import { CommerceError, systemClock, NOOP_LOGGER, redactedErrorText } from './chunk-QQ3WY5L3.js';
+import { isRecord } from './chunk-3M6U7ILB.js';
+import { x402ExactPermit2ProxyAddress, toFacilitatorEvmSigner, PERMIT2_ADDRESS } from '@x402/evm';
+import { isAddress, getAddress, formatUnits, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, BaseError, ContractFunctionRevertedError } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { HTTPFacilitatorClient } from '@x402/core/http';
+import { SettleError, VerifyError } from '@x402/core/types';
+import { x402Facilitator } from '@x402/core/facilitator';
+import { registerExactEvmScheme } from '@x402/evm/exact/facilitator';
+import { PaymentPayloadV2Schema } from '@x402/core/schemas';
+
+// src/payments/x402/provider/constants.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 DEFAULT_IDS = {
+  next: (prefix) => `${prefix ? `${prefix}_` : ""}${crypto.randomUUID()}`
+};
+
+// 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);
+}
+
+// src/payments/x402/provider/fee-payer.ts
+var SUPPORTED_TTL_MS = 6e4;
+function createSvmFeePayerSource(ctx) {
+  const { clock, remoteBinding } = ctx;
+  let supportedSnapshot;
+  const feePayers = /* @__PURE__ */ new Map();
+  function currentSupported() {
+    const now = clock.monotonicMs();
+    if (supportedSnapshot && now - supportedSnapshot.at < SUPPORTED_TTL_MS) {
+      return supportedSnapshot.response;
+    }
+    const remote = remoteBinding;
+    const response = remote.supported();
+    const snapshot = { at: now, response };
+    supportedSnapshot = snapshot;
+    response.catch(() => {
+      if (supportedSnapshot === snapshot) supportedSnapshot = void 0;
+    });
+    return response;
+  }
+  async function svmFeePayer(offer) {
+    let supported;
+    try {
+      supported = await currentSupported();
+    } catch (cause) {
+      throw new CommerceError(
+        "PAYMENT_PROVIDER_UNAVAILABLE",
+        `x402 provider: facilitator ${offer.binding.describe} did not answer /supported, which names the Solana fee payer`,
+        { cause }
+      );
+    }
+    const listed = supported.kinds.find(
+      (kind) => kind.x402Version === X402_VERSION && kind.scheme === "exact" && kind.network === offer.network
+    )?.extra?.["feePayer"];
+    const previous = feePayers.get(offer.network);
+    const stillSigns = previous !== void 0 && (previous === listed || Object.values(supported.signers).some((s) => s.includes(previous)));
+    const feePayer = stillSigns ? previous : listed;
+    if (typeof feePayer !== "string" || normalizeAddress(offer.profile, feePayer) === void 0) {
+      throw new CommerceError(
+        "PAYMENT_PROVIDER_UNAVAILABLE",
+        `x402 provider: facilitator ${offer.binding.describe} names no Solana fee payer for ${offer.network}`
+      );
+    }
+    feePayers.set(offer.network, feePayer);
+    return feePayer;
+  }
+  return svmFeePayer;
+}
+function createHealthCheck(ctx) {
+  const { offers, clock, deploymentMode, remoteBinding, svm, near } = ctx;
+  async function offerHealth(offer, kinds) {
+    if (offer.family === "svm") return svmOfferHealth(offer, kinds);
+    if (offer.family === "near") return nearOfferHealth(offer, kinds);
+    const { profile, rpcOrigin, healthClient, binding } = offer;
+    const chainId = await healthClient.getChainId();
+    if (chainId !== profile.chainId) {
+      return {
+        status: "fail",
+        detail: `RPC at ${rpcOrigin} reports chain id ${chainId}, expected ${profile.chainId} (${profile.displayName})`
+      };
+    }
+    const code = await healthClient.getCode({ address: offer.asset });
+    if (!code || code === "0x") {
+      return {
+        status: "fail",
+        detail: `No contract code found at configured asset address ${offer.asset}`
+      };
+    }
+    if (offer.method === "permit2") {
+      for (const [name, address] of PERMIT2_CONTRACTS) {
+        const deployed = await healthClient.getCode({ address });
+        if (!deployed || deployed === "0x") {
+          return {
+            status: "fail",
+            detail: `No ${name} contract code found at ${address} on ${profile.displayName}`
+          };
+        }
+      }
+    }
+    const contracts = `asset ${offer.asset}${offer.method === "permit2" ? ", Permit2 and its x402 proxy" : ""}`;
+    if (binding.kind === "remote") {
+      const supportsUs = (await kinds()).some(
+        (kind) => kind.x402Version === X402_VERSION && kind.scheme === "exact" && kind.network === offer.network
+      );
+      if (!supportsUs) {
+        return {
+          status: "fail",
+          detail: `Facilitator ${binding.describe} does not advertise x402 v${X402_VERSION} scheme=exact on ${offer.network} (${profile.displayName}); no payment on this deployment can settle`
+        };
+      }
+      return {
+        status: "pass",
+        detail: `${describeDeploymentMode(deploymentMode)}: RPC ${rpcOrigin} reachable, chain id ${profile.chainId} (${profile.displayName}), ${contracts} have code, facilitator ${binding.describe} supports exact/${offer.network}`
+      };
+    }
+    const isAnvil = await probeIsAnvilNode(healthClient);
+    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.`
+      };
+    }
+    return {
+      status: "pass",
+      detail: `${describeDeploymentMode(deploymentMode)}: RPC ${rpcOrigin} reachable, chain id ${profile.chainId}, ${contracts} have code, confirmed Anvil dev node`
+    };
+  }
+  async function svmOfferHealth(offer, kinds) {
+    const { profile, rpcOrigin, binding } = offer;
+    const svmModule = await svm();
+    const genesis = await jsonRpc(offer.rpcUrl, "getGenesisHash", []);
+    const cluster = typeof genesis === "string" ? `solana:${genesis.slice(0, 32)}` : void 0;
+    if (cluster !== offer.network) {
+      return {
+        status: "fail",
+        detail: `RPC at ${rpcOrigin} serves ${cluster ?? "an unknown cluster"}, expected ${offer.network} (${profile.displayName})`
+      };
+    }
+    const mint = await jsonRpc(offer.rpcUrl, "getAccountInfo", [
+      offer.asset,
+      { encoding: "base64" }
+    ]);
+    const mintInfo = readMint(mint);
+    if (mintInfo === void 0) {
+      return {
+        status: "fail",
+        detail: `No initialized token mint found at configured asset address ${offer.asset}`
+      };
+    }
+    const { decimals, tokenProgram } = mintInfo;
+    if (decimals !== offer.assetDecimals) {
+      return {
+        status: "fail",
+        detail: `Mint ${offer.asset} has ${decimals} decimals, configured ${offer.assetDecimals}`
+      };
+    }
+    const payeeAccount = await svmModule.associatedTokenAccount(
+      offer.payTo,
+      offer.asset,
+      tokenProgram
+    );
+    const account = await jsonRpc(offer.rpcUrl, "getAccountInfo", [
+      payeeAccount,
+      { encoding: "base64" }
+    ]);
+    const accountValue = isRecord(account) ? account["value"] : void 0;
+    if (!isRecord(accountValue) || accountValue["owner"] !== tokenProgram) {
+      return {
+        status: "fail",
+        detail: `payTo ${offer.payTo} has no token account for mint ${offer.asset}; create its associated token account (${payeeAccount}) before taking payments`
+      };
+    }
+    const feePayer = (await kinds()).find(
+      (kind) => kind.x402Version === X402_VERSION && kind.scheme === "exact" && kind.network === offer.network
+    )?.extra?.["feePayer"];
+    if (typeof feePayer !== "string" || normalizeAddress(profile, feePayer) === void 0) {
+      return {
+        status: "fail",
+        detail: `Facilitator ${binding.describe} does not advertise x402 v${X402_VERSION} scheme=exact on ${offer.network} (${profile.displayName}) with a fee payer; no payment on this deployment can settle`
+      };
+    }
+    return {
+      status: "pass",
+      detail: `${describeDeploymentMode(deploymentMode)}: RPC ${rpcOrigin} serves ${profile.displayName}, mint ${offer.asset} has ${decimals} decimals and a token account for ${offer.payTo}, facilitator ${binding.describe} supports exact/${offer.network} with fee payer ${feePayer}`
+    };
+  }
+  async function nearOfferHealth(offer, kinds) {
+    const { profile, rpcOrigin, binding, rpcUrl } = offer;
+    await near();
+    const status = await jsonRpc(rpcUrl, "status", []);
+    const chainId = isRecord(status) ? status["chain_id"] : void 0;
+    const expected = offer.network.slice("near:".length);
+    if (chainId !== expected) {
+      return {
+        status: "fail",
+        detail: `RPC at ${rpcOrigin} serves chain ${String(chainId ?? "unknown")}, expected ${expected} (${profile.displayName})`
+      };
+    }
+    const token = await jsonRpc(rpcUrl, "query", {
+      request_type: "view_account",
+      finality: "final",
+      account_id: offer.asset
+    });
+    if (!isRecord(token) || token["code_hash"] === NEAR_EMPTY_CODE_HASH) {
+      return {
+        status: "fail",
+        detail: `No contract code found at configured asset account ${offer.asset}`
+      };
+    }
+    const metadata = await nearView(rpcUrl, offer.asset, "ft_metadata", {});
+    const decimals = isRecord(metadata) ? metadata["decimals"] : void 0;
+    if (decimals !== offer.assetDecimals) {
+      return {
+        status: "fail",
+        detail: `Token ${offer.asset} has ${String(decimals)} decimals, configured ${offer.assetDecimals}`
+      };
+    }
+    let registered = true;
+    try {
+      registered = await nearView(rpcUrl, offer.asset, "storage_balance_of", {
+        account_id: offer.payTo
+      }) !== null;
+    } catch (err) {
+      if (!/MethodNotFound|MethodResolveError/i.test(redactedErrorText(err))) throw err;
+    }
+    if (!registered) {
+      return {
+        status: "fail",
+        detail: `payTo ${offer.payTo} has no storage registered with token ${offer.asset}; register it (NEP-145 storage_deposit) before taking payments`
+      };
+    }
+    const listed = (await kinds()).some(
+      (kind) => kind.x402Version === X402_VERSION && kind.scheme === "exact" && kind.network === offer.network
+    );
+    if (!listed) {
+      return {
+        status: "fail",
+        detail: `Facilitator ${binding.describe} does not advertise x402 v${X402_VERSION} scheme=exact on ${offer.network} (${profile.displayName}); no payment on this deployment can settle`
+      };
+    }
+    return {
+      status: "pass",
+      detail: `${describeDeploymentMode(deploymentMode)}: RPC ${rpcOrigin} serves ${expected}, token ${offer.asset} has ${decimals} decimals and storage for ${offer.payTo}, facilitator ${binding.describe} supports exact/${offer.network}`
+    };
+  }
+  async function computeHealth() {
+    const startedAt = clock.monotonicMs();
+    const checkedAt = clock.nowIso();
+    let supported;
+    const kinds = () => {
+      supported ??= remoteBinding.supported().then((response) => response.kinds);
+      return supported;
+    };
+    const results = await Promise.all(
+      offers.map(
+        (offer) => offerHealth(offer, kinds).catch((err) => ({
+          status: "fail",
+          detail: `x402 health check failed: ${redactedErrorText(err)}`
+        }))
+      )
+    );
+    const failed = results.some((result) => result.status === "fail");
+    const details = offers.flatMap((offer, index) => {
+      const result = results[index];
+      if (failed && result.status !== "fail") return [];
+      return [offers.length === 1 ? result.detail : `${x402OfferName(offer)}: ${result.detail}`];
+    });
+    return {
+      status: failed ? "fail" : "pass",
+      detail: details.join("; "),
+      components: offers.map((offer, index) => ({
+        name: x402OfferName(offer),
+        status: results[index].status
+      })),
+      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 health;
+}
+var PERMIT2_CONTRACTS = [
+  ["Permit2", PERMIT2_ADDRESS],
+  ["x402 exact Permit2 proxy", x402ExactPermit2ProxyAddress]
+];
+var TOKEN_PROGRAMS = /* @__PURE__ */ new Set([
+  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+  "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+]);
+function readMint(result) {
+  const value = isRecord(result) ? result["value"] : void 0;
+  if (!isRecord(value)) return void 0;
+  const owner = value["owner"];
+  if (typeof owner !== "string" || !TOKEN_PROGRAMS.has(owner)) return void 0;
+  const data = value["data"];
+  if (!Array.isArray(data) || typeof data[0] !== "string") return void 0;
+  const bytes = Buffer.from(data[0], "base64");
+  const decimals = bytes[44];
+  return bytes.length >= 82 && bytes[45] === 1 && decimals !== void 0 ? { decimals, tokenProgram: owner } : void 0;
+}
+async function jsonRpc(rpcUrl, method, params) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+    signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS)
+  });
+  const body = await response.json();
+  if (body.error !== void 0) {
+    throw new CommerceError(
+      "PAYMENT_PROVIDER_UNAVAILABLE",
+      `RPC ${method} failed: ${JSON.stringify(body.error)}`
+    );
+  }
+  return body.result;
+}
+async function nearView(rpcUrl, accountId, method, args) {
+  const result = await jsonRpc(rpcUrl, "query", {
+    request_type: "call_function",
+    finality: "final",
+    account_id: accountId,
+    method_name: method,
+    args_base64: Buffer.from(JSON.stringify(args)).toString("base64")
+  });
+  const bytes = isRecord(result) ? result["result"] : void 0;
+  if (!Array.isArray(bytes)) {
+    throw new CommerceError(
+      "PAYMENT_PROVIDER_UNAVAILABLE",
+      `NEAR view ${method} returned no result`
+    );
+  }
+  return JSON.parse(Buffer.from(bytes).toString("utf8"));
+}
+var NEAR_EMPTY_CODE_HASH = "11111111111111111111111111111111";
+async function probeIsAnvilNode(client) {
+  const request = client.request;
+  try {
+    await request({ method: "anvil_nodeInfo", params: [] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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, chainId) {
+  const chain = buildLocalChain(rpcUrl, chainId);
+  const account = privateKeyToAccount(signerPrivateKey);
+  return createWalletClient({
+    account,
+    chain,
+    transport: http(rpcUrl)
+  }).extend(publicActions);
+}
+var SETTLEMENT_CONFIRMATION_TIMEOUT_MS = 6e4;
+var SUPPORTED_TIMEOUT_MS = 1e4;
+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 } : {}
+  });
+  const supportedClient = new HTTPFacilitatorClient({
+    url: options.url,
+    timeoutMs: SUPPORTED_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
+      };
+    },
+    supported: () => withDeadline(supportedClient.getSupported(), SUPPORTED_TIMEOUT_MS)
+  };
+}
+function withDeadline(call, ms) {
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          `x402 provider: facilitator /supported did not answer within ${ms / 1e3} s`
+        )
+      ),
+      ms
+    );
+    timer.unref();
+  });
+  return Promise.race([call, deadline]).finally(() => clearTimeout(timer));
+}
+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
+      };
+    }
+  };
+}
+var SETTLEMENT_PENDING_REASON = "settlement_pending";
+var TRANSACTION_FAILED_REASONS = [
+  "invalid_exact_evm_transaction_failed",
+  "invalid_exact_svm_transaction_failed",
+  "settlement_failed"
+];
+var isTransactionFailedReason = (reason) => reason !== void 0 && TRANSACTION_FAILED_REASONS.some((known) => reason === known || reason.startsWith(`${known}:`));
+var ON_CHAIN_FAILURE_REASONS = {
+  evm: "invalid_exact_evm_transaction_failed",
+  svm: "invalid_exact_svm_transaction_failed",
+  near: "settlement_failed"
+};
+var UNKNOWN_OUTCOME_REASONS = /* @__PURE__ */ new Set([
+  "duplicate_settlement",
+  "post_settlement_transfer_not_confirmed"
+]);
+var NO_VERDICT_REASONS = /* @__PURE__ */ new Set([
+  "unexpected_verify_error",
+  "invalid_exact_near_no_relayer_configured",
+  "invalid_exact_near_current_block_height_unavailable",
+  "invalid_exact_near_access_key_lookup_failed",
+  "invalid_exact_near_account_lookup_failed",
+  "invalid_exact_near_token_account_lookup_failed",
+  "invalid_exact_near_balance_check_failed",
+  "invalid_exact_near_storage_check_failed",
+  "invalid_exact_svm_payload_missing_fee_payer",
+  "invalid_exact_svm_fee_payer_not_managed_by_facilitator",
+  "invalid_exact_svm_unsupported_scheme",
+  "invalid_exact_svm_network_mismatch"
+]);
+var NEAR_PRE_SUBMISSION_REASONS = /* @__PURE__ */ new Set([
+  "invalid_x402_version",
+  "unsupported_scheme",
+  "invalid_network",
+  "insufficient_funds",
+  "verification_failed"
+]);
+var isNearVerdict = (reason) => reason !== void 0 && (reason === "settlement_failed" || reason.startsWith("invalid_exact_near_") || NEAR_PRE_SUBMISSION_REASONS.has(reason));
+var MAX_REASON_LENGTH = 128;
+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;
+}
+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");
+}
+
+// src/payments/x402/provider/offers.ts
+function resolveOffers(inputs, options) {
+  let remoteBinding;
+  let mode;
+  const built = /* @__PURE__ */ new Map();
+  const resolveList = (list, field) => {
+    const seen = /* @__PURE__ */ new Set();
+    return list.map((input, index) => {
+      const at = (name) => field(index, name);
+      const known = findX402Network(input.network, options.customNetworks);
+      if (known !== void 0 && known.family !== "evm") {
+        const shape = known.family === "svm" ? "a Solana address (base58, 32 bytes)" : "a NEAR account ID";
+        for (const name of ["asset", "payTo"]) {
+          if (normalizeAddress(known, input[name]) === void 0) {
+            throw new CommerceError("CONFIG_INVALID", `x402 provider: ${at(name)} is not ${shape}`);
+          }
+        }
+        if (input.assetTransferMethod !== void 0) {
+          throw new CommerceError(
+            "CONFIG_INVALID",
+            `x402 provider: ${at("assetTransferMethod")} applies to EVM networks only`
+          );
+        }
+      } else {
+        if (!isAddress(input.asset)) {
+          throw new CommerceError(
+            "CONFIG_INVALID",
+            `x402 provider: ${at("asset")} is not a valid EVM address (0x and 40 hex characters; a mixed-case address needs a valid EIP-55 checksum)`
+          );
+        }
+        if (!isAddress(input.payTo)) {
+          throw new CommerceError(
+            "CONFIG_INVALID",
+            `x402 provider: ${at("payTo")} is not a valid EVM address (0x and 40 hex characters; a mixed-case address needs a valid EIP-55 checksum)`
+          );
+        }
+        assertPayToIsNotDevAddress(input.rpcUrl, input.payTo);
+        if ((input.assetTransferMethod ?? "eip3009") === "eip3009" && (!input.assetName || !input.assetVersion)) {
+          throw new CommerceError(
+            "CONFIG_INVALID",
+            `x402 provider: an EIP-3009 offer needs ${at("assetName")} and ${at("assetVersion")}, the token's EIP-712 domain`
+          );
+        }
+      }
+      if (!Number.isInteger(input.assetDecimals) || input.assetDecimals < 0) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `x402 provider: ${at("assetDecimals")} must be a non-negative integer`
+        );
+      }
+      const deployment = resolveX402Deployment({
+        network: input.network,
+        ...options.customNetworks !== void 0 ? { customNetworks: options.customNetworks } : {},
+        payTo: input.payTo,
+        asset: input.asset,
+        ...input.assetName !== void 0 ? { assetName: input.assetName } : {},
+        ...input.assetVersion !== void 0 ? { assetVersion: input.assetVersion } : {},
+        facilitator: options.facilitator,
+        ...options.allowMainnet !== void 0 ? { allowMainnet: options.allowMainnet } : {},
+        ...options.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: options.allowUnauthenticatedFacilitator } : {}
+      });
+      const profile = deployment.profile;
+      if (mode !== void 0 && deployment.mode !== mode) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `x402 provider: offers mix ${mode} and ${deployment.mode} networks; every offer must be on a ${mode} network`
+        );
+      }
+      mode = deployment.mode;
+      const comparable = (value) => profile.family === "evm" ? value.toLowerCase() : value;
+      const key = `${input.network}|${comparable(input.asset)}|${comparable(input.payTo)}`;
+      if (seen.has(key)) {
+        throw new CommerceError(
+          "CONFIG_INVALID",
+          `x402 provider: ${at("network")} repeats an earlier offer of the same asset to the same payTo on ${input.network}`
+        );
+      }
+      seen.add(key);
+      const identity = [
+        key,
+        input.assetTransferMethod ?? "eip3009",
+        input.assetName,
+        input.assetVersion,
+        input.assetDecimals,
+        input.rpcUrl
+      ].join("|");
+      const existing = built.get(identity);
+      if (existing !== void 0) return existing;
+      let binding;
+      if (options.facilitator.mode === "local") {
+        assertDevKeyIsLocalOnly(input.rpcUrl, options.facilitator.signerPrivateKey);
+        let client;
+        try {
+          client = createLocalFacilitatorClient(
+            input.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, input.network, isProviderUnavailableError);
+      } else {
+        remoteBinding ??= createRemoteFacilitatorBinding({
+          url: options.facilitator.url,
+          auth: options.facilitator.auth
+        });
+        binding = remoteBinding;
+      }
+      const base = {
+        network: input.network,
+        assetDecimals: input.assetDecimals,
+        rpcUrl: input.rpcUrl,
+        rpcOrigin: describeRpc(input.rpcUrl),
+        binding
+      };
+      const offer = profile.family === "svm" ? { ...base, family: "svm", profile, asset: input.asset, payTo: input.payTo } : profile.family === "near" ? { ...base, family: "near", profile, asset: input.asset, payTo: input.payTo } : {
+        ...base,
+        family: "evm",
+        profile,
+        method: input.assetTransferMethod ?? "eip3009",
+        asset: input.asset,
+        assetName: input.assetName,
+        assetVersion: input.assetVersion,
+        payTo: input.payTo,
+        healthClient: createLocalPublicClient(
+          input.rpcUrl,
+          HEALTH_TIMEOUT_MS,
+          profile.chainId
+        )
+      };
+      built.set(identity, offer);
+      return offer;
+    });
+  };
+  const offers = resolveList(
+    inputs,
+    (index, name) => inputs.length === 1 ? `"${name}"` : `"offers[${index}].${name}"`
+  );
+  const resourceOffers = new Map(
+    Object.entries(options.resourceOffers ?? {}).map(([id, list]) => {
+      if (list.length === 0) {
+        throw new CommerceError("CONFIG_INVALID", `x402 provider: "resourceOffers.${id}" is empty`);
+      }
+      return [id, resolveList(list, (index, name) => `"resourceOffers.${id}[${index}].${name}"`)];
+    })
+  );
+  return {
+    offers,
+    resourceOffers,
+    pool: [...built.values()],
+    deploymentMode: mode,
+    remoteBinding
+  };
+}
+function offerCurrency(offer, quoted) {
+  const canonical = offer.profile.canonicalAsset;
+  return canonical !== void 0 && sameAddress(offer.profile, offer.asset, canonical.address) ? canonical.symbol : quoted;
+}
+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 forFacilitator(payload) {
+  const { resource: _resource, extensions: _extensions, ...rest } = payload;
+  return rest;
+}
+function decodeJson(payloadBase64) {
+  try {
+    return JSON.parse(Buffer.from(payloadBase64, "base64").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function isExactEvmPayload(payload) {
+  const inner = payload.payload;
+  return payload.accepted.scheme === "exact" && isRecord(inner) && isRecord(inner["authorization"]) && !("permit2Authorization" in inner) && typeof inner["signature"] === "string";
+}
+var UINT256 = /^(0|[1-9]\d{0,77})$/;
+var UINT256_MAX = 2n ** 256n - 1n;
+var BYTES32 = /^0x[0-9a-fA-F]{64}$/;
+var isUint256 = (value) => typeof value === "string" && UINT256.test(value) && BigInt(value) <= UINT256_MAX;
+function hasEip3009Fields(authorization) {
+  return isEvmAddress(authorization["from"]) && isEvmAddress(authorization["to"]) && isUint256(authorization["value"]) && isUint256(authorization["validAfter"]) && isUint256(authorization["validBefore"]) && typeof authorization["nonce"] === "string" && BYTES32.test(authorization["nonce"]);
+}
+function isExactPermit2Payload(payload) {
+  const inner = payload.payload;
+  if (payload.accepted.scheme !== "exact" || !isRecord(inner)) return false;
+  const auth = inner["permit2Authorization"];
+  if (!isRecord(auth) || "authorization" in inner || typeof inner["signature"] !== "string") {
+    return false;
+  }
+  const { permitted, witness } = auth;
+  return isRecord(permitted) && isRecord(witness) && isEvmAddress(auth["from"]) && isEvmAddress(auth["spender"]) && isEvmAddress(permitted["token"]) && isEvmAddress(witness["to"]) && isUint256(permitted["amount"]) && isUint256(auth["nonce"]) && isUint256(auth["deadline"]) && isUint256(witness["validAfter"]);
+}
+
+// src/payments/x402/provider/requirement.ts
+var SELECTED_OFFER_KEY = "x402.offer";
+function offerIndexOf(requirement) {
+  const selected = requirement.metadata?.[SELECTED_OFFER_KEY];
+  if (typeof selected === "number") return selected;
+  return requirement.challenge.accepts.length <= 1 ? 0 : void 0;
+}
+function acceptedMatchesOffer(offered, accepted, network) {
+  if (!network) return false;
+  const same = (a, b) => sameAddress(network, a, b);
+  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 && same(accepted.asset, offered.asset) && same(accepted.payTo, offered.payTo) && Object.entries(offeredExtra).every(([key, value]) => acceptedExtra[key] === value) && flow(acceptedExtra) === flow(offeredExtra);
+}
+function createRequirementBuilders(ctx, svmFeePayer) {
+  const { options, offersFor, clock, ids, maxTimeoutSeconds } = ctx;
+  async function createRequirement(context) {
+    const offers = offersFor(context.resource.id);
+    const paymentFlow = options.resourcePaymentFlows?.[context.resource.id] ?? options.paymentFlow ?? X402_DEFAULT_PAYMENT_FLOW;
+    const flow = paymentFlow === "upfront" ? { paymentFlow } : {};
+    const accepts = await Promise.all(
+      offers.map(async (offer) => ({
+        scheme: "exact",
+        network: offer.network,
+        asset: offer.asset,
+        amount: parseCanonicalAmount(context.amount, offer.assetDecimals).toString(),
+        payTo: offer.payTo,
+        maxTimeoutSeconds,
+        // EIP-3009 needs `name`/`version` for a shared EIP-712 domain without
+        // a token `version()` call; Permit2 uses its own domain. EVM clients
+        // sign the named `assetTransferMethod`. Solana needs the facilitator's
+        // fee payer; NEAR needs no scheme-specific extra because the
+        // facilitator chooses its relayer.
+        extra: offer.family === "svm" ? { feePayer: await svmFeePayer(offer), ...flow } : offer.family === "near" ? { ...flow } : {
+          ...offer.assetName !== void 0 ? { name: offer.assetName } : {},
+          ...offer.assetVersion !== void 0 ? { version: offer.assetVersion } : {},
+          assetTransferMethod: offer.method,
+          ...flow
+        }
+      }))
+    );
+    const single = offers.length === 1 ? offers[0] : void 0;
+    const resourceId = encodeURIComponent(context.resource.id);
+    const envelope = {
+      x402Version: X402_VERSION,
+      resource: {
+        url: single ? `resource://agent-commerce/${encodeURIComponent(single.network)}/${single.payTo}/resources/${resourceId}` : `resource://agent-commerce/resources/${resourceId}`,
+        description: context.resource.description ?? context.resource.name,
+        // The media type the merchant declares, else `application/json`; an HTTP
+        // delivery carries the backend's own type when it is text and fits the body
+        mimeType: options.resourceMimeTypes?.[context.resource.id] ?? DEFAULT_MIME_TYPE
+      },
+      accepts
+    };
+    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,
+      // Several offers name several destinations; selection fills these in
+      ...single ? { destination: single.payTo, network: single.network, asset: single.asset } : {},
+      expiresAt,
+      challenge: {
+        provider: "x402",
+        version: X402_PROTOCOL_VERSION,
+        accepts,
+        envelope
+      },
+      metadata: {
+        [SETTLE_AFTER_BACKEND_METADATA_KEY]: paymentFlow === "authorization",
+        // The SDK server keeps no record of a payload whose handler or
+        // settlement failed and verifies it again; the chain spends it once
+        [REUSE_REJECTED_AUTHORIZATION_METADATA_KEY]: true
+      }
+    };
+  }
+  async function selectRequirement(context) {
+    const { requirement, submission } = context;
+    const offered = requirement.challenge.accepts;
+    if (offered.length < 2) return requirement;
+    const offers = offersFor(requirement.resourceId);
+    const payload = decodePaymentSubmission(submission.payload);
+    if (!payload) return requirement;
+    const matches = offered.flatMap(
+      (offer2, index2) => acceptedMatchesOffer(offer2, payload.accepted, offers[index2]?.profile) ? [index2] : []
+    );
+    const index = matches.length === 1 ? matches[0] : void 0;
+    const offer = index === void 0 ? void 0 : offers[index];
+    if (index === void 0 || !offer) return requirement;
+    return {
+      ...requirement,
+      destination: offer.payTo,
+      network: offer.network,
+      asset: offer.asset,
+      metadata: { ...requirement.metadata, [SELECTED_OFFER_KEY]: index }
+    };
+  }
+  return { createRequirement, selectRequirement };
+}
+function readTransfer(payload, offer) {
+  const { chainId } = offer.profile;
+  if (offer.method === "eip3009") {
+    if (!isExactEvmPayload(payload)) return "unsupported_scheme";
+    const { authorization } = payload.payload;
+    const { from: from2, to, value, nonce: nonce2 } = authorization;
+    if (!hasEip3009Fields(authorization) || !isAddress(from2) || !isAddress(to)) {
+      return "invalid_payload";
+    }
+    return {
+      from: getAddress(from2),
+      to: getAddress(to),
+      value,
+      replayKey: computeReplayKey({
+        chainId,
+        asset: getAddress(offer.asset),
+        from: getAddress(from2),
+        nonce: nonce2
+      }),
+      recipientMismatch: "invalid_exact_evm_payload_recipient_mismatch",
+      amountMismatch: "invalid_exact_evm_payload_authorization_value_mismatch"
+    };
+  }
+  if (!isExactPermit2Payload(payload)) return "unsupported_scheme";
+  const { from, spender, permitted, witness, nonce } = payload.payload.permit2Authorization;
+  if (getAddress(spender) !== getAddress(x402ExactPermit2ProxyAddress)) {
+    return "invalid_permit2_spender";
+  }
+  if (getAddress(permitted.token) !== getAddress(offer.asset)) return "permit2_token_mismatch";
+  return {
+    from: getAddress(from),
+    to: getAddress(witness.to),
+    value: permitted.amount,
+    replayKey: computePermit2ReplayKey({ chainId, owner: getAddress(from), nonce }),
+    recipientMismatch: "invalid_permit2_recipient_mismatch",
+    amountMismatch: "permit2_amount_mismatch"
+  };
+}
+
+// src/payments/x402/provider/settle.ts
+function createSettle(ctx) {
+  const { offersFor, clock, logger } = ctx;
+  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 index = offerIndexOf(requirement);
+    const offer = index === void 0 ? void 0 : offersFor(requirement.resourceId)[index];
+    const requirements = index === void 0 ? void 0 : requirement.challenge.accepts[index];
+    if (!offer || !requirements) {
+      throw new CommerceError(
+        "PAYMENT_INVALID",
+        "x402 provider: settle() found no payment requirements to settle against"
+      );
+    }
+    const payload = decodePaymentSubmission(submission.payload);
+    const transfer = payload && offer.family === "evm" ? readTransfer(payload, offer) : void 0;
+    if (!payload || typeof transfer === "string") {
+      throw new CommerceError(
+        "PAYMENT_INVALID",
+        "x402 provider: settle() received an undecodable payment payload"
+      );
+    }
+    const reference = (value) => isTransactionReference(offer.profile, value);
+    const rejectedSettlement = (rejectionReason) => ({
+      status: "rejected",
+      provider: "x402",
+      amount: verification.amount,
+      currency: verification.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 = offer.binding.open();
+    let sdkResult;
+    try {
+      sdkResult = await scope.settle(forFacilitator(payload), requirements);
+    } catch (err) {
+      if (isProviderUnavailableError(err) || scope.transportFailed()) {
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          `x402 provider: ${offer.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");
+    }
+    const payer = verification.payer ?? sdkResult.payer;
+    if (!sdkResult.success) {
+      if (isTransactionFailedReason(sdkResult.errorReason) && !reference(sdkResult.transaction)) {
+        logger.warn(
+          { reportedReason: redactedErrorText(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 (offer.family === "near" && NO_VERDICT_REASONS.has(sdkResult.errorReason ?? "") && !sdkResult.transaction) {
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "x402 provider: the facilitator could not check the payment before submitting it",
+          {
+            details: {
+              settlementNotSubmitted: true,
+              reason: sanitizeReason(sdkResult.errorReason, "facilitator_unavailable")
+            }
+          }
+        );
+      }
+      if (sdkResult.errorReason === SETTLEMENT_PENDING_REASON || sdkResult.errorMessage?.startsWith(SETTLEMENT_PENDING_REASON) === true || UNKNOWN_OUTCOME_REASONS.has(sdkResult.errorReason ?? "") || NO_VERDICT_REASONS.has(sdkResult.errorReason ?? "") || 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.transaction && sdkResult.errorReason !== ON_CHAIN_FAILURE_REASONS[offer.family]) {
+        logger.warn(
+          { reportedReason: redactedErrorText(sdkResult.errorReason ?? "") },
+          "x402 settle(): the facilitator reported a failure with a transaction; outcome unknown"
+        );
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "x402 provider: the facilitator reported a failed settlement with a transaction; outcome unknown",
+          { details: { transactionHash: sdkResult.transaction } }
+        );
+      }
+      if (offer.family === "near" && !isNearVerdict(sdkResult.errorReason)) {
+        logger.warn(
+          { reportedReason: redactedErrorText(sdkResult.errorReason ?? "") },
+          "x402 settle(): NEAR facilitator failure reason is not a verdict; outcome unknown"
+        );
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "x402 provider: settlement failed with an unclassified error; outcome unknown"
+        );
+      }
+      if (sdkResult.errorReason !== void 0) {
+        logger.debug(
+          { reportedReason: redactedErrorText(sdkResult.errorReason) },
+          "x402 settle(): facilitator failure reason"
+        );
+      }
+      return {
+        ...rejectedSettlement(sanitizeReason(sdkResult.errorReason, "settlement_failed")),
+        network: sdkResult.network,
+        ...payer !== void 0 ? { payer } : {},
+        // The failed transaction, which the facilitator paid for
+        ...sdkResult.transaction ? { externalReference: sdkResult.transaction } : {}
+      };
+    }
+    if (!reference(sdkResult.transaction) || sdkResult.network !== offer.network) {
+      logger.warn(
+        { network: sdkResult.network },
+        "x402 settle(): the facilitator reported a success it did not identify; outcome unknown"
+      );
+      throw new CommerceError(
+        "PAYMENT_PROVIDER_UNAVAILABLE",
+        "x402 provider: the facilitator reported a settlement without a valid transaction; outcome unknown"
+      );
+    }
+    return {
+      status: "settled",
+      provider: "x402",
+      externalReference: sdkResult.transaction,
+      ...payer !== void 0 ? { payer } : {},
+      payee: requirements.payTo,
+      amount: verification.amount,
+      currency: verification.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. verify() matched an EVM authorization's value to the offer.
+      metadata: {
+        amountBaseUnits: transfer?.value ?? requirements.amount,
+        // The resource's own price, when it names a currency other than the token
+        ...verification.currency !== requirement.currency ? { quote: { amount: requirement.amount, currency: requirement.currency } } : {}
+      }
+    };
+  }
+  return settle;
+}
+function createVerify(ctx) {
+  const { offersFor, clock, logger, svm, near } = ctx;
+  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 index = offerIndexOf(requirement);
+    if (index === void 0) {
+      return rejected("invalid_payment_requirements");
+    }
+    const offer = offersFor(requirement.resourceId)[index];
+    const requirements = requirement.challenge.accepts[index];
+    if (!offer || !requirements) {
+      return rejected("missing_payment_requirements");
+    }
+    if (requirement.expiresAt !== void 0 && Date.parse(requirement.expiresAt) < clock.now().getTime()) {
+      return rejected("requirement_expired");
+    }
+    if (!sameAddress(offer.profile, requirements.asset, offer.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");
+    }
+    let transfer;
+    let replayKey;
+    let derivedPayer;
+    if (offer.family === "svm") {
+      const identity = (await svm()).svmReplayKey(payload.payload, offer.network);
+      if (typeof identity === "string") return rejected(identity);
+      replayKey = identity.replayKey;
+    } else if (offer.family === "near") {
+      const inspected = (await near()).inspectNearPayload(payload.payload, {
+        network: offer.network,
+        asset: offer.asset,
+        payTo: offer.payTo,
+        amount: requirements.amount
+      });
+      if (typeof inspected === "string") return rejected(inspected);
+      replayKey = inspected.replayKey;
+      derivedPayer = inspected.payer;
+    } else {
+      const read = readTransfer(payload, offer);
+      if (typeof read === "string") return rejected(read);
+      transfer = read;
+      replayKey = read.replayKey;
+      derivedPayer = read.from;
+    }
+    if (payload.accepted.network !== offer.network) {
+      return rejected("invalid_network");
+    }
+    const offeredUrl = requirement.challenge.envelope?.resource?.url;
+    if (!acceptedMatchesOffer(requirements, payload.accepted, offer.profile) || payload.resource !== void 0 && payload.resource.url !== offeredUrl) {
+      return rejected("invalid_payment_requirements");
+    }
+    let required;
+    try {
+      required = BigInt(requirements.amount);
+    } catch {
+      return rejected("invalid_payload");
+    }
+    if (transfer) {
+      if (transfer.to !== getAddress(offer.payTo)) {
+        return rejected(transfer.recipientMismatch);
+      }
+      let authorizedValue;
+      try {
+        authorizedValue = BigInt(transfer.value);
+      } catch {
+        return rejected("invalid_payload");
+      }
+      if (authorizedValue !== required) {
+        return rejected(transfer.amountMismatch);
+      }
+    }
+    const scope = offer.binding.open();
+    let sdkResult;
+    try {
+      sdkResult = await scope.verify(forFacilitator(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: ${offer.binding.kind} facilitator returned no verdict during verify()`,
+        { cause: err }
+      );
+    }
+    if (!sdkResult.isValid) {
+      if (scope.transportFailed() || NO_VERDICT_REASONS.has(sdkResult.invalidReason ?? "")) {
+        if (sdkResult.invalidReason !== void 0) {
+          logger.debug(
+            { reportedReason: redactedErrorText(sdkResult.invalidReason) },
+            "x402 verify(): local facilitator transport failure reason"
+          );
+        }
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          `x402 provider: ${offer.binding.kind} facilitator unreachable during verify()`
+        );
+      }
+      if (sdkResult.invalidReason !== void 0) {
+        logger.debug(
+          { reportedReason: redactedErrorText(sdkResult.invalidReason) },
+          "x402 verify(): facilitator rejection reason"
+        );
+      }
+      return rejected(sanitizeReason(sdkResult.invalidReason, "invalid_payment"));
+    }
+    const payer = derivedPayer ?? (sdkResult.payer !== void 0 && normalizeAddress(offer.profile, sdkResult.payer) ? sdkResult.payer : void 0);
+    return {
+      status: "verified",
+      provider: "x402",
+      ...payer !== void 0 ? { payer } : {},
+      payee: transfer?.to ?? offer.payTo,
+      amount: formatUnits(required, offer.assetDecimals),
+      currency: offerCurrency(offer, requirement.currency),
+      network: payload.accepted.network,
+      asset: offer.family === "evm" ? getAddress(requirements.asset) : offer.asset,
+      replayKey
+    };
+  }
+  return verify;
+}
+
+// src/payments/x402/provider/index.ts
+function createX402PaymentProvider(options) {
+  const inputs = "offers" in options ? options.offers : [options];
+  if (inputs.length === 0) {
+    throw new CommerceError("CONFIG_INVALID", 'x402 provider: "offers" is empty');
+  }
+  if (options.maxTimeoutSeconds !== void 0 && (!Number.isInteger(options.maxTimeoutSeconds) || options.maxTimeoutSeconds <= 0)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `x402 provider: maxTimeoutSeconds must be a positive integer (got ${options.maxTimeoutSeconds})`
+    );
+  }
+  const {
+    offers: defaultOffers,
+    resourceOffers,
+    pool: offers,
+    deploymentMode,
+    remoteBinding
+  } = resolveOffers(inputs, options);
+  const offersFor = (resourceId) => resourceOffers.get(resourceId) ?? defaultOffers;
+  const severalOffers = [defaultOffers, ...resourceOffers.values()].some((list) => list.length > 1);
+  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 evmOffers = offers.filter((offer) => offer.family === "evm");
+  const hasSvm = offers.some((offer) => offer.family === "svm");
+  const hasNear = offers.some((offer) => offer.family === "near");
+  const descriptor = {
+    name: "x402",
+    kind: "payment",
+    implementationVersion: PACKAGE_VERSION,
+    supportedSpec: `x402/v${X402_VERSION} scheme=exact family=${[
+      ...evmOffers.length > 0 ? ["eip155"] : [],
+      ...hasSvm ? ["solana"] : [],
+      ...hasNear ? ["near"] : []
+    ].join(",")}`,
+    capabilities: [
+      ...evmOffers.length > 0 ? ["exact-evm"] : [],
+      ...hasSvm ? ["exact-svm"] : [],
+      ...hasNear ? ["exact-near"] : [],
+      `${options.facilitator.mode}-facilitator`,
+      ...evmOffers.some((offer) => offer.method === "eip3009") ? ["eip-3009"] : [],
+      ...evmOffers.some((offer) => offer.method === "permit2") ? ["permit2"] : [],
+      "caip-2",
+      `mode=${deploymentMode}`,
+      "authorization-flow",
+      "upfront-flow",
+      ...severalOffers ? ["multiple-offers"] : []
+    ],
+    status: "stable",
+    unsupported: [
+      "permit2 gas sponsoring extensions",
+      "upto scheme",
+      "batch-settlement scheme",
+      "auth-capture scheme"
+    ]
+  };
+  const svmModule = hasSvm ? loadOptionalModule(() => import('./svm-3MMYFPC7.js'), "Solana offers need @x402/svm and @solana/kit") : void 0;
+  const nearModule = hasNear ? loadOptionalModule(() => import('./near-5AY3HWYF.js'), "NEAR offers need @x402/near") : void 0;
+  const svm = async () => {
+    if (!svmModule)
+      throw new CommerceError("INTERNAL_ERROR", "x402 provider: no Solana offer is configured");
+    return svmModule;
+  };
+  const near = async () => {
+    if (!nearModule)
+      throw new CommerceError("INTERNAL_ERROR", "x402 provider: no NEAR offer is configured");
+    return nearModule;
+  };
+  const ctx = {
+    options,
+    offers,
+    offersFor,
+    deploymentMode,
+    remoteBinding,
+    clock,
+    ids,
+    logger,
+    maxTimeoutSeconds,
+    svm,
+    near
+  };
+  const { createRequirement, selectRequirement } = createRequirementBuilders(
+    ctx,
+    createSvmFeePayerSource(ctx)
+  );
+  const verify = createVerify(ctx);
+  const settle = createSettle(ctx);
+  const health = createHealthCheck(ctx);
+  return {
+    name: "x402",
+    descriptor,
+    createRequirement,
+    // A single offer needs no selection
+    ...severalOffers ? { selectRequirement } : {},
+    verify,
+    settle,
+    health
+  };
+}
+function loadOptionalModule(load, missing) {
+  const loading = load().catch((cause) => {
+    throw new CommerceError("PAYMENT_PROVIDER_UNAVAILABLE", `x402 provider: ${missing}`, {
+      cause
+    });
+  });
+  loading.catch(() => {
+  });
+  return loading;
+}
+
+export { DEFAULT_IDS, chainIdFromCaip2, createX402PaymentProvider, parseCanonicalAmount };
+//# sourceMappingURL=chunk-KLX2YZDG.js.map
+//# sourceMappingURL=chunk-KLX2YZDG.js.map