@devlab.group/agent-commerce 2.4.1 → 2.5.0

package/dist/cli/{chunk-TNMLDPUO.js → chunk-QA2OPHBF.js}

@@ -1,11 +1,12 @@
-import { isWellKnownDevKey, assertPayToIsNotDevAddress, resolveX402Deployment, assertDevKeyIsLocalOnly, describeRpc, x402OfferName } from './chunk-WYOGIANL.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-OZ4LAWBK.js';
-import { computeReplayKey, computePermit2ReplayKey } from './chunk-OSTCU6ZK.js';
-import { PACKAGE_VERSION } from './chunk-ITWNSS2B.js';
-import { CommerceError, systemClock, NOOP_LOGGER, redactedErrorText } from './chunk-QQ3WY5L3.js';
+import { PACKAGE_VERSION } from './chunk-M7NXVRU5.js';
+import { isWellKnownDevKey, assertPayToIsNotDevAddress, resolveX402Deployment, assertDevKeyIsLocalOnly, describeRpc, x402OfferName } from './chunk-4H2QLHQI.js';
+import { findX402Network, normalizeAddress, canonicalJson, X402_DEFAULT_PAYMENT_FLOW, REUSE_REJECTED_AUTHORIZATION_METADATA_KEY, SETTLE_AFTER_BACKEND_METADATA_KEY, sameAddress, LOCAL_CHAIN_ID, isTransactionReference, isEvmAddress, describeDeploymentMode } from './chunk-5R7DM5LM.js';
+import { systemClock, NOOP_LOGGER, RECONCILIATION_METADATA_KEY } from './chunk-IDY2735M.js';
+import { CommerceError, redactedErrorText, isCommerceError } from './chunk-SYQLJXIU.js';
+import { LOCATOR_VERSION, eip3009Locator, computeReplayKey, permit2Locator, computePermit2ReplayKey, isoFromSeconds } from './chunk-663ALDZA.js';
 import { isRecord } from './chunk-3M6U7ILB.js';
-import { x402ExactPermit2ProxyAddress, toFacilitatorEvmSigner, PERMIT2_ADDRESS } from '@x402/evm';
-import { isAddress, keccak256, stringToBytes, getAddress, formatUnits, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, BaseError, ContractFunctionRevertedError, erc20Abi } from 'viem';
+import { x402ExactPermit2ProxyAddress, toFacilitatorEvmSigner, PERMIT2_ADDRESS, eip3009ABI, x402ExactPermit2ProxyABI } from '@x402/evm';
+import { parseAbi, isAddress, keccak256, stringToBytes, isHash, getAddress, formatUnits, createWalletClient, http, publicActions, createPublicClient, HttpRequestError, TimeoutError, WaitForTransactionReceiptTimeoutError, BaseError, ContractFunctionRevertedError, erc20Abi, parseEventLogs, isAddressEqual, TransactionReceiptNotFoundError, decodeFunctionData } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { HTTPFacilitatorClient } from '@x402/core/http';
 import { SettleError, VerifyError } from '@x402/core/types';
