@bankofai/x402-core 2.6.0-beta.0

package/dist/esm/client/index.d.mts

@@ -0,0 +1,329 @@
+import { c as PaymentRequired, a as PaymentRequirements, P as PaymentPayload, N as Network, h as SchemeNetworkClient, S as SettleResponse } from '../assetRegistry-CRVM0KEs.mjs';
+
+/**
+ * Client Hook Context Interfaces
+ */
+interface PaymentCreationContext {
+    paymentRequired: PaymentRequired;
+    selectedRequirements: PaymentRequirements;
+}
+interface PaymentCreatedContext extends PaymentCreationContext {
+    paymentPayload: PaymentPayload;
+}
+interface PaymentCreationFailureContext extends PaymentCreationContext {
+    error: Error;
+}
+/**
+ * Client Hook Type Definitions
+ */
+type BeforePaymentCreationHook = (context: PaymentCreationContext) => Promise<void | {
+    abort: true;
+    reason: string;
+}>;
+type AfterPaymentCreationHook = (context: PaymentCreatedContext) => Promise<void>;
+type OnPaymentCreationFailureHook = (context: PaymentCreationFailureContext) => Promise<void | {
+    recovered: true;
+    payload: PaymentPayload;
+}>;
+type SelectPaymentRequirements = (x402Version: number, paymentRequirements: PaymentRequirements[]) => PaymentRequirements;
+/**
+ * Extension that can enrich payment payloads on the client side.
+ *
+ * Client extensions are invoked after the scheme creates the base payment payload
+ * but before it is returned. This allows mechanism-specific logic (e.g., EVM EIP-2612
+ * permit signing) to enrich the payload's extensions data.
+ */
+interface ClientExtension {
+    /**
+     * Unique key identifying this extension (e.g., "eip2612GasSponsoring").
+     * Must match the extension key used in PaymentRequired.extensions.
+     */
+    key: string;
+    /**
+     * Called after payload creation when the extension key is present in
+     * paymentRequired.extensions. Allows the extension to enrich the payload
+     * with extension-specific data (e.g., signing an EIP-2612 permit).
+     *
+     * @param paymentPayload - The payment payload to enrich
+     * @param paymentRequired - The original PaymentRequired response
+     * @returns The enriched payment payload
+     */
+    enrichPaymentPayload?: (paymentPayload: PaymentPayload, paymentRequired: PaymentRequired) => Promise<PaymentPayload>;
+}
+/**
+ * A policy function that filters or transforms payment requirements.
+ * Policies are applied in order before the selector chooses the final option.
+ *
+ * @param x402Version - The x402 protocol version
+ * @param paymentRequirements - Array of payment requirements to filter/transform
+ * @returns Filtered array of payment requirements
+ */
+type PaymentPolicy = (x402Version: number, paymentRequirements: PaymentRequirements[]) => PaymentRequirements[];
+/**
+ * Configuration for registering a payment scheme with a specific network
+ */
+interface SchemeRegistration {
+    /**
+     * The network identifier (e.g., 'eip155:8453', 'solana:mainnet')
+     */
+    network: Network;
+    /**
+     * The scheme client implementation for this network
+     */
+    client: SchemeNetworkClient;
+    /**
+     * The x402 protocol version to use for this scheme
+     *
+     * @default 2
+     */
+    x402Version?: number;
+}
+/**
+ * Configuration options for the fetch wrapper
+ */
+interface x402ClientConfig {
+    /**
+     * Array of scheme registrations defining which payment methods are supported
+     */
+    schemes: SchemeRegistration[];
+    /**
+     * Policies to apply to the client
+     */
+    policies?: PaymentPolicy[];
+    /**
+     * Custom payment requirements selector function
+     * If not provided, uses the default selector (first available option)
+     */
+    paymentRequirementsSelector?: SelectPaymentRequirements;
+}
+/**
+ * Core client for managing x402 payment schemes and creating payment payloads.
+ *
+ * Handles registration of payment schemes, policy-based filtering of payment requirements,
+ * and creation of payment payloads based on server requirements.
+ */
+declare class x402Client {
+    private readonly paymentRequirementsSelector;
+    private readonly registeredClientSchemes;
+    private readonly policies;
+    private readonly registeredExtensions;
+    private beforePaymentCreationHooks;
+    private afterPaymentCreationHooks;
+    private onPaymentCreationFailureHooks;
+    /**
+     * Creates a new x402Client instance.
+     *
+     * @param paymentRequirementsSelector - Function to select payment requirements from available options
+     */
+    constructor(paymentRequirementsSelector?: SelectPaymentRequirements);
+    /**
+     * Creates a new x402Client instance from a configuration object.
+     *
+     * @param config - The client configuration including schemes, policies, and payment requirements selector
+     * @returns A configured x402Client instance
+     */
+    static fromConfig(config: x402ClientConfig): x402Client;
+    /**
+     * Registers a scheme client for the current x402 version.
+     *
+     * @param network - The network to register the client for
+     * @param client - The scheme network client to register
+     * @returns The x402Client instance for chaining
+     */
+    register(network: Network, client: SchemeNetworkClient): x402Client;
+    /**
+     * Registers a scheme client for x402 version 1.
+     *
+     * @param network - The v1 network identifier (e.g., 'base-sepolia', 'solana-devnet')
+     * @param client - The scheme network client to register
+     * @returns The x402Client instance for chaining
+     */
+    registerV1(network: string, client: SchemeNetworkClient): x402Client;
+    /**
+     * Registers a policy to filter or transform payment requirements.
+     *
+     * Policies are applied in order after filtering by registered schemes
+     * and before the selector chooses the final payment requirement.
+     *
+     * @param policy - Function to filter/transform payment requirements
+     * @returns The x402Client instance for chaining
+     *
+     * @example
+     * ```typescript
+     * // Prefer cheaper options
+     * client.registerPolicy((version, reqs) =>
+     *   reqs.filter(r => BigInt(r.value) < BigInt('1000000'))
+     * );
+     *
+     * // Prefer specific networks
+     * client.registerPolicy((version, reqs) =>
+     *   reqs.filter(r => r.network.startsWith('eip155:'))
+     * );
+     * ```
+     */
+    registerPolicy(policy: PaymentPolicy): x402Client;
+    /**
+     * Registers a client extension that can enrich payment payloads.
+     *
+     * Extensions are invoked after the scheme creates the base payload and the
+     * payload is wrapped with extensions/resource/accepted data. If the extension's
+     * key is present in `paymentRequired.extensions`, the extension's
+     * `enrichPaymentPayload` hook is called to modify the payload.
+     *
+     * @param extension - The client extension to register
+     * @returns The x402Client instance for chaining
+     */
+    registerExtension(extension: ClientExtension): x402Client;
+    /**
+     * Register a hook to execute before payment payload creation.
+     * Can abort creation by returning { abort: true, reason: string }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Client instance for chaining
+     */
+    onBeforePaymentCreation(hook: BeforePaymentCreationHook): x402Client;
+    /**
+     * Register a hook to execute after successful payment payload creation.
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Client instance for chaining
+     */
+    onAfterPaymentCreation(hook: AfterPaymentCreationHook): x402Client;
+    /**
+     * Register a hook to execute when payment payload creation fails.
+     * Can recover from failure by returning { recovered: true, payload: PaymentPayload }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Client instance for chaining
+     */
+    onPaymentCreationFailure(hook: OnPaymentCreationFailureHook): x402Client;
+    /**
+     * Creates a payment payload based on a PaymentRequired response.
+     *
+     * Automatically extracts x402Version, resource, and extensions from the PaymentRequired
+     * response and constructs a complete PaymentPayload with the accepted requirements.
+     *
+     * @param paymentRequired - The PaymentRequired response from the server
+     * @returns Promise resolving to the complete payment payload
+     */
+    createPaymentPayload(paymentRequired: PaymentRequired): Promise<PaymentPayload>;
+    /**
+     * Merges server-declared extensions with scheme-provided extensions.
+     * Scheme extensions overlay on top of server extensions at each key,
+     * preserving server-provided schema while overlaying scheme-provided info.
+     *
+     * @param serverExtensions - Extensions declared by the server in the 402 response
+     * @param schemeExtensions - Extensions provided by the scheme client (e.g. EIP-2612)
+     * @returns The merged extensions object, or undefined if both inputs are undefined
+     */
+    private mergeExtensions;
+    /**
+     * Enriches a payment payload by calling registered extension hooks.
+     * For each extension key present in the PaymentRequired response,
+     * invokes the corresponding extension's enrichPaymentPayload callback.
+     *
+     * @param paymentPayload - The payment payload to enrich with extension data
+     * @param paymentRequired - The PaymentRequired response containing extension declarations
+     * @returns The enriched payment payload with extension data applied
+     */
+    private enrichPaymentPayloadWithExtensions;
+    /**
+     * Selects appropriate payment requirements based on registered clients and policies.
+     *
+     * Selection process:
+     * 1. Filter by registered schemes (network + scheme support)
+     * 2. Apply all registered policies in order
+     * 3. Use selector to choose final requirement
+     *
+     * @param x402Version - The x402 protocol version
+     * @param paymentRequirements - Array of available payment requirements
+     * @returns The selected payment requirements
+     */
+    private selectPaymentRequirements;
+    /**
+     * Internal method to register a scheme client.
+     *
+     * @param x402Version - The x402 protocol version
+     * @param network - The network to register the client for
+     * @param client - The scheme network client to register
+     * @returns The x402Client instance for chaining
+     */
+    private _registerScheme;
+}
+
+/**
+ * Context provided to onPaymentRequired hooks.
+ */
+interface PaymentRequiredContext {
+    paymentRequired: PaymentRequired;
+}
+/**
+ * Hook called when a 402 response is received, before payment processing.
+ * Return headers to try before payment, or void to proceed directly to payment.
+ */
+type PaymentRequiredHook = (context: PaymentRequiredContext) => Promise<{
+    headers: Record<string, string>;
+} | void>;
+/**
+ * HTTP-specific client for handling x402 payment protocol over HTTP.
+ *
+ * Wraps a x402Client to provide HTTP-specific encoding/decoding functionality
+ * for payment headers and responses while maintaining the builder pattern.
+ */
+declare class x402HTTPClient {
+    private readonly client;
+    private paymentRequiredHooks;
+    /**
+     * Creates a new x402HTTPClient instance.
+     *
+     * @param client - The underlying x402Client for payment logic
+     */
+    constructor(client: x402Client);
+    /**
+     * Register a hook to handle 402 responses before payment.
+     * Hooks run in order; first to return headers wins.
+     *
+     * @param hook - The hook function to register
+     * @returns This instance for chaining
+     */
+    onPaymentRequired(hook: PaymentRequiredHook): this;
+    /**
+     * Run hooks and return headers if any hook provides them.
+     *
+     * @param paymentRequired - The payment required response from the server
+     * @returns Headers to use for retry, or null to proceed to payment
+     */
+    handlePaymentRequired(paymentRequired: PaymentRequired): Promise<Record<string, string> | null>;
+    /**
+     * Encodes a payment payload into appropriate HTTP headers based on version.
+     *
+     * @param paymentPayload - The payment payload to encode
+     * @returns HTTP headers containing the encoded payment signature
+     */
+    encodePaymentSignatureHeader(paymentPayload: PaymentPayload): Record<string, string>;
+    /**
+     * Extracts payment required information from HTTP response.
+     *
+     * @param getHeader - Function to retrieve header value by name (case-insensitive)
+     * @param body - Optional response body for v1 compatibility
+     * @returns The payment required object
+     */
+    getPaymentRequiredResponse(getHeader: (name: string) => string | null | undefined, body?: unknown): PaymentRequired;
+    /**
+     * Extracts payment settlement response from HTTP headers.
+     *
+     * @param getHeader - Function to retrieve header value by name (case-insensitive)
+     * @returns The settlement response object
+     */
+    getPaymentSettleResponse(getHeader: (name: string) => string | null | undefined): SettleResponse;
+    /**
+     * Creates a payment payload for the given payment requirements.
+     * Delegates to the underlying x402Client.
+     *
+     * @param paymentRequired - The payment required response from the server
+     * @returns Promise resolving to the payment payload
+     */
+    createPaymentPayload(paymentRequired: PaymentRequired): Promise<PaymentPayload>;
+}
+
+export { type AfterPaymentCreationHook, type BeforePaymentCreationHook, type ClientExtension, type OnPaymentCreationFailureHook, type PaymentCreatedContext, type PaymentCreationContext, type PaymentCreationFailureContext, type PaymentPolicy, type PaymentRequiredContext, type PaymentRequiredHook, type SchemeRegistration, type SelectPaymentRequirements, x402Client, type x402ClientConfig, x402HTTPClient };

package/dist/esm/client/index.mjs

@@ -0,0 +1,330 @@
+import {
+  x402HTTPClient
+} from "../chunk-DACUCTGT.mjs";
+import {
+  x402Version
+} from "../chunk-DFUINDLZ.mjs";
+import "../chunk-HRQUGJ3Y.mjs";
+import {
+  findByNetworkAndScheme,
+  findSchemesByNetwork
+} from "../chunk-TDLQZ6MP.mjs";
+import "../chunk-BJTO5JO5.mjs";
+
+// src/client/x402Client.ts
+var x402Client = class _x402Client {
+  /**
+   * Creates a new x402Client instance.
+   *
+   * @param paymentRequirementsSelector - Function to select payment requirements from available options
+   */
+  constructor(paymentRequirementsSelector) {
+    this.registeredClientSchemes = /* @__PURE__ */ new Map();
+    this.policies = [];
+    this.registeredExtensions = /* @__PURE__ */ new Map();
+    this.beforePaymentCreationHooks = [];
+    this.afterPaymentCreationHooks = [];
+    this.onPaymentCreationFailureHooks = [];
+    this.paymentRequirementsSelector = paymentRequirementsSelector || ((x402Version2, accepts) => accepts[0]);
+  }
+  /**
+   * Creates a new x402Client instance from a configuration object.
+   *
+   * @param config - The client configuration including schemes, policies, and payment requirements selector
+   * @returns A configured x402Client instance
+   */
+  static fromConfig(config) {
+    const client = new _x402Client(config.paymentRequirementsSelector);
+    config.schemes.forEach((scheme) => {
+      if (scheme.x402Version === 1) {
+        client.registerV1(scheme.network, scheme.client);
+      } else {
+        client.register(scheme.network, scheme.client);
+      }
+    });
+    config.policies?.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+    return client;
+  }
+  /**
+   * Registers a scheme client for the current x402 version.
+   *
+   * @param network - The network to register the client for
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  register(network, client) {
+    return this._registerScheme(x402Version, network, client);
+  }
+  /**
+   * Registers a scheme client for x402 version 1.
+   *
+   * @param network - The v1 network identifier (e.g., 'base-sepolia', 'solana-devnet')
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  registerV1(network, client) {
+    return this._registerScheme(1, network, client);
+  }
+  /**
+   * Registers a policy to filter or transform payment requirements.
+   *
+   * Policies are applied in order after filtering by registered schemes
+   * and before the selector chooses the final payment requirement.
+   *
+   * @param policy - Function to filter/transform payment requirements
+   * @returns The x402Client instance for chaining
+   *
+   * @example
+   * ```typescript
+   * // Prefer cheaper options
+   * client.registerPolicy((version, reqs) =>
+   *   reqs.filter(r => BigInt(r.value) < BigInt('1000000'))
+   * );
+   *
+   * // Prefer specific networks
+   * client.registerPolicy((version, reqs) =>
+   *   reqs.filter(r => r.network.startsWith('eip155:'))
+   * );
+   * ```
+   */
+  registerPolicy(policy) {
+    this.policies.push(policy);
+    return this;
+  }
+  /**
+   * Registers a client extension that can enrich payment payloads.
+   *
+   * Extensions are invoked after the scheme creates the base payload and the
+   * payload is wrapped with extensions/resource/accepted data. If the extension's
+   * key is present in `paymentRequired.extensions`, the extension's
+   * `enrichPaymentPayload` hook is called to modify the payload.
+   *
+   * @param extension - The client extension to register
+   * @returns The x402Client instance for chaining
+   */
+  registerExtension(extension) {
+    this.registeredExtensions.set(extension.key, extension);
+    return this;
+  }
+  /**
+   * Register a hook to execute before payment payload creation.
+   * Can abort creation by returning { abort: true, reason: string }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onBeforePaymentCreation(hook) {
+    this.beforePaymentCreationHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute after successful payment payload creation.
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onAfterPaymentCreation(hook) {
+    this.afterPaymentCreationHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute when payment payload creation fails.
+   * Can recover from failure by returning { recovered: true, payload: PaymentPayload }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onPaymentCreationFailure(hook) {
+    this.onPaymentCreationFailureHooks.push(hook);
+    return this;
+  }
+  /**
+   * Creates a payment payload based on a PaymentRequired response.
+   *
+   * Automatically extracts x402Version, resource, and extensions from the PaymentRequired
+   * response and constructs a complete PaymentPayload with the accepted requirements.
+   *
+   * @param paymentRequired - The PaymentRequired response from the server
+   * @returns Promise resolving to the complete payment payload
+   */
+  async createPaymentPayload(paymentRequired) {
+    const clientSchemesByNetwork = this.registeredClientSchemes.get(paymentRequired.x402Version);
+    if (!clientSchemesByNetwork) {
+      throw new Error(`No client registered for x402 version: ${paymentRequired.x402Version}`);
+    }
+    const requirements = this.selectPaymentRequirements(paymentRequired.x402Version, paymentRequired.accepts);
+    const context = {
+      paymentRequired,
+      selectedRequirements: requirements
+    };
+    for (const hook of this.beforePaymentCreationHooks) {
+      const result = await hook(context);
+      if (result && "abort" in result && result.abort) {
+        throw new Error(`Payment creation aborted: ${result.reason}`);
+      }
+    }
+    try {
+      const schemeNetworkClient = findByNetworkAndScheme(clientSchemesByNetwork, requirements.scheme, requirements.network);
+      if (!schemeNetworkClient) {
+        throw new Error(`No client registered for scheme: ${requirements.scheme} and network: ${requirements.network}`);
+      }
+      const partialPayload = await schemeNetworkClient.createPaymentPayload(
+        paymentRequired.x402Version,
+        requirements,
+        { extensions: paymentRequired.extensions }
+      );
+      let paymentPayload;
+      if (partialPayload.x402Version == 1) {
+        paymentPayload = partialPayload;
+      } else {
+        const mergedExtensions = this.mergeExtensions(
+          paymentRequired.extensions,
+          partialPayload.extensions
+        );
+        paymentPayload = {
+          x402Version: partialPayload.x402Version,
+          payload: partialPayload.payload,
+          extensions: mergedExtensions,
+          resource: paymentRequired.resource,
+          accepted: requirements
+        };
+      }
+      paymentPayload = await this.enrichPaymentPayloadWithExtensions(paymentPayload, paymentRequired);
+      const createdContext = {
+        ...context,
+        paymentPayload
+      };
+      for (const hook of this.afterPaymentCreationHooks) {
+        await hook(createdContext);
+      }
+      return paymentPayload;
+    } catch (error) {
+      const failureContext = {
+        ...context,
+        error
+      };
+      for (const hook of this.onPaymentCreationFailureHooks) {
+        const result = await hook(failureContext);
+        if (result && "recovered" in result && result.recovered) {
+          return result.payload;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Merges server-declared extensions with scheme-provided extensions.
+   * Scheme extensions overlay on top of server extensions at each key,
+   * preserving server-provided schema while overlaying scheme-provided info.
+   *
+   * @param serverExtensions - Extensions declared by the server in the 402 response
+   * @param schemeExtensions - Extensions provided by the scheme client (e.g. EIP-2612)
+   * @returns The merged extensions object, or undefined if both inputs are undefined
+   */
+  mergeExtensions(serverExtensions, schemeExtensions) {
+    if (!schemeExtensions) return serverExtensions;
+    if (!serverExtensions) return schemeExtensions;
+    const merged = { ...serverExtensions };
+    for (const [key, schemeValue] of Object.entries(schemeExtensions)) {
+      const serverValue = merged[key];
+      if (serverValue && typeof serverValue === "object" && schemeValue && typeof schemeValue === "object") {
+        merged[key] = { ...serverValue, ...schemeValue };
+      } else {
+        merged[key] = schemeValue;
+      }
+    }
+    return merged;
+  }
+  /**
+   * Enriches a payment payload by calling registered extension hooks.
+   * For each extension key present in the PaymentRequired response,
+   * invokes the corresponding extension's enrichPaymentPayload callback.
+   *
+   * @param paymentPayload - The payment payload to enrich with extension data
+   * @param paymentRequired - The PaymentRequired response containing extension declarations
+   * @returns The enriched payment payload with extension data applied
+   */
+  async enrichPaymentPayloadWithExtensions(paymentPayload, paymentRequired) {
+    if (!paymentRequired.extensions || this.registeredExtensions.size === 0) {
+      return paymentPayload;
+    }
+    let enriched = paymentPayload;
+    for (const [key, extension] of this.registeredExtensions) {
+      if (key in paymentRequired.extensions && extension.enrichPaymentPayload) {
+        enriched = await extension.enrichPaymentPayload(enriched, paymentRequired);
+      }
+    }
+    return enriched;
+  }
+  /**
+   * Selects appropriate payment requirements based on registered clients and policies.
+   *
+   * Selection process:
+   * 1. Filter by registered schemes (network + scheme support)
+   * 2. Apply all registered policies in order
+   * 3. Use selector to choose final requirement
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - Array of available payment requirements
+   * @returns The selected payment requirements
+   */
+  selectPaymentRequirements(x402Version2, paymentRequirements) {
+    const clientSchemesByNetwork = this.registeredClientSchemes.get(x402Version2);
+    if (!clientSchemesByNetwork) {
+      throw new Error(`No client registered for x402 version: ${x402Version2}`);
+    }
+    const supportedPaymentRequirements = paymentRequirements.filter((requirement) => {
+      let clientSchemes = findSchemesByNetwork(clientSchemesByNetwork, requirement.network);
+      if (!clientSchemes) {
+        return false;
+      }
+      return clientSchemes.has(requirement.scheme);
+    });
+    if (supportedPaymentRequirements.length === 0) {
+      throw new Error(`No network/scheme registered for x402 version: ${x402Version2} which comply with the payment requirements. ${JSON.stringify({
+        x402Version: x402Version2,
+        paymentRequirements,
+        x402Versions: Array.from(this.registeredClientSchemes.keys()),
+        networks: Array.from(clientSchemesByNetwork.keys()),
+        schemes: Array.from(clientSchemesByNetwork.values()).map((schemes) => Array.from(schemes.keys())).flat()
+      })}`);
+    }
+    let filteredRequirements = supportedPaymentRequirements;
+    for (const policy of this.policies) {
+      filteredRequirements = policy(x402Version2, filteredRequirements);
+      if (filteredRequirements.length === 0) {
+        throw new Error(`All payment requirements were filtered out by policies for x402 version: ${x402Version2}`);
+      }
+    }
+    return this.paymentRequirementsSelector(x402Version2, filteredRequirements);
+  }
+  /**
+   * Internal method to register a scheme client.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param network - The network to register the client for
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  _registerScheme(x402Version2, network, client) {
+    if (!this.registeredClientSchemes.has(x402Version2)) {
+      this.registeredClientSchemes.set(x402Version2, /* @__PURE__ */ new Map());
+    }
+    const clientSchemesByNetwork = this.registeredClientSchemes.get(x402Version2);
+    if (!clientSchemesByNetwork.has(network)) {
+      clientSchemesByNetwork.set(network, /* @__PURE__ */ new Map());
+    }
+    const clientByScheme = clientSchemesByNetwork.get(network);
+    if (!clientByScheme.has(client.scheme)) {
+      clientByScheme.set(client.scheme, client);
+    }
+    return this;
+  }
+};
+export {
+  x402Client,
+  x402HTTPClient
+};
+//# sourceMappingURL=index.mjs.map