@dexterai/x402 3.8.0 → 3.9.0

package/dist/client/index.d.ts

@@ -1,100 +1,240 @@
-export { P as PaymentReceipt, a as X402Client, X as X402ClientConfig, c as createX402Client, f as fireImpressionBeacon, g as getPaymentReceipt, d as getSponsoredAccessInfo, b as getSponsoredRecommendations } from '../sponsored-access-D96FgkQK.js';
-import { A as AccessPassClientConfig, P as PaymentAccept, S as SolanaWallet, E as EvmWallet, W as WalletSet } from '../types-htvWHuW3.js';
-export { d as AccessPassInfo, b as AccessPassTier, C as ChainAdapter, X as X402Error, a as createEvmAdapter, c as createSolanaAdapter } from '../types-htvWHuW3.js';
+import { W as WalletSet, S as SettlementProbe, a as SolanaWallet, E as EvmWallet, A as AccessPassClientConfig, P as PaymentAccept } from '../types-RxdlGPaG.js';
+export { e as AccessPassInfo, d as AccessPassTier, C as ChainAdapter, X as X402Error, b as createEvmAdapter, c as createSolanaAdapter } from '../types-RxdlGPaG.js';
+import { SIWxSigner } from '@x402/extensions/sign-in-with-x';
 import { Keypair } from '@solana/web3.js';
+export { P as PaymentReceipt, d as X402Client, X as X402ClientConfig, c as createX402Client, f as fireImpressionBeacon, b as getPaymentReceipt, a as getSponsoredAccessInfo, g as getSponsoredRecommendations } from '../x402-client-CzseAnIt.js';
 export { FormattedResource as CapabilityAPI, CapabilitySearchOptions, CapabilitySearchResult, NoMatchReason, capabilitySearch } from '@dexterai/x402-core';
-import { SIWxSigner } from '@x402/extensions/sign-in-with-x';
 export { B as BASE_MAINNET, D as DEXTER_FACILITATOR_URL, S as SOLANA_MAINNET, U as USDC_MINT } from '../constants-qU-4U3L-.js';
 export { SponsoredAccessSettlementInfo, SponsoredRecommendation } from '@dexterai/x402-ads-types';
 
 /**
- * Options for wrapFetch
+ * Shared contract for the x402 version seam. Both the v1 and v2 strategy
+ * modules implement PaymentStrategy. Callers depend ONLY on this file —
+ * never on a specific version module.
  */
-interface WrapFetchOptions {
-    /**
-     * Solana private key (base58 string or JSON array)
-     * Required for Solana payments.
-     */
-    walletPrivateKey?: string | number[] | Uint8Array;
-    /**
-     * EVM private key (hex string with or without 0x prefix)
-     * Required for Base/EVM payments.
-     * Note: EVM support requires viem - import from '@dexterai/x402/adapters'
-     */
-    evmPrivateKey?: string;
-    /**
-     * Preferred network when multiple options are available
-     * @default 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' (Solana mainnet)
-     */
-    preferredNetwork?: string;
-    /**
-     * Facilitator URL
-     * @default 'https://x402.dexter.cash'
-     */
-    facilitatorUrl?: string;
-    /**
-     * Custom RPC URLs by network
-     */
-    rpcUrls?: Record<string, string>;
+
+/** A network reference, kept in BOTH forms so neither version loses info. */
+interface NetworkRef {
+    /** CAIP-2 form, e.g. "eip155:8453", "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp". */
+    caip2: string;
+    /** Bare form, e.g. "base", "solana". */
+    bare: string;
+    /** "evm" | "svm" — which signer family. */
+    family: 'evm' | 'svm';
+}
+/** One payment option parsed from a 402 challenge, version-normalised. */
+interface ChallengeOption {
+    scheme: string;
+    network: NetworkRef;
+    /** Atomic amount as a string (e.g. "2000"). */
+    amount: string;
+    asset: string;
+    payTo: string;
+    /** Optional — v1 challenges may omit it; a strategy supplies a default when absent. */
+    maxTimeoutSeconds?: number;
+    /** Scheme-specific extras, passed through verbatim from the merchant. */
+    extra?: Record<string, unknown>;
+}
+/** A 402 challenge, normalised across v1 and v2. */
+interface PaymentChallenge {
+    x402Version: 1 | 2;
+    options: ChallengeOption[];
+    resourceUrl?: string;
+}
+/**
+ * Result of a paid fetch. Never throws for an expected failure.
+ *
+ * The `ok: true` branch is further discriminated by `paid`:
+ *   - `paid: true`  — the endpoint demanded payment and we paid; `amountPaid`
+ *                     and `network` are present, `txSignature` optional.
+ *                     `response` is usually the merchant's response, but is
+ *                     `undefined` when the payment settled and the merchant
+ *                     never delivered a response before the deadline (a
+ *                     confirmed-but-unanswered payment — see `payment_unconfirmed`
+ *                     below for the unconfirmed counterpart).
+ *   - `paid: false` — the endpoint returned a non-402 directly; no payment
+ *                     was attempted. Only `response` is present, because no
+ *                     payment-related fields are meaningful in that case.
+ *
+ * Callers should narrow on `paid` before reading payment fields. Previously
+ * (3.8.x and earlier) the dispatcher returned a phantom `network` placeholder
+ * on the unpaid branch; the discriminator forces a correct read.
+ */
+type PayResult = {
+    ok: true;
+    paid: true;
     /**
-     * Maximum payment amount in atomic units
-     * Rejects payments exceeding this amount.
+     * The merchant's response. `undefined` when the payment was confirmed
+     * settled but the merchant did not respond before the deadline — you
+     * paid, the merchant never answered. Always check before use.
      */
+    response: Response | undefined;
+    /** Atomic amount actually paid. */
+    amountPaid: string;
+    network: NetworkRef;
+    txSignature?: string;
+} | {
+    ok: true;
+    paid: false;
+    response: Response;
+} | {
+    ok: false;
+    reason: 'unsupported_network' | 'insufficient_funds'
+    /** The merchant rejected the payment itself — bad/declined payload,
+     *  failed verification. Our side: check the payment. */
+     | 'merchant_rejected'
+    /** The merchant ACCEPTED the payment shape but their own settlement
+     *  failed (their facilitator errored). Not our payload — a
+     *  merchant-side defect. `detail` carries their verbatim error. */
+     | 'settlement_failed' | 'no_payment_options'
+    /** No payment was sent before the deadline — the unpaid probe (or
+     *  build/sign) ran past the pre-payment timeout. No money moved;
+     *  safe to retry. */
+     | 'timeout'
+    /** The payment authorization WAS sent to the merchant, the merchant
+     *  did not respond before the deadline, and settlement could not be
+     *  confirmed. The payment MAY have settled on-chain. DO NOT
+     *  blind-retry — a retry signs a fresh authorization and can pay
+     *  again. `detail` explains the state. */
+     | 'payment_unconfirmed' | 'budget_exceeded' | 'error';
+    detail?: string;
+};
+
+/** Options for a paid fetch. */
+interface PayAndFetchOptions {
+    /** Max total atomic spend for this call. */
     maxAmountAtomic?: string;
     /**
-     * Enable verbose logging
+     * Pre-payment timeout in ms — the deadline for the unpaid probe and the
+     * build/sign step, i.e. everything BEFORE the payment authorization is
+     * sent. Exceeding it yields `reason: 'timeout'` (no money moved, safe to
+     * retry). Default 15000.
+     *
+     * This does NOT bound the wait for the merchant's response once payment
+     * has been dispatched — see `responseTimeoutMs`. The two phases have
+     * separate deadlines on purpose: once the payment is out the door,
+     * aborting the wait does not un-spend the money.
      */
-    verbose?: boolean;
+    timeoutMs?: number;
     /**
-     * Access pass configuration.
-     * When provided, the client prefers purchasing time-limited passes
-     * over per-request payments. One payment grants unlimited requests.
+     * Post-payment timeout in ms — the deadline for the merchant's response
+     * AFTER the payment authorization has been sent. Exceeding it does not
+     * yield `'timeout'`; it yields `'payment_unconfirmed'` (or, once on-chain
+     * confirmation lands, a confirmed `paid: true`). Default 120000.
      *
-     * @example
-     * ```typescript
-     * const x402Fetch = wrapFetch(fetch, {
-     *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
-     *   accessPass: { preferTier: '1h', maxSpend: '1.00' },
-     * });
-     * // First call: auto-buys 1-hour pass
-     * // All subsequent calls: uses cached pass (no payment)
-     * ```
+     * Generous by design: research / scout / agent endpoints routinely take
+     * tens of seconds, and the money is already committed once this phase
+     * begins — there is no benefit to a tight deadline here.
      */
-    accessPass?: AccessPassClientConfig;
+    responseTimeoutMs?: number;
     /**
-     * Called before signing a payment. Return true to proceed, false to reject.
-     * Used internally by Budget Accounts — can also be set directly.
+     * Solana RPC endpoint for v1 SVM payment signing. v1 Solana `exact`
+     * signing builds a real transaction and needs RPC access (mint lookup,
+     * recent blockhash). Ignored for EVM-only flows. Defaults to the public
+     * Solana RPC when omitted — callers should pass their own for
+     * reliability.
      */
-    onPaymentRequired?: (requirements: PaymentAccept) => boolean | Promise<boolean>;
+    solanaRpcUrl?: string;
 }
 /**
- * Wrap fetch with automatic x402 payment handling
+ * The contract each version module implements.
  *
- * @param fetchImpl - The fetch function to wrap (usually `fetch` or `node-fetch`)
- * @param options - Configuration options
- * @returns A fetch function that handles x402 payments automatically
+ * parseChallenge: given a raw 402 Response, extract the challenge — or
+ *   null if this strategy does not recognise it as its version.
+ * pay: given a parsed challenge, sign + send the paid request, return
+ *   the merchant's response.
+ */
+interface PaymentStrategy {
+    readonly version: 1 | 2;
+    parseChallenge(res: Response): Promise<PaymentChallenge | null>;
+    pay(url: string, requestInit: RequestInit, challenge: PaymentChallenge, wallets: WalletSet, opts: PayAndFetchOptions): Promise<PayResult>;
+}
+
+/**
+ * The x402 version dispatcher — the ONLY code in the stack that decides
+ * v1 vs v2. It probes the endpoint once; if the response is a 402, it
+ * asks each strategy to parse it (v2 first, since v2 is current) and
+ * routes to whichever recognises it. Callers use payAndFetch and never
+ * branch on protocol version themselves.
+ */
+
+/**
+ * Given a 402 Response, return the strategy that recognises it, or null.
+ * Exported for testing; payAndFetch is the normal entrypoint.
+ */
+declare function detectStrategy(res: Response): Promise<PaymentStrategy | null>;
+/**
+ * Pay for and fetch a resource. Probes once; if the endpoint demands
+ * payment, detects the protocol version, and pays via the matching
+ * strategy. Returns a typed PayResult — never throws for an expected
+ * failure.
+ */
+declare function payAndFetch(url: string, requestInit: RequestInit, wallets: WalletSet, opts: PayAndFetchOptions): Promise<PayResult>;
+
+/**
+ * Two-way map between CAIP-2 network identifiers (x402 v2) and bare
+ * network names (x402 v1). The verifier's old bug was a one-way, lossy
+ * rewrite to bare names. This map is lossless: a NetworkRef always
+ * carries BOTH forms, so a v1 signer can use the bare name internally
+ * while the wire payload keeps whatever the merchant advertised.
+ */
+
+/**
+ * Resolve a network string — CAIP-2 or bare — to a NetworkRef.
+ * Only networks in the canonical ENTRIES table resolve. An
+ * unrecognised network (including an unmapped eip155:* / solana:*
+ * chain) returns null — callers must not receive a half-resolved,
+ * misleading NetworkRef.
+ */
+declare function toNetworkRef(network: string): NetworkRef | null;
+
+/**
+ * Map a WalletSet to a SIWxSigner for wrapFetchWithSIWx, or null when
+ * neither wallet can sign SIW-X proofs.
+ */
+declare function toSiwxSigner(wallets: WalletSet): SIWxSigner | null;
+
+/**
+ * Standalone v1 X-PAYMENT header builder.
  *
- * @example Basic usage
- * ```typescript
- * import { wrapFetch } from '@dexterai/x402/client';
+ * Extracted from v1-strategy so that external consumers that manage their
+ * own fetch (e.g. a dexter-api payment route) can build a v1 header without
+ * pulling in the full PaymentStrategy machinery or the upstream `x402` lib.
  *
- * const x402Fetch = wrapFetch(fetch, {
- *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
- * });
+ * MUST NOT import v2-strategy or v1-strategy (seam isolation).
+ */
+
+/** Result of building a v1 X-PAYMENT header value. Never thrown. */
+type V1HeaderResult = {
+    ok: true;
+    headerValue: string;
+    option: ChallengeOption;
+    /**
+     * Data to confirm settlement on-chain if a post-payment timeout fires.
+     * `undefined` for schemes with no on-chain confirmation check.
+     */
+    settlementProbe?: SettlementProbe;
+} | {
+    ok: false;
+    reason: 'unsupported_network' | 'budget_exceeded' | 'merchant_rejected' | 'error';
+    detail?: string;
+};
+/**
+ * Build a v1 `X-PAYMENT` header value for one of a challenge's options.
  *
- * const response = await x402Fetch('https://api.example.com/protected');
- * ```
+ * This is the v1 payment-construction seam: it picks the first option
+ * whose chain family has a usable wallet, signs the v1 `exact` payload
+ * (EIP-3009 for EVM; a partially-signed Solana transaction for SVM),
+ * and base64-encodes the v1 PaymentPayload. It does NOT send a request —
+ * the caller owns the fetch. payAndFetch's v1 strategy uses this; so do
+ * external consumers that manage their own request flow.
  *
- * @example With options
- * ```typescript
- * const x402Fetch = wrapFetch(fetch, {
- *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
- *   maxAmountAtomic: '1000000',  // Max $1.00 per request
- *   verbose: true,
- * });
- * ```
+ * Returns a typed result; never throws for an expected failure.
+ *
+ * NO NETWORK REWRITE: the `network` field on the wire is the merchant's
+ * advertised v1 bare name verbatim (option.network.bare).
  */
-declare function wrapFetch(fetchImpl: typeof globalThis.fetch, options: WrapFetchOptions): typeof globalThis.fetch;
+declare function buildV1PaymentHeader(challenge: PaymentChallenge, wallets: WalletSet, opts: PayAndFetchOptions): Promise<V1HeaderResult>;
 
 /**
  * Keypair Wallet for Node.js
@@ -236,6 +376,101 @@ declare function createEvmKeypairWallet(privateKey: string): Promise<EvmWallet>;
  */
 declare function isEvmKeypairWallet(wallet: unknown): wallet is EvmWallet;
 
+/**
+ * Options for wrapFetch
+ */
+interface WrapFetchOptions {
+    /**
+     * Solana private key (base58 string or JSON array)
+     * Required for Solana payments.
+     */
+    walletPrivateKey?: string | number[] | Uint8Array;
+    /**
+     * EVM private key (hex string with or without 0x prefix)
+     * Required for Base/EVM payments.
+     * Note: EVM support requires viem - import from '@dexterai/x402/adapters'
+     */
+    evmPrivateKey?: string;
+    /**
+     * Preferred network when multiple options are available
+     * @default 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' (Solana mainnet)
+     */
+    preferredNetwork?: string;
+    /**
+     * Facilitator URL
+     * @default 'https://x402.dexter.cash'
+     */
+    facilitatorUrl?: string;
+    /**
+     * Custom RPC URLs by network
+     */
+    rpcUrls?: Record<string, string>;
+    /**
+     * Maximum payment amount in atomic units
+     * Rejects payments exceeding this amount.
+     */
+    maxAmountAtomic?: string;
+    /**
+     * Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Access pass configuration.
+     * When provided, the client prefers purchasing time-limited passes
+     * over per-request payments. One payment grants unlimited requests.
+     *
+     * @example
+     * ```typescript
+     * const x402Fetch = wrapFetch(fetch, {
+     *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
+     *   accessPass: { preferTier: '1h', maxSpend: '1.00' },
+     * });
+     * // First call: auto-buys 1-hour pass
+     * // All subsequent calls: uses cached pass (no payment)
+     * ```
+     */
+    accessPass?: AccessPassClientConfig;
+    /**
+     * Called before signing a payment. Return true to proceed, false to reject.
+     * Used internally by Budget Accounts — can also be set directly.
+     */
+    onPaymentRequired?: (requirements: PaymentAccept) => boolean | Promise<boolean>;
+}
+/**
+ * Wrap fetch with automatic x402 payment handling
+ *
+ * @deprecated Slated for removal in `@dexterai/x402` 5.0. Use `payAndFetch`
+ * instead — it's version-agnostic across x402 v1 and v2 and returns a
+ * discriminated union that separates merchant rejection from settlement
+ * failure. Migration: `wrapFetch(fetch, { walletPrivateKey })` →
+ * `payAndFetch(url, init, { solana: createKeypairWallet(pk) })`.
+ *
+ * @param fetchImpl - The fetch function to wrap (usually `fetch` or `node-fetch`)
+ * @param options - Configuration options
+ * @returns A fetch function that handles x402 payments automatically
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { wrapFetch } from '@dexterai/x402/client';
+ *
+ * const x402Fetch = wrapFetch(fetch, {
+ *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
+ * });
+ *
+ * const response = await x402Fetch('https://api.example.com/protected');
+ * ```
+ *
+ * @example With options
+ * ```typescript
+ * const x402Fetch = wrapFetch(fetch, {
+ *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
+ *   maxAmountAtomic: '1000000',  // Max $1.00 per request
+ *   verbose: true,
+ * });
+ * ```
+ */
+declare function wrapFetch(fetchImpl: typeof globalThis.fetch, options: WrapFetchOptions): typeof globalThis.fetch;
+
 /**
  * Budget Account — Autonomous Agent Spending Controls
  *
@@ -321,169 +556,4 @@ interface BudgetAccount {
  */
 declare function createBudgetAccount(config: BudgetAccountConfig): BudgetAccount;
 
-/**
- * Shared contract for the x402 version seam. Both the v1 and v2 strategy
- * modules implement PaymentStrategy. Callers depend ONLY on this file —
- * never on a specific version module.
- */
-
-/** A network reference, kept in BOTH forms so neither version loses info. */
-interface NetworkRef {
-    /** CAIP-2 form, e.g. "eip155:8453", "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp". */
-    caip2: string;
-    /** Bare form, e.g. "base", "solana". */
-    bare: string;
-    /** "evm" | "svm" — which signer family. */
-    family: 'evm' | 'svm';
-}
-/** One payment option parsed from a 402 challenge, version-normalised. */
-interface ChallengeOption {
-    scheme: string;
-    network: NetworkRef;
-    /** Atomic amount as a string (e.g. "2000"). */
-    amount: string;
-    asset: string;
-    payTo: string;
-    /** Optional — v1 challenges may omit it; a strategy supplies a default when absent. */
-    maxTimeoutSeconds?: number;
-    /** Scheme-specific extras, passed through verbatim from the merchant. */
-    extra?: Record<string, unknown>;
-}
-/** A 402 challenge, normalised across v1 and v2. */
-interface PaymentChallenge {
-    x402Version: 1 | 2;
-    options: ChallengeOption[];
-    resourceUrl?: string;
-}
-/** Result of a paid fetch. Never throws for an expected failure. */
-type PayResult = {
-    ok: true;
-    response: Response;
-    /** Atomic amount actually paid. */
-    amountPaid: string;
-    network: NetworkRef;
-    txSignature?: string;
-} | {
-    ok: false;
-    reason: 'unsupported_network' | 'insufficient_funds'
-    /** The merchant rejected the payment itself — bad/declined payload,
-     *  failed verification. Our side: check the payment. */
-     | 'merchant_rejected'
-    /** The merchant ACCEPTED the payment shape but their own settlement
-     *  failed (their facilitator errored). Not our payload — a
-     *  merchant-side defect. `detail` carries their verbatim error. */
-     | 'settlement_failed' | 'no_payment_options' | 'timeout' | 'budget_exceeded' | 'error';
-    detail?: string;
-};
-
-/** Options for a paid fetch. */
-interface PayAndFetchOptions {
-    /** Max total atomic spend for this call. */
-    maxAmountAtomic?: string;
-    /** Per-request timeout in ms. Default 15000. */
-    timeoutMs?: number;
-    /**
-     * Solana RPC endpoint for v1 SVM payment signing. v1 Solana `exact`
-     * signing builds a real transaction and needs RPC access (mint lookup,
-     * recent blockhash). Ignored for EVM-only flows. Defaults to the public
-     * Solana RPC when omitted — callers should pass their own for
-     * reliability.
-     */
-    solanaRpcUrl?: string;
-}
-/**
- * The contract each version module implements.
- *
- * parseChallenge: given a raw 402 Response, extract the challenge — or
- *   null if this strategy does not recognise it as its version.
- * pay: given a parsed challenge, sign + send the paid request, return
- *   the merchant's response.
- */
-interface PaymentStrategy {
-    readonly version: 1 | 2;
-    parseChallenge(res: Response): Promise<PaymentChallenge | null>;
-    pay(url: string, requestInit: RequestInit, challenge: PaymentChallenge, wallets: WalletSet, opts: PayAndFetchOptions): Promise<PayResult>;
-}
-
-/**
- * The x402 version dispatcher — the ONLY code in the stack that decides
- * v1 vs v2. It probes the endpoint once; if the response is a 402, it
- * asks each strategy to parse it (v2 first, since v2 is current) and
- * routes to whichever recognises it. Callers use payAndFetch and never
- * branch on protocol version themselves.
- */
-
-/**
- * Given a 402 Response, return the strategy that recognises it, or null.
- * Exported for testing; payAndFetch is the normal entrypoint.
- */
-declare function detectStrategy(res: Response): Promise<PaymentStrategy | null>;
-/**
- * Pay for and fetch a resource. Probes once; if the endpoint demands
- * payment, detects the protocol version, and pays via the matching
- * strategy. Returns a typed PayResult — never throws for an expected
- * failure.
- */
-declare function payAndFetch(url: string, requestInit: RequestInit, wallets: WalletSet, opts: PayAndFetchOptions): Promise<PayResult>;
-
-/**
- * Two-way map between CAIP-2 network identifiers (x402 v2) and bare
- * network names (x402 v1). The verifier's old bug was a one-way, lossy
- * rewrite to bare names. This map is lossless: a NetworkRef always
- * carries BOTH forms, so a v1 signer can use the bare name internally
- * while the wire payload keeps whatever the merchant advertised.
- */
-
-/**
- * Resolve a network string — CAIP-2 or bare — to a NetworkRef.
- * Only networks in the canonical ENTRIES table resolve. An
- * unrecognised network (including an unmapped eip155:* / solana:*
- * chain) returns null — callers must not receive a half-resolved,
- * misleading NetworkRef.
- */
-declare function toNetworkRef(network: string): NetworkRef | null;
-
-/**
- * Map a WalletSet to a SIWxSigner for wrapFetchWithSIWx, or null when
- * neither wallet can sign SIW-X proofs.
- */
-declare function toSiwxSigner(wallets: WalletSet): SIWxSigner | null;
-
-/**
- * Standalone v1 X-PAYMENT header builder.
- *
- * Extracted from v1-strategy so that external consumers that manage their
- * own fetch (e.g. a dexter-api payment route) can build a v1 header without
- * pulling in the full PaymentStrategy machinery or the upstream `x402` lib.
- *
- * MUST NOT import v2-strategy or v1-strategy (seam isolation).
- */
-
-/** Result of building a v1 X-PAYMENT header value. Never thrown. */
-type V1HeaderResult = {
-    ok: true;
-    headerValue: string;
-    option: ChallengeOption;
-} | {
-    ok: false;
-    reason: 'unsupported_network' | 'budget_exceeded' | 'merchant_rejected' | 'error';
-    detail?: string;
-};
-/**
- * Build a v1 `X-PAYMENT` header value for one of a challenge's options.
- *
- * This is the v1 payment-construction seam: it picks the first option
- * whose chain family has a usable wallet, signs the v1 `exact` payload
- * (EIP-3009 for EVM; a partially-signed Solana transaction for SVM),
- * and base64-encodes the v1 PaymentPayload. It does NOT send a request —
- * the caller owns the fetch. payAndFetch's v1 strategy uses this; so do
- * external consumers that manage their own request flow.
- *
- * Returns a typed result; never throws for an expected failure.
- *
- * NO NETWORK REWRITE: the `network` field on the wire is the merchant's
- * advertised v1 bare name verbatim (option.network.bare).
- */
-declare function buildV1PaymentHeader(challenge: PaymentChallenge, wallets: WalletSet, opts: PayAndFetchOptions): Promise<V1HeaderResult>;
-
 export { AccessPassClientConfig, type BudgetAccount, type BudgetAccountConfig, type BudgetConfig, type ChallengeOption, KEYPAIR_SYMBOL, type KeypairWallet, type NetworkRef, type PayAndFetchOptions, type PayResult, type PaymentChallenge, type PaymentRecord, type PaymentStrategy, type V1HeaderResult, WalletSet, type WrapFetchOptions, buildV1PaymentHeader, createBudgetAccount, createEvmKeypairWallet, createKeypairWallet, detectStrategy, isEvmKeypairWallet, isKeypairWallet, payAndFetch, toNetworkRef, toSiwxSigner, wrapFetch };