@payroute/x402-sdk 1.0.0 → 1.0.2

package/README.md

@@ -6,26 +6,24 @@ This SDK abstracts the complexity of **HTTP 402 Pay-Per-Hit** workflows, enablin
 
 ## Features
 
-- 🚀 **Full x402 Abstraction**: Automates the HTTP 402 -> Payment -> Retry loop.
-- 💸 **Mantle Network Support**: Built for Mantle Mainnet and Sepolia Testnet.
-- 🤖 **AI Agent Ready**: Dedicated methods for interacting with Payroute-enabled AI Agents.
-- 📦 **Token Management**: Automatically handles ERC20 (MUSD) approvals and transfers.
-- 🛡️ **Type-Safe**: Written in TypeScript with full type definitions.
+- **Full x402 Abstraction**: Automates the HTTP 402 -> Payment -> Retry loop.
+- **Mantle Network Support**: Built for Mantle Mainnet and Sepolia Testnet.
+- **AI Agent Ready**: Dedicated methods for interacting with Payroute-enabled AI Agents.
+- **Token Management**: Automatically handles ERC20 (MUSD) approvals and transfers.
+- **Type-Safe**: Written in TypeScript with full type definitions.
 
 ## Installation
 
 ```bash
-npm install payroute-x402-sdk ethers
+npm install @payroute/x402-sdk
 ```
 
-_Note: `ethers` peer dependency (v6) is required._
-
 ## Quick Start
 
 ### 1. Initialize the Service
 
 ```typescript
-import { PaymentService } from "payroute-x402-sdk";
+import { PaymentService } from "@payroute/x402-sdk";
 
 const service = new PaymentService({
   privateKey: process.env.WALLET_PRIVATE_KEY, // Your EVM private key
@@ -37,24 +35,43 @@ const service = new PaymentService({
 
 Access premium content served behind a Payroute gateway.
 
+#### Direct Payment (Non-Escrow)
+
+Use this method for direct peer-to-peer payments to a receiver.
+
 ```typescript
 try {
-  const content = await service.getProxyEndpoint("my-premium-blog-post");
+  const content = await service.getProxyEndpoint("MantleDocs");
   console.log("Accessed Content:", content);
 } catch (error) {
   console.error("Payment or Fetch Failed:", error);
 }
 ```
 
+#### Escrow Payment
+
+Use this method when the gateway requires payment via an escrow smart contract.
+
+```typescript
+try {
+  const contentStart = await service.getProxyEndpointEscrow("BitcoinOutlook");
+  console.log("Accessed Escrow Content:", contentStart);
+} catch (error) {
+  console.error("Payment or Fetch Failed:", error);
+}
+```
+
 ### 3. Interact with a Paid AI Agent
 
 Send messages to an AI agent that requires per-message payments.
 
+#### Direct Payment (Non-Escrow)
+
 ```typescript
 try {
   const response = await service.generateAIResponse(
-    "finance-advisor-agent",
-    "What is the outlook for MNT?"
+    "mantleAgent",
+    "How to build smart contract on Mantle Network?"
   );
   console.log("AI Response:", response);
 } catch (error) {
@@ -62,6 +79,20 @@ try {
 }
 ```
 
+#### Escrow Payment
+
+```typescript
+try {
+  const responseEscrow = await service.generateAIResponseEscrow(
+    "mantleAgent",
+    "How to build AVS on EigenLayer?"
+  );
+  console.log("AI Response Escrow:", responseEscrow);
+} catch (error) {
+  console.error("Agent Interaction Failed:", error);
+}
+```
+
 ## Advanced Usage
 
 ### Custom RPC Provider
@@ -75,22 +106,73 @@ const service = new PaymentService({
 });
 ```
 
-### Generic Pay-And-Retry
+## Integration with AI Agents & LLMs
+
+One of the most powerful use cases for `@payroute/x402-sdk` is enabling **Autonomous Economic Agents**. Because the SDK handles the entire payment lifecycle programmatically, LLMs can "pay" for their own resources without user intervention.
+
+### Example: Autonomous Research Agent
 
-If you are building a custom integration that follows the x402 generic pattern but doesn't fit the standard gateway/agent flow, you can use the low-level `payAndRetry` method.
+Imagine an AI agent tasked with gathering premium market data. It can use this SDK to automatically pay for each data point it accesses using its own wallet.
 
 ```typescript
-const response = await service.payAndRetry({
-  paymentData: {
-    amount: "1000000000000000000", // 1 ETH/MNT in wei
-    recipient: "0x123...",
-  },
-  retryRequest: async (headers) => {
-    // Perform your custom retry logic here using the provided headers
-    // headers['X-Payment-Tx'] will contain the transaction hash
-    return fetch("https://api.custom.com/resource", { headers });
-  },
+import { PaymentService } from "@payroute/x402-sdk";
+import { openai } from "./my-llm-setup"; // Hypothetical LLM client
+
+// 1. Give the Agent a Wallet
+const agentWalletKey = process.env.AGENT_PRIVATE_KEY;
+const payroute = new PaymentService({
+  privateKey: agentWalletKey,
+  network: "mantle",
 });
+
+async function autonomousResearchTask(topic: string) {
+  console.log(`Agent starting research on: ${topic}...`);
+
+  // 2. Agent decides it needs premium data (e.g., from 'HighValueData' endpoint)
+  // The SDK handles the 402 challenge, approves tokens, pays, and returns the data.
+  console.log("Accessing premium data source...");
+
+  // THIS SINGLE LINE handles the entire negotiation and payment
+  const premiumData = await payroute.getProxyEndpointEscrow("HighValueData");
+
+  // 3. Agent processes the purchased data
+  console.log("Data acquired. Analyzing...");
+  const analysis = await openai.chat.completions.create({
+    model: "gpt-4",
+    messages: [
+      {
+        role: "user",
+        content: `Analyze this data: ${JSON.stringify(premiumData)}`,
+      },
+    ],
+  });
+
+  return analysis.choices[0].message.content;
+}
+```
+
+This pattern transforms **passive tools** into **economically active agents** capable of trading value for information or services on the open market.
+
+### Example: Agent-to-Agent Consultation
+
+Your agent can also pay to converse with other specialized AI agents (e.g., a "Legal Expert" or "Medical Advisor").
+
+```typescript
+async function consultExpertAgent(problem: string) {
+  // Agent identifies it needs help from a specific expert agent slug
+  const expertAgentSlug = "legal-expert-v1";
+
+  console.log(`Consulting ${expertAgentSlug}...`);
+
+  // The SDK handles payment for the conversation turn
+  const expertAdvice = await payroute.generateAIResponseEscrow(
+    expertAgentSlug,
+    `I have a user asking about: ${problem}. What are the compliance risks?`
+  );
+
+  // Initial Agent integrates the paid advice into its final response
+  return expertAdvice.response;
+}
 ```
 
 ## Architecture
@@ -98,9 +180,11 @@ const response = await service.payAndRetry({
 The SDK implements the **Payroute x402 Protocol**:
 
 1.  **Request**: SDK attempts to access a resource.
-2.  **Challenge (402)**: Server responds with `402 Payment Required` and payment details (Escrow contract, Amount, Transaction ID).
-3.  **Approval**: SDK approves the required token (MUSD) for the escrow contract.
-4.  **Payment**: SDK calls the Escrow contract's `createTx` function.
+2.  **Challenge (402)**: Server responds with `402 Payment Required` and payment details (Receiver Address, Amount, Transaction ID, and optionally Escrow Address).
+3.  **Approval (If needed)**: SDK approves the required token (MUSD) for the escrow contract or spends directly.
+4.  **Payment**:
+    - **Direct**: Transfers MUSD directly to the receiver.
+    - **Escrow**: Calls the Escrow contract's `createTx` function.
 5.  **Confirmation**: SDK waits for blockchain confirmation.
 6.  **Retry**: SDK retries the original request with the transaction hash in the `x-payment-tx` header.
 7.  **Response**: Server validates the transaction and returns the content.

package/dist/index.d.mts

@@ -13,6 +13,7 @@ interface PaymentServiceConfig {
     privateKey: string;
     network?: 'mantle' | 'mantleTestnet' | 'localhost';
     rpcUrl?: string;
+    apiBaseUrl?: string;
 }
 /**
  * PaymentService class
@@ -21,6 +22,7 @@ interface PaymentServiceConfig {
 declare class PaymentService {
     private wallet;
     private provider;
+    private apiBaseUrl;
     constructor(config: PaymentServiceConfig);
     /**
      * Performs a payment on-chain and retries the original request with proof of payment.
@@ -29,10 +31,6 @@ declare class PaymentService {
      * @param params.retryRequest - A callback that performs the HTTP request. Must accept headers.
      * @returns The response from the retried request.
      */
-    payAndRetry<T>(params: {
-        paymentData: PaymentData;
-        retryRequest: (headers: Record<string, string>) => Promise<T>;
-    }): Promise<T>;
     /**
      * Get AI response
      *
@@ -40,6 +38,13 @@ declare class PaymentService {
      * @returns
      */
     generateAIResponse<T = any>(agentSlug: string, message: string): Promise<T>;
+    /**
+   * Get AI response
+   *
+   * @param agentSlug
+   * @returns
+   */
+    generateAIResponseEscrow<T = any>(agentSlug: string, message: string): Promise<T>;
     /**
      * Get proxy endpoint
      *
@@ -47,6 +52,13 @@ declare class PaymentService {
      * @returns
      */
     getProxyEndpoint<T = any>(gatewaySlug: string): Promise<T>;
+    /**
+     * Get proxy endpoint escrow
+     *
+     * @param gatewaySlug
+     * @returns
+     */
+    getProxyEndpointEscrow<T = any>(gatewaySlug: string): Promise<T>;
     /**
      * Helper to get the current wallet address
      */

package/dist/index.d.ts

@@ -13,6 +13,7 @@ interface PaymentServiceConfig {
     privateKey: string;
     network?: 'mantle' | 'mantleTestnet' | 'localhost';
     rpcUrl?: string;
+    apiBaseUrl?: string;
 }
 /**
  * PaymentService class
@@ -21,6 +22,7 @@ interface PaymentServiceConfig {
 declare class PaymentService {
     private wallet;
     private provider;
+    private apiBaseUrl;
     constructor(config: PaymentServiceConfig);
     /**
      * Performs a payment on-chain and retries the original request with proof of payment.
@@ -29,10 +31,6 @@ declare class PaymentService {
      * @param params.retryRequest - A callback that performs the HTTP request. Must accept headers.
      * @returns The response from the retried request.
      */
-    payAndRetry<T>(params: {
-        paymentData: PaymentData;
-        retryRequest: (headers: Record<string, string>) => Promise<T>;
-    }): Promise<T>;
     /**
      * Get AI response
      *
@@ -40,6 +38,13 @@ declare class PaymentService {
      * @returns
      */
     generateAIResponse<T = any>(agentSlug: string, message: string): Promise<T>;
+    /**
+   * Get AI response
+   *
+   * @param agentSlug
+   * @returns
+   */
+    generateAIResponseEscrow<T = any>(agentSlug: string, message: string): Promise<T>;
     /**
      * Get proxy endpoint
      *
@@ -47,6 +52,13 @@ declare class PaymentService {
      * @returns
      */
     getProxyEndpoint<T = any>(gatewaySlug: string): Promise<T>;
+    /**
+     * Get proxy endpoint escrow
+     *
+     * @param gatewaySlug
+     * @returns
+     */
+    getProxyEndpointEscrow<T = any>(gatewaySlug: string): Promise<T>;
     /**
      * Helper to get the current wallet address
      */

package/dist/index.js

@@ -43,17 +43,18 @@ var NETWORKS = {
     chainId: 31337
   }
 };
-var BASE_ENDPOINT = "https://x402-services.vercel.app";
 var ESCROW_ABI = [
-  "function createTx(string txId, address creator, uint256 amount) external payable"
+  "function createTx(bytes32 txId, address creator, uint256 amount)"
 ];
 var MUSD_ADDRESS = "0x4dABf45C8cF333Ef1e874c3FDFC3C86799af80c8";
 var ERC20_ABI = [
-  "function approve(address spender, uint256 amount) external returns (bool)"
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function transfer(address to, uint256 amount) external returns (bool)"
 ];
 var PaymentService = class {
   wallet;
   provider;
+  apiBaseUrl;
   constructor(config) {
     const networkKey = config.network || "mantle";
     const networkConfig = NETWORKS[networkKey];
@@ -67,6 +68,7 @@ var PaymentService = class {
     } catch (error) {
       throw new Error("Invalid private key provided.");
     }
+    this.apiBaseUrl = config.apiBaseUrl || "https://x402-services.vercel.app";
   }
   /**
    * Performs a payment on-chain and retries the original request with proof of payment.
@@ -75,43 +77,120 @@ var PaymentService = class {
    * @param params.retryRequest - A callback that performs the HTTP request. Must accept headers.
    * @returns The response from the retried request.
    */
-  async payAndRetry(params) {
-    const { paymentData, retryRequest } = params;
+  // async payAndRetry<T>(params: {
+  //   paymentData: PaymentData;
+  //   retryRequest: (headers: Record<string, string>) => Promise<T>;
+  // }): Promise<T> {
+  //   const { paymentData, retryRequest } = params;
+  //   try {
+  //     // 1. Validate Payment Data
+  //     if (!ethers.isAddress(paymentData.recipient)) {
+  //       throw new Error(`Invalid recipient address: ${paymentData.recipient}`);
+  //     }
+  //     // 2. Build Transaction
+  //     const txRequest = {
+  //       to: paymentData.recipient,
+  //       value: BigInt(paymentData.amount),
+  //       // Gas limit/price will be estimated by provider/wallet
+  //     };
+  //     // 3. Sign & Send Transaction
+  //     // console.log(`Sending payment of ${paymentData.amount} wei to ${paymentData.recipient}...`);
+  //     const txResponse = await this.wallet.sendTransaction(txRequest);
+  //     // 4. Wait for confirmation
+  //     // console.log(`Transaction sent: ${txResponse.hash}. Waiting for confirmation...`);
+  //     const receipt = await txResponse.wait(1); // Wait for 1 confirmation
+  //     if (!receipt || receipt.status !== 1) {
+  //       throw new Error('Transaction failed or was reverted on-chain.');
+  //     }
+  //     // 5. Retry original request with header X-Payment-Tx
+  //     const txHash = receipt.hash;
+  //     const headers = {
+  //       'X-Payment-Tx': txHash,
+  //       'Content-Type': 'application/json', // Default content type, extendable if needed
+  //     };
+  //     // 6. Return final HTTP response
+  //     return await retryRequest(headers);
+  //   } catch (error: any) {
+  //     // 7. Throw clear errors on failure
+  //     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred during payment flow';
+  //     // console.error('PaymentService Error:', errorMessage);
+  //     throw new Error(`PaymentService Failed: ${errorMessage}`);
+  //   }
+  // }
+  /**
+   * Get AI response
+   * 
+   * @param agentSlug
+   * @returns
+   */
+  async generateAIResponse(agentSlug, message) {
     try {
-      if (!import_ethers.ethers.isAddress(paymentData.recipient)) {
-        throw new Error(`Invalid recipient address: ${paymentData.recipient}`);
+      const initialResponse = await fetch(`${this.apiBaseUrl}/agent/${agentSlug}/chat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          message
+        })
+      });
+      if (!initialResponse.ok && initialResponse.status !== 402) {
+        throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
-      const txRequest = {
-        to: paymentData.recipient,
-        value: BigInt(paymentData.amount)
-        // Gas limit/price will be estimated by provider/wallet
-      };
-      const txResponse = await this.wallet.sendTransaction(txRequest);
+      const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment detail not found in response.");
+      }
+      const txId = paymentDetail.transactionId;
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = import_ethers.ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
+      }
+      const musdContract = new import_ethers.ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
+      console.log(`Approving MUSD spending for ${receiverAddress}...`);
+      const approveTx = await musdContract.approve(receiverAddress, amount);
+      await approveTx.wait(1);
+      console.log(`Initiating Expect Payment to creator ${receiverAddress} (${amount} wei)`);
+      const txResponse = await musdContract.transfer(receiverAddress, amount);
+      console.log(`Payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
-        throw new Error("Transaction failed or was reverted on-chain.");
+        throw new Error("Payment transaction failed.");
       }
-      const txHash = receipt.hash;
+      const finalTxHash = receipt.hash;
       const headers = {
-        "X-Payment-Tx": txHash,
-        "Content-Type": "application/json"
-        // Default content type, extendable if needed
+        "Content-Type": "application/json",
+        "x-payment-tx": finalTxHash
       };
-      return await retryRequest(headers);
+      console.log(`Retry with txHash: ${finalTxHash}`);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/agent/${agentSlug}/chat`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          message
+        })
+      });
+      if (!retryResponse.ok) {
+        const errorText = await retryResponse.text();
+        throw new Error(`Retry failed: ${retryResponse.status} - ${errorText}`);
+      }
+      return await retryResponse.json();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error occurred during payment flow";
       throw new Error(`PaymentService Failed: ${errorMessage}`);
     }
   }
   /**
-   * Get AI response
-   * 
-   * @param agentSlug
-   * @returns
-   */
-  async generateAIResponse(agentSlug, message) {
+  * Get AI response
+  * 
+  * @param agentSlug
+  * @returns
+  */
+  async generateAIResponseEscrow(agentSlug, message) {
     try {
-      const initialResponse = await fetch(`${BASE_ENDPOINT}/agent/${agentSlug}/chat`, {
+      const initialResponse = await fetch(`${this.apiBaseUrl}/agent/escrow/${agentSlug}/chat`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -124,32 +203,41 @@ var PaymentService = class {
         throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
       const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment detail not found in response.");
+      }
       const txId = paymentDetail.transactionId;
       const escrowAddress = paymentDetail.escrowAddress;
-      const amountPayment = paymentDetail.amountPayment;
-      const contractAddress = paymentDetail.contractAddress;
-      if (!contractAddress) {
-        throw new Error("Contract address not found in payment details.");
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = import_ethers.ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
       }
       const musdContract = new import_ethers.ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
-      const approveTx = await musdContract.approve(contractAddress, amountPayment);
+      console.log(`Approving MUSD spending for ${escrowAddress}...`);
+      const approveTx = await musdContract.approve(escrowAddress, amount);
       await approveTx.wait(1);
-      const contract = new import_ethers.ethers.Contract(contractAddress, ESCROW_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${escrowAddress} for creator ${receiverAddress} (${amount} wei)`);
+      const contract = new import_ethers.ethers.Contract(escrowAddress, ESCROW_ABI, this.wallet);
       const txResponse = await contract.createTx(
         txId,
-        escrowAddress,
-        amountPayment
+        receiverAddress,
+        amount
       );
+      console.log(`Escrow payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
         throw new Error("Escrow transaction failed.");
       }
       const finalTxHash = receipt.hash;
       const headers = {
-        "x-payment-tx": finalTxHash,
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "x-payment-tx": finalTxHash
       };
-      const retryResponse = await fetch(`${BASE_ENDPOINT}/agent/${agentSlug}/chat`, {
+      console.log(`Retry with txHash: ${finalTxHash}`);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/agent/escrow/${agentSlug}/chat`, {
         method: "POST",
         headers,
         body: JSON.stringify({
@@ -174,7 +262,70 @@ var PaymentService = class {
    */
   async getProxyEndpoint(gatewaySlug) {
     try {
-      const initialResponse = await fetch(`${BASE_ENDPOINT}/escrow/${gatewaySlug}`);
+      let initialResponse;
+      try {
+        initialResponse = await fetch(`${this.apiBaseUrl}/${gatewaySlug}`);
+      } catch (e) {
+        throw new Error(`Initial Endpoint Failed: ${e}`);
+      }
+      if (initialResponse.ok) {
+        return await initialResponse.json();
+      }
+      if (initialResponse.status !== 402) {
+        throw new Error(`Unexpected status code: ${initialResponse.status}`);
+      }
+      const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment Detail not found.");
+      }
+      console.log("Payment Detail:", paymentDetail);
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = import_ethers.ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
+      }
+      const musdContract = new import_ethers.ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${receiverAddress} (${amount} wei)`);
+      const txResponse = await musdContract.transfer(receiverAddress, amount);
+      console.log(`Payment sent: ${txResponse.hash}. Waiting for confirmation...`);
+      const receipt = await txResponse.wait(1);
+      if (!receipt || receipt.status !== 1) {
+        throw new Error("Payment transaction failed.");
+      }
+      const finalTxHash = receipt.hash;
+      const headers = {
+        "x-payment-tx": finalTxHash
+      };
+      console.log("view header: ", headers);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/${gatewaySlug}`, {
+        method: "GET",
+        headers
+      });
+      if (!retryResponse.ok) {
+        const errorText = await retryResponse.text();
+        throw new Error(`Retry failed: ${retryResponse.status} - ${errorText}`);
+      }
+      return await retryResponse.json();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error : "Unknown error in getProxyEndpoint";
+      throw new Error(`Proxy Endpoint Failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Get proxy endpoint escrow
+   * 
+   * @param gatewaySlug 
+   * @returns 
+   */
+  async getProxyEndpointEscrow(gatewaySlug) {
+    try {
+      let initialResponse;
+      try {
+        initialResponse = await fetch(`${this.apiBaseUrl}/escrow/${gatewaySlug}`);
+      } catch (e) {
+        throw new Error(`Initial Endpoint Failed: ${e}`);
+      }
       if (initialResponse.ok) {
         return await initialResponse.json();
       }
@@ -182,32 +333,40 @@ var PaymentService = class {
         throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
       const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment Detail not found.");
+      }
+      console.log("Payment Detail:", paymentDetail);
       const txId = paymentDetail.transactionId;
       const escrowAddress = paymentDetail.escrowAddress;
-      const amountPayment = paymentDetail.amountPayment;
-      const contractAddress = paymentDetail.contractAddress;
-      if (!contractAddress) {
-        throw new Error("Contract address not found in payment details.");
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = import_ethers.ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
       }
       const musdContract = new import_ethers.ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
-      const approveTx = await musdContract.approve(contractAddress, amountPayment);
+      console.log(`Approving MUSD spending for ${escrowAddress}`);
+      const approveTx = await musdContract.approve(escrowAddress, amount);
       await approveTx.wait(1);
-      const contract = new import_ethers.ethers.Contract(contractAddress, ESCROW_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${escrowAddress} for creator ${receiverAddress} (${amount} wei)`);
+      const contract = new import_ethers.ethers.Contract(escrowAddress, ESCROW_ABI, this.wallet);
       const txResponse = await contract.createTx(
         txId,
-        escrowAddress,
-        amountPayment
+        receiverAddress,
+        amount
       );
+      console.log(`Escrow payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
         throw new Error("Escrow transaction failed.");
       }
       const finalTxHash = receipt.hash;
       const headers = {
-        "x-payment-tx": finalTxHash,
-        "Content-Type": "application/json"
+        "x-payment-tx": finalTxHash
       };
-      const retryResponse = await fetch(`${BASE_ENDPOINT}/${gatewaySlug}`, {
+      console.log("view header: ", headers);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/escrow/${gatewaySlug}`, {
         method: "GET",
         headers
       });
@@ -217,7 +376,7 @@ var PaymentService = class {
       }
       return await retryResponse.json();
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error in getProxyEndpoint";
+      const errorMessage = error instanceof Error ? error : "Unknown error in getProxyEndpoint";
       throw new Error(`Proxy Endpoint Failed: ${errorMessage}`);
     }
   }

package/dist/index.mjs

@@ -17,17 +17,18 @@ var NETWORKS = {
     chainId: 31337
   }
 };
-var BASE_ENDPOINT = "https://x402-services.vercel.app";
 var ESCROW_ABI = [
-  "function createTx(string txId, address creator, uint256 amount) external payable"
+  "function createTx(bytes32 txId, address creator, uint256 amount)"
 ];
 var MUSD_ADDRESS = "0x4dABf45C8cF333Ef1e874c3FDFC3C86799af80c8";
 var ERC20_ABI = [
-  "function approve(address spender, uint256 amount) external returns (bool)"
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function transfer(address to, uint256 amount) external returns (bool)"
 ];
 var PaymentService = class {
   wallet;
   provider;
+  apiBaseUrl;
   constructor(config) {
     const networkKey = config.network || "mantle";
     const networkConfig = NETWORKS[networkKey];
@@ -41,6 +42,7 @@ var PaymentService = class {
     } catch (error) {
       throw new Error("Invalid private key provided.");
     }
+    this.apiBaseUrl = config.apiBaseUrl || "https://x402-services.vercel.app";
   }
   /**
    * Performs a payment on-chain and retries the original request with proof of payment.
@@ -49,43 +51,120 @@ var PaymentService = class {
    * @param params.retryRequest - A callback that performs the HTTP request. Must accept headers.
    * @returns The response from the retried request.
    */
-  async payAndRetry(params) {
-    const { paymentData, retryRequest } = params;
+  // async payAndRetry<T>(params: {
+  //   paymentData: PaymentData;
+  //   retryRequest: (headers: Record<string, string>) => Promise<T>;
+  // }): Promise<T> {
+  //   const { paymentData, retryRequest } = params;
+  //   try {
+  //     // 1. Validate Payment Data
+  //     if (!ethers.isAddress(paymentData.recipient)) {
+  //       throw new Error(`Invalid recipient address: ${paymentData.recipient}`);
+  //     }
+  //     // 2. Build Transaction
+  //     const txRequest = {
+  //       to: paymentData.recipient,
+  //       value: BigInt(paymentData.amount),
+  //       // Gas limit/price will be estimated by provider/wallet
+  //     };
+  //     // 3. Sign & Send Transaction
+  //     // console.log(`Sending payment of ${paymentData.amount} wei to ${paymentData.recipient}...`);
+  //     const txResponse = await this.wallet.sendTransaction(txRequest);
+  //     // 4. Wait for confirmation
+  //     // console.log(`Transaction sent: ${txResponse.hash}. Waiting for confirmation...`);
+  //     const receipt = await txResponse.wait(1); // Wait for 1 confirmation
+  //     if (!receipt || receipt.status !== 1) {
+  //       throw new Error('Transaction failed or was reverted on-chain.');
+  //     }
+  //     // 5. Retry original request with header X-Payment-Tx
+  //     const txHash = receipt.hash;
+  //     const headers = {
+  //       'X-Payment-Tx': txHash,
+  //       'Content-Type': 'application/json', // Default content type, extendable if needed
+  //     };
+  //     // 6. Return final HTTP response
+  //     return await retryRequest(headers);
+  //   } catch (error: any) {
+  //     // 7. Throw clear errors on failure
+  //     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred during payment flow';
+  //     // console.error('PaymentService Error:', errorMessage);
+  //     throw new Error(`PaymentService Failed: ${errorMessage}`);
+  //   }
+  // }
+  /**
+   * Get AI response
+   * 
+   * @param agentSlug
+   * @returns
+   */
+  async generateAIResponse(agentSlug, message) {
     try {
-      if (!ethers.isAddress(paymentData.recipient)) {
-        throw new Error(`Invalid recipient address: ${paymentData.recipient}`);
+      const initialResponse = await fetch(`${this.apiBaseUrl}/agent/${agentSlug}/chat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          message
+        })
+      });
+      if (!initialResponse.ok && initialResponse.status !== 402) {
+        throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
-      const txRequest = {
-        to: paymentData.recipient,
-        value: BigInt(paymentData.amount)
-        // Gas limit/price will be estimated by provider/wallet
-      };
-      const txResponse = await this.wallet.sendTransaction(txRequest);
+      const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment detail not found in response.");
+      }
+      const txId = paymentDetail.transactionId;
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
+      }
+      const musdContract = new ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
+      console.log(`Approving MUSD spending for ${receiverAddress}...`);
+      const approveTx = await musdContract.approve(receiverAddress, amount);
+      await approveTx.wait(1);
+      console.log(`Initiating Expect Payment to creator ${receiverAddress} (${amount} wei)`);
+      const txResponse = await musdContract.transfer(receiverAddress, amount);
+      console.log(`Payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
-        throw new Error("Transaction failed or was reverted on-chain.");
+        throw new Error("Payment transaction failed.");
       }
-      const txHash = receipt.hash;
+      const finalTxHash = receipt.hash;
       const headers = {
-        "X-Payment-Tx": txHash,
-        "Content-Type": "application/json"
-        // Default content type, extendable if needed
+        "Content-Type": "application/json",
+        "x-payment-tx": finalTxHash
       };
-      return await retryRequest(headers);
+      console.log(`Retry with txHash: ${finalTxHash}`);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/agent/${agentSlug}/chat`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          message
+        })
+      });
+      if (!retryResponse.ok) {
+        const errorText = await retryResponse.text();
+        throw new Error(`Retry failed: ${retryResponse.status} - ${errorText}`);
+      }
+      return await retryResponse.json();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error occurred during payment flow";
       throw new Error(`PaymentService Failed: ${errorMessage}`);
     }
   }
   /**
-   * Get AI response
-   * 
-   * @param agentSlug
-   * @returns
-   */
-  async generateAIResponse(agentSlug, message) {
+  * Get AI response
+  * 
+  * @param agentSlug
+  * @returns
+  */
+  async generateAIResponseEscrow(agentSlug, message) {
     try {
-      const initialResponse = await fetch(`${BASE_ENDPOINT}/agent/${agentSlug}/chat`, {
+      const initialResponse = await fetch(`${this.apiBaseUrl}/agent/escrow/${agentSlug}/chat`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -98,32 +177,41 @@ var PaymentService = class {
         throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
       const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment detail not found in response.");
+      }
       const txId = paymentDetail.transactionId;
       const escrowAddress = paymentDetail.escrowAddress;
-      const amountPayment = paymentDetail.amountPayment;
-      const contractAddress = paymentDetail.contractAddress;
-      if (!contractAddress) {
-        throw new Error("Contract address not found in payment details.");
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
       }
       const musdContract = new ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
-      const approveTx = await musdContract.approve(contractAddress, amountPayment);
+      console.log(`Approving MUSD spending for ${escrowAddress}...`);
+      const approveTx = await musdContract.approve(escrowAddress, amount);
       await approveTx.wait(1);
-      const contract = new ethers.Contract(contractAddress, ESCROW_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${escrowAddress} for creator ${receiverAddress} (${amount} wei)`);
+      const contract = new ethers.Contract(escrowAddress, ESCROW_ABI, this.wallet);
       const txResponse = await contract.createTx(
         txId,
-        escrowAddress,
-        amountPayment
+        receiverAddress,
+        amount
       );
+      console.log(`Escrow payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
         throw new Error("Escrow transaction failed.");
       }
       const finalTxHash = receipt.hash;
       const headers = {
-        "x-payment-tx": finalTxHash,
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "x-payment-tx": finalTxHash
       };
-      const retryResponse = await fetch(`${BASE_ENDPOINT}/agent/${agentSlug}/chat`, {
+      console.log(`Retry with txHash: ${finalTxHash}`);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/agent/escrow/${agentSlug}/chat`, {
         method: "POST",
         headers,
         body: JSON.stringify({
@@ -148,7 +236,70 @@ var PaymentService = class {
    */
   async getProxyEndpoint(gatewaySlug) {
     try {
-      const initialResponse = await fetch(`${BASE_ENDPOINT}/escrow/${gatewaySlug}`);
+      let initialResponse;
+      try {
+        initialResponse = await fetch(`${this.apiBaseUrl}/${gatewaySlug}`);
+      } catch (e) {
+        throw new Error(`Initial Endpoint Failed: ${e}`);
+      }
+      if (initialResponse.ok) {
+        return await initialResponse.json();
+      }
+      if (initialResponse.status !== 402) {
+        throw new Error(`Unexpected status code: ${initialResponse.status}`);
+      }
+      const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment Detail not found.");
+      }
+      console.log("Payment Detail:", paymentDetail);
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
+      }
+      const musdContract = new ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${receiverAddress} (${amount} wei)`);
+      const txResponse = await musdContract.transfer(receiverAddress, amount);
+      console.log(`Payment sent: ${txResponse.hash}. Waiting for confirmation...`);
+      const receipt = await txResponse.wait(1);
+      if (!receipt || receipt.status !== 1) {
+        throw new Error("Payment transaction failed.");
+      }
+      const finalTxHash = receipt.hash;
+      const headers = {
+        "x-payment-tx": finalTxHash
+      };
+      console.log("view header: ", headers);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/${gatewaySlug}`, {
+        method: "GET",
+        headers
+      });
+      if (!retryResponse.ok) {
+        const errorText = await retryResponse.text();
+        throw new Error(`Retry failed: ${retryResponse.status} - ${errorText}`);
+      }
+      return await retryResponse.json();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error : "Unknown error in getProxyEndpoint";
+      throw new Error(`Proxy Endpoint Failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Get proxy endpoint escrow
+   * 
+   * @param gatewaySlug 
+   * @returns 
+   */
+  async getProxyEndpointEscrow(gatewaySlug) {
+    try {
+      let initialResponse;
+      try {
+        initialResponse = await fetch(`${this.apiBaseUrl}/escrow/${gatewaySlug}`);
+      } catch (e) {
+        throw new Error(`Initial Endpoint Failed: ${e}`);
+      }
       if (initialResponse.ok) {
         return await initialResponse.json();
       }
@@ -156,32 +307,40 @@ var PaymentService = class {
         throw new Error(`Unexpected status code: ${initialResponse.status}`);
       }
       const paymentDetail = await initialResponse.json();
+      if (!paymentDetail) {
+        throw new Error("Payment Detail not found.");
+      }
+      console.log("Payment Detail:", paymentDetail);
       const txId = paymentDetail.transactionId;
       const escrowAddress = paymentDetail.escrowAddress;
-      const amountPayment = paymentDetail.amountPayment;
-      const contractAddress = paymentDetail.contractAddress;
-      if (!contractAddress) {
-        throw new Error("Contract address not found in payment details.");
+      const amountPayment = paymentDetail.amount;
+      const receiverAddress = paymentDetail.receiverAddress;
+      const amount = ethers.parseUnits(amountPayment.toString(), 6);
+      if (!receiverAddress) {
+        throw new Error("Receiver address not found in payment details.");
       }
       const musdContract = new ethers.Contract(MUSD_ADDRESS, ERC20_ABI, this.wallet);
-      const approveTx = await musdContract.approve(contractAddress, amountPayment);
+      console.log(`Approving MUSD spending for ${escrowAddress}`);
+      const approveTx = await musdContract.approve(escrowAddress, amount);
       await approveTx.wait(1);
-      const contract = new ethers.Contract(contractAddress, ESCROW_ABI, this.wallet);
+      console.log(`Initiating Expect Payment to ${escrowAddress} for creator ${receiverAddress} (${amount} wei)`);
+      const contract = new ethers.Contract(escrowAddress, ESCROW_ABI, this.wallet);
       const txResponse = await contract.createTx(
         txId,
-        escrowAddress,
-        amountPayment
+        receiverAddress,
+        amount
       );
+      console.log(`Escrow payment sent: ${txResponse.hash}. Waiting for confirmation...`);
       const receipt = await txResponse.wait(1);
       if (!receipt || receipt.status !== 1) {
         throw new Error("Escrow transaction failed.");
       }
       const finalTxHash = receipt.hash;
       const headers = {
-        "x-payment-tx": finalTxHash,
-        "Content-Type": "application/json"
+        "x-payment-tx": finalTxHash
       };
-      const retryResponse = await fetch(`${BASE_ENDPOINT}/${gatewaySlug}`, {
+      console.log("view header: ", headers);
+      const retryResponse = await fetch(`${this.apiBaseUrl}/escrow/${gatewaySlug}`, {
         method: "GET",
         headers
       });
@@ -191,7 +350,7 @@ var PaymentService = class {
       }
       return await retryResponse.json();
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error in getProxyEndpoint";
+      const errorMessage = error instanceof Error ? error : "Unknown error in getProxyEndpoint";
       throw new Error(`Proxy Endpoint Failed: ${errorMessage}`);
     }
   }

package/package.json

@@ -1,10 +1,27 @@
 {
   "name": "@payroute/x402-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "SDK for automation payment gateway with x402",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsup"
   },