@@ -54,10 +55,9 @@ function parseCanonicalAmount(amount, decimals) {
 
 // src/payments/x402/provider/fee-payer.ts
 var SUPPORTED_TTL_MS = 6e4;
-function createSvmFeePayerSource(ctx) {
+function createSupportedSource(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) {
@@ -72,6 +72,10 @@ function createSvmFeePayerSource(ctx) {
     });
     return response;
   }
+  return currentSupported;
+}
+function createSvmFeePayerSource(currentSupported) {
+  const feePayers = /* @__PURE__ */ new Map();
   async function svmFeePayer(offer) {
     let supported;
     try {
@@ -100,6 +104,43 @@ function createSvmFeePayerSource(ctx) {
   }
   return svmFeePayer;
 }
+function createNearRelayerSource(currentSupported, logger) {
+  return async (offer) => {
+    let supported;
+    try {
+      supported = await currentSupported();
+    } catch (err) {
+      logger.warn(
+        { err: redactedErrorText(err) },
+        `x402 verify(): facilitator ${offer.binding.describe} did not answer /supported; the NEAR locator names no relayer`
+      );
+      return [];
+    }
+    const { signers } = supported;
+    return [.../* @__PURE__ */ new Set([...signers[offer.network] ?? [], ...signers["near:*"] ?? []])];
+  };
+}
+
+// src/payments/x402/json-rpc.ts
+async function jsonRpc(rpcUrl, method, params, timeoutMs) {
+  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(timeoutMs)
+  });
+  const body = await response.json();
+  if (body.error !== void 0) {
+    throw new CommerceError(
+      "PAYMENT_PROVIDER_UNAVAILABLE",
+      `RPC ${method} failed: ${JSON.stringify(body.error)}`,
+      { details: { rpcError: body.error } }
+    );
+  }
+  return body.result;
+}
+
+// src/payments/x402/provider/health.ts
 function createHealthCheck(ctx) {
   const { offers, clock, deploymentMode, remoteBinding, svm, near } = ctx;
   async function offerHealth(offer, kinds) {
@@ -173,7 +214,7 @@ function createHealthCheck(ctx) {
   async function svmOfferHealth(offer, kinds) {
     const { profile, rpcOrigin, binding } = offer;
     const svmModule = await svm();
-    const genesis = await jsonRpc(offer.rpcUrl, "getGenesisHash", []);
+    const genesis = await rpc(offer.rpcUrl, "getGenesisHash", []);
     const cluster = typeof genesis === "string" ? `solana:${genesis.slice(0, 32)}` : void 0;
     if (cluster !== offer.network) {
       return {
@@ -181,10 +222,7 @@ function createHealthCheck(ctx) {
         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 mint = await rpc(offer.rpcUrl, "getAccountInfo", [offer.asset, { encoding: "base64" }]);
     const mintInfo = readMint(mint);
     if (mintInfo === void 0) {
       return {
@@ -204,7 +242,7 @@ function createHealthCheck(ctx) {
       offer.asset,
       tokenProgram
     );
-    const account = await jsonRpc(offer.rpcUrl, "getAccountInfo", [
+    const account = await rpc(offer.rpcUrl, "getAccountInfo", [
       payeeAccount,
       { encoding: "base64" }
     ]);
@@ -232,7 +270,7 @@ function createHealthCheck(ctx) {
   async function nearOfferHealth(offer, kinds) {
     const { profile, rpcOrigin, binding, rpcUrl } = offer;
     await near();
-    const status = await jsonRpc(rpcUrl, "status", []);
+    const status = await rpc(rpcUrl, "status", []);
     const chainId = isRecord(status) ? status["chain_id"] : void 0;
     const expected = offer.network.slice("near:".length);
     if (chainId !== expected) {
@@ -241,7 +279,7 @@ function createHealthCheck(ctx) {
         detail: `RPC at ${rpcOrigin} serves chain ${String(chainId ?? "unknown")}, expected ${expected} (${profile.displayName})`
       };
     }
-    const token = await jsonRpc(rpcUrl, "query", {
+    const token = await rpc(rpcUrl, "query", {
       request_type: "view_account",
       finality: "final",
       account_id: offer.asset
@@ -359,24 +397,9 @@ function readMint(result) {
   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;
-}
+var rpc = (rpcUrl, method, params) => jsonRpc(rpcUrl, method, params, HEALTH_TIMEOUT_MS);
 async function nearView(rpcUrl, accountId, method, args) {
-  const result = await jsonRpc(rpcUrl, "query", {
+  const result = await rpc(rpcUrl, "query", {
     request_type: "call_function",
     finality: "final",
     account_id: accountId,
@@ -421,7 +444,7 @@ function buildLocalChain(rpcUrl, chainId = LOCAL_CHAIN_ID) {
 function createLocalPublicClient(rpcUrl, timeoutMs, chainId) {
   return createPublicClient({
     chain: buildLocalChain(rpcUrl, chainId),
-    transport: http(rpcUrl, { timeout: timeoutMs } )
+    transport: http(rpcUrl, timeoutMs !== void 0 ? { timeout: timeoutMs } : void 0)
   });
 }
 function createLocalFacilitatorClient(rpcUrl, signerPrivateKey, chainId) {
@@ -800,29 +823,6 @@ function offerCurrency(offer, quoted) {
   const canonical = offer.profile.canonicalAsset;
   return canonical !== void 0 && sameAddress(offer.profile, offer.asset, canonical.address) ? canonical.symbol : quoted;
 }
-
-// src/core/canonical-json.ts
-var LONE_SURROGATE = new RegExp("\\p{Cs}", "u");
-function canonicalJson(value) {
-  if (typeof value === "string")
-    return LONE_SURROGATE.test(value) ? void 0 : JSON.stringify(value);
-  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : void 0;
-  if (value === null || typeof value === "boolean") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    const items = value.map(canonicalJson);
-    return items.includes(void 0) ? void 0 : `[${items.join(",")}]`;
-  }
-  if (typeof value !== "object") return void 0;
-  const members = [];
-  for (const key of Object.keys(value).sort()) {
-    const member = canonicalJson(value[key]);
-    if (member === void 0 || LONE_SURROGATE.test(key)) return void 0;
-    members.push(`${JSON.stringify(key)}:${member}`);
-  }
-  return `{${members.join(",")}}`;
-}
-
-// src/payments/x402/provider/quote.ts
 var QUOTE_EXTENSION = "erc-8409";
 var QUOTE_REQUEST_SCHEME = "agent-commerce/request/v1";
 var QUOTE_DOMAIN = { name: "Signed Service Payment Quotes", version: "1" };
@@ -966,6 +966,553 @@ function quoteRequestHash(resourceId, input) {
   const canonical = canonicalJson({ input, resource: resourceId });
   return canonical === void 0 ? void 0 : keccak256(stringToBytes(canonical));
 }
+var EVENTS = parseAbi([
+  "event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce)",
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+]);
+var NONCE_BITMAP_ABI = parseAbi([
+  "function nonceBitmap(address owner, uint256 wordPosition) view returns (uint256)"
+]);
+var CLOCK_MARGIN_SECONDS = 900n;
+var LOG_CHUNK_BLOCKS = 10000n;
+var MAX_WINDOW_BLOCKS = 200000n;
+var UINT = /^\d{1,78}$/;
+function parseEvmLocator(locator) {
+  const address = (key) => {
+    const value = locator[key];
+    return typeof value === "string" && isAddress(value) ? value : void 0;
+  };
+  const uint = (key) => {
+    const value = locator[key];
+    return typeof value === "string" && UINT.test(value) ? BigInt(value) : void 0;
+  };
+  const expiresAt = typeof locator["expiresAt"] === "string" ? locator["expiresAt"] : void 0;
+  if (locator["method"] === "eip3009") {
+    const [asset, from, to] = [address("asset"), address("from"), address("to")];
+    const [value, validAfter, validBefore] = [
+      uint("value"),
+      uint("validAfter"),
+      uint("validBefore")
+    ];
+    const nonce = locator["nonce"];
+    if (!asset || !from || !to || value === void 0 || validAfter === void 0) return void 0;
+    if (validBefore === void 0 || typeof nonce !== "string" || !isHash(nonce)) return void 0;
+    return { method: "eip3009", asset, from, to, value, nonce, validAfter, validBefore, expiresAt };
+  }
+  if (locator["method"] === "permit2") {
+    const [asset, owner, to, proxy] = [
+      address("asset"),
+      address("owner"),
+      address("to"),
+      address("proxy")
+    ];
+    const [amount, nonce, deadline, validAfter] = [
+      uint("amount"),
+      uint("nonce"),
+      uint("deadline"),
+      uint("validAfter")
+    ];
+    if (!asset || !owner || !to || !proxy || amount === void 0 || nonce === void 0) {
+      return void 0;
+    }
+    if (deadline === void 0 || validAfter === void 0) return void 0;
+    return {
+      method: "permit2",
+      asset,
+      owner,
+      to,
+      amount,
+      nonce,
+      deadline,
+      validAfter,
+      proxy,
+      expiresAt
+    };
+  }
+  return void 0;
+}
+async function readEvmEvidence(input) {
+  const { client, chainId, locator, attempt } = input;
+  const reported = await client.getChainId();
+  if (reported !== chainId) {
+    return unknown("chain_mismatch", { chainId: reported, expectedChainId: chainId });
+  }
+  const finalized = await client.getBlock({ blockTag: "finalized" });
+  const finalizedAt = isoFromSeconds(String(finalized.timestamp));
+  const finality = {
+    finalizedBlock: String(finalized.number),
+    ...finalizedAt !== void 0 ? { finalizedAt } : {}
+  };
+  const method = locator.method === "eip3009" ? eip3009(client, locator) : permit2(client, locator);
+  const settled = (hash, block) => block <= finalized.number ? {
+    outcome: "settled",
+    reason: "transfer_final",
+    externalReference: hash,
+    evidence: { transactionHash: hash, blockNumber: String(block), ...finality }
+  } : unknown("not_final", { transactionHash: hash, blockNumber: String(block), ...finality });
+  const reference = attempt.externalReference;
+  if (reference !== void 0 && isHash(reference)) {
+    const block = await method.carries(reference);
+    if (block !== void 0) return settled(reference, block);
+  }
+  if (!await method.used(finalized.number)) {
+    if (finalized.timestamp >= method.endsAt) {
+      return {
+        outcome: "not-settled",
+        reason: "expired_unused",
+        evidence: { nonceUsed: false, ...finality }
+      };
+    }
+    if (await method.used()) return unknown("not_final", finality);
+    return {
+      ...unknown("not_expired", finality),
+      ...locator.expiresAt !== void 0 ? { retryAfter: locator.expiresAt } : {}
+    };
+  }
+  const createdAt = BigInt(Math.floor(Date.parse(attempt.createdAt) / 1e3));
+  const fromSeconds = max(method.validAfter, createdAt - CLOCK_MARGIN_SECONDS);
+  const fromBlock = await firstBlockAt(client, fromSeconds, finalized);
+  const endBlock = await firstBlockAt(client, method.endsAt, finalized) - 1n;
+  const toBlock = min(endBlock, fromBlock + MAX_WINDOW_BLOCKS - 1n);
+  const window = { fromBlock: String(fromBlock), toBlock: String(toBlock), ...finality };
+  for (const [start, end] of logRanges(fromBlock, toBlock)) {
+    for (const hash of await method.candidates(start, end)) {
+      const block = await method.carries(hash);
+      if (block !== void 0) return settled(hash, block);
+    }
+  }
+  if (toBlock < endBlock) {
+    return unknown("search_window_too_wide", { ...window, endBlock: String(endBlock) });
+  }
+  return unknown("used_without_record", { nonceUsed: true, ...window });
+}
+function eip3009(client, locator) {
+  const { asset, from, to, value, nonce } = locator;
+  return {
+    endsAt: locator.validBefore,
+    validAfter: locator.validAfter,
+    used: (blockNumber) => client.readContract({
+      address: asset,
+      abi: eip3009ABI,
+      functionName: "authorizationState",
+      args: [from, nonce],
+      ...blockNumber !== void 0 ? { blockNumber } : {}
+    }),
+    async candidates(fromBlock, toBlock) {
+      const logs = await client.getLogs({
+        address: asset,
+        event: EVENTS[0],
+        args: { authorizer: from, nonce },
+        fromBlock,
+        toBlock
+      });
+      return logs.map((log) => log.transactionHash);
+    },
+    async carries(hash) {
+      const receipt = await receiptOf(client, hash);
+      if (receipt?.status !== "success") return void 0;
+      const logs = parseEventLogs({ abi: EVENTS, logs: receipt.logs }).filter(
+        (log) => isAddressEqual(log.address, asset)
+      );
+      const used = logs.some(
+        (log) => log.eventName === "AuthorizationUsed" && isAddressEqual(log.args.authorizer, from) && log.args.nonce.toLowerCase() === nonce.toLowerCase()
+      );
+      return used && logs.some((log) => isTransfer(log, from, to, value)) ? receipt.blockNumber : void 0;
+    }
+  };
+}
+function permit2(client, locator) {
+  const { asset, owner, to, amount, nonce, proxy } = locator;
+  return {
+    // Permit2 accepts a transfer while the timestamp is at most the deadline
+    endsAt: locator.deadline + 1n,
+    validAfter: locator.validAfter,
+    async used(blockNumber) {
+      const bitmap = await client.readContract({
+        address: PERMIT2_ADDRESS,
+        abi: NONCE_BITMAP_ABI,
+        functionName: "nonceBitmap",
+        args: [owner, nonce >> 8n],
+        ...blockNumber !== void 0 ? { blockNumber } : {}
+      });
+      return (bitmap >> (nonce & 0xffn) & 1n) === 1n;
+    },
+    // Match the nonce in proxy calldata to distinguish transfers with the
+    // same owner, recipient and amount
+    async candidates(fromBlock, toBlock) {
+      const logs = await client.getLogs({
+        address: asset,
+        event: EVENTS[1],
+        args: { from: owner, to },
+        fromBlock,
+        toBlock
+      });
+      return [...new Set(logs.map((log) => log.transactionHash))];
+    },
+    async carries(hash) {
+      const receipt = await receiptOf(client, hash);
+      if (receipt?.status !== "success" || !receipt.to || !isAddressEqual(receipt.to, proxy)) {
+        return void 0;
+      }
+      const call = proxyCall((await client.getTransaction({ hash })).input);
+      const named = call !== void 0 && isAddressEqual(call.owner, owner) && call.nonce === nonce && isAddressEqual(call.asset, asset) && isAddressEqual(call.to, to);
+      const transferred = parseEventLogs({ abi: EVENTS, logs: receipt.logs }).some(
+        (log) => isAddressEqual(log.address, asset) && isTransfer(log, owner, to, amount)
+      );
+      return named && transferred ? receipt.blockNumber : void 0;
+    }
+  };
+}
+function proxyCall(input) {
+  let call;
+  try {
+    call = decodeProxyInput(input);
+  } catch {
+    return void 0;
+  }
+  const parts = call.functionName === "settle" ? call.args : call.functionName === "settleWithPermit" ? [call.args[1], call.args[2], call.args[3]] : void 0;
+  if (parts === void 0) return void 0;
+  const [permit, owner, witness] = parts;
+  return { owner, nonce: permit.nonce, asset: permit.permitted.token, to: witness.to };
+}
+var decodeProxyInput = (data) => decodeFunctionData({ abi: x402ExactPermit2ProxyABI, data });
+function isTransfer(log, from, to, value) {
+  return log.eventName === "Transfer" && isAddressEqual(log.args.from, from) && isAddressEqual(log.args.to, to) && log.args.value === value;
+}
+async function receiptOf(client, hash) {
+  try {
+    return await client.getTransactionReceipt({ hash });
+  } catch (err) {
+    if (err instanceof TransactionReceiptNotFoundError) return void 0;
+    throw err;
+  }
+}
+function logRanges(fromBlock, toBlock) {
+  const ranges = [];
+  for (let start = fromBlock; start <= toBlock; start += LOG_CHUNK_BLOCKS) {
+    ranges.push([start, min(start + LOG_CHUNK_BLOCKS - 1n, toBlock)]);
+  }
+  return ranges;
+}
+async function firstBlockAt(client, seconds, finalized) {
+  if (seconds > finalized.timestamp) return finalized.number + 1n;
+  const timestampOf = async (blockNumber) => (await client.getBlock({ blockNumber })).timestamp;
+  let low = 0n;
+  let lowTime = await timestampOf(low);
+  if (lowTime >= seconds) return 0n;
+  let high = finalized.number;
+  let highTime = finalized.timestamp;
+  for (let step = 0; high - low > 1n; step++) {
+    let middle = (low + high) / 2n;
+    if (step % 2 === 0 && highTime > lowTime) {
+      const guess = low + (seconds - lowTime) * (high - low) / (highTime - lowTime);
+      middle = min(max(guess, low + 1n), high - 1n);
+    }
+    const timestamp = await timestampOf(middle);
+    if (timestamp >= seconds) [high, highTime] = [middle, timestamp];
+    else [low, lowTime] = [middle, timestamp];
+  }
+  return high;
+}
+function unknown(reason, evidence) {
+  return { outcome: "unknown", reason, ...evidence !== void 0 ? { evidence } : {} };
+}
+var max = (a, b) => a > b ? a : b;
+var min = (a, b) => a < b ? a : b;
+
+// src/payments/x402/reconcile/near.ts
+var UINT2 = /^\d{1,20}$/;
+var TX_HASH = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function parseNearLocator(locator) {
+  const text = (key) => {
+    const value = locator[key];
+    return typeof value === "string" && value !== "" ? value : void 0;
+  };
+  const uint = (key) => {
+    const value = text(key);
+    return value !== void 0 && UINT2.test(value) ? value : void 0;
+  };
+  const [senderId, publicKey, asset, receiver] = [
+    text("senderId"),
+    text("publicKey"),
+    text("asset"),
+    text("receiver")
+  ];
+  const [nonce, maxBlockHeight, amount] = [uint("nonce"), uint("maxBlockHeight"), uint("amount")];
+  const relayers = locator["relayers"] ?? [];
+  if (!senderId || !publicKey || !asset || !receiver || !nonce || !maxBlockHeight || !amount) {
+    return void 0;
+  }
+  if (!Array.isArray(relayers) || !relayers.every((id) => typeof id === "string")) {
+    return void 0;
+  }
+  return {
+    senderId,
+    publicKey,
+    nonce: BigInt(nonce),
+    maxBlockHeight: BigInt(maxBlockHeight),
+    asset,
+    receiver,
+    amount,
+    relayers
+  };
+}
+async function readNearEvidence(input) {
+  const { rpc: rpc2, network, locator, attempt } = input;
+  const status = await rpc2("status", []);
+  const chainId = isRecord(status) ? status["chain_id"] : void 0;
+  const expected = network.slice("near:".length);
+  if (chainId !== expected) {
+    return unknown("chain_mismatch", { chainId, expectedChainId: expected });
+  }
+  const reference = attempt.externalReference;
+  if (reference !== void 0 && TX_HASH.test(reference)) {
+    for (const relayer of locator.relayers) {
+      const outcome = await txStatus(rpc2, reference, relayer);
+      if (outcome === void 0) continue;
+      if (outcome.final_execution_status !== "FINAL") {
+        return unknown("not_final", { transactionHash: reference });
+      }
+      if (carries(outcome, locator)) {
+        return {
+          outcome: "settled",
+          reason: "transfer_final",
+          externalReference: reference,
+          evidence: { transactionHash: reference, relayer }
+        };
+      }
+      break;
+    }
+  }
+  const block = await rpc2("block", { finality: "final" });
+  const height = block.header?.height;
+  if (typeof height !== "number" || !Number.isSafeInteger(height)) {
+    throw new CommerceError("PAYMENT_PROVIDER_UNAVAILABLE", "block returned no height");
+  }
+  const finality = { finalBlock: String(height) };
+  let key;
+  try {
+    key = await rpc2("query", {
+      request_type: "view_access_key",
+      block_id: height,
+      account_id: locator.senderId,
+      public_key: locator.publicKey
+    });
+  } catch (err) {
+    if (rpcErrorName(err) === "UNKNOWN_ACCESS_KEY") return unknown("access_key_missing", finality);
+    throw err;
+  }
+  if (typeof key.error === "string") return unknown("access_key_missing", finality);
+  if (typeof key.nonce !== "number" || !Number.isSafeInteger(key.nonce)) {
+    throw new CommerceError("PAYMENT_PROVIDER_UNAVAILABLE", "view_access_key returned no nonce");
+  }
+  const evidence = { keyNonce: String(key.nonce), ...finality };
+  if (BigInt(key.nonce) >= locator.nonce) return unknown("used_without_record", evidence);
+  if (BigInt(height) > locator.maxBlockHeight) {
+    return { outcome: "not-settled", reason: "expired_unused", evidence };
+  }
+  return unknown("not_expired", { maxBlockHeight: String(locator.maxBlockHeight), ...evidence });
+}
+async function txStatus(rpc2, hash, sender) {
+  try {
+    return await rpc2("EXPERIMENTAL_tx_status", {
+      tx_hash: hash,
+      sender_account_id: sender,
+      wait_until: "NONE"
+    });
+  } catch (err) {
+    if (rpcErrorName(err) === "UNKNOWN_TRANSACTION") return void 0;
+    throw err;
+  }
+}
+function carries(outcome, locator) {
+  const delegated = (outcome.transaction?.actions ?? []).some((action) => {
+    const delegate = action.Delegate?.delegate_action;
+    return delegate?.sender_id === locator.senderId && delegate.public_key === locator.publicKey && String(delegate.nonce) === String(locator.nonce);
+  });
+  const succeeded = new Set(
+    (outcome.receipts_outcome ?? []).filter((entry) => isRecord(entry.outcome?.status) && "SuccessValue" in entry.outcome.status).map((entry) => entry.id)
+  );
+  const transferred = (outcome.receipts ?? []).some(
+    (receipt) => receipt.receiver_id === locator.asset && receipt.predecessor_id === locator.senderId && succeeded.has(receipt.receipt_id) && (receipt.receipt?.Action?.actions ?? []).some((action) => {
+      const call = action.FunctionCall;
+      if (call?.method_name !== "ft_transfer" || typeof call.args !== "string") return false;
+      const args = parseArgs(call.args);
+      return args?.["receiver_id"] === locator.receiver && args["amount"] === locator.amount;
+    })
+  );
+  return delegated && transferred;
+}
+function parseArgs(base64) {
+  try {
+    const args = JSON.parse(Buffer.from(base64, "base64").toString("utf8"));
+    return isRecord(args) ? args : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function rpcErrorName(err) {
+  const rpcError = isCommerceError(err) ? err.details?.["rpcError"] : void 0;
+  return isRecord(rpcError) && isRecord(rpcError["cause"]) ? rpcError["cause"]["name"] : void 0;
+}
+
+// src/payments/x402/reconcile/svm.ts
+var CLOCK_MARGIN_SECONDS2 = 900;
+var HISTORY_PAGE = 1e3;
+var MAX_HISTORY_PAGES = 5;
+var BASE58 = /^[1-9A-HJ-NP-Za-km-z]+$/;
+var MESSAGE_HASH = /^[A-Za-z0-9+/]{43}=$/;
+function parseSvmLocator(locator) {
+  const { messageHash, recentBlockhash, payer } = locator;
+  if (typeof messageHash !== "string" || !MESSAGE_HASH.test(messageHash)) return void 0;
+  if (!isBase58(recentBlockhash, 32, 44)) return void 0;
+  if (payer !== void 0 && !isBase58(payer, 32, 44)) return void 0;
+  return { messageHash, recentBlockhash, payer };
+}
+async function readSvmEvidence(input) {
+  const { rpc: rpc2, network, locator, attempt, messageHashOf } = input;
+  const genesis = await rpc2("getGenesisHash", []);
+  const served = `solana:${String(genesis).slice(0, 32)}`;
+  if (served !== network) {
+    return unknown("chain_mismatch", { network: served, expectedNetwork: network });
+  }
+  const carries2 = async (id) => {
+    const landed = await rpc2("getTransaction", [
+      id,
+      { encoding: "base64", commitment: "finalized", maxSupportedTransactionVersion: 0 }
+    ]);
+    if (landed?.meta?.err !== null || typeof landed.slot !== "number") return void 0;
+    const [wire] = Array.isArray(landed.transaction) ? landed.transaction : [];
+    return typeof wire === "string" && messageHashOf(wire) === locator.messageHash ? landed.slot : void 0;
+  };
+  const settled = (id, slot) => ({
+    outcome: "settled",
+    reason: "transfer_final",
+    externalReference: id,
+    evidence: { transactionId: id, slot: String(slot) }
+  });
+  const reference = attempt.externalReference;
+  if (reference !== void 0 && isBase58(reference, 64, 88)) {
+    const slot = await carries2(reference);
+    if (slot !== void 0) return settled(reference, slot);
+  }
+  if (locator.payer !== void 0) {
+    const createdAt = Math.floor(Date.parse(attempt.createdAt) / 1e3);
+    const from = createdAt - CLOCK_MARGIN_SECONDS2;
+    const to = createdAt + CLOCK_MARGIN_SECONDS2;
+    let before;
+    search: for (let page = 0; ; page += 1) {
+      if (page === MAX_HISTORY_PAGES) return unknown("history_too_long", { payer: locator.payer });
+      const entries = await rpc2("getSignaturesForAddress", [
+        locator.payer,
+        {
+          commitment: "finalized",
+          limit: HISTORY_PAGE,
+          ...before !== void 0 ? { before } : {}
+        }
+      ]);
+      if (!Array.isArray(entries)) {
+        throw new CommerceError(
+          "PAYMENT_PROVIDER_UNAVAILABLE",
+          "getSignaturesForAddress returned no list"
+        );
+      }
+      for (const entry of entries) {
+        if (typeof entry.signature !== "string") continue;
+        before = entry.signature;
+        const time = typeof entry.blockTime === "number" ? entry.blockTime : void 0;
+        if (time !== void 0 && time < from) break search;
+        if (entry.err !== null || time !== void 0 && time > to) continue;
+        const slot = await carries2(entry.signature);
+        if (slot !== void 0) return settled(entry.signature, slot);
+      }
+      if (entries.length < HISTORY_PAGE) break;
+    }
+  }
+  const validity = await rpc2("isBlockhashValid", [
+    locator.recentBlockhash,
+    { commitment: "confirmed" }
+  ]);
+  const valid = isRecord(validity) ? validity["value"] : void 0;
+  if (typeof valid !== "boolean") {
+    throw new CommerceError("PAYMENT_PROVIDER_UNAVAILABLE", "isBlockhashValid returned no value");
+  }
+  return unknown(valid ? "not_expired" : "blockhash_expired", {
+    payerSearched: locator.payer !== void 0
+  });
+}
+function isBase58(value, minLength, maxLength) {
+  return typeof value === "string" && value.length >= minLength && value.length <= maxLength && BASE58.test(value);
+}
+
+// src/payments/x402/provider/reconcile.ts
+var RECONCILE_TIMEOUT_MS = 3e4;
+function createReconcile(ctx) {
+  const clients = /* @__PURE__ */ new Map();
+  const evmClient = (offer) => {
+    let client = clients.get(offer);
+    if (client === void 0) {
+      client = createLocalPublicClient(offer.rpcUrl, RECONCILE_TIMEOUT_MS, offer.profile.chainId);
+      clients.set(offer, client);
+    }
+    return client;
+  };
+  const rpc2 = (offer) => (method, params) => jsonRpc(offer.rpcUrl, method, params, RECONCILE_TIMEOUT_MS);
+  const read = async (offer, evidence) => {
+    try {
+      return await evidence();
+    } catch (err) {
+      return unknown("rpc_error", { rpc: offer.rpcOrigin, error: redactedErrorText(err) });
+    }
+  };
+  return async ({ attempt, locator }) => {
+    if (locator === void 0) return unknown("no_locator");
+    if (locator["v"] !== LOCATOR_VERSION) return unknown("unsupported_locator_version");
+    const network = locator["network"];
+    if (typeof network !== "string") return unknown("unsupported_family");
+    const offerFor = (family) => ctx.offers.find(
+      (candidate) => candidate.family === family && candidate.network === network
+    );
+    const notConfigured = unknown("network_not_configured", { network });
+    if (network.startsWith("eip155:")) {
+      const parsed = parseEvmLocator(locator);
+      if (parsed === void 0) return unknown("invalid_locator");
+      const offer = offerFor("evm");
+      if (offer === void 0) return notConfigured;
+      return read(
+        offer,
+        () => readEvmEvidence({
+          client: evmClient(offer),
+          chainId: offer.profile.chainId,
+          locator: parsed,
+          attempt
+        })
+      );
+    }
+    if (network.startsWith("solana:")) {
+      const parsed = parseSvmLocator(locator);
+      if (parsed === void 0) return unknown("invalid_locator");
+      const offer = offerFor("svm");
+      if (offer === void 0) return notConfigured;
+      const { messageHashOf } = await ctx.svm();
+      return read(
+        offer,
+        () => readSvmEvidence({ rpc: rpc2(offer), network, locator: parsed, attempt, messageHashOf })
+      );
+    }
+    if (network.startsWith("near:")) {
+      const parsed = parseNearLocator(locator);
+      if (parsed === void 0) return unknown("invalid_locator");
+      const offer = offerFor("near");
+      if (offer === void 0) return notConfigured;
+      return read(
+        offer,
+        () => readNearEvidence({ rpc: rpc2(offer), network, locator: parsed, attempt })
+      );
+    }
+    return unknown("unsupported_family");
+  };
+}
 function decodePaymentSubmission(payloadBase64) {
   const json = decodeJson(payloadBase64);
   if (json === void 0) return void 0;
@@ -1140,12 +1687,13 @@ function readTransfer(payload, offer) {
         from: getAddress(from2),
         nonce: nonce2
       }),
+      locator: eip3009Locator(offer.network, offer.asset, authorization),
       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;
+  const { from, spender, permitted, witness, nonce, deadline } = payload.payload.permit2Authorization;
   if (getAddress(spender) !== getAddress(x402ExactPermit2ProxyAddress)) {
     return "invalid_permit2_spender";
   }
@@ -1155,6 +1703,16 @@ function readTransfer(payload, offer) {
     to: getAddress(witness.to),
     value: permitted.amount,
     replayKey: computePermit2ReplayKey({ chainId, owner: getAddress(from), nonce }),
+    locator: permit2Locator(offer.network, {
+      asset: permitted.token,
+      owner: from,
+      to: witness.to,
+      amount: permitted.amount,
+      nonce,
+      deadline,
+      validAfter: witness.validAfter,
+      proxy: spender
+    }),
     recipientMismatch: "invalid_permit2_recipient_mismatch",
     amountMismatch: "permit2_amount_mismatch"
   };
@@ -1329,7 +1887,8 @@ function createSettle(ctx) {
   }
   return settle;
 }
-function createVerify(ctx) {
+var RELAYER_GRACE_MS = 1e3;
+function createVerify(ctx, nearRelayers) {
   const { offersFor, clock, logger, svm, near } = ctx;
   async function verify(context) {
     const { requirement, submission } = context;
@@ -1372,11 +1931,13 @@ function createVerify(ctx) {
     }
     let transfer;
     let replayKey;
+    let locator;
     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;
+      const inspected = (await svm()).inspectSvmPayload(payload.payload, offer.network);
+      if (typeof inspected === "string") return rejected(inspected);
+      replayKey = inspected.replayKey;
+      locator = inspected.locator;
     } else if (offer.family === "near") {
       const inspected = (await near()).inspectNearPayload(payload.payload, {
         network: offer.network,
@@ -1386,12 +1947,14 @@ function createVerify(ctx) {
       });
       if (typeof inspected === "string") return rejected(inspected);
       replayKey = inspected.replayKey;
+      locator = inspected.locator;
       derivedPayer = inspected.payer;
     } else {
       const read = readTransfer(payload, offer);
       if (typeof read === "string") return rejected(read);
       transfer = read;
       replayKey = read.replayKey;
+      locator = read.locator;
       derivedPayer = read.from;
     }
     if (payload.accepted.network !== offer.network) {
@@ -1421,6 +1984,7 @@ function createVerify(ctx) {
         return rejected(transfer.amountMismatch);
       }
     }
+    const relayers = offer.family === "near" ? nearRelayers(offer) : void 0;
     const scope = offer.binding.open();
     let sdkResult;
     try {
@@ -1457,6 +2021,9 @@ function createVerify(ctx) {
       return rejected(sanitizeReason(sdkResult.invalidReason, "invalid_payment"));
     }
     const payer = derivedPayer ?? (sdkResult.payer !== void 0 && normalizeAddress(offer.profile, sdkResult.payer) ? sdkResult.payer : void 0);
+    if (offer.family === "svm" && payer !== void 0) locator = { ...locator, payer };
+    const relayerIds = relayers !== void 0 ? await withinGrace(relayers) : [];
+    if (relayerIds.length > 0) locator = { ...locator, relayers: relayerIds };
     return {
       status: "verified",
       provider: "x402",
@@ -1466,10 +2033,26 @@ function createVerify(ctx) {
       currency: offerCurrency(offer, requirement.currency),
       network: payload.accepted.network,
       asset: offer.family === "evm" ? getAddress(requirements.asset) : offer.asset,
-      replayKey
+      replayKey,
+      metadata: { [RECONCILIATION_METADATA_KEY]: locator }
     };
   }
   return verify;
+  async function withinGrace(relayers) {
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(void 0), RELAYER_GRACE_MS);
+      timer.unref();
+    });
+    const ids = await Promise.race([relayers, late]).finally(() => clearTimeout(timer));
+    if (ids === void 0) {
+      logger.warn(
+        { graceMs: RELAYER_GRACE_MS },
+        "x402 verify(): /supported is slow; the NEAR locator names no relayer"
+      );
+    }
+    return ids ?? [];
+  }
 }
 
 // src/payments/x402/provider/index.ts
@@ -1538,8 +2121,8 @@ function createX402PaymentProvider(options) {
       "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 svmModule = hasSvm ? loadOptionalModule(() => import('./svm-KDSPDFJG.js'), "Solana offers need @x402/svm and @solana/kit") : void 0;
+  const nearModule = hasNear ? loadOptionalModule(() => import('./near-U6365VFX.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");
@@ -1564,11 +2147,12 @@ function createX402PaymentProvider(options) {
     svm,
     near
   };
+  const supported = createSupportedSource(ctx);
   const { createRequirement, selectRequirement } = createRequirementBuilders(
     ctx,
-    createSvmFeePayerSource(ctx)
+    createSvmFeePayerSource(supported)
   );
-  const verify = createVerify(ctx);
+  const verify = createVerify(ctx, createNearRelayerSource(supported, logger));
   const settle = createSettle(ctx);
   const health = createHealthCheck(ctx);
   return {
@@ -1579,6 +2163,7 @@ function createX402PaymentProvider(options) {
     ...severalOffers ? { selectRequirement } : {},
     verify,
     settle,
+    reconcile: createReconcile(ctx),
     health,
     ...quotes ? {
       quote: {
@@ -1601,5 +2186,5 @@ function loadOptionalModule(load, missing) {
 }
 
 export { DEFAULT_IDS, chainIdFromCaip2, createX402PaymentProvider, parseCanonicalAmount };
-//# sourceMappingURL=chunk-TNMLDPUO.js.map
-//# sourceMappingURL=chunk-TNMLDPUO.js.map
+//# sourceMappingURL=chunk-QA2OPHBF.js.map
+//# sourceMappingURL=chunk-QA2OPHBF.js.map