@alleyboss/micropay-solana-x402-paywall 3.5.0 → 3.5.2

package/dist/index.js

@@ -626,6 +626,456 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
+// src/fetch/types.ts
+var X402ErrorCode = {
+  /** User rejected the payment */
+  USER_REJECTED: "USER_REJECTED",
+  /** Insufficient wallet balance */
+  INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+  /** Transaction failed on-chain */
+  TRANSACTION_FAILED: "TRANSACTION_FAILED",
+  /** Network/RPC error */
+  NETWORK_ERROR: "NETWORK_ERROR",
+  /** Invalid 402 response format */
+  INVALID_402_RESPONSE: "INVALID_402_RESPONSE",
+  /** Payment timeout */
+  TIMEOUT: "TIMEOUT",
+  /** Wallet not connected */
+  WALLET_NOT_CONNECTED: "WALLET_NOT_CONNECTED",
+  /** Payment amount exceeds maxPaymentPerRequest */
+  AMOUNT_EXCEEDS_LIMIT: "AMOUNT_EXCEEDS_LIMIT",
+  /** Recipient address not in allowedRecipients whitelist */
+  RECIPIENT_NOT_ALLOWED: "RECIPIENT_NOT_ALLOWED",
+  /** Rate limit exceeded */
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED"
+};
+
+// src/fetch/errors.ts
+var X402PaymentError = class _X402PaymentError extends Error {
+  constructor(message, code, requirements, cause) {
+    super(message);
+    this.code = code;
+    this.requirements = requirements;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _X402PaymentError);
+    }
+  }
+  name = "X402PaymentError";
+  /**
+   * Check if error is retryable
+   */
+  get isRetryable() {
+    const retryableCodes = [
+      X402ErrorCode.NETWORK_ERROR,
+      X402ErrorCode.TIMEOUT,
+      X402ErrorCode.TRANSACTION_FAILED
+    ];
+    return retryableCodes.includes(this.code);
+  }
+  /**
+   * Convert to JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      requirements: this.requirements,
+      isRetryable: this.isRetryable
+    };
+  }
+};
+function userRejectedError(requirements) {
+  return new X402PaymentError(
+    "User rejected the payment request",
+    X402ErrorCode.USER_REJECTED,
+    requirements
+  );
+}
+function insufficientBalanceError(requirements, balance) {
+  return new X402PaymentError(
+    `Insufficient balance: have ${balance} lamports, need ${requirements.amount}`,
+    X402ErrorCode.INSUFFICIENT_BALANCE,
+    requirements
+  );
+}
+function transactionFailedError(requirements, cause) {
+  return new X402PaymentError(
+    `Transaction failed: ${cause?.message ?? "Unknown error"}`,
+    X402ErrorCode.TRANSACTION_FAILED,
+    requirements,
+    cause
+  );
+}
+function networkError(cause) {
+  return new X402PaymentError(
+    `Network error: ${cause?.message ?? "Connection failed"}`,
+    X402ErrorCode.NETWORK_ERROR,
+    void 0,
+    cause
+  );
+}
+function invalid402ResponseError(details) {
+  return new X402PaymentError(
+    `Invalid 402 response: ${details ?? "Missing or malformed payment requirements"}`,
+    X402ErrorCode.INVALID_402_RESPONSE
+  );
+}
+function timeoutError(requirements) {
+  return new X402PaymentError(
+    "Payment flow timed out",
+    X402ErrorCode.TIMEOUT,
+    requirements
+  );
+}
+function walletNotConnectedError() {
+  return new X402PaymentError(
+    "Wallet is not connected",
+    X402ErrorCode.WALLET_NOT_CONNECTED
+  );
+}
+function amountExceedsLimitError(requirements, limit) {
+  return new X402PaymentError(
+    `Payment amount ${requirements.amount} exceeds limit of ${limit} lamports`,
+    X402ErrorCode.AMOUNT_EXCEEDS_LIMIT,
+    requirements
+  );
+}
+function recipientNotAllowedError(requirements, recipient) {
+  return new X402PaymentError(
+    `Recipient ${recipient} is not in the allowed recipients list`,
+    X402ErrorCode.RECIPIENT_NOT_ALLOWED,
+    requirements
+  );
+}
+function rateLimitExceededError(limit, windowMs) {
+  return new X402PaymentError(
+    `Rate limit exceeded: max ${limit} payments per ${windowMs / 1e3}s`,
+    X402ErrorCode.RATE_LIMIT_EXCEEDED
+  );
+}
+
+// src/shared/constants.ts
+var RPC_ENDPOINTS = {
+  "mainnet-beta": "https://api.mainnet-beta.solana.com",
+  "devnet": "https://api.devnet.solana.com",
+  "testnet": "https://api.testnet.solana.com"
+};
+var DEFAULT_CONFIRMATION_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RATE_LIMIT_WINDOW_MS = 6e4;
+var DEFAULT_RATE_LIMIT_MAX_PAYMENTS = 10;
+
+// src/fetch/x402Fetch.ts
+function isKeypair(wallet) {
+  return wallet instanceof Keypair;
+}
+function isWalletConnected(wallet) {
+  if (isKeypair(wallet)) return true;
+  return wallet.connected && wallet.publicKey != null;
+}
+function getPublicKey(wallet) {
+  if (isKeypair(wallet)) return wallet.publicKey;
+  if (!wallet.publicKey) throw walletNotConnectedError();
+  return wallet.publicKey;
+}
+function parse402Response(response) {
+  const x402Header = response.headers.get("X-Payment-Requirements");
+  if (x402Header) {
+    try {
+      const parsed = JSON.parse(x402Header);
+      return {
+        payTo: parsed.payTo ?? parsed.recipient,
+        amount: String(parsed.amount),
+        asset: parsed.asset ?? "SOL",
+        network: parsed.network ?? "solana-mainnet",
+        description: parsed.description,
+        resource: parsed.resource,
+        maxAge: parsed.maxAge
+      };
+    } catch {
+      throw invalid402ResponseError("Invalid X-Payment-Requirements header");
+    }
+  }
+  const wwwAuth = response.headers.get("WWW-Authenticate");
+  if (wwwAuth?.startsWith("X402")) {
+    try {
+      const base64Part = wwwAuth.slice(5).trim();
+      const jsonStr = atob(base64Part);
+      const parsed = JSON.parse(jsonStr);
+      return {
+        payTo: parsed.payTo ?? parsed.recipient,
+        amount: String(parsed.amount),
+        asset: parsed.asset ?? "SOL",
+        network: parsed.network ?? "solana-mainnet",
+        description: parsed.description,
+        resource: parsed.resource,
+        maxAge: parsed.maxAge
+      };
+    } catch {
+      throw invalid402ResponseError("Invalid WWW-Authenticate header");
+    }
+  }
+  const paymentRequired = response.headers.get("payment-required");
+  if (paymentRequired) {
+    try {
+      const jsonStr = atob(paymentRequired.trim());
+      const parsed = JSON.parse(jsonStr);
+      const option = Array.isArray(parsed.accepts) && parsed.accepts.length > 0 ? parsed.accepts[0] : parsed;
+      return {
+        payTo: option.payTo ?? option.recipient,
+        amount: String(option.amount),
+        asset: option.asset ?? "SOL",
+        network: option.network ?? "solana-mainnet",
+        description: parsed.description ?? option.description,
+        resource: parsed.resource ?? option.resource,
+        maxAge: parsed.maxAge ?? option.maxAge
+      };
+    } catch {
+      throw invalid402ResponseError("Invalid payment-required header");
+    }
+  }
+  throw invalid402ResponseError("No payment requirements found in 402 response");
+}
+function buildPaymentHeader(signature) {
+  const payload = {
+    x402Version: 2,
+    scheme: "exact",
+    payload: { signature }
+  };
+  return `X402 ${btoa(JSON.stringify(payload))}`;
+}
+function createX402Fetch(config) {
+  const {
+    wallet,
+    network = "mainnet-beta",
+    connection: providedConnection,
+    // Reserved for future facilitator integration
+    onPaymentRequired,
+    onPaymentSuccess,
+    onPaymentError,
+    priorityFee,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    timeout = DEFAULT_CONFIRMATION_TIMEOUT,
+    // Security options
+    maxPaymentPerRequest,
+    allowedRecipients,
+    // UX options
+    commitment = "confirmed",
+    rateLimit
+  } = config;
+  const paymentTimestamps = [];
+  const rateLimitMax = rateLimit?.maxPayments ?? DEFAULT_RATE_LIMIT_MAX_PAYMENTS;
+  const rateLimitWindow = rateLimit?.windowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS;
+  function checkRateLimit() {
+    const now = Date.now();
+    while (paymentTimestamps.length > 0 && paymentTimestamps[0] < now - rateLimitWindow) {
+      paymentTimestamps.shift();
+    }
+    if (paymentTimestamps.length >= rateLimitMax) {
+      throw rateLimitExceededError(rateLimitMax, rateLimitWindow);
+    }
+  }
+  function recordPayment() {
+    paymentTimestamps.push(Date.now());
+  }
+  function validateSecurityRequirements(requirements) {
+    const amountLamports = BigInt(requirements.amount);
+    if (maxPaymentPerRequest !== void 0 && amountLamports > maxPaymentPerRequest) {
+      throw amountExceedsLimitError(requirements, maxPaymentPerRequest);
+    }
+    if (allowedRecipients !== void 0 && allowedRecipients.length > 0) {
+      if (!allowedRecipients.includes(requirements.payTo)) {
+        throw recipientNotAllowedError(requirements, requirements.payTo);
+      }
+    }
+  }
+  const connection = providedConnection ?? new Connection(RPC_ENDPOINTS[network], {
+    commitment
+  });
+  async function executePayment(requirements) {
+    const payer = getPublicKey(wallet);
+    const recipient = new PublicKey(requirements.payTo);
+    const amountLamports = BigInt(requirements.amount);
+    const balance = await connection.getBalance(payer);
+    if (BigInt(balance) < amountLamports) {
+      throw insufficientBalanceError(requirements, BigInt(balance));
+    }
+    const instructions = [];
+    if (priorityFee?.enabled) {
+      instructions.push(
+        ComputeBudgetProgram.setComputeUnitPrice({
+          microLamports: priorityFee.microLamports ?? 5e3
+        })
+      );
+    }
+    instructions.push(
+      SystemProgram.transfer({
+        fromPubkey: payer,
+        toPubkey: recipient,
+        lamports: amountLamports
+      })
+    );
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const messageV0 = new TransactionMessage({
+      payerKey: payer,
+      recentBlockhash: blockhash,
+      instructions
+    }).compileToV0Message();
+    const tx = new VersionedTransaction(messageV0);
+    if (isKeypair(wallet)) {
+      tx.sign([wallet]);
+    } else {
+      const signerWallet = wallet;
+      if (!signerWallet.signTransaction) {
+        throw new X402PaymentError(
+          "Wallet does not support transaction signing. Use a SignerWalletAdapter.",
+          "WALLET_NOT_CONNECTED"
+        );
+      }
+      const signedTx = await signerWallet.signTransaction(tx);
+      if (signedTx.signatures[0]) {
+        tx.signatures[0] = signedTx.signatures[0];
+      }
+    }
+    const signature = await connection.sendTransaction(tx, {
+      maxRetries
+    });
+    await connection.confirmTransaction({
+      signature,
+      blockhash,
+      lastValidBlockHeight
+    }, commitment);
+    return signature;
+  }
+  async function x402Fetch(input, init) {
+    const { skipPayment, paymentOverride, ...fetchInit } = init ?? {};
+    let response;
+    try {
+      response = await fetch(input, fetchInit);
+    } catch (error) {
+      throw networkError(error instanceof Error ? error : void 0);
+    }
+    if (response.status !== 402) {
+      return response;
+    }
+    if (skipPayment) {
+      return response;
+    }
+    if (!isWalletConnected(wallet)) {
+      throw walletNotConnectedError();
+    }
+    let requirements;
+    try {
+      requirements = parse402Response(response);
+      if (paymentOverride) {
+        requirements = { ...requirements, ...paymentOverride };
+      }
+    } catch (error) {
+      if (error instanceof X402PaymentError) throw error;
+      throw invalid402ResponseError(error instanceof Error ? error.message : void 0);
+    }
+    validateSecurityRequirements(requirements);
+    checkRateLimit();
+    if (onPaymentRequired) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const shouldProceed = await onPaymentRequired(requirements, url);
+      if (!shouldProceed) {
+        throw userRejectedError(requirements);
+      }
+    }
+    let signature;
+    try {
+      const paymentPromise = executePayment(requirements);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(timeoutError(requirements)), timeout);
+      });
+      signature = await Promise.race([paymentPromise, timeoutPromise]);
+      recordPayment();
+      if (onPaymentSuccess) {
+        await onPaymentSuccess(signature, requirements);
+      }
+    } catch (error) {
+      if (error instanceof X402PaymentError) {
+        if (onPaymentError) {
+          await onPaymentError(error, requirements);
+        }
+        throw error;
+      }
+      const wrappedError = transactionFailedError(
+        requirements,
+        error instanceof Error ? error : void 0
+      );
+      if (onPaymentError) {
+        await onPaymentError(wrappedError, requirements);
+      }
+      throw wrappedError;
+    }
+    const retryHeaders = new Headers(fetchInit?.headers);
+    retryHeaders.set("Authorization", buildPaymentHeader(signature));
+    try {
+      return await fetch(input, {
+        ...fetchInit,
+        headers: retryHeaders
+      });
+    } catch (error) {
+      throw networkError(error instanceof Error ? error : void 0);
+    }
+  }
+  return x402Fetch;
+}
+
+// src/agent/payingAgent.ts
+function createPayingAgent(privateKey, config = {}) {
+  const {
+    network = "mainnet-beta",
+    rpcUrl,
+    maxPaymentPerRequest,
+    allowedRecipients,
+    priorityFee = true
+  } = config;
+  let keypair;
+  if (privateKey.includes(",")) {
+    const bytes = new Uint8Array(privateKey.split(",").map((n) => parseInt(n.trim(), 10)));
+    keypair = Keypair.fromSecretKey(bytes);
+  } else {
+    keypair = Keypair.fromSecretKey(bs58.decode(privateKey));
+  }
+  const endpoint = rpcUrl ?? RPC_ENDPOINTS[network];
+  const connection = new Connection(endpoint, "confirmed");
+  const fetchConfig = {
+    wallet: keypair,
+    network,
+    connection,
+    maxPaymentPerRequest,
+    allowedRecipients,
+    priorityFee: priorityFee ? { enabled: true, microLamports: 5e3 } : void 0
+  };
+  const x402Fetch = createX402Fetch(fetchConfig);
+  return {
+    get: (url, init) => x402Fetch(url, { ...init, method: "GET" }),
+    post: (url, body, init) => x402Fetch(url, {
+      ...init,
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json",
+        ...init?.headers
+      }
+    }),
+    fetch: (url, init) => x402Fetch(url, init),
+    publicKey: keypair.publicKey.toBase58(),
+    getBalance: async () => {
+      const lamports = await connection.getBalance(keypair.publicKey);
+      return {
+        lamports: BigInt(lamports),
+        sol: lamports / 1e9
+      };
+    }
+  };
+}
+
 // src/pricing/utils.ts
 function lamportsToSol(lamports) {
   return Number(lamports) / 1e9;
@@ -777,4 +1227,4 @@ function getProviders() {
   return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
 }
 
-export { LocalSvmFacilitator, RemoteSvmFacilitator, addCredits, clearPriceCache, configurePricing, createCreditSession, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, usdToLamports, useCredit, validateCreditSession };
+export { LocalSvmFacilitator, RemoteSvmFacilitator, addCredits, clearPriceCache, configurePricing, createCreditSession, createPayingAgent, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, usdToLamports, useCredit, validateCreditSession };

package/dist/next/index.cjs

@@ -233,31 +233,14 @@ function createX402Middleware(config) {
   const server$2 = new server.x402ResourceServer(facilitatorClient);
   server$1.registerExactSvmScheme(server$2);
   const networkId = config.network === "mainnet-beta" ? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" : "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-  return function withMicropay(handler, routeConfig) {
+  return function withMicropay(handler, _routeConfig) {
     const priceValue = config.price?.toString() || "0";
-    const amountValue = (BigInt(priceValue) * BigInt(1e6)).toString();
-    const paymentSpec = {
-      scheme: "exact",
-      payTo: config.walletAddress,
-      amount: amountValue,
-      network: networkId,
-      asset: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
-      // Native SOL asset
-    };
-    const finalConfig = routeConfig || {
-      accepts: {
-        ...paymentSpec,
-        price: priceValue
-        // Include for x402 SDK 402 generation
-      }
-    };
-    const wrappedHandler = next.withX402(handler, finalConfig, server$2);
     return async (req, ctx) => {
       const authHeader = req.headers?.get?.("authorization") || req.headers?.authorization;
       if (authHeader && authHeader.toLowerCase().startsWith("x402 ")) {
         try {
-          const base64Payload = authHeader.slice(5);
-          const payloadJson = Buffer.from(base64Payload, "base64").toString("utf8");
+          const base64Payload2 = authHeader.slice(5);
+          const payloadJson = Buffer.from(base64Payload2, "base64").toString("utf8");
           let payload = JSON.parse(payloadJson);
           if (payload.scheme === "exact-svm" || payload.scheme === "exact-evm") {
             payload = transformPayAIToX402(payload, networkId);
@@ -267,7 +250,7 @@ function createX402Middleware(config) {
             const verifyPaymentSpec = {
               scheme: payload.scheme || "exact",
               network: payload.network || networkId,
-              amount: amountValue,
+              amount: priceValue,
               payTo: config.walletAddress
             };
             let verifyResult;
@@ -290,32 +273,33 @@ function createX402Middleware(config) {
         } catch (parseError) {
         }
       }
-      const compatibleReq = new Proxy(req, {
-        get(target, prop) {
-          if (prop === "url") {
-            return target.nextUrl?.pathname || target.url;
-          }
-          if (prop === "headers") {
-            const headers = target.headers;
-            return new Proxy(headers, {
-              get(hTarget, hProp) {
-                if (hProp === "authorization" || hProp === "Authorization") {
-                  const val3 = hTarget.get("authorization");
-                  return val3;
-                }
-                if (typeof hProp === "string" && !["get", "set", "has", "delete", "entries", "keys", "values", "forEach", "append"].includes(hProp) && typeof hTarget[hProp] === "undefined") {
-                  return hTarget.get(hProp) || void 0;
-                }
-                const val2 = hTarget[hProp];
-                return typeof val2 === "function" ? val2.bind(hTarget) : val2;
-              }
-            });
-          }
-          const val = target[prop];
-          return typeof val === "function" ? val.bind(target) : val;
+      const paymentPayload = {
+        x402Version: 2,
+        error: "Payment required",
+        resource: {
+          url: req.nextUrl?.pathname || req.url,
+          description: "",
+          mimeType: ""
+        },
+        accepts: [{
+          scheme: "exact",
+          network: networkId,
+          amount: priceValue,
+          // Use raw lamports, no multiplier
+          asset: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+          payTo: config.walletAddress,
+          maxTimeoutSeconds: 300,
+          extra: { feePayer: "11111111111111111111111111111111" }
+        }]
+      };
+      const base64Payload = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+      return new Response(JSON.stringify({}), {
+        status: 402,
+        headers: {
+          "Content-Type": "application/json",
+          "payment-required": base64Payload
         }
       });
-      return await wrappedHandler(compatibleReq, ctx);
     };
   };
 }

package/dist/next/index.d.cts

@@ -19,7 +19,7 @@ interface X402Config {
 /**
  * Create a specialized Next.js middleware with Solana support pre-configured
  */
-declare function createX402Middleware(config: X402Config): (handler: any, routeConfig?: any) => (req: any, ctx: any) => Promise<any>;
+declare function createX402Middleware(config: X402Config): (handler: any, _routeConfig?: any) => (req: any, ctx: any) => Promise<any>;
 declare const withX402: typeof withX402$1;
 
 export { type X402Config, createX402Middleware, withX402 };

package/dist/next/index.d.ts

@@ -19,7 +19,7 @@ interface X402Config {
 /**
  * Create a specialized Next.js middleware with Solana support pre-configured
  */
-declare function createX402Middleware(config: X402Config): (handler: any, routeConfig?: any) => (req: any, ctx: any) => Promise<any>;
+declare function createX402Middleware(config: X402Config): (handler: any, _routeConfig?: any) => (req: any, ctx: any) => Promise<any>;
 declare const withX402: typeof withX402$1;
 
 export { type X402Config, createX402Middleware, withX402 };

package/dist/next/index.js

@@ -232,31 +232,14 @@ function createX402Middleware(config) {
   const server = new x402ResourceServer(facilitatorClient);
   registerExactSvmScheme(server);
   const networkId = config.network === "mainnet-beta" ? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" : "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-  return function withMicropay(handler, routeConfig) {
+  return function withMicropay(handler, _routeConfig) {
     const priceValue = config.price?.toString() || "0";
-    const amountValue = (BigInt(priceValue) * BigInt(1e6)).toString();
-    const paymentSpec = {
-      scheme: "exact",
-      payTo: config.walletAddress,
-      amount: amountValue,
-      network: networkId,
-      asset: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
-      // Native SOL asset
-    };
-    const finalConfig = routeConfig || {
-      accepts: {
-        ...paymentSpec,
-        price: priceValue
-        // Include for x402 SDK 402 generation
-      }
-    };
-    const wrappedHandler = withX402$1(handler, finalConfig, server);
     return async (req, ctx) => {
       const authHeader = req.headers?.get?.("authorization") || req.headers?.authorization;
       if (authHeader && authHeader.toLowerCase().startsWith("x402 ")) {
         try {
-          const base64Payload = authHeader.slice(5);
-          const payloadJson = Buffer.from(base64Payload, "base64").toString("utf8");
+          const base64Payload2 = authHeader.slice(5);
+          const payloadJson = Buffer.from(base64Payload2, "base64").toString("utf8");
           let payload = JSON.parse(payloadJson);
           if (payload.scheme === "exact-svm" || payload.scheme === "exact-evm") {
             payload = transformPayAIToX402(payload, networkId);
@@ -266,7 +249,7 @@ function createX402Middleware(config) {
             const verifyPaymentSpec = {
               scheme: payload.scheme || "exact",
               network: payload.network || networkId,
-              amount: amountValue,
+              amount: priceValue,
               payTo: config.walletAddress
             };
             let verifyResult;
@@ -289,32 +272,33 @@ function createX402Middleware(config) {
         } catch (parseError) {
         }
       }
-      const compatibleReq = new Proxy(req, {
-        get(target, prop) {
-          if (prop === "url") {
-            return target.nextUrl?.pathname || target.url;
-          }
-          if (prop === "headers") {
-            const headers = target.headers;
-            return new Proxy(headers, {
-              get(hTarget, hProp) {
-                if (hProp === "authorization" || hProp === "Authorization") {
-                  const val3 = hTarget.get("authorization");
-                  return val3;
-                }
-                if (typeof hProp === "string" && !["get", "set", "has", "delete", "entries", "keys", "values", "forEach", "append"].includes(hProp) && typeof hTarget[hProp] === "undefined") {
-                  return hTarget.get(hProp) || void 0;
-                }
-                const val2 = hTarget[hProp];
-                return typeof val2 === "function" ? val2.bind(hTarget) : val2;
-              }
-            });
-          }
-          const val = target[prop];
-          return typeof val === "function" ? val.bind(target) : val;
+      const paymentPayload = {
+        x402Version: 2,
+        error: "Payment required",
+        resource: {
+          url: req.nextUrl?.pathname || req.url,
+          description: "",
+          mimeType: ""
+        },
+        accepts: [{
+          scheme: "exact",
+          network: networkId,
+          amount: priceValue,
+          // Use raw lamports, no multiplier
+          asset: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+          payTo: config.walletAddress,
+          maxTimeoutSeconds: 300,
+          extra: { feePayer: "11111111111111111111111111111111" }
+        }]
+      };
+      const base64Payload = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+      return new Response(JSON.stringify({}), {
+        status: 402,
+        headers: {
+          "Content-Type": "application/json",
+          "payment-required": base64Payload
         }
       });
-      return await wrappedHandler(compatibleReq, ctx);
     };
   };
 }