@devlab.group/agent-commerce 2.0.0 → 2.1.0

package/dist/chunk-IFGRCXME.js

@@ -0,0 +1,581 @@
+import { CommerceError } from './chunk-SY6GUYSQ.js';
+
+// src/payments/x402/networks.ts
+var LOCAL_CHAIN_ID = 31337;
+var usdc = (address, name) => ({ symbol: "USDC", address, name, version: "2", decimals: 6 });
+var PROFILES = [
+  {
+    family: "evm",
+    id: `eip155:${LOCAL_CHAIN_ID}`,
+    chainId: LOCAL_CHAIN_ID,
+    displayName: "Local Anvil",
+    kind: "testnet",
+    local: true
+  },
+  {
+    family: "evm",
+    id: "eip155:84532",
+    chainId: 84532,
+    displayName: "Base Sepolia",
+    kind: "testnet",
+    canonicalAsset: usdc("0x036CbD53842c5426634e7929541eC2318f3dCF7e", "USDC")
+  },
+  {
+    family: "evm",
+    id: "eip155:8453",
+    chainId: 8453,
+    displayName: "Base",
+    kind: "mainnet",
+    canonicalAsset: usdc("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "USD Coin")
+  },
+  {
+    family: "evm",
+    id: "eip155:1",
+    chainId: 1,
+    displayName: "Ethereum",
+    kind: "mainnet",
+    canonicalAsset: usdc("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "USD Coin")
+  },
+  {
+    family: "evm",
+    id: "eip155:137",
+    chainId: 137,
+    displayName: "Polygon",
+    kind: "mainnet",
+    canonicalAsset: usdc("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", "USD Coin")
+  },
+  {
+    family: "evm",
+    id: "eip155:42161",
+    chainId: 42161,
+    displayName: "Arbitrum One",
+    kind: "mainnet",
+    canonicalAsset: usdc("0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "USD Coin")
+  },
+  {
+    family: "evm",
+    id: "eip155:421614",
+    chainId: 421614,
+    displayName: "Arbitrum Sepolia",
+    kind: "testnet",
+    canonicalAsset: usdc("0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d", "USD Coin")
+  },
+  {
+    family: "evm",
+    id: "eip155:43114",
+    chainId: 43114,
+    displayName: "Avalanche C-Chain",
+    kind: "mainnet",
+    canonicalAsset: usdc("0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", "USD Coin")
+  },
+  {
+    family: "svm",
+    id: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+    displayName: "Solana",
+    kind: "mainnet",
+    canonicalAsset: {
+      symbol: "USDC",
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      decimals: 6
+    }
+  },
+  {
+    family: "svm",
+    id: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    displayName: "Solana Devnet",
+    kind: "testnet",
+    canonicalAsset: {
+      symbol: "USDC",
+      address: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+      decimals: 6
+    }
+  },
+  // NEAR's USDC contracts are implicit accounts: 64 lowercase hex characters
+  {
+    family: "near",
+    id: "near:mainnet",
+    displayName: "NEAR",
+    kind: "mainnet",
+    canonicalAsset: {
+      symbol: "USDC",
+      address: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      decimals: 6
+    }
+  },
+  {
+    family: "near",
+    id: "near:testnet",
+    displayName: "NEAR Testnet",
+    kind: "testnet",
+    canonicalAsset: {
+      symbol: "USDC",
+      address: "3e2210e1184b45b64c8a434c0a7e7b23cc04ea7eb7a6c3c32520d03d4afcb8af",
+      decimals: 6
+    }
+  }
+];
+var BY_ID = new Map(PROFILES.map((profile) => [profile.id, profile]));
+var SUPPORTED_NETWORK_IDS = PROFILES.filter(
+  (p) => p.family === "evm"
+).map((p) => p.id);
+var EVM_NETWORK_ID = /^eip155:([1-9]\d{0,15})$/;
+function invalid(message, path) {
+  return new CommerceError("CONFIG_INVALID", message, { details: { path } });
+}
+function findX402Network(id, custom) {
+  const builtIn = BY_ID.get(id);
+  if (builtIn) return builtIn;
+  const declared = custom?.[id];
+  const chainId = Number(EVM_NETWORK_ID.exec(id)?.[1]);
+  if (!declared || !Number.isSafeInteger(chainId)) return void 0;
+  return {
+    family: "evm",
+    id,
+    chainId,
+    displayName: declared.displayName,
+    kind: declared.kind
+  };
+}
+function requireX402Network(id, path, custom) {
+  const network = findX402Network(id, custom);
+  if (!network) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `${path}: "${id}" is not a known network. Built-in CAIP-2 identifiers: ${PROFILES.map((p) => p.id).join(", ")}. Declare another EVM network under payments.x402.networks with its kind and displayName.`,
+      { details: { path, network: id } }
+    );
+  }
+  return network;
+}
+function validateCustomNetworks(custom, path) {
+  for (const id of Object.keys(custom)) {
+    const at = `${path}.${id}`;
+    if (BY_ID.has(id)) {
+      throw invalid(
+        `${at}: "${id}" is a built-in network and cannot be redeclared; remove this entry`,
+        at
+      );
+    }
+    if (!findX402Network(id, custom)) {
+      throw invalid(
+        `${at}: "${id}" is not an EVM CAIP-2 identifier ("eip155:" followed by a positive chain id below 2^53). Only EVM networks can be declared.`,
+        at
+      );
+    }
+  }
+}
+function resolveDeploymentMode(profile) {
+  return profile.local ? "local" : profile.kind;
+}
+var LIVE_MAINNET_BANNER = "LIVE MAINNET MODE - REAL FUNDS";
+function describeDeploymentMode(mode) {
+  return mode === "mainnet" ? LIVE_MAINNET_BANNER : mode.toUpperCase();
+}
+
+// src/core/execution/settlement-order.ts
+var SETTLE_AFTER_BACKEND_METADATA_KEY = "settleAfterBackend";
+var REUSE_REJECTED_AUTHORIZATION_METADATA_KEY = "reuseRejectedAuthorization";
+
+// src/payments/x402/addresses.ts
+var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var EVM_ZERO = /^0x0{40}$/i;
+var isEvmAddress = (value) => typeof value === "string" && EVM_ADDRESS.test(value);
+var isEvmZeroAddress = (value) => EVM_ZERO.test(value);
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var SOLANA_ADDRESS = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var SOLANA_ZERO = "11111111111111111111111111111111";
+var EVM_TRANSACTION_HASH = /^0x[0-9a-fA-F]{64}$/;
+var SOLANA_SIGNATURE = /^[1-9A-HJ-NP-Za-km-z]{64,88}$/;
+var NEAR_ACCOUNT_ID = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+var NEAR_TRANSACTION_HASH = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function normalizeAddress(network, value) {
+  switch (network.family) {
+    case "evm":
+      return isEvmAddress(value) ? value : void 0;
+    case "svm":
+      return SOLANA_ADDRESS.test(value) && base58ByteLength(value) === 32 ? value : void 0;
+    case "near":
+      return value.length >= 2 && value.length <= 64 && NEAR_ACCOUNT_ID.test(value) ? value : void 0;
+  }
+}
+function isBurnAddress(network, wireAddress) {
+  switch (network.family) {
+    case "evm":
+      return isEvmZeroAddress(wireAddress);
+    case "svm":
+      return wireAddress === SOLANA_ZERO;
+    case "near":
+      return false;
+  }
+}
+function sameAddress(network, a, b) {
+  return network.family === "evm" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function isTransactionReference(network, value) {
+  switch (network.family) {
+    case "evm":
+      return EVM_TRANSACTION_HASH.test(value);
+    case "svm":
+      return SOLANA_SIGNATURE.test(value) && base58ByteLength(value) === 64;
+    case "near":
+      return NEAR_TRANSACTION_HASH.test(value) && base58ByteLength(value) === 32;
+  }
+}
+function base58ByteLength(value) {
+  let n = 0n;
+  for (const char of value) n = n * 58n + BigInt(BASE58_ALPHABET.indexOf(char));
+  const leadingZeros = value.length - value.replace(/^1+/, "").length;
+  return leadingZeros + (n === 0n ? 0 : Math.ceil(n.toString(16).length / 2));
+}
+
+// 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 === "::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 is not a valid URL", {
+      cause
+    });
+  }
+}
+function describeRpc(rpcUrl) {
+  try {
+    return new URL(rpcUrl).origin;
+  } catch {
+    return "[unparseable rpcUrl]";
+  }
+}
+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 ${describeRpc(rpcUrl)} does not look like a local/private chain. A public dev key must never sign against a public network: 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 ${describeRpc(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.`
+    );
+  }
+}
+
+// src/payments/x402/guardrails.ts
+var BASE_SEPOLIA = "eip155:84532";
+function invalid2(message, path) {
+  return new CommerceError("CONFIG_INVALID", message, { details: { path } });
+}
+function resolveX402Deployment(input) {
+  const at = input.configPath ?? "payments.x402";
+  const payTo = input.payToField ?? "payTo";
+  const profile = requireX402Network(input.network, `${at}.network`, input.customNetworks);
+  const mode = resolveDeploymentMode(profile);
+  if (profile.kind === "mainnet" && input.facilitator.mode === "local") {
+    throw invalid2(
+      `${at}: network "${profile.id}" (${profile.displayName}) is a mainnet and cannot be served by facilitator.mode "local". A mainnet deployment must settle through a remote facilitator.`,
+      `${at}.facilitator.mode`
+    );
+  }
+  if (input.facilitator.mode === "local" && mode !== "local") {
+    throw invalid2(
+      profile.id === BASE_SEPOLIA ? `${at}: the local Anvil chain is eip155:${LOCAL_CHAIN_ID}, Anvil's default chain id; "${BASE_SEPOLIA}" is public Base Sepolia. Set ${at}.network to eip155:${LOCAL_CHAIN_ID}, start Anvil with its default chain id and redeploy the local contracts (npm run chain:start, npm run chain:deploy).` : `${at}: facilitator.mode "local" serves the local Anvil chain (eip155:${LOCAL_CHAIN_ID}) only, not "${profile.id}" (${profile.displayName}). Use a remote facilitator.`,
+      `${at}.facilitator.mode`
+    );
+  }
+  if (mode === "mainnet" && input.allowMainnet !== true) {
+    throw invalid2(
+      `${at}: network "${profile.id}" (${profile.displayName}) settles real funds. Set ${at}.allowMainnet: true to acknowledge this explicitly - it is never the default.`,
+      `${at}.allowMainnet`
+    );
+  }
+  if (input.facilitator.mode === "remote") {
+    assertFacilitatorUrlIsSafe(input.facilitator.url, mode, at);
+    if (input.facilitator.auth.type === "cdp" && !isCdpFacilitatorUrl(input.facilitator.url)) {
+      throw invalid2(
+        `${at}: facilitator.auth.type "cdp" signs requests for ${CDP_FACILITATOR_URL} only, so facilitator ${describeOrigin(input.facilitator.url)} cannot accept its credential. Set facilitator.url to ${CDP_FACILITATOR_URL}, or use auth.type "bearer" or "none".`,
+        `${at}.facilitator.url`
+      );
+    }
+    if (mode === "mainnet" && input.facilitator.auth.type === "none" && input.allowUnauthenticatedFacilitator !== true) {
+      throw invalid2(
+        `${at}: no credential is configured for facilitator ${describeOrigin(input.facilitator.url)} on mainnet. Set ${at}.allowUnauthenticatedFacilitator: true to accept anonymous access and the facilitator's limits, or configure facilitator.auth.`,
+        `${at}.allowUnauthenticatedFacilitator`
+      );
+    }
+    for (const [field, value] of credentialFields(input.facilitator.auth)) {
+      if (value.trim() === "") {
+        throw invalid2(
+          `${at}: facilitator.auth.type is "${input.facilitator.auth.type}" but ${field} is empty. An empty credential is refused rather than sent.`,
+          `${at}.facilitator.auth.${field}`
+        );
+      }
+    }
+  }
+  if (isBurnAddress(profile, input.payTo)) {
+    throw invalid2(
+      `${at}: "${payTo}" is the zero address. Every payment settled there is destroyed.`,
+      `${at}.${payTo}`
+    );
+  }
+  if (mode !== "local" && isWellKnownDevAddress(input.payTo)) {
+    throw invalid2(
+      `${at}: "${payTo}" (${input.payTo}) is a well-known Anvil development address and this is a ${mode} deployment. Anyone can spend what settles there. Set ${payTo} to your own merchant wallet.`,
+      `${at}.${payTo}`
+    );
+  }
+  const canonical = profile.canonicalAsset;
+  if (canonical) {
+    if (!sameAddress(profile, input.asset, canonical.address)) {
+      throw invalid2(
+        `${at}: asset ${input.asset} is not ${canonical.symbol} on ${profile.displayName} (expected ${canonical.address}). A built-in network settles only in its ${canonical.symbol}.`,
+        `${at}.asset`
+      );
+    }
+    const domain = "name" in canonical ? canonical : void 0;
+    if (domain && input.assetName !== void 0 && input.assetName !== domain.name) {
+      throw invalid2(
+        `${at}: assetName "${input.assetName}" is not the EIP-712 domain name ${canonical.symbol} reports on ${profile.displayName} (expected "${domain.name}"). Every payment would be refused after the buyer signed.`,
+        `${at}.assetName`
+      );
+    }
+    if (domain && input.assetVersion !== void 0 && input.assetVersion !== domain.version) {
+      throw invalid2(
+        `${at}: assetVersion "${input.assetVersion}" is not the EIP-712 domain version ${canonical.symbol} reports on ${profile.displayName} (expected "${domain.version}").`,
+        `${at}.assetVersion`
+      );
+    }
+  }
+  return { profile, mode };
+}
+function assertFacilitatorUrlIsSafe(url, mode, at) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (cause) {
+    throw new CommerceError("CONFIG_INVALID", `${at}: facilitator.url is not a valid URL`, {
+      cause,
+      details: { path: `${at}.facilitator.url` }
+    });
+  }
+  if (parsed.protocol === "https:") return;
+  if (parsed.protocol !== "http:") {
+    throw invalid2(
+      `${at}: facilitator ${describeOrigin(url)} must be reached over https (or http on a local/private host); got "${parsed.protocol}//"`,
+      `${at}.facilitator.url`
+    );
+  }
+  if (mode !== "mainnet" && isLikelyLocalOrPrivateHost(parsed.hostname)) return;
+  throw invalid2(
+    `${at}: facilitator ${describeOrigin(url)} is reached over plain HTTP. Payment authorizations and settlement results would travel unencrypted. Use https, or point at a local/private host on a non-mainnet deployment.`,
+    `${at}.facilitator.url`
+  );
+}
+var CDP_FACILITATOR_URL = "https://api.cdp.coinbase.com/platform/v2/x402";
+function isCdpFacilitatorUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const expected = new URL(CDP_FACILITATOR_URL);
+    return parsed.origin === expected.origin && parsed.pathname.replace(/\/+$/, "") === expected.pathname && parsed.search === "";
+  } catch {
+    return false;
+  }
+}
+function describeOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "[unparseable facilitator.url]";
+  }
+}
+function credentialFields(auth) {
+  switch (auth.type) {
+    case "bearer":
+      return [["token", auth.token]];
+    case "cdp":
+      return [
+        ["apiKeyId", auth.apiKeyId],
+        ["apiKeySecret", auth.apiKeySecret]
+      ];
+    default:
+      return [];
+  }
+}
+
+// src/payments/x402/options.ts
+function x402OfferName(offer) {
+  const evm = offer.network.startsWith("eip155:");
+  const address = (value) => evm ? value.toLowerCase() : value;
+  return `${offer.network} ${address(offer.asset)} ${address(offer.payTo)}`;
+}
+var FIELD_MEANINGS = {
+  assetName: "EIP-712 domain name",
+  assetVersion: "EIP-712 domain version",
+  assetDecimals: "decimals"
+};
+var ADDRESS_SHAPES = {
+  evm: '"0x" followed by 40 hex characters',
+  svm: "a base58 public key of 32 bytes",
+  near: 'a NEAR account ID: 2 to 64 lowercase characters, digits and single "-", "_" or "." separators'
+};
+function invalid3(message, path) {
+  return new CommerceError("CONFIG_INVALID", message, { details: { path } });
+}
+function resolveX402Option(input, path, custom) {
+  if (input.scheme !== void 0 && input.scheme !== "exact") {
+    throw invalid3(
+      `${path}.scheme: "${input.scheme}" is not supported; the only x402 scheme is "exact"`,
+      `${path}.scheme`
+    );
+  }
+  const network = requireX402Network(input.network, `${path}.network`, custom);
+  const address = (field, value) => {
+    const wire = normalizeAddress(network, value);
+    if (wire === void 0) {
+      throw invalid3(
+        // The value is not echoed: a swapped variable could put a key here
+        `${path}.${field} is not a plausible address on ${network.displayName} (expected ${ADDRESS_SHAPES[network.family]})`,
+        `${path}.${field}`
+      );
+    }
+    return wire;
+  };
+  const payTo = address("payTo", input.payTo);
+  if (isBurnAddress(network, payTo)) {
+    throw invalid3(
+      `${path}.payTo is the zero address of ${network.displayName}. Every payment settled there is destroyed.`,
+      `${path}.payTo`
+    );
+  }
+  const method = input.assetTransferMethod ?? "eip3009";
+  if (method !== "eip3009" && method !== "permit2") {
+    throw invalid3(
+      `${path}.assetTransferMethod: "${method}" is not supported; use "eip3009" or "permit2"`,
+      `${path}.assetTransferMethod`
+    );
+  }
+  if (network.family !== "evm" && input.assetTransferMethod !== void 0) {
+    throw invalid3(
+      `${path}.assetTransferMethod applies to EVM networks only, not to ${network.displayName}`,
+      `${path}.assetTransferMethod`
+    );
+  }
+  if (network.family !== "evm") {
+    for (const field of ["assetName", "assetVersion"]) {
+      if (input[field] !== void 0) {
+        throw invalid3(
+          `${path}.${field}: an EIP-712 domain applies to EVM tokens only, not to ${network.displayName}`,
+          `${path}.${field}`
+        );
+      }
+    }
+  }
+  const canonical = network.canonicalAsset;
+  const domain = canonical && "name" in canonical ? canonical : void 0;
+  const asset = input.asset !== void 0 ? address("asset", input.asset) : void 0;
+  if (asset !== void 0 && isBurnAddress(network, asset)) {
+    throw invalid3(`${path}.asset must not be the zero address`, `${path}.asset`);
+  }
+  if (canonical && (asset === void 0 || sameAddress(network, asset, canonical.address))) {
+    const expected = {
+      assetName: domain?.name,
+      assetVersion: domain?.version,
+      assetDecimals: canonical.decimals
+    };
+    for (const field of ["assetName", "assetVersion", "assetDecimals"]) {
+      const given = input[field];
+      if (given !== void 0 && given !== expected[field]) {
+        throw invalid3(
+          `${path}.${field} does not match ${canonical.symbol} on ${network.displayName}, which reports ${FIELD_MEANINGS[field]} ${JSON.stringify(expected[field])}. Remove ${field}, or set asset to the token it describes.`,
+          `${path}.${field}`
+        );
+      }
+    }
+    return {
+      scheme: "exact",
+      network,
+      payTo,
+      asset: asset ?? canonical.address,
+      ...domain ? { assetName: domain.name, assetVersion: domain.version } : {},
+      assetDecimals: canonical.decimals,
+      defaultAssetSymbol: canonical.symbol,
+      assetTransferMethod: method
+    };
+  }
+  const required = network.family === "evm" && method === "eip3009" ? ["asset", "assetName", "assetVersion", "assetDecimals"] : ["asset", "assetDecimals"];
+  const missing = required.filter((field) => input[field] === void 0);
+  if (asset === void 0 || missing.length > 0) {
+    throw invalid3(
+      canonical ? `${path}: a token other than ${canonical.symbol} on ${network.displayName} needs ${missing.join(", ")}` : `${path}: ${network.displayName} has no default asset, so the option needs ${missing.join(", ")}`,
+      `${path}.${missing[0] ?? "asset"}`
+    );
+  }
+  return {
+    scheme: "exact",
+    network,
+    payTo,
+    asset,
+    ...input.assetName !== void 0 ? { assetName: input.assetName } : {},
+    ...input.assetVersion !== void 0 ? { assetVersion: input.assetVersion } : {},
+    assetDecimals: input.assetDecimals,
+    assetTransferMethod: method
+  };
+}
+
+// src/payments/x402/payment-flow.ts
+var X402_PAYMENT_FLOWS = ["authorization", "upfront"];
+var X402_DEFAULT_PAYMENT_FLOW = "authorization";
+
+export { LOCAL_CHAIN_ID, REUSE_REJECTED_AUTHORIZATION_METADATA_KEY, SETTLE_AFTER_BACKEND_METADATA_KEY, SUPPORTED_NETWORK_IDS, X402_DEFAULT_PAYMENT_FLOW, X402_PAYMENT_FLOWS, assertDevKeyIsLocalOnly, assertPayToIsNotDevAddress, describeDeploymentMode, describeRpc, findX402Network, isEvmAddress, isEvmZeroAddress, isTransactionReference, normalizeAddress, requireX402Network, resolveDeploymentMode, resolveX402Deployment, resolveX402Option, sameAddress, validateCustomNetworks, x402OfferName };
+//# sourceMappingURL=chunk-IFGRCXME.js.map
+//# sourceMappingURL=chunk-IFGRCXME.js.map