@compass-labs/api-sdk 0.0.3

package/src/mcp-server/tools/uniswapV3SwapSellExactly.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { uniswapV3SwapSellExactly } from "../../funcs/uniswapV3SwapSellExactly.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.UniswapSellExactlyRequest$inboundSchema,
+};
+
+export const tool$uniswapV3SwapSellExactly: ToolDefinition<typeof args> = {
+  name: "uniswap-v3-swap-sell-exactly",
+  description: `Sell exact amount
+
+This endpoint allows users to trade a specific amount of one token into another
+token using the Uniswap protocol.
+
+The transaction is executed on the specified blockchain network, and the user must
+provide the necessary transaction details, including the token to sell, the token to
+receive, and the amount to sell. If the token being sold is WETH and needs to be
+wrapped, the appropriate amount will be wrapped automatically.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await uniswapV3SwapSellExactly(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalAllowance.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalAllowance } from "../../funcs/universalAllowance.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericAllowanceRequest$inboundSchema,
+};
+
+export const tool$universalAllowance: ToolDefinition<typeof args> = {
+  name: "universal-allowance",
+  description: `Get allowance - Protocol
+
+In decentralized finance (DeFi) protocols such as Uniswap or AAVE, users must set
+a token allowance to authorize the protocol to spend a specified amount of their
+tokens on their behalf.
+
+This is a crucial step before engaging in any transactions or operations within
+these protocols, ensuring that the protocol has the necessary permissions to manage
+the user's tokens securely and efficiently.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalAllowance(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalAllowanceSet.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalAllowanceSet } from "../../funcs/universalAllowanceSet.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.IncreaseAllowanceRequest$inboundSchema,
+};
+
+export const tool$universalAllowanceSet: ToolDefinition<typeof args> = {
+  name: "universal-allowance-set",
+  description: `Set Allowance - Protocol
+
+This endpoint allows users to modify the token allowance for a specific protocol.
+
+In decentralized finance (DeFi), setting an allowance is a necessary step to
+authorize a protocol to spend a specified amount of tokens on behalf of the user.
+This operation is crucial for ensuring that the protocol can manage the user's
+tokens securely and efficiently, enabling seamless transactions and operations
+within the DeFi ecosystem.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalAllowanceSet(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalBalance.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalBalance } from "../../funcs/universalBalance.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericBalanceRequest$inboundSchema,
+};
+
+export const tool$universalBalance: ToolDefinition<typeof args> = {
+  name: "universal-balance",
+  description: `User Token Balance
+
+Returns the balance of a specific ERC20 token for a given user address.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalBalance(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalEns.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalEns } from "../../funcs/universalEns.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericEnsRequest$inboundSchema,
+};
+
+export const tool$universalEns: ToolDefinition<typeof args> = {
+  name: "universal-ens",
+  description: `Resolve ENS
+
+An ENS name is a string ending in \`.eth\`.
+
+E.g. \`vitalik.eth\`. This endpoint can be used to
+query the actual ethereum wallet address behind the ENS name.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalEns(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalPortfolio.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalPortfolio } from "../../funcs/universalPortfolio.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericPortfolioRequest$inboundSchema,
+};
+
+export const tool$universalPortfolio: ToolDefinition<typeof args> = {
+  name: "universal-portfolio",
+  description: `List user portfolio
+
+Fetch the detailed portfolio of a specific wallet address on a given blockchain.
+
+This includes the total value of the portfolio in USD and a breakdown of token
+balances, including their respective values and quantities.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalPortfolio(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalPriceUsd.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalPriceUsd } from "../../funcs/universalPriceUsd.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericPriceUsdRequest$inboundSchema,
+};
+
+export const tool$universalPriceUsd: ToolDefinition<typeof args> = {
+  name: "universal-price-usd",
+  description: `Token price
+
+Retrieves the price of the specified token relative to USD using Chainlink's on-
+chain price feeds.
+
+Chainlink is a decentralized oracle that aggregates price data from off-chain
+sources. This ensures the price is tamper-resistant but the price might be stale
+with the update frequency of the oracle.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalPriceUsd(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalSupportedTokens.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalSupportedTokens } from "../../funcs/universalSupportedTokens.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericSupportedTokensRequest$inboundSchema,
+};
+
+export const tool$universalSupportedTokens: ToolDefinition<typeof args> = {
+  name: "universal-supported-tokens",
+  description: `List supported tokens
+
+Get the list of supported tokens on a chain by the Compass API.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalSupportedTokens(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalTransferErc20.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalTransferErc20 } from "../../funcs/universalTransferErc20.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.TransferErc20Request$inboundSchema,
+};
+
+export const tool$universalTransferErc20: ToolDefinition<typeof args> = {
+  name: "universal-transfer-erc20",
+  description: `Transfer Token
+
+Sends ERC20 tokens from the sender's address to the specified recipient.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalTransferErc20(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalTransferNativeToken.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalTransferNativeToken } from "../../funcs/universalTransferNativeToken.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.TransferEthRequest$inboundSchema,
+};
+
+export const tool$universalTransferNativeToken: ToolDefinition<typeof args> = {
+  name: "universal-transfer-native-token",
+  description: `Transfer ETH
+
+Sends native ETH from the sender's address to the specified recipient.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalTransferNativeToken(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalUnwrapWeth.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalUnwrapWeth } from "../../funcs/universalUnwrapWeth.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.UnwrapWethRequest$inboundSchema,
+};
+
+export const tool$universalUnwrapWeth: ToolDefinition<typeof args> = {
+  name: "universal-unwrap-weth",
+  description: `Unwrap WETH
+
+Unwrapping WETH converts the ERC-20 compliant form of ETH back to native ETH that
+can be used for gas and other native purposes.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalUnwrapWeth(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalVisualizePortfolio.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalVisualizePortfolio } from "../../funcs/universalVisualizePortfolio.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenericVisualizePortfolioRequest$inboundSchema,
+};
+
+export const tool$universalVisualizePortfolio: ToolDefinition<typeof args> = {
+  name: "universal-visualize-portfolio",
+  description: `Visualize user portfolio
+
+Generate a visual representation of the token portfolio for a wallet address.
+
+The response is an SVG image of a pie chart depicting the relative distribution of
+tokens held, colored and labeled with token symbols, percentages and token values in
+USD.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalVisualizePortfolio(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/universalWrapEth.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalWrapEth } from "../../funcs/universalWrapEth.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.WrapEthRequest$inboundSchema,
+};
+
+export const tool$universalWrapEth: ToolDefinition<typeof args> = {
+  name: "universal-wrap-eth",
+  description: `Wrap ETH
+
+Wrapping ETH creates an ERC-20 compliant form of ETH that is typically needed for
+it to be traded on DeFi protocols.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await universalWrapEth(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools.ts

@@ -0,0 +1,129 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { objectOutputType, ZodRawShape, ZodTypeAny } from "zod";
+import { CompassApiSDKCore } from "../core.js";
+import { ConsoleLogger } from "./console-logger.js";
+import { MCPScope } from "./scopes.js";
+import { isAsyncIterable, isBinaryData, valueToBase64 } from "./shared.js";
+
+export type ToolDefinition<Args extends undefined | ZodRawShape = undefined> =
+  Args extends ZodRawShape ? {
+      name: string;
+      description: string;
+      scopes?: MCPScope[];
+      args: Args;
+      tool: (
+        client: CompassApiSDKCore,
+        args: objectOutputType<Args, ZodTypeAny>,
+        extra: RequestHandlerExtra,
+      ) => CallToolResult | Promise<CallToolResult>;
+    }
+    : {
+      name: string;
+      description: string;
+      scopes?: MCPScope[];
+      args?: undefined;
+      tool: (
+        client: CompassApiSDKCore,
+        extra: RequestHandlerExtra,
+      ) => CallToolResult | Promise<CallToolResult>;
+    };
+
+// Optional function to assist with formatting tool results
+export async function formatResult(
+  value: unknown,
+  init: { response?: Response | undefined },
+): Promise<CallToolResult> {
+  if (typeof value === "undefined") {
+    return { content: [] };
+  }
+
+  const { response } = init;
+  const contentType = response?.headers.get("content-type") ?? "";
+  let content: CallToolResult["content"] = [];
+
+  if (contentType.search(/\bjson\b/g)) {
+    content = [{ type: "text", text: JSON.stringify(value) }];
+  } else if (
+    contentType.startsWith("text/event-stream")
+    && isAsyncIterable(value)
+  ) {
+    content = await consumeSSE(value);
+  } else if (contentType.startsWith("text/") && typeof value === "string") {
+    content = [{ type: "text", text: value }];
+  } else if (isBinaryData(value) && contentType.startsWith("image/")) {
+    const data = await valueToBase64(value);
+    content = data == null
+      ? []
+      : [{ type: "image", data, mimeType: contentType }];
+  } else {
+    return {
+      content: [{
+        type: "text",
+        text: `Unsupported content type: "${contentType}"`,
+      }],
+      isError: true,
+    };
+  }
+
+  return { content };
+}
+
+async function consumeSSE(
+  value: AsyncIterable<unknown>,
+): Promise<CallToolResult["content"]> {
+  const content: CallToolResult["content"] = [];
+
+  for await (const chunk of value) {
+    if (typeof chunk === "string") {
+      content.push({ type: "text", text: chunk });
+    } else {
+      content.push({ type: "text", text: JSON.stringify(chunk) });
+    }
+  }
+
+  return content;
+}
+
+export function createRegisterTool(
+  logger: ConsoleLogger,
+  server: McpServer,
+  sdk: CompassApiSDKCore,
+  allowedScopes: Set<MCPScope>,
+  allowedTools?: Set<string>,
+): <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>) => void {
+  return <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>): void => {
+    if (allowedTools && !allowedTools.has(tool.name)) {
+      return;
+    }
+
+    const scopes = tool.scopes ?? [];
+    if (allowedScopes.size > 0 && scopes.length === 0) {
+      return;
+    }
+
+    if (
+      allowedScopes.size > 0
+      && !scopes.every((s: MCPScope) => allowedScopes.has(s))
+    ) {
+      return;
+    }
+
+    if (tool.args) {
+      server.tool(tool.name, tool.description, tool.args, async (args, ctx) => {
+        return tool.tool(sdk, args, ctx);
+      });
+    } else {
+      server.tool(tool.name, tool.description, async (ctx) => {
+        return tool.tool(sdk, ctx);
+      });
+    }
+
+    logger.debug("Registered tool", { name: tool.name });
+  };
+}