@dcentralab/d402-client 0.3.4 → 0.3.7

package/dist/index.mjs

@@ -297,12 +297,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";
@@ -319,27 +319,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,
@@ -347,7 +359,7 @@ async function signD402Payment(params) {
     payload: {
       signature,
       authorization: {
-        from: consumerWallet,
+        from: iatpWalletAddress,
         to: paymentRequirement.payTo,
         value: paymentRequirement.maxAmountRequired,
         validAfter,
@@ -406,6 +418,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 = {}) {
@@ -5039,7 +5176,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}`);
@@ -5051,7 +5188,7 @@ async function createIATPWallet(params) {
     chain,
     transport
   });
-  const walletClient = createWalletClient({
+  const walletClient = externalWalletClient ?? createWalletClient({
     account: ownerAccount,
     chain,
     transport
@@ -5060,14 +5197,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
@@ -5245,6 +5382,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;
@@ -5388,7 +5526,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;
     }
@@ -5397,14 +5543,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"
         }
@@ -5414,6 +5561,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
@@ -5421,6 +5625,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;
@@ -5493,6 +5702,6 @@ async function withdrawAllAvailableEpochs(params) {
 init_utils();
 init_errors();
 
-export { ContractName, D402Client, Invalid402ResponseError, MissingRequestConfigError, PaymentAlreadyAttemptedError, PaymentAmountExceededError, PaymentError, PaymentVerificationError, UnsupportedNetworkError, UnsupportedSchemeError, createIATPWallet, createPaymentSelector, decodePayment, decodePaymentResponse, encodePayment, executeWithdrawal, findMatchingPaymentRequirement, formatMoney, generateNonce, getAvailableBalance, getChainId, getContractAbi, getContractAddress, getContractConfig, getCurrentTimestamp, getLockedBalanceForProvider, getUnlockedBalanceForProvider, getUsdcAddress, getWalletsByOwner, getWithdrawalRequest, isValidAddress, normalizeAddress, parseAllPaymentRequirements, parseMoney, parsePaymentRequirement, requestWithdrawal, selectPaymentRequirement, signD402Payment, sortPaymentRequirements, usdToUsdc, withdrawAllAvailableEpochs };
+export { ContractName, D402Client, Invalid402ResponseError, MissingRequestConfigError, PaymentAlreadyAttemptedError, PaymentAmountExceededError, PaymentError, PaymentVerificationError, UnsupportedNetworkError, UnsupportedSchemeError, buildMcpHeaders, buildToolCallPayload, createIATPWallet, createPaymentSelector, decodePayment, decodePaymentResponse, encodePayment, executeWithdrawal, extractToolResult, findMatchingPaymentRequirement, formatMoney, generateNonce, getAvailableBalance, getChainId, getContractAbi, getContractAddress, getContractConfig, getCurrentTimestamp, getLockedBalanceForProvider, getUnlockedBalanceForProvider, getUsdcAddress, getWalletsByOwner, getWithdrawalRequest, initMcpSession, isValidAddress, normalizeAddress, parseAllPaymentRequirements, parseMcpResponse, parseMoney, parsePaymentRequirement, requestWithdrawal, selectPaymentRequirement, signD402Payment, sortPaymentRequirements, usdToUsdc, withdrawAllAvailableEpochs };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map