Function createPayFetchWithPreAuth

src/payment-preauth.ts:47–171

(
  baseFetch: FetchFn,
  client: x402Client,
  ttlMs = DEFAULT_TTL_MS,
  options?: { skipPreAuth?: boolean; estimateAmount?: EstimateFn },
)

type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

export function createPayFetchWithPreAuth(
  baseFetch: FetchFn,
  client: x402Client,
  ttlMs = DEFAULT_TTL_MS,
  options?: { skipPreAuth?: boolean; estimateAmount?: EstimateFn },
): FetchFn {
  const httpClient = new x402HTTPClient(client);
  const cache = new Map<string, CachedEntry>();

  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
    const request = new Request(input, init);
    const urlPath = new URL(request.url).pathname;

    // Extract model + size from the request body. Model gives a per-model cache
    // key (a cached sonnet payment must not be applied to a free model); body
    // length + max_tokens drive the up-front cost estimate used to decide
    // whether a cached pre-auth still covers this (possibly larger) request.
    let requestModel = "";
    let bodyLength = 0;
    let maxTokens = 0;
    if (init?.body) {
      try {
        const bodyStr =
          init.body instanceof Uint8Array
            ? new TextDecoder().decode(init.body)
            : typeof init.body === "string"
              ? init.body
              : "";
        if (bodyStr) {
          bodyLength = bodyStr.length;
          const parsed = JSON.parse(bodyStr) as { model?: string; max_tokens?: number };
          requestModel = parsed.model ?? "";
          maxTokens = Number(parsed.max_tokens) || 0;
        }
      } catch {
        /* not JSON, use empty model */
      }
    }
    const cacheKey = `${urlPath}:${requestModel}`;

    // Up-front estimate of what THIS request will cost (USDC micro-units), used
    // both to gate pre-auth reuse and to record what a new cache entry covers.
    const estimateMicros = (): number | undefined => {
      if (!options?.estimateAmount || !requestModel) return undefined;
      const est = options.estimateAmount(requestModel, bodyLength, maxTokens);
      return est === undefined ? undefined : Number(est);
    };
    const needMicros = estimateMicros();

    // Try pre-auth only when we can PROVE the cached payment still covers this
    // request (needMicros <= what the cached entry covered). Skip for Solana:
    // payments use per-tx blockhashes that expire ~60-90s, making cached
    // requirements useless and causing double charges.
    const cached = !options?.skipPreAuth ? cache.get(cacheKey) : undefined;
    const preAuthCovers =
      cached !== undefined &&
      Date.now() - cached.cachedAt < ttlMs &&
      cached.coverMicros !== undefined &&