@teneo-protocol/sdk 2.0.0 → 2.2.0

package/src/managers/message-router.ts

@@ -1,6 +1,7 @@
 /**
  * MessageRouter - Manages message sending and routing
  * Handles user messages, direct commands, and message-response patterns
+ * Supports quote-approve payment flow (v2.2.0)
  */
 
 import { EventEmitter } from "eventemitter3";
@@ -11,11 +12,15 @@ import { ResponseFormatter, FormattedResponse } from "../formatters/response-for
 import {
   UserMessage,
   createUserMessage,
+  createRequestTask,
+  createConfirmTask,
   Logger,
   ResponseFormat,
-  TaskResponseMessage
+  TaskResponseMessage,
+  TaskQuoteMessage,
+  PricingInfo
 } from "../types";
-import { SDKEvents, SDKError, ValidationError, AgentResponse } from "../types/events";
+import { SDKEvents, SDKError, ValidationError, AgentResponse, PaymentError } from "../types/events";
 import { ErrorCode } from "../types/error-codes";
 import { TIMEOUTS } from "../constants";
 import {
@@ -24,6 +29,8 @@ import {
   AgentCommandContentSchema
 } from "../types/validation";
 import { waitForEvent } from "../utils/event-waiter";
+import { PaymentClient, buildX402ResourceUrl } from "../payments/payment-client";
+import type { SecurePrivateKey } from "../utils/secure-private-key";
 
 export interface SendMessageOptions {
   room: string;
@@ -39,6 +46,30 @@ export interface AgentCommand {
   room: string;
 }
 
+/**
+ * Result of a quote request, containing pricing and agent details.
+ */
+export interface QuoteResult {
+  taskId: string;
+  agentId: string;
+  agentName: string;
+  agentWallet: string;
+  command: string;
+  pricing: PricingInfo;
+  expiresAt: Date;
+}
+
+export interface MessageRouterConfig {
+  messageTimeout?: number;
+  responseFormat?: ResponseFormat;
+  autoApproveQuotes?: boolean;
+  maxPricePerRequest?: number;
+  quoteTimeout?: number;
+  wsUrl?: string;
+  paymentNetwork?: string;
+  paymentAsset?: string;
+}
+
 export class MessageRouter extends EventEmitter<SDKEvents> {
   private readonly wsClient: WebSocketClient;
   private readonly webhookHandler: WebhookHandler;
@@ -47,15 +78,22 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
   private readonly messageTimeout: number;
   private readonly responseFormat: ResponseFormat;
 
+  // Quote-approve flow (v2.2.0)
+  private paymentClient: PaymentClient | null = null;
+  private readonly pendingQuotes: Map<string, QuoteResult> = new Map();
+  private readonly autoApproveQuotes: boolean;
+  private readonly maxPricePerRequest?: number;
+  private readonly quoteTimeout: number;
+  private readonly wsUrl: string;
+  private readonly paymentNetwork: string;
+  private readonly paymentAsset: string;
+
   constructor(
     wsClient: WebSocketClient,
     webhookHandler: WebhookHandler,
     responseFormatter: ResponseFormatter,
     logger: Logger,
-    config: {
-      messageTimeout?: number;
-      responseFormat?: ResponseFormat;
-    }
+    config: MessageRouterConfig
   ) {
     super();
     this.wsClient = wsClient;
@@ -65,9 +103,29 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
     this.messageTimeout = config.messageTimeout ?? TIMEOUTS.DEFAULT_MESSAGE_TIMEOUT;
     this.responseFormat = config.responseFormat ?? "humanized";
 
+    // Quote-approve config (v2.2.0)
+    this.autoApproveQuotes = config.autoApproveQuotes ?? true;
+    this.maxPricePerRequest = config.maxPricePerRequest;
+    this.quoteTimeout = config.quoteTimeout ?? 30000;
+    this.wsUrl = config.wsUrl ?? "";
+    this.paymentNetwork = config.paymentNetwork ?? "eip155:3338";
+    // USDC contract address on PEAQ network
+    this.paymentAsset = config.paymentAsset ?? "0xbbA60da06c2c5424f03f7434542280FCAd453d10";
+
     this.setupEventForwarding();
   }
 
+  /**
+   * Sets up the payment client for quote-approve flow.
+   * Must be called before using requestQuote/confirmQuote with paid tasks.
+   */
+  public setPaymentClient(secureKey: SecurePrivateKey, walletAddress: string): void {
+    this.paymentClient = new PaymentClient(secureKey, walletAddress, {
+      network: this.paymentNetwork,
+      asset: this.paymentAsset
+    });
+  }
+
   /**
    * Sends a message to agents via the coordinator.
    * The coordinator intelligently selects the most appropriate agent.
@@ -107,21 +165,31 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
       throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
     }
 
-    // Validate content
     const validatedContent = MessageContentSchema.parse(content);
-
     const room = options.room;
     if (!room) {
       throw new ValidationError("Room parameter is required");
     }
 
-    // Use custom 'from' address if provided, otherwise use wallet address from auth state
+    // Use quote-approve flow with auto-approval (v2.2.0)
+    if (this.autoApproveQuotes) {
+      this.logger.debug("MessageRouter: Using quote-approve flow", {
+        content: validatedContent,
+        room
+      });
+      const quote = await this.requestQuote(validatedContent, room);
+      return await this.confirmQuote(quote.taskId, {
+        waitForResponse: options.waitForResponse,
+        timeout: options.timeout ?? this.messageTimeout
+      });
+    }
+
+    // Legacy flow (auto-approval disabled - user must manually confirm quotes)
     const authState = this.wsClient.getAuthState();
     const fromAddress = options.from ?? authState.walletAddress;
-
     const message = createUserMessage(validatedContent, room, fromAddress);
 
-    this.logger.debug("MessageRouter: Sending message", {
+    this.logger.debug("MessageRouter: Sending message (legacy)", {
       content: validatedContent,
       room,
       from: fromAddress
@@ -164,7 +232,6 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
       throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
     }
 
-    // Validate command
     const validatedAgent = AgentIdSchema.parse(command.agent);
     const validatedCommand = AgentCommandContentSchema.parse(command.command);
 
@@ -173,15 +240,24 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
       throw new ValidationError("Room parameter is required");
     }
 
-    // Get wallet address from auth state
+    const content = `@${validatedAgent} ${validatedCommand}`;
+
+    // Use quote-approve flow with auto-approval (v2.2.0)
+    if (this.autoApproveQuotes) {
+      this.logger.debug("MessageRouter: Using quote-approve flow", { content, room });
+      const quote = await this.requestQuote(content, room);
+      return await this.confirmQuote(quote.taskId, {
+        waitForResponse,
+        timeout: this.messageTimeout
+      });
+    }
+
+    // Legacy flow (auto-approval disabled - user must manually confirm quotes)
     const authState = this.wsClient.getAuthState();
     const walletAddress = authState.walletAddress;
-
-    // Format as direct command
-    const content = `@${validatedAgent} ${validatedCommand}`;
     const message = createUserMessage(content, room, walletAddress);
 
-    this.logger.debug("MessageRouter: Sending direct command", {
+    this.logger.debug("MessageRouter: Sending direct command (legacy)", {
       agent: validatedAgent,
       command: validatedCommand,
       room,
@@ -204,6 +280,128 @@ export class MessageRouter extends EventEmitter<SDKEvents> {
     }
   }
 
+  /**
+   * Requests a quote for a task without auto-approval.
+   * Returns the quote data for manual confirmation.
+   */
+  public async requestQuote(content: string, room: string): Promise<QuoteResult> {
+    if (!this.wsClient.isConnected) {
+      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+    }
+
+    const message = createRequestTask(content, room);
+    this.logger.debug("MessageRouter: Requesting quote", { content, room });
+
+    await this.wsClient.sendMessage(message);
+
+    const quote = await waitForEvent<TaskQuoteMessage>(this.wsClient, "quote:received", {
+      timeout: this.quoteTimeout,
+      timeoutMessage: `Quote request timed out after ${this.quoteTimeout}ms`
+    });
+
+    const result: QuoteResult = {
+      taskId: quote.data.task_id,
+      agentId: quote.data.agent_id,
+      agentName: quote.data.agent_name,
+      agentWallet: quote.data.agent_wallet,
+      command: quote.data.command,
+      pricing: quote.data.pricing,
+      expiresAt: new Date(quote.data.expires_at)
+    };
+
+    this.pendingQuotes.set(result.taskId, result);
+    return result;
+  }
+
+  /**
+   * Confirms a quote and executes the task with payment.
+   * Can optionally wait for the task response.
+   */
+  public async confirmQuote(
+    taskId: string,
+    options?: { waitForResponse?: boolean; timeout?: number }
+  ): Promise<FormattedResponse | void> {
+    if (!this.wsClient.isConnected) {
+      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+    }
+
+    const quote = this.pendingQuotes.get(taskId);
+    if (!quote) {
+      throw new ValidationError(`No pending quote found for task ${taskId}`);
+    }
+
+    if (new Date() > quote.expiresAt) {
+      this.pendingQuotes.delete(taskId);
+      throw new SDKError("Quote has expired", ErrorCode.QUOTE_EXPIRED);
+    }
+
+    // Check price limit
+    if (this.maxPricePerRequest !== undefined) {
+      const priceInUnits = quote.pricing.pricePerUnit * 1_000_000;
+      if (priceInUnits > this.maxPricePerRequest) {
+        this.emit("payment:blocked", {
+          agentId: quote.agentId,
+          agentPrice: priceInUnits,
+          maxPrice: this.maxPricePerRequest
+        });
+        throw new PaymentError(
+          `Quote price exceeds limit: ${priceInUnits} > ${this.maxPricePerRequest}`,
+          ErrorCode.PRICE_LIMIT_EXCEEDED,
+          { agentId: quote.agentId, agentPrice: priceInUnits, maxPrice: this.maxPricePerRequest }
+        );
+      }
+    }
+
+    let paymentHeader: string | undefined;
+
+    // Create payment header if payment client is configured and price > 0
+    if (this.paymentClient && quote.pricing.pricePerUnit > 0) {
+      try {
+        paymentHeader = await this.paymentClient.createPaymentHeader(
+          quote.pricing.pricePerUnit * 1_000_000,
+          quote.agentWallet,
+          buildX402ResourceUrl(this.wsUrl)
+        );
+        this.emit("payment:attached", {
+          agentId: quote.agentId,
+          amount: quote.pricing.pricePerUnit * 1_000_000,
+          command: quote.command
+        });
+      } catch (error) {
+        this.logger.error("Failed to create payment header for quote confirmation", error);
+        throw new PaymentError("Failed to create payment", ErrorCode.PAYMENT_FAILED, {
+          agentId: quote.agentId
+        });
+      }
+    }
+
+    const confirmMessage = createConfirmTask(taskId, paymentHeader);
+
+    this.logger.debug("MessageRouter: Confirming quote", { taskId });
+
+    await this.wsClient.sendMessage(confirmMessage);
+
+    // Delete quote only after successful send (enables retry on network failure)
+    this.pendingQuotes.delete(taskId);
+
+    if (options?.waitForResponse) {
+      const timeout = options.timeout ?? this.messageTimeout;
+      const response = await waitForEvent<AgentResponse>(this.wsClient, "agent:response", {
+        timeout,
+        filter: (r) => r.taskId === taskId,
+        timeoutMessage: `Task response timed out after ${timeout}ms (taskId: ${taskId})`
+      });
+      return response as FormattedResponse;
+    }
+  }
+
+  /**
+   * Gets a pending quote by task ID.
+   */
+  public getPendingQuote(taskId: string): QuoteResult | undefined {
+    return this.pendingQuotes.get(taskId);
+  }
+
   /**
    * Send message and wait for agent response
    * Uses event-waiter utility for clean Promise-based waiting with automatic cleanup

package/src/managers/room-management-manager.ts

@@ -58,7 +58,7 @@ export class RoomManagementManager extends EventEmitter<SDKEvents> {
    */
   public async createRoom(options: CreateRoomOptions): Promise<RoomInfo> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     // Validate inputs
@@ -135,7 +135,7 @@ export class RoomManagementManager extends EventEmitter<SDKEvents> {
    */
   public async updateRoom(roomId: string, updates: UpdateRoomOptions): Promise<RoomInfo> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     // Verify user owns room
@@ -224,7 +224,7 @@ export class RoomManagementManager extends EventEmitter<SDKEvents> {
    */
   public async deleteRoom(roomId: string): Promise<void> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     // Verify user owns room
@@ -505,10 +505,7 @@ export class RoomManagementManager extends EventEmitter<SDKEvents> {
       throw new SDKError("Room name cannot be empty", ErrorCode.VALIDATION_ERROR);
     }
     if (name.length > 100) {
-      throw new SDKError(
-        "Room name too long (max 100 characters)",
-        ErrorCode.VALIDATION_ERROR
-      );
+      throw new SDKError("Room name too long (max 100 characters)", ErrorCode.VALIDATION_ERROR);
     }
   }
 

package/src/managers/room-manager.ts

@@ -5,13 +5,7 @@
 
 import { EventEmitter } from "eventemitter3";
 import { WebSocketClient } from "../core/websocket-client";
-import {
-  createSubscribe,
-  createUnsubscribe,
-  createListRooms,
-  Logger,
-  RoomInfo
-} from "../types";
+import { createSubscribe, createUnsubscribe, createListRooms, Logger, RoomInfo } from "../types";
 import { SDKEvents, SDKError } from "../types/events";
 import { ErrorCode } from "../types/error-codes";
 import { RoomIdSchema } from "../types/validation";
@@ -29,7 +23,7 @@ export class RoomManager extends EventEmitter<SDKEvents> {
   }
 
   /**
-   * Subscribes to a public room in the Teneo network.
+   * Subscribes to a public room in the Teneo Protocol.
    * Validates room ID and sends subscribe message to the server.
    * The actual subscription state is updated when the server confirms via room:subscribed event.
    *
@@ -46,7 +40,7 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    */
   public async subscribeToRoom(roomId: string): Promise<void> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     // Validate room ID
@@ -59,24 +53,26 @@ export class RoomManager extends EventEmitter<SDKEvents> {
   }
 
   /**
-   * Unsubscribes from a room in the Teneo network.
+   * Unsubscribes from a public room in the Teneo Protocol.
    * Validates room ID and sends unsubscribe message to the server.
    * The actual subscription state is updated when the server confirms via room:unsubscribed event.
    *
-   * @param roomId - The ID of the room to unsubscribe from
+   * Note: This only applies to public rooms. Private rooms cannot be unsubscribed from.
+   *
+   * @param roomId - The ID of the public room to unsubscribe from
    * @returns Promise that resolves when unsubscribed
    * @throws {SDKError} If not connected to the network
    * @throws {ValidationError} If roomId is empty or invalid
    *
    * @example
    * ```typescript
-   * await roomManager.unsubscribeFromRoom('general');
-   * console.log('Unsubscription request sent for general room');
+   * await roomManager.unsubscribeFromRoom('public-announcements');
+   * console.log('Unsubscription request sent for public room');
    * ```
    */
   public async unsubscribeFromRoom(roomId: string): Promise<void> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     // Validate room ID
@@ -185,7 +181,7 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    */
   public async listRooms(): Promise<RoomInfo[]> {
     if (!this.wsClient.isConnected) {
-      throw new SDKError("Not connected to Teneo network", ErrorCode.NOT_CONNECTED);
+      throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
 
     this.logger.info("RoomManager: Listing rooms");

package/src/payments/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Payment module exports for quote-approve flow (v2.2.0)
+ */
+
+export {
+  PaymentClient,
+  type PaymentClientConfig,
+  // Constants
+  USDC_CONTRACT,
+  PEAQ_CHAIN_ID,
+  USDC_DECIMALS,
+  X402_VERSION,
+  DEFAULT_PAYMENT_TIMEOUT_SECONDS,
+  DEFAULT_PAY_TO_ADDRESS,
+  DEFAULT_RPC_URL,
+  // Utilities
+  buildX402ResourceUrl,
+  usdcToUnits,
+  unitsToUsdc,
+  // Types
+  type SupportedChain
+} from "./payment-client";

package/src/payments/payment-client.ts

@@ -0,0 +1,240 @@
+/**
+ * PaymentClient - Handles x402 payment header generation for quote-approve flow
+ *
+ * Creates x402 V2 payment headers for USDC payments on PEAQ network.
+ * Implements ERC-3009 TransferWithAuthorization signing using viem's EIP-712.
+ */
+
+import { defineChain, type Hex, toHex } from "viem";
+import { privateKeyToAccount, signTypedData } from "viem/accounts";
+import type { SecurePrivateKey } from "../utils/secure-private-key";
+
+// PEAQ chain definition
+const peaq = defineChain({
+  id: 3338,
+  name: "peaq",
+  network: "peaq",
+  nativeCurrency: {
+    decimals: 18,
+    name: "PEAQ",
+    symbol: "PEAQ"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://peaq.api.onfinality.io/public"]
+    },
+    public: {
+      http: ["https://peaq.api.onfinality.io/public"]
+    }
+  }
+});
+
+// USDC contract on PEAQ
+const USDC_CONTRACT = "0xbbA60da06c2c5424f03f7434542280FCAd453d10";
+const PEAQ_NETWORK_CAIP2 = "eip155:3338";
+
+// ERC-3009 TransferWithAuthorization EIP-712 types
+const ERC3009_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+} as const;
+
+export interface PaymentClientConfig {
+  network?: string; // CAIP-2 format, default: "eip155:3338"
+  asset?: string; // Asset contract, default: USDC on PEAQ
+  resourceUrl?: string; // x402 resource URL
+}
+
+// x402 constants
+export const USDC_DECIMALS = 6;
+export const X402_VERSION = 2;
+export const DEFAULT_PAYMENT_TIMEOUT_SECONDS = 60;
+export const DEFAULT_PAY_TO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export const DEFAULT_RPC_URL = "https://peaq.api.onfinality.io/public";
+export type SupportedChain = "peaq";
+
+// Re-export constants for external use
+export { USDC_CONTRACT, PEAQ_NETWORK_CAIP2 as PEAQ_CHAIN_ID };
+
+/**
+ * Converts a WebSocket URL to an HTTP(S) URL for x402 resource specification.
+ * The x402 protocol requires HTTP URLs, not WebSocket URLs.
+ *
+ * @param wsUrl - WebSocket URL (wss:// or ws://)
+ * @returns HTTP URL (https:// or http://)
+ *
+ * @example
+ * buildX402ResourceUrl("wss://api.teneo.com/ws") // "https://api.teneo.com/x402"
+ */
+export function buildX402ResourceUrl(wsUrl: string): string {
+  const httpUrl = wsUrl.replace(/^wss:\/\//, "https://").replace(/^ws:\/\//, "http://");
+
+  // Replace /ws endpoint with /x402, or append /x402 if URL doesn't end with /ws
+  return /\/ws\/?$/.test(httpUrl)
+    ? httpUrl.replace(/\/ws\/?$/, "/x402")
+    : httpUrl.replace(/\/?$/, "/x402");
+}
+
+/**
+ * Converts USDC human-readable amount to micro-units (6 decimals).
+ * @param usdc - Amount in USDC (e.g., 1.5)
+ * @returns Amount in micro-units (e.g., 1500000)
+ */
+export function usdcToUnits(usdc: number): number {
+  return Math.round(usdc * 10 ** USDC_DECIMALS);
+}
+
+/**
+ * Converts micro-units to USDC human-readable amount.
+ * @param units - Amount in micro-units (e.g., 1500000)
+ * @returns Amount in USDC (e.g., 1.5)
+ */
+export function unitsToUsdc(units: number): number {
+  return units / 10 ** USDC_DECIMALS;
+}
+
+/**
+ * Generate a random 32-byte nonce as hex string
+ */
+function generateNonce(): Hex {
+  const randomBytes = new Uint8Array(32);
+  crypto.getRandomValues(randomBytes);
+  return toHex(randomBytes);
+}
+
+/**
+ * PaymentClient handles creation of x402 V2 payment headers
+ * for the quote-approve payment flow.
+ */
+export class PaymentClient {
+  private readonly secureKey: SecurePrivateKey;
+  private readonly walletAddress: string;
+  private readonly network: string;
+  private readonly asset: string;
+  private readonly resourceUrl: string;
+
+  constructor(
+    secureKey: SecurePrivateKey,
+    walletAddress: string,
+    config: PaymentClientConfig = {}
+  ) {
+    this.secureKey = secureKey;
+    this.walletAddress = walletAddress;
+    this.network = config.network ?? PEAQ_NETWORK_CAIP2;
+    this.asset = config.asset ?? USDC_CONTRACT;
+    this.resourceUrl = config.resourceUrl ?? "";
+  }
+
+  /**
+   * Creates an x402 V2 payment header for a specific amount and recipient.
+   *
+   * @param amountMicroUnits - Amount in micro-units (e.g., 1000 = 0.001 USDC)
+   * @param recipientAddress - Wallet address of the payment recipient (agent)
+   * @param resourceUrl - Optional override for x402 resource URL
+   * @returns Base64 encoded x402 V2 payment header
+   */
+  async createPaymentHeader(
+    amountMicroUnits: number,
+    recipientAddress: string,
+    resourceUrl?: string
+  ): Promise<string> {
+    const resource = resourceUrl || this.resourceUrl || this.getDefaultResourceUrl();
+    const amountStr = Math.round(amountMicroUnits).toString();
+
+    // Create payment header using the secure key
+    const header = await this.secureKey.use(async (privateKey) => {
+      const account = privateKeyToAccount(privateKey as `0x${string}`);
+
+      // Time bounds for the authorization (valid for 60 seconds)
+      const now = Math.floor(Date.now() / 1000);
+      const validAfter = now - 60; // Valid from 60 seconds ago
+      const validBefore = now + 60; // Valid until 60 seconds from now
+      const nonce = generateNonce();
+
+      // EIP-712 domain for USDC on PEAQ
+      const domain = {
+        name: "USDC",
+        version: "2",
+        chainId: BigInt(peaq.id),
+        verifyingContract: this.asset as `0x${string}`
+      };
+
+      // ERC-3009 TransferWithAuthorization message
+      const message = {
+        from: account.address,
+        to: recipientAddress as `0x${string}`,
+        value: BigInt(amountStr),
+        validAfter: BigInt(validAfter),
+        validBefore: BigInt(validBefore),
+        nonce: nonce
+      };
+
+      // Sign the EIP-712 typed data
+      const signature = await signTypedData({
+        privateKey: privateKey as `0x${string}`,
+        domain,
+        types: ERC3009_TYPES,
+        primaryType: "TransferWithAuthorization",
+        message
+      });
+
+      // Build V1 payload (authorization data)
+      const v1Payload = {
+        authorization: {
+          from: account.address,
+          to: recipientAddress,
+          value: amountStr,
+          validAfter: validAfter.toString(),
+          validBefore: validBefore.toString(),
+          nonce: nonce
+        },
+        signature: signature
+      };
+
+      // Build V2 payload (what the backend expects)
+      const v2Payload = {
+        x402Version: 2,
+        resource: {
+          url: resource,
+          description: "Teneo SDK payment",
+          mimeType: "application/json"
+        },
+        accepted: {
+          scheme: "exact",
+          network: this.network,
+          amount: amountStr,
+          asset: this.asset,
+          payTo: recipientAddress,
+          maxTimeoutSeconds: 60,
+          extra: { name: "USDC", version: "2" }
+        },
+        payload: v1Payload
+      };
+
+      return Buffer.from(JSON.stringify(v2Payload)).toString("base64");
+    });
+
+    return header;
+  }
+
+  /**
+   * Get default x402 resource URL from WebSocket URL
+   */
+  private getDefaultResourceUrl(): string {
+    // Default fallback
+    return "https://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/x402";
+  }
+
+  /**
+   * Gets the wallet address associated with this payment client.
+   */
+  get address(): string {
+    return this.walletAddress;
+  }
+}