@alleyboss/micropay-solana-x402-paywall 3.3.7 → 3.3.8

package/dist/index.cjs

@@ -528,6 +528,216 @@ function useFormatPrice(lamports) {
     isLoading: false
   };
 }
+var LocalSvmFacilitator = class {
+  scheme = "exact";
+  caipFamily = "solana:*";
+  connection;
+  constructor(rpcUrl) {
+    console.log("[LocalSvmFacilitator] Initialized with RPC:", rpcUrl);
+    this.connection = new web3_js.Connection(rpcUrl, "confirmed");
+  }
+  /**
+   * Get supported payment kinds
+   * Mocking the response of the /supported endpoint
+   */
+  /**
+   * Network Constants - CAIP-2 format for x402 v2
+   * These match the official Solana chain IDs used by x402 protocol
+   */
+  NETWORKS = {
+    DEVNET: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+  };
+  /**
+   * DUMMY_FEE_PAYER Explanation (for auditors):
+   * 
+   * In a HOSTED facilitator (like x402.org), the `feePayer` field in the 
+   * SupportedResponse.extra specifies which address will pay transaction fees
+   * when the facilitator submits transactions on behalf of users.
+   * 
+   * In LOCAL/SELF-SOVEREIGN mode (this implementation):
+   * - The USER pays their own transaction fees directly
+   * - The facilitator NEVER submits transactions - it only VERIFIES them
+   * - Therefore, no fee payer address is actually used
+   * 
+   * However, the x402 protocol REQUIRES this field in the response schema.
+   * We use the System Program address (all 1s) as a placeholder because:
+   * 1. It's clearly not a real wallet (obvious placeholder)
+   * 2. It cannot receive funds or sign transactions
+   * 3. It signals to developers that fee paying is handled differently
+   * 
+   * SECURITY NOTE: This is NOT a security risk because:
+   * - The fee payer is never used in verify() or settle() methods
+   * - Users sign and pay for their own transactions
+   * - The address is just a protocol-required placeholder
+   * 
+   * @see https://docs.x402.org for protocol specification
+   */
+  DUMMY_FEE_PAYER = "11111111111111111111111111111111";
+  /**
+   * Get supported payment kinds
+   * Returns x402 v2 compatible response with CAIP-2 network identifiers
+   * 
+   * NOTE: The feePayer in extra.feePayer is a placeholder only.
+   * In self-sovereign mode, users pay their own transaction fees.
+   */
+  async getSupported(_extensionKeys = []) {
+    const supported = {
+      kinds: [
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.DEVNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        },
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.MAINNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        }
+      ],
+      extensions: [],
+      signers: {
+        // Placeholder - in self-sovereign mode, users are their own signers
+        "solana:*": [this.DUMMY_FEE_PAYER]
+      }
+    };
+    return supported;
+  }
+  /**
+   * Get mechanism-specific extra data
+   */
+  getExtra(_network) {
+    return void 0;
+  }
+  /**
+   * Get default signers (not used for local verification usually, but required by interface)
+   */
+  getSigners(_network) {
+    return [];
+  }
+  /**
+   * Enable debug logging (disable in production)
+   */
+  debug = process.env.NODE_ENV === "development";
+  /**
+   * Verify a payment on-chain
+   */
+  async verify(payload, requirements) {
+    try {
+      const signature = payload.payload.signature;
+      if (!signature) {
+        return { isValid: false, invalidReason: "Missing signature in payment payload" };
+      }
+      const payTo = requirements.payTo;
+      const amountVal = requirements.amount || requirements.maxAmountRequired || "0";
+      const requiredAmount = BigInt(amountVal);
+      if (this.debug) {
+        console.log(`[LocalSvmFacilitator] Verifying tx: ${signature.slice(0, 8)}...`);
+      }
+      const tx = await this.fetchTransactionWithRetry(signature, 3);
+      if (!tx) {
+        return { isValid: false, invalidReason: "Transaction not found or not confirmed" };
+      }
+      const instructions = tx.transaction.message.instructions;
+      let paidAmount = 0n;
+      let payer = void 0;
+      for (const ix of instructions) {
+        if ("program" in ix && ix.program === "system") {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transfer" && parsed.info?.destination === payTo) {
+            paidAmount += BigInt(parsed.info.lamports);
+            if (!payer) payer = parsed.info.source;
+          }
+        }
+        if ("program" in ix && (ix.program === "spl-token" || ix.program === "spl-token-2022")) {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transferChecked" || parsed?.type === "transfer") {
+            if (this.debug) {
+              console.log(`[LocalSvmFacilitator] Found SPL transfer`);
+            }
+          }
+        }
+      }
+      if (paidAmount >= requiredAmount) {
+        if (this.debug) {
+          console.log(`[LocalSvmFacilitator] Verification SUCCESS for tx: ${signature.slice(0, 8)}...`);
+        }
+        return {
+          isValid: true,
+          payer: payer || tx.transaction.message.accountKeys[0].pubkey.toBase58()
+        };
+      }
+      return {
+        isValid: false,
+        invalidReason: "Insufficient payment amount",
+        payer
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (this.debug) {
+        console.error("[LocalSvmFacilitator] Verify error:", errorMessage);
+      }
+      throw new types.VerifyError(500, {
+        isValid: false,
+        invalidReason: errorMessage
+      });
+    }
+  }
+  /**
+   * Fetch transaction with exponential backoff retry
+   */
+  async fetchTransactionWithRetry(signature, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const tx = await this.connection.getParsedTransaction(signature, {
+          maxSupportedTransactionVersion: 0,
+          commitment: "confirmed"
+        });
+        if (tx) return tx;
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("RPC error");
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
+      }
+    }
+    if (lastError) throw lastError;
+    return null;
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Settle a payment (not applicable for direct chain verification, usually)
+   * But we must implement it. For 'exact', settlement is just verification + finality.
+   */
+  async settle(payload, requirements) {
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      throw new types.SettleError(400, {
+        success: false,
+        errorReason: verifyResult.invalidReason || "Verification failed",
+        transaction: payload.payload.signature,
+        network: requirements.network
+      });
+    }
+    return {
+      success: true,
+      payer: verifyResult.payer,
+      transaction: payload.payload.signature,
+      network: requirements.network
+    };
+  }
+};
 var DEFAULT_COMPUTE_UNITS = 2e5;
 var DEFAULT_MICRO_LAMPORTS = 1e3;
 function createPriorityFeeInstructions(config = {}) {
@@ -870,6 +1080,7 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
+exports.LocalSvmFacilitator = LocalSvmFacilitator;
 exports.addCredits = addCredits;
 exports.buildSolanaPayUrl = buildSolanaPayUrl;
 exports.clearPriceCache = clearPriceCache;

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 export * from '@x402/core';
+import { PaymentPayload, PaymentRequirements, VerifyResponse, SettleResponse, SupportedResponse, Network } from '@x402/core/types';
 export * from '@x402/core/types';
 export * from '@x402/core/client';
 export * from '@x402/svm';
@@ -7,3 +8,95 @@ export { AgentPaymentResult, CreditSessionClaims, CreditSessionConfig, CreditSes
 export { CustomPriceProvider, PriceConfig, PriceData, clearPriceCache, configurePricing, formatPriceDisplay, formatPriceSync, getProviders, getSolPrice, lamportsToSol, lamportsToUsd, usdToLamports } from './pricing/index.cjs';
 import '@solana/web3.js';
 import './types-BWYQMw03.cjs';
+
+interface FacilitatorClient {
+    verify(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+    settle(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+    getSupported(extensionKeys?: string[]): Promise<SupportedResponse>;
+}
+/**
+ * Local SVM Facilitator
+ *
+ * Verifies and settles Solana payments locally using a direct RPC connection,
+ * bypassing the need for a hosted facilitator service.
+ */
+declare class LocalSvmFacilitator implements FacilitatorClient {
+    readonly scheme = "exact";
+    readonly caipFamily = "solana:*";
+    private connection;
+    constructor(rpcUrl: string);
+    /**
+     * Get supported payment kinds
+     * Mocking the response of the /supported endpoint
+     */
+    /**
+     * Network Constants - CAIP-2 format for x402 v2
+     * These match the official Solana chain IDs used by x402 protocol
+     */
+    private readonly NETWORKS;
+    /**
+     * DUMMY_FEE_PAYER Explanation (for auditors):
+     *
+     * In a HOSTED facilitator (like x402.org), the `feePayer` field in the
+     * SupportedResponse.extra specifies which address will pay transaction fees
+     * when the facilitator submits transactions on behalf of users.
+     *
+     * In LOCAL/SELF-SOVEREIGN mode (this implementation):
+     * - The USER pays their own transaction fees directly
+     * - The facilitator NEVER submits transactions - it only VERIFIES them
+     * - Therefore, no fee payer address is actually used
+     *
+     * However, the x402 protocol REQUIRES this field in the response schema.
+     * We use the System Program address (all 1s) as a placeholder because:
+     * 1. It's clearly not a real wallet (obvious placeholder)
+     * 2. It cannot receive funds or sign transactions
+     * 3. It signals to developers that fee paying is handled differently
+     *
+     * SECURITY NOTE: This is NOT a security risk because:
+     * - The fee payer is never used in verify() or settle() methods
+     * - Users sign and pay for their own transactions
+     * - The address is just a protocol-required placeholder
+     *
+     * @see https://docs.x402.org for protocol specification
+     */
+    private readonly DUMMY_FEE_PAYER;
+    /**
+     * Get supported payment kinds
+     * Returns x402 v2 compatible response with CAIP-2 network identifiers
+     *
+     * NOTE: The feePayer in extra.feePayer is a placeholder only.
+     * In self-sovereign mode, users pay their own transaction fees.
+     */
+    getSupported(_extensionKeys?: string[]): Promise<SupportedResponse>;
+    /**
+     * Get mechanism-specific extra data
+     */
+    getExtra(_network: Network): Record<string, unknown> | undefined;
+    /**
+     * Get default signers (not used for local verification usually, but required by interface)
+     */
+    getSigners(_network: string): string[];
+    /**
+     * Enable debug logging (disable in production)
+     */
+    private debug;
+    /**
+     * Verify a payment on-chain
+     */
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Fetch transaction with exponential backoff retry
+     */
+    private fetchTransactionWithRetry;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Settle a payment (not applicable for direct chain verification, usually)
+     * But we must implement it. For 'exact', settlement is just verification + finality.
+     */
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+}
+
+export { LocalSvmFacilitator };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from '@x402/core';
+import { PaymentPayload, PaymentRequirements, VerifyResponse, SettleResponse, SupportedResponse, Network } from '@x402/core/types';
 export * from '@x402/core/types';
 export * from '@x402/core/client';
 export * from '@x402/svm';
@@ -7,3 +8,95 @@ export { AgentPaymentResult, CreditSessionClaims, CreditSessionConfig, CreditSes
 export { CustomPriceProvider, PriceConfig, PriceData, clearPriceCache, configurePricing, formatPriceDisplay, formatPriceSync, getProviders, getSolPrice, lamportsToSol, lamportsToUsd, usdToLamports } from './pricing/index.js';
 import '@solana/web3.js';
 import './types-BWYQMw03.js';
+
+interface FacilitatorClient {
+    verify(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+    settle(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+    getSupported(extensionKeys?: string[]): Promise<SupportedResponse>;
+}
+/**
+ * Local SVM Facilitator
+ *
+ * Verifies and settles Solana payments locally using a direct RPC connection,
+ * bypassing the need for a hosted facilitator service.
+ */
+declare class LocalSvmFacilitator implements FacilitatorClient {
+    readonly scheme = "exact";
+    readonly caipFamily = "solana:*";
+    private connection;
+    constructor(rpcUrl: string);
+    /**
+     * Get supported payment kinds
+     * Mocking the response of the /supported endpoint
+     */
+    /**
+     * Network Constants - CAIP-2 format for x402 v2
+     * These match the official Solana chain IDs used by x402 protocol
+     */
+    private readonly NETWORKS;
+    /**
+     * DUMMY_FEE_PAYER Explanation (for auditors):
+     *
+     * In a HOSTED facilitator (like x402.org), the `feePayer` field in the
+     * SupportedResponse.extra specifies which address will pay transaction fees
+     * when the facilitator submits transactions on behalf of users.
+     *
+     * In LOCAL/SELF-SOVEREIGN mode (this implementation):
+     * - The USER pays their own transaction fees directly
+     * - The facilitator NEVER submits transactions - it only VERIFIES them
+     * - Therefore, no fee payer address is actually used
+     *
+     * However, the x402 protocol REQUIRES this field in the response schema.
+     * We use the System Program address (all 1s) as a placeholder because:
+     * 1. It's clearly not a real wallet (obvious placeholder)
+     * 2. It cannot receive funds or sign transactions
+     * 3. It signals to developers that fee paying is handled differently
+     *
+     * SECURITY NOTE: This is NOT a security risk because:
+     * - The fee payer is never used in verify() or settle() methods
+     * - Users sign and pay for their own transactions
+     * - The address is just a protocol-required placeholder
+     *
+     * @see https://docs.x402.org for protocol specification
+     */
+    private readonly DUMMY_FEE_PAYER;
+    /**
+     * Get supported payment kinds
+     * Returns x402 v2 compatible response with CAIP-2 network identifiers
+     *
+     * NOTE: The feePayer in extra.feePayer is a placeholder only.
+     * In self-sovereign mode, users pay their own transaction fees.
+     */
+    getSupported(_extensionKeys?: string[]): Promise<SupportedResponse>;
+    /**
+     * Get mechanism-specific extra data
+     */
+    getExtra(_network: Network): Record<string, unknown> | undefined;
+    /**
+     * Get default signers (not used for local verification usually, but required by interface)
+     */
+    getSigners(_network: string): string[];
+    /**
+     * Enable debug logging (disable in production)
+     */
+    private debug;
+    /**
+     * Verify a payment on-chain
+     */
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Fetch transaction with exponential backoff retry
+     */
+    private fetchTransactionWithRetry;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Settle a payment (not applicable for direct chain verification, usually)
+     * But we must implement it. For 'exact', settlement is just verification + finality.
+     */
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+}
+
+export { LocalSvmFacilitator };

package/dist/index.js

@@ -1,9 +1,10 @@
 export * from '@x402/core';
+import { VerifyError, SettleError } from '@x402/core/types';
 export * from '@x402/core/types';
 export * from '@x402/core/client';
 export * from '@x402/svm';
 import { decodePaymentRequiredHeader, encodePaymentSignatureHeader } from '@x402/core/http';
-import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL, Keypair, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } from '@solana/web3.js';
+import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL, Connection, Keypair, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } from '@solana/web3.js';
 import { useState, useCallback, useEffect, useRef } from 'react';
 import bs58 from 'bs58';
 import { SignJWT, jwtVerify } from 'jose';
@@ -522,6 +523,216 @@ function useFormatPrice(lamports) {
     isLoading: false
   };
 }
+var LocalSvmFacilitator = class {
+  scheme = "exact";
+  caipFamily = "solana:*";
+  connection;
+  constructor(rpcUrl) {
+    console.log("[LocalSvmFacilitator] Initialized with RPC:", rpcUrl);
+    this.connection = new Connection(rpcUrl, "confirmed");
+  }
+  /**
+   * Get supported payment kinds
+   * Mocking the response of the /supported endpoint
+   */
+  /**
+   * Network Constants - CAIP-2 format for x402 v2
+   * These match the official Solana chain IDs used by x402 protocol
+   */
+  NETWORKS = {
+    DEVNET: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+  };
+  /**
+   * DUMMY_FEE_PAYER Explanation (for auditors):
+   * 
+   * In a HOSTED facilitator (like x402.org), the `feePayer` field in the 
+   * SupportedResponse.extra specifies which address will pay transaction fees
+   * when the facilitator submits transactions on behalf of users.
+   * 
+   * In LOCAL/SELF-SOVEREIGN mode (this implementation):
+   * - The USER pays their own transaction fees directly
+   * - The facilitator NEVER submits transactions - it only VERIFIES them
+   * - Therefore, no fee payer address is actually used
+   * 
+   * However, the x402 protocol REQUIRES this field in the response schema.
+   * We use the System Program address (all 1s) as a placeholder because:
+   * 1. It's clearly not a real wallet (obvious placeholder)
+   * 2. It cannot receive funds or sign transactions
+   * 3. It signals to developers that fee paying is handled differently
+   * 
+   * SECURITY NOTE: This is NOT a security risk because:
+   * - The fee payer is never used in verify() or settle() methods
+   * - Users sign and pay for their own transactions
+   * - The address is just a protocol-required placeholder
+   * 
+   * @see https://docs.x402.org for protocol specification
+   */
+  DUMMY_FEE_PAYER = "11111111111111111111111111111111";
+  /**
+   * Get supported payment kinds
+   * Returns x402 v2 compatible response with CAIP-2 network identifiers
+   * 
+   * NOTE: The feePayer in extra.feePayer is a placeholder only.
+   * In self-sovereign mode, users pay their own transaction fees.
+   */
+  async getSupported(_extensionKeys = []) {
+    const supported = {
+      kinds: [
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.DEVNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        },
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.MAINNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        }
+      ],
+      extensions: [],
+      signers: {
+        // Placeholder - in self-sovereign mode, users are their own signers
+        "solana:*": [this.DUMMY_FEE_PAYER]
+      }
+    };
+    return supported;
+  }
+  /**
+   * Get mechanism-specific extra data
+   */
+  getExtra(_network) {
+    return void 0;
+  }
+  /**
+   * Get default signers (not used for local verification usually, but required by interface)
+   */
+  getSigners(_network) {
+    return [];
+  }
+  /**
+   * Enable debug logging (disable in production)
+   */
+  debug = process.env.NODE_ENV === "development";
+  /**
+   * Verify a payment on-chain
+   */
+  async verify(payload, requirements) {
+    try {
+      const signature = payload.payload.signature;
+      if (!signature) {
+        return { isValid: false, invalidReason: "Missing signature in payment payload" };
+      }
+      const payTo = requirements.payTo;
+      const amountVal = requirements.amount || requirements.maxAmountRequired || "0";
+      const requiredAmount = BigInt(amountVal);
+      if (this.debug) {
+        console.log(`[LocalSvmFacilitator] Verifying tx: ${signature.slice(0, 8)}...`);
+      }
+      const tx = await this.fetchTransactionWithRetry(signature, 3);
+      if (!tx) {
+        return { isValid: false, invalidReason: "Transaction not found or not confirmed" };
+      }
+      const instructions = tx.transaction.message.instructions;
+      let paidAmount = 0n;
+      let payer = void 0;
+      for (const ix of instructions) {
+        if ("program" in ix && ix.program === "system") {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transfer" && parsed.info?.destination === payTo) {
+            paidAmount += BigInt(parsed.info.lamports);
+            if (!payer) payer = parsed.info.source;
+          }
+        }
+        if ("program" in ix && (ix.program === "spl-token" || ix.program === "spl-token-2022")) {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transferChecked" || parsed?.type === "transfer") {
+            if (this.debug) {
+              console.log(`[LocalSvmFacilitator] Found SPL transfer`);
+            }
+          }
+        }
+      }
+      if (paidAmount >= requiredAmount) {
+        if (this.debug) {
+          console.log(`[LocalSvmFacilitator] Verification SUCCESS for tx: ${signature.slice(0, 8)}...`);
+        }
+        return {
+          isValid: true,
+          payer: payer || tx.transaction.message.accountKeys[0].pubkey.toBase58()
+        };
+      }
+      return {
+        isValid: false,
+        invalidReason: "Insufficient payment amount",
+        payer
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (this.debug) {
+        console.error("[LocalSvmFacilitator] Verify error:", errorMessage);
+      }
+      throw new VerifyError(500, {
+        isValid: false,
+        invalidReason: errorMessage
+      });
+    }
+  }
+  /**
+   * Fetch transaction with exponential backoff retry
+   */
+  async fetchTransactionWithRetry(signature, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const tx = await this.connection.getParsedTransaction(signature, {
+          maxSupportedTransactionVersion: 0,
+          commitment: "confirmed"
+        });
+        if (tx) return tx;
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("RPC error");
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
+      }
+    }
+    if (lastError) throw lastError;
+    return null;
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Settle a payment (not applicable for direct chain verification, usually)
+   * But we must implement it. For 'exact', settlement is just verification + finality.
+   */
+  async settle(payload, requirements) {
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      throw new SettleError(400, {
+        success: false,
+        errorReason: verifyResult.invalidReason || "Verification failed",
+        transaction: payload.payload.signature,
+        network: requirements.network
+      });
+    }
+    return {
+      success: true,
+      payer: verifyResult.payer,
+      transaction: payload.payload.signature,
+      network: requirements.network
+    };
+  }
+};
 var DEFAULT_COMPUTE_UNITS = 2e5;
 var DEFAULT_MICRO_LAMPORTS = 1e3;
 function createPriorityFeeInstructions(config = {}) {
@@ -864,4 +1075,4 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
-export { addCredits, buildSolanaPayUrl, clearPriceCache, configurePricing, createCreditSession, createPaymentFlow, createPaymentReference, createX402AuthorizationHeader, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, sendSolanaPayment, usdToLamports, useCredit, useFormatPrice, useLamportsToUsd, useMicropay, usePaywallResource, usePricing, validateCreditSession };
+export { LocalSvmFacilitator, addCredits, buildSolanaPayUrl, clearPriceCache, configurePricing, createCreditSession, createPaymentFlow, createPaymentReference, createX402AuthorizationHeader, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, sendSolanaPayment, usdToLamports, useCredit, useFormatPrice, useLamportsToUsd, useMicropay, usePaywallResource, usePricing, validateCreditSession };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@alleyboss/micropay-solana-x402-paywall",
-    "version": "3.3.7",
+    "version": "3.3.8",
     "description": "Production-ready Solana micropayments library wrapper for official x402 SDK",
     "author": "AlleyBoss",
     "license": "MIT",