@dcentralab/d402-client 0.3.4 → 0.3.7

package/dist/index.js

@@ -299,12 +299,12 @@ __export(signer_exports, {
 async function signD402Payment(params) {
   const {
     operatorAccount,
+    walletClient,
     paymentRequirement,
     iatpWalletAddress,
     requestPath,
     d402Version = 1
   } = params;
-  const consumerWallet = iatpWalletAddress || operatorAccount.address;
   let finalRequestPath = requestPath || paymentRequirement.resource || "/mcp";
   if (!finalRequestPath || finalRequestPath.trim() === "") {
     finalRequestPath = "/mcp";
@@ -321,27 +321,39 @@ async function signD402Payment(params) {
     name: walletName,
     version: walletVersion,
     chainId,
-    verifyingContract: consumerWallet
+    verifyingContract: iatpWalletAddress
   };
   const message = {
-    wallet: consumerWallet,
+    wallet: iatpWalletAddress,
     provider: paymentRequirement.payTo,
     token: paymentRequirement.asset,
     amount: BigInt(paymentRequirement.maxAmountRequired),
     deadline: BigInt(validBefore),
     requestPath: finalRequestPath
   };
-  if (!operatorAccount.signTypedData) {
-    throw new Error("Account does not support signTypedData");
+  let signature;
+  if (walletClient) {
+    signature = await walletClient.signTypedData({
+      account: operatorAccount,
+      domain,
+      types: {
+        PullFundsForSettlement: EIP712_TYPES.PullFundsForSettlement
+      },
+      primaryType: "PullFundsForSettlement",
+      message
+    });
+  } else if (operatorAccount.signTypedData) {
+    signature = await operatorAccount.signTypedData({
+      domain,
+      types: {
+        PullFundsForSettlement: EIP712_TYPES.PullFundsForSettlement
+      },
+      primaryType: "PullFundsForSettlement",
+      message
+    });
+  } else {
+    throw new Error("Account does not support signTypedData. Pass walletClient for wagmi support.");
   }
-  const signature = await operatorAccount.signTypedData({
-    domain,
-    types: {
-      PullFundsForSettlement: EIP712_TYPES.PullFundsForSettlement
-    },
-    primaryType: "PullFundsForSettlement",
-    message
-  });
   const signedPayment = {
     d402Version,
     scheme: paymentRequirement.scheme,
@@ -349,7 +361,7 @@ async function signD402Payment(params) {
     payload: {
       signature,
       authorization: {
-        from: consumerWallet,
+        from: iatpWalletAddress,
         to: paymentRequirement.payTo,
         value: paymentRequirement.maxAmountRequired,
         validAfter,
@@ -408,6 +420,131 @@ var init_encoder = __esm({
   }
 });
 
+// src/mcp/session.ts
+var session_exports = {};
+__export(session_exports, {
+  DEFAULT_JSONRPC_VERSION: () => DEFAULT_JSONRPC_VERSION,
+  DEFAULT_REQUEST_ID: () => DEFAULT_REQUEST_ID,
+  initMcpSession: () => initMcpSession
+});
+async function initMcpSession(endpoint) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept": "application/json, text/event-stream"
+    },
+    body: JSON.stringify({
+      jsonrpc: DEFAULT_JSONRPC_VERSION,
+      id: DEFAULT_REQUEST_ID,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "d402-client", version: "1.0" }
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`MCP init failed: ${response.status} ${response.statusText}`);
+  }
+  return response.headers.get("mcp-session-id");
+}
+var DEFAULT_REQUEST_ID, DEFAULT_JSONRPC_VERSION;
+var init_session = __esm({
+  "src/mcp/session.ts"() {
+    DEFAULT_REQUEST_ID = "init-1";
+    DEFAULT_JSONRPC_VERSION = "2.0";
+  }
+});
+
+// src/mcp/payload.ts
+var payload_exports = {};
+__export(payload_exports, {
+  buildMcpHeaders: () => buildMcpHeaders,
+  buildToolCallPayload: () => buildToolCallPayload
+});
+function buildToolCallPayload(toolName, args, requestId = DEFAULT_REQUEST_ID) {
+  return {
+    jsonrpc: DEFAULT_JSONRPC_VERSION,
+    id: requestId,
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args
+    }
+  };
+}
+function buildMcpHeaders(sessionId) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream"
+  };
+  if (sessionId) {
+    headers["mcp-session-id"] = sessionId;
+  }
+  return headers;
+}
+var init_payload = __esm({
+  "src/mcp/payload.ts"() {
+    init_session();
+  }
+});
+
+// src/mcp/response.ts
+var response_exports = {};
+__export(response_exports, {
+  extractToolResult: () => extractToolResult,
+  parseMcpResponse: () => parseMcpResponse
+});
+async function parseMcpResponse(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream")) {
+    return parseSSEResponse(await response.text());
+  } else {
+    return await response.json();
+  }
+}
+function parseSSEResponse(text) {
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      const jsonStr = line.substring(6);
+      try {
+        return JSON.parse(jsonStr);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return {
+    id: "unknown",
+    result: { raw: text },
+    error: {
+      code: -32700,
+      message: "Could not parse SSE response",
+      data: text
+    }
+  };
+}
+function extractToolResult(response) {
+  if (response.error) {
+    throw new Error(`MCP error ${response.error.code}: ${response.error.message}`);
+  }
+  if (response.result && typeof response.result === "object") {
+    const result = response.result;
+    if (result.structuredContent) {
+      return result.structuredContent;
+    }
+    return result;
+  }
+  return response.result;
+}
+var init_response = __esm({
+  "src/mcp/response.ts"() {
+  }
+});
+
 // src/payment/selector.ts
 init_errors();
 function selectPaymentRequirement(requirements, options = {}) {
@@ -5041,7 +5178,7 @@ function getContractConfig(contractName, network = "sepolia") {
 
 // src/wallet/creation.ts
 async function createIATPWallet(params) {
-  const { ownerAccount, network = "sepolia", rpcUrl } = params;
+  const { ownerAccount, walletClient: externalWalletClient, network = "sepolia", rpcUrl } = params;
   const factoryConfig = getContractConfig("IATPWalletFactory" /* IATP_WALLET_FACTORY */, network);
   if (!factoryConfig) {
     throw new Error(`IATPWalletFactory not found for network: ${network}`);
@@ -5053,7 +5190,7 @@ async function createIATPWallet(params) {
     chain,
     transport
   });
-  const walletClient = viem.createWalletClient({
+  const walletClient = externalWalletClient ?? viem.createWalletClient({
     account: ownerAccount,
     chain,
     transport
@@ -5062,14 +5199,14 @@ async function createIATPWallet(params) {
   if (balance === 0n) {
     throw new Error("Owner has no ETH for gas. Please fund the account.");
   }
-  const { request } = await publicClient.simulateContract({
+  const hash = await walletClient.writeContract({
     account: ownerAccount,
     address: factoryConfig.address,
     abi: factoryConfig.abi,
     functionName: "createWallet",
-    args: [operatorAddress, 0, "", ""]
+    args: [operatorAddress, 0, "", ""],
+    chain
   });
-  const hash = await walletClient.writeContract(request);
   const receipt = await publicClient.waitForTransactionReceipt({
     hash,
     timeout: 3e5
@@ -5247,6 +5384,7 @@ var D402Client = class {
    */
   constructor(config) {
     this.operatorAccount = config.operatorAccount;
+    this.walletClient = config.walletClient;
     this.iatpWalletAddress = config.iatpWalletAddress;
     this.maxValue = config.maxValue;
     this.networkFilter = config.networkFilter;
@@ -5390,7 +5528,15 @@ var D402Client = class {
     const { parseAllPaymentRequirements: parseAllPaymentRequirements2 } = await Promise.resolve().then(() => (init_parser(), parser_exports));
     const { signD402Payment: signD402Payment2 } = await Promise.resolve().then(() => (init_signer(), signer_exports));
     const { encodePayment: encodePayment2 } = await Promise.resolve().then(() => (init_encoder(), encoder_exports));
-    let response = await fetch(url, init);
+    const enhancedInit = {
+      ...init,
+      headers: {
+        ...init?.headers,
+        // Preserve existing Accept header or set default for MCP compatibility
+        "Accept": init?.headers?.["Accept"] || "application/json, text/event-stream"
+      }
+    };
+    let response = await fetch(url, enhancedInit);
     if (response.status !== 402) {
       return response;
     }
@@ -5399,14 +5545,15 @@ var D402Client = class {
       const selectedRequirement = this.selectPaymentRequirement(requirements);
       const signedPayment = await signD402Payment2({
         operatorAccount: this.operatorAccount,
+        walletClient: this.walletClient,
         paymentRequirement: selectedRequirement,
         iatpWalletAddress: this.iatpWalletAddress
       });
       const paymentHeader = encodePayment2(signedPayment);
       response = await fetch(url, {
-        ...init,
+        ...enhancedInit,
         headers: {
-          ...init?.headers,
+          ...enhancedInit.headers,
           "X-Payment": paymentHeader,
           "Access-Control-Expose-Headers": "X-Payment-Response"
         }
@@ -5416,6 +5563,63 @@ var D402Client = class {
       throw error;
     }
   }
+  // ========================================================================
+  // MCP Methods - Simplified API for MCP tool calls
+  // ========================================================================
+  /**
+   * Call an MCP tool with automatic session initialization and payment handling.
+   * 
+   * This is the simplest way to call an MCP tool. It handles:
+   * - MCP session initialization
+   * - JSON-RPC payload construction
+   * - HTTP 402 payment flow
+   * - SSE/JSON response parsing
+   * 
+   * @param endpoint - MCP server endpoint URL
+   * @param toolName - Name of the tool to call
+   * @param input - Tool arguments
+   * @param options - Optional configuration
+   * @returns The tool's result data
+   * 
+   * @example
+   * ```ts
+   * const client = new D402Client({
+   *   operatorAccount: walletClient.account,
+   *   walletClient,
+   *   iatpWalletAddress,
+   * })
+   * 
+   * // Simple one-liner!
+   * const result = await client.mcpCall(
+   *   'https://my-mcp.example.com/mcp',
+   *   'google_search',
+   *   { q: 'test search' }
+   * )
+   * 
+   * console.log(result) // { searchResults: [...] }
+   * ```
+   */
+  async mcpCall(endpoint, toolName, input, options) {
+    const { initMcpSession: initMcpSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+    const { buildToolCallPayload: buildToolCallPayload2, buildMcpHeaders: buildMcpHeaders2 } = await Promise.resolve().then(() => (init_payload(), payload_exports));
+    const { parseMcpResponse: parseMcpResponse2, extractToolResult: extractToolResult2 } = await Promise.resolve().then(() => (init_response(), response_exports));
+    let sessionId = null;
+    if (!options?.skipInit) {
+      try {
+        sessionId = await initMcpSession2(endpoint);
+      } catch {
+      }
+    }
+    const headers = buildMcpHeaders2(sessionId);
+    const payload = buildToolCallPayload2(toolName, input, options?.requestId);
+    const response = await this.fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    const parsed = await parseMcpResponse2(response);
+    return extractToolResult2(parsed);
+  }
 };
 
 // src/index.ts
@@ -5423,6 +5627,11 @@ init_signer();
 init_parser();
 init_encoder();
 
+// src/mcp/index.ts
+init_session();
+init_payload();
+init_response();
+
 // src/settlement/queries.ts
 async function getLockedBalanceForProvider(params) {
   const { publicClient, providerAddress, tokenAddress, network = "sepolia" } = params;
@@ -5497,12 +5706,15 @@ init_errors();
 
 exports.ContractName = ContractName;
 exports.D402Client = D402Client;
+exports.buildMcpHeaders = buildMcpHeaders;
+exports.buildToolCallPayload = buildToolCallPayload;
 exports.createIATPWallet = createIATPWallet;
 exports.createPaymentSelector = createPaymentSelector;
 exports.decodePayment = decodePayment;
 exports.decodePaymentResponse = decodePaymentResponse;
 exports.encodePayment = encodePayment;
 exports.executeWithdrawal = executeWithdrawal;
+exports.extractToolResult = extractToolResult;
 exports.findMatchingPaymentRequirement = findMatchingPaymentRequirement;
 exports.formatMoney = formatMoney;
 exports.generateNonce = generateNonce;
@@ -5517,9 +5729,11 @@ exports.getUnlockedBalanceForProvider = getUnlockedBalanceForProvider;
 exports.getUsdcAddress = getUsdcAddress;
 exports.getWalletsByOwner = getWalletsByOwner;
 exports.getWithdrawalRequest = getWithdrawalRequest;
+exports.initMcpSession = initMcpSession;
 exports.isValidAddress = isValidAddress;
 exports.normalizeAddress = normalizeAddress;
 exports.parseAllPaymentRequirements = parseAllPaymentRequirements;
+exports.parseMcpResponse = parseMcpResponse;
 exports.parseMoney = parseMoney;
 exports.parsePaymentRequirement = parsePaymentRequirement;
 exports.requestWithdrawal = requestWithdrawal;