x402-express-mantle 1.0.0

package/lib/esm/exact/v1/facilitator/index.d.mts

@@ -0,0 +1,71 @@
+import { SchemeNetworkFacilitator, PaymentPayload, PaymentRequirements, VerifyResponse, SettleResponse } from '@x402/core/types';
+import { F as FacilitatorSvmSigner } from '../../../signer-BMkbhFYE.mjs';
+import '@solana/kit';
+
+/**
+ * SVM facilitator implementation for the Exact payment scheme (V1).
+ */
+declare class ExactSvmSchemeV1 implements SchemeNetworkFacilitator {
+    private readonly signer;
+    readonly scheme = "exact";
+    readonly caipFamily = "solana:*";
+    /**
+     * Creates a new ExactSvmFacilitatorV1 instance.
+     *
+     * @param signer - The SVM RPC client for facilitator operations
+     * @returns ExactSvmFacilitatorV1 instance
+     */
+    constructor(signer: FacilitatorSvmSigner);
+    /**
+     * Get mechanism-specific extra data for the supported kinds endpoint.
+     * For SVM, this includes a randomly selected fee payer address.
+     * Random selection distributes load across multiple signers.
+     *
+     * @param _ - The network identifier (unused for SVM)
+     * @returns Extra data with feePayer address
+     */
+    getExtra(_: string): Record<string, unknown> | undefined;
+    /**
+     * Get signer addresses used by this facilitator.
+     * For SVM, returns all available fee payer addresses.
+     *
+     * @param _ - The network identifier (unused for SVM)
+     * @returns Array of fee payer addresses
+     */
+    getSigners(_: string): string[];
+    /**
+     * Verifies a payment payload (V1).
+     *
+     * @param payload - The payment payload to verify
+     * @param requirements - The payment requirements
+     * @returns Promise resolving to verification response
+     */
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settles a payment by submitting the transaction (V1).
+     * Ensures the correct signer is used based on the feePayer specified in requirements.
+     *
+     * @param payload - The payment payload to settle
+     * @param requirements - The payment requirements
+     * @returns Promise resolving to settlement response
+     */
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Verify compute limit instruction
+     *
+     * @param instruction - The compute limit instruction
+     * @param instruction.programAddress - Program address
+     * @param instruction.data - Instruction data bytes
+     */
+    private verifyComputeLimitInstruction;
+    /**
+     * Verify compute price instruction
+     *
+     * @param instruction - The compute price instruction
+     * @param instruction.programAddress - Program address
+     * @param instruction.data - Instruction data bytes
+     */
+    private verifyComputePriceInstruction;
+}
+
+export { ExactSvmSchemeV1 };

package/lib/esm/exact/v1/facilitator/index.mjs

@@ -0,0 +1,8 @@
+import {
+  ExactSvmSchemeV1
+} from "../../../chunk-3CEIVWNN.mjs";
+import "../../../chunk-IKSTWKEM.mjs";
+export {
+  ExactSvmSchemeV1
+};
+//# sourceMappingURL=index.mjs.map

package/lib/esm/exact/v1/facilitator/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/lib/esm/facilitator/index.d.mts

@@ -0,0 +1,192 @@
+import { P as PaymentPayload, a as PaymentRequirements, V as VerifyResponse, S as SettleResponse, N as Network, b as SchemeNetworkFacilitator } from '../mechanisms-CzuGzYsS.mjs';
+
+/**
+ * Facilitator Hook Context Interfaces
+ */
+interface FacilitatorVerifyContext {
+    paymentPayload: PaymentPayload;
+    requirements: PaymentRequirements;
+}
+interface FacilitatorVerifyResultContext extends FacilitatorVerifyContext {
+    result: VerifyResponse;
+}
+interface FacilitatorVerifyFailureContext extends FacilitatorVerifyContext {
+    error: Error;
+}
+interface FacilitatorSettleContext {
+    paymentPayload: PaymentPayload;
+    requirements: PaymentRequirements;
+}
+interface FacilitatorSettleResultContext extends FacilitatorSettleContext {
+    result: SettleResponse;
+}
+interface FacilitatorSettleFailureContext extends FacilitatorSettleContext {
+    error: Error;
+}
+/**
+ * Facilitator Hook Type Definitions
+ */
+type FacilitatorBeforeVerifyHook = (context: FacilitatorVerifyContext) => Promise<void | {
+    abort: true;
+    reason: string;
+}>;
+type FacilitatorAfterVerifyHook = (context: FacilitatorVerifyResultContext) => Promise<void>;
+type FacilitatorOnVerifyFailureHook = (context: FacilitatorVerifyFailureContext) => Promise<void | {
+    recovered: true;
+    result: VerifyResponse;
+}>;
+type FacilitatorBeforeSettleHook = (context: FacilitatorSettleContext) => Promise<void | {
+    abort: true;
+    reason: string;
+}>;
+type FacilitatorAfterSettleHook = (context: FacilitatorSettleResultContext) => Promise<void>;
+type FacilitatorOnSettleFailureHook = (context: FacilitatorSettleFailureContext) => Promise<void | {
+    recovered: true;
+    result: SettleResponse;
+}>;
+/**
+ * Facilitator client for the x402 payment protocol.
+ * Manages payment scheme registration, verification, and settlement.
+ */
+declare class x402Facilitator {
+    private readonly registeredFacilitatorSchemes;
+    private readonly extensions;
+    private beforeVerifyHooks;
+    private afterVerifyHooks;
+    private onVerifyFailureHooks;
+    private beforeSettleHooks;
+    private afterSettleHooks;
+    private onSettleFailureHooks;
+    /**
+     * Registers a scheme facilitator for the current x402 version.
+     * Networks are stored and used for getSupported() - no need to specify them later.
+     *
+     * @param networks - Single network or array of networks this facilitator supports
+     * @param facilitator - The scheme network facilitator to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    register(networks: Network | Network[], facilitator: SchemeNetworkFacilitator): x402Facilitator;
+    /**
+     * Registers a scheme facilitator for x402 version 1.
+     * Networks are stored and used for getSupported() - no need to specify them later.
+     *
+     * @param networks - Single network or array of networks this facilitator supports
+     * @param facilitator - The scheme network facilitator to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    registerV1(networks: Network | Network[], facilitator: SchemeNetworkFacilitator): x402Facilitator;
+    /**
+     * Registers a protocol extension.
+     *
+     * @param extension - The extension name to register (e.g., "bazaar", "sign_in_with_x")
+     * @returns The x402Facilitator instance for chaining
+     */
+    registerExtension(extension: string): x402Facilitator;
+    /**
+     * Gets the list of registered extensions.
+     *
+     * @returns Array of extension names
+     */
+    getExtensions(): string[];
+    /**
+     * Register a hook to execute before facilitator payment verification.
+     * Can abort verification by returning { abort: true, reason: string }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onBeforeVerify(hook: FacilitatorBeforeVerifyHook): x402Facilitator;
+    /**
+     * Register a hook to execute after successful facilitator payment verification (isValid: true).
+     * This hook is NOT called when verification fails (isValid: false) - use onVerifyFailure for that.
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onAfterVerify(hook: FacilitatorAfterVerifyHook): x402Facilitator;
+    /**
+     * Register a hook to execute when facilitator payment verification fails.
+     * Called when: verification returns isValid: false, or an exception is thrown during verification.
+     * Can recover from failure by returning { recovered: true, result: VerifyResponse }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onVerifyFailure(hook: FacilitatorOnVerifyFailureHook): x402Facilitator;
+    /**
+     * Register a hook to execute before facilitator payment settlement.
+     * Can abort settlement by returning { abort: true, reason: string }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onBeforeSettle(hook: FacilitatorBeforeSettleHook): x402Facilitator;
+    /**
+     * Register a hook to execute after successful facilitator payment settlement.
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onAfterSettle(hook: FacilitatorAfterSettleHook): x402Facilitator;
+    /**
+     * Register a hook to execute when facilitator payment settlement fails.
+     * Can recover from failure by returning { recovered: true, result: SettleResponse }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    onSettleFailure(hook: FacilitatorOnSettleFailureHook): x402Facilitator;
+    /**
+     * Gets supported payment kinds, extensions, and signers.
+     * Uses networks registered during register() calls - no parameters needed.
+     * Returns flat array format for backward compatibility with V1 clients.
+     *
+     * @returns Supported response with kinds as array (with version in each element), extensions, and signers
+     */
+    getSupported(): {
+        kinds: Array<{
+            x402Version: number;
+            scheme: string;
+            network: string;
+            extra?: Record<string, unknown>;
+        }>;
+        extensions: string[];
+        signers: Record<string, string[]>;
+    };
+    /**
+     * Verifies a payment payload against requirements.
+     *
+     * @param paymentPayload - The payment payload to verify
+     * @param paymentRequirements - The payment requirements to verify against
+     * @returns Promise resolving to the verification response
+     */
+    verify(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settles a payment based on the payload and requirements.
+     *
+     * @param paymentPayload - The payment payload to settle
+     * @param paymentRequirements - The payment requirements for settlement
+     * @returns Promise resolving to the settlement response
+     */
+    settle(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Internal method to register a scheme facilitator.
+     *
+     * @param x402Version - The x402 protocol version
+     * @param networks - Array of concrete networks this facilitator supports
+     * @param facilitator - The scheme network facilitator to register
+     * @returns The x402Facilitator instance for chaining
+     */
+    private _registerScheme;
+    /**
+     * Derives a wildcard pattern from an array of networks.
+     * If all networks share the same namespace, returns wildcard pattern.
+     * Otherwise returns the first network for exact matching.
+     *
+     * @param networks - Array of networks
+     * @returns Derived pattern for matching
+     */
+    private derivePattern;
+}
+
+export { type FacilitatorAfterSettleHook, type FacilitatorAfterVerifyHook, type FacilitatorBeforeSettleHook, type FacilitatorBeforeVerifyHook, type FacilitatorOnSettleFailureHook, type FacilitatorOnVerifyFailureHook, type FacilitatorSettleContext, type FacilitatorSettleFailureContext, type FacilitatorSettleResultContext, type FacilitatorVerifyContext, type FacilitatorVerifyFailureContext, type FacilitatorVerifyResultContext, x402Facilitator };

package/lib/esm/facilitator/index.mjs

@@ -0,0 +1,373 @@
+import {
+  x402Version
+} from "../chunk-VE37GDG2.mjs";
+import "../chunk-BJTO5JO5.mjs";
+
+// src/facilitator/x402Facilitator.ts
+var x402Facilitator = class {
+  constructor() {
+    this.registeredFacilitatorSchemes = /* @__PURE__ */ new Map();
+    this.extensions = [];
+    this.beforeVerifyHooks = [];
+    this.afterVerifyHooks = [];
+    this.onVerifyFailureHooks = [];
+    this.beforeSettleHooks = [];
+    this.afterSettleHooks = [];
+    this.onSettleFailureHooks = [];
+  }
+  /**
+   * Registers a scheme facilitator for the current x402 version.
+   * Networks are stored and used for getSupported() - no need to specify them later.
+   *
+   * @param networks - Single network or array of networks this facilitator supports
+   * @param facilitator - The scheme network facilitator to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  register(networks, facilitator) {
+    const networksArray = Array.isArray(networks) ? networks : [networks];
+    return this._registerScheme(x402Version, networksArray, facilitator);
+  }
+  /**
+   * Registers a scheme facilitator for x402 version 1.
+   * Networks are stored and used for getSupported() - no need to specify them later.
+   *
+   * @param networks - Single network or array of networks this facilitator supports
+   * @param facilitator - The scheme network facilitator to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  registerV1(networks, facilitator) {
+    const networksArray = Array.isArray(networks) ? networks : [networks];
+    return this._registerScheme(1, networksArray, facilitator);
+  }
+  /**
+   * Registers a protocol extension.
+   *
+   * @param extension - The extension name to register (e.g., "bazaar", "sign_in_with_x")
+   * @returns The x402Facilitator instance for chaining
+   */
+  registerExtension(extension) {
+    if (!this.extensions.includes(extension)) {
+      this.extensions.push(extension);
+    }
+    return this;
+  }
+  /**
+   * Gets the list of registered extensions.
+   *
+   * @returns Array of extension names
+   */
+  getExtensions() {
+    return [...this.extensions];
+  }
+  /**
+   * Register a hook to execute before facilitator payment verification.
+   * Can abort verification by returning { abort: true, reason: string }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onBeforeVerify(hook) {
+    this.beforeVerifyHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute after successful facilitator payment verification (isValid: true).
+   * This hook is NOT called when verification fails (isValid: false) - use onVerifyFailure for that.
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onAfterVerify(hook) {
+    this.afterVerifyHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute when facilitator payment verification fails.
+   * Called when: verification returns isValid: false, or an exception is thrown during verification.
+   * Can recover from failure by returning { recovered: true, result: VerifyResponse }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onVerifyFailure(hook) {
+    this.onVerifyFailureHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute before facilitator payment settlement.
+   * Can abort settlement by returning { abort: true, reason: string }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onBeforeSettle(hook) {
+    this.beforeSettleHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute after successful facilitator payment settlement.
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onAfterSettle(hook) {
+    this.afterSettleHooks.push(hook);
+    return this;
+  }
+  /**
+   * Register a hook to execute when facilitator payment settlement fails.
+   * Can recover from failure by returning { recovered: true, result: SettleResponse }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  onSettleFailure(hook) {
+    this.onSettleFailureHooks.push(hook);
+    return this;
+  }
+  /**
+   * Gets supported payment kinds, extensions, and signers.
+   * Uses networks registered during register() calls - no parameters needed.
+   * Returns flat array format for backward compatibility with V1 clients.
+   *
+   * @returns Supported response with kinds as array (with version in each element), extensions, and signers
+   */
+  getSupported() {
+    const kinds = [];
+    const signersByFamily = {};
+    for (const [version, schemeDataArray] of this.registeredFacilitatorSchemes) {
+      for (const schemeData of schemeDataArray) {
+        const { facilitator, networks } = schemeData;
+        const scheme = facilitator.scheme;
+        for (const network of networks) {
+          const extra = facilitator.getExtra(network);
+          kinds.push({
+            x402Version: version,
+            scheme,
+            network,
+            ...extra && { extra }
+          });
+          const family = facilitator.caipFamily;
+          if (!signersByFamily[family]) {
+            signersByFamily[family] = /* @__PURE__ */ new Set();
+          }
+          facilitator.getSigners(network).forEach((signer) => signersByFamily[family].add(signer));
+        }
+      }
+    }
+    const signers = {};
+    for (const [family, signerSet] of Object.entries(signersByFamily)) {
+      signers[family] = Array.from(signerSet);
+    }
+    return {
+      kinds,
+      extensions: this.extensions,
+      signers
+    };
+  }
+  /**
+   * Verifies a payment payload against requirements.
+   *
+   * @param paymentPayload - The payment payload to verify
+   * @param paymentRequirements - The payment requirements to verify against
+   * @returns Promise resolving to the verification response
+   */
+  async verify(paymentPayload, paymentRequirements) {
+    const context = {
+      paymentPayload,
+      requirements: paymentRequirements
+    };
+    for (const hook of this.beforeVerifyHooks) {
+      const result = await hook(context);
+      if (result && "abort" in result && result.abort) {
+        return {
+          isValid: false,
+          invalidReason: result.reason
+        };
+      }
+    }
+    try {
+      const schemeDataArray = this.registeredFacilitatorSchemes.get(paymentPayload.x402Version);
+      if (!schemeDataArray) {
+        throw new Error(
+          `No facilitator registered for x402 version: ${paymentPayload.x402Version}`
+        );
+      }
+      let schemeNetworkFacilitator;
+      for (const schemeData of schemeDataArray) {
+        if (schemeData.facilitator.scheme === paymentRequirements.scheme) {
+          if (schemeData.networks.has(paymentRequirements.network)) {
+            schemeNetworkFacilitator = schemeData.facilitator;
+            break;
+          }
+          const patternRegex = new RegExp("^" + schemeData.pattern.replace("*", ".*") + "$");
+          if (patternRegex.test(paymentRequirements.network)) {
+            schemeNetworkFacilitator = schemeData.facilitator;
+            break;
+          }
+        }
+      }
+      if (!schemeNetworkFacilitator) {
+        throw new Error(
+          `No facilitator registered for scheme: ${paymentRequirements.scheme} and network: ${paymentRequirements.network}`
+        );
+      }
+      const verifyResult = await schemeNetworkFacilitator.verify(
+        paymentPayload,
+        paymentRequirements
+      );
+      if (!verifyResult.isValid) {
+        const failureContext = {
+          ...context,
+          error: new Error(verifyResult.invalidReason || "Verification failed")
+        };
+        for (const hook of this.onVerifyFailureHooks) {
+          const result = await hook(failureContext);
+          if (result && "recovered" in result && result.recovered) {
+            const recoveredContext = {
+              ...context,
+              result: result.result
+            };
+            for (const hook2 of this.afterVerifyHooks) {
+              await hook2(recoveredContext);
+            }
+            return result.result;
+          }
+        }
+        return verifyResult;
+      }
+      const resultContext = {
+        ...context,
+        result: verifyResult
+      };
+      for (const hook of this.afterVerifyHooks) {
+        await hook(resultContext);
+      }
+      return verifyResult;
+    } catch (error) {
+      const failureContext = {
+        ...context,
+        error
+      };
+      for (const hook of this.onVerifyFailureHooks) {
+        const result = await hook(failureContext);
+        if (result && "recovered" in result && result.recovered) {
+          return result.result;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Settles a payment based on the payload and requirements.
+   *
+   * @param paymentPayload - The payment payload to settle
+   * @param paymentRequirements - The payment requirements for settlement
+   * @returns Promise resolving to the settlement response
+   */
+  async settle(paymentPayload, paymentRequirements) {
+    const context = {
+      paymentPayload,
+      requirements: paymentRequirements
+    };
+    for (const hook of this.beforeSettleHooks) {
+      const result = await hook(context);
+      if (result && "abort" in result && result.abort) {
+        throw new Error(`Settlement aborted: ${result.reason}`);
+      }
+    }
+    try {
+      const schemeDataArray = this.registeredFacilitatorSchemes.get(paymentPayload.x402Version);
+      if (!schemeDataArray) {
+        throw new Error(
+          `No facilitator registered for x402 version: ${paymentPayload.x402Version}`
+        );
+      }
+      let schemeNetworkFacilitator;
+      for (const schemeData of schemeDataArray) {
+        if (schemeData.facilitator.scheme === paymentRequirements.scheme) {
+          if (schemeData.networks.has(paymentRequirements.network)) {
+            schemeNetworkFacilitator = schemeData.facilitator;
+            break;
+          }
+          const patternRegex = new RegExp("^" + schemeData.pattern.replace("*", ".*") + "$");
+          if (patternRegex.test(paymentRequirements.network)) {
+            schemeNetworkFacilitator = schemeData.facilitator;
+            break;
+          }
+        }
+      }
+      if (!schemeNetworkFacilitator) {
+        throw new Error(
+          `No facilitator registered for scheme: ${paymentRequirements.scheme} and network: ${paymentRequirements.network}`
+        );
+      }
+      const settleResult = await schemeNetworkFacilitator.settle(
+        paymentPayload,
+        paymentRequirements
+      );
+      const resultContext = {
+        ...context,
+        result: settleResult
+      };
+      for (const hook of this.afterSettleHooks) {
+        await hook(resultContext);
+      }
+      return settleResult;
+    } catch (error) {
+      const failureContext = {
+        ...context,
+        error
+      };
+      for (const hook of this.onSettleFailureHooks) {
+        const result = await hook(failureContext);
+        if (result && "recovered" in result && result.recovered) {
+          return result.result;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Internal method to register a scheme facilitator.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param networks - Array of concrete networks this facilitator supports
+   * @param facilitator - The scheme network facilitator to register
+   * @returns The x402Facilitator instance for chaining
+   */
+  _registerScheme(x402Version2, networks, facilitator) {
+    if (!this.registeredFacilitatorSchemes.has(x402Version2)) {
+      this.registeredFacilitatorSchemes.set(x402Version2, []);
+    }
+    const schemeDataArray = this.registeredFacilitatorSchemes.get(x402Version2);
+    schemeDataArray.push({
+      facilitator,
+      networks: new Set(networks),
+      pattern: this.derivePattern(networks)
+    });
+    return this;
+  }
+  /**
+   * Derives a wildcard pattern from an array of networks.
+   * If all networks share the same namespace, returns wildcard pattern.
+   * Otherwise returns the first network for exact matching.
+   *
+   * @param networks - Array of networks
+   * @returns Derived pattern for matching
+   */
+  derivePattern(networks) {
+    if (networks.length === 0) return "";
+    if (networks.length === 1) return networks[0];
+    const namespaces = networks.map((n) => n.split(":")[0]);
+    const uniqueNamespaces = new Set(namespaces);
+    if (uniqueNamespaces.size === 1) {
+      return `${namespaces[0]}:*`;
+    }
+    return networks[0];
+  }
+};
+export {
+  x402Facilitator
+};
+//# sourceMappingURL=index.mjs.map