@compass-labs/api-sdk 0.0.3

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

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamLiquidityProvisionMint } from "../../funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionMint.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    components.AerodromeSlipstreamMintLiquidityProvisionRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamLiquidityProvisionMint:
+  ToolDefinition<typeof args> = {
+    name: "aerodrome-slipstream-slipstream-liquidity-provision-mint",
+    description: `Open a new LP position
+
+Initiate a new Liquidity Provider (LP) position by minting tokens.
+
+This endpoint allows users to open a new LP position, enabling them to participate
+in liquidity provision. The minting process involves creating a new position with
+specified parameters, such as token amounts and pool details. The response will
+confirm the successful creation of the LP position, providing users with the
+necessary information to manage their newly minted position. This functionality is
+crucial for users looking to expand their liquidity provision activities, offering
+them the opportunity to engage in decentralized finance (DeFi) markets effectively.`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] =
+        await aerodromeSlipstreamSlipstreamLiquidityProvisionMint(
+          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/aerodromeSlipstreamSlipstreamLiquidityProvisionPositions.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamLiquidityProvisionPositions } from "../../funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionPositions.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    operations
+      .AerodromeSlipstreamLiquidityProvisionPositionsRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamLiquidityProvisionPositions:
+  ToolDefinition<typeof args> = {
+    name: "aerodrome-slipstream-slipstream-liquidity-provision-positions",
+    description: `List LP positions
+
+Retrieve the total number of Liquidity Provider (LP) positions associated with a
+specific sender.
+
+This endpoint allows users to query and obtain detailed information about their LP
+positions, including the number of active positions they hold. The response model,
+AerodromeLPPositionsInfo, provides a structured representation of the LP positions
+data, ensuring clarity and ease of use. This functionality is essential for users
+managing their liquidity provision activities, enabling them to make informed
+decisions based on their current positions.`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] =
+        await aerodromeSlipstreamSlipstreamLiquidityProvisionPositions(
+          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/aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw } from "../../funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request:
+    components
+      .AerodromeSlipstreamWithdrawLiquidityProvisionRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw:
+  ToolDefinition<typeof args> = {
+    name: "aerodrome-slipstream-slipstream-liquidity-provision-withdraw",
+    description: `Withdraw an LP position
+
+Withdraw an existing Liquidity Provider (LP) position.
+
+This endpoint allows users to remove their tokens from an LP position, effectively
+closing their participation in the liquidity pool. The withdrawal process involves
+specifying the LP position to be closed, and the response will confirm the
+successful removal of liquidity, providing users with details about the withdrawn
+tokens and any remaining balances. This functionality is essential for users who
+wish to exit their liquidity provision activities, enabling them to reclaim their
+assets and potentially reallocate them to other investment opportunities. The
+endpoint ensures a smooth and secure withdrawal process, facilitating users'
+strategic management of their decentralized finance (DeFi) portfolios.`,
+    args,
+    tool: async (client, args, ctx) => {
+      const [result, apiCall] =
+        await aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw(
+          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/aerodromeSlipstreamSlipstreamPoolPrice.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamPoolPrice } from "../../funcs/aerodromeSlipstreamSlipstreamPoolPrice.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.AerodromeSlipstreamPoolPriceRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamPoolPrice: ToolDefinition<
+  typeof args
+> = {
+  name: "aerodrome-slipstream-slipstream-pool-price",
+  description: `Pool price
+
+This endpoint retrieves the current price of a pool, indicating how many token0
+you can purchase for 1 token1.
+
+Note that this is an instantaneous price and may change during any trade. For a more
+accurate representation of the trade ratios between the two assets, consider using
+the quote endpoint.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await aerodromeSlipstreamSlipstreamPoolPrice(
+      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/aerodromeSlipstreamSlipstreamSwapBuyExactly.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamSwapBuyExactly } from "../../funcs/aerodromeSlipstreamSlipstreamSwapBuyExactly.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.AerodromeSlipstreamBuyExactlyRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamSwapBuyExactly: ToolDefinition<
+  typeof args
+> = {
+  name: "aerodrome-slipstream-slipstream-swap-buy-exactly",
+  description: `Swap - into specified amount
+
+This endpoint facilitates the trading of tokens by allowing users to specify the
+exact amount of the output token they wish to receive.
+
+Utilizing the Aerodrome Slipstream protocol, the system calculates the necessary
+amount of the input token required to achieve the desired output. This operation is
+particularly useful for users who have a specific target amount of the output token
+in mind and are willing to provide the corresponding input token amount. The
+transaction is executed with consideration of current market conditions, including
+liquidity and price impact, ensuring that the trade is completed efficiently and
+effectively.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await aerodromeSlipstreamSlipstreamSwapBuyExactly(
+      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/aerodromeSlipstreamSlipstreamSwapSellExactly.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aerodromeSlipstreamSlipstreamSwapSellExactly } from "../../funcs/aerodromeSlipstreamSlipstreamSwapSellExactly.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.AerodromeSlipstreamSellExactlyRequest$inboundSchema,
+};
+
+export const tool$aerodromeSlipstreamSlipstreamSwapSellExactly: ToolDefinition<
+  typeof args
+> = {
+  name: "aerodrome-slipstream-slipstream-swap-sell-exactly",
+  description: `Swap - from specified amount
+
+This endpoint allows users to trade a specific amount of one token into another
+token using the Aerodrome Slipstream protocol.
+
+The transaction is executed by specifying the exact amount of the input token to be
+sold, and the system calculates the amount of the output token that will be
+received. The operation ensures that the trade is conducted within the constraints
+of the current market conditions, taking into account the liquidity and price
+impact. This endpoint is suitable for users who want to sell a precise quantity of a
+token and are willing to accept the resulting amount of the other token.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] =
+      await aerodromeSlipstreamSlipstreamSwapSellExactly(
+        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/morphoAllowance.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoAllowance } from "../../funcs/morphoAllowance.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.MorphoSetVaultAllowanceRequest$inboundSchema,
+};
+
+export const tool$morphoAllowance: ToolDefinition<typeof args> = {
+  name: "morpho-allowance",
+  description: `Set Allowance for Vault
+
+Set an allowance for a Morpho vault. You must set this for at least the amount you wish to deposit - before depositing.
+
+Each vault has only one associated token that can be deposited.
+
+Use the 'Get Vaults' endpoint to query a list of vaults you can deposit into.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoAllowance(
+      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/morphoBorrow.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoBorrow } from "../../funcs/morphoBorrow.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.MorphoBorrowRequest$inboundSchema,
+};
+
+export const tool$morphoBorrow: ToolDefinition<typeof args> = {
+  name: "morpho-borrow",
+  description: `Borrow from Market
+
+Borrow tokens from a Morpho Market against supplied collateral.
+
+The position could be liquidated when a borrower's Loan-To-Value (LTV) exceeds the
+Liquidation Loan-To-Value (LLTV) threshold of the market.
+
+A Morpho Market is a primitive lending pool that pairs one collateral asset with one
+loan asset. Each market is isolated (meaning risks are contained within each
+individual market), immutable (cannot be changed after deployment), and will persist
+as long as the blockchain it is deployed on is live.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoBorrow(
+      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/morphoDeposit.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoDeposit } from "../../funcs/morphoDeposit.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.MorphoDepositRequest$inboundSchema,
+};
+
+export const tool$morphoDeposit: ToolDefinition<typeof args> = {
+  name: "morpho-deposit",
+  description: `Deposit to Vault
+
+Deposit tokens into a Morpho Vault to earn passive yield from interest paid by
+borrowers.
+
+Each vault accepts one unique token that can be deposited.
+
+A Morpho Vault has one loan asset and can allocate deposits to multiple Morpho
+markets. Users can deposit into a vault to start earning passive yield from interest
+paid by borrowers. Vaults feature automated risk management, actively curating risk
+exposure for all deposited assets so users don't need to make these decisions
+themselves. Users maintain full control over their assets, can monitor the vault's
+state at any time, and withdraw their liquidity at their discretion.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoDeposit(
+      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/morphoMarketPosition.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoMarketPosition } from "../../funcs/morphoMarketPosition.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.MorphoMarketPositionRequest$inboundSchema,
+};
+
+export const tool$morphoMarketPosition: ToolDefinition<typeof args> = {
+  name: "morpho-market-position",
+  description: `Check Market Position
+
+Check how many shares you've borrowed and the equivalent token amount of a given
+market.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoMarketPosition(
+      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/morphoMarkets.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoMarkets } from "../../funcs/morphoMarkets.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.MorphoMarketsRequest$inboundSchema,
+};
+
+export const tool$morphoMarkets: ToolDefinition<typeof args> = {
+  name: "morpho-markets",
+  description: `Get Markets
+
+Query a list of markets you can borrow from.
+
+Each market has one unique token that can be borrowed against one unique token that
+can be used as collateral.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoMarkets(
+      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/morphoRepay.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoRepay } from "../../funcs/morphoRepay.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.MorphoRepayRequest$inboundSchema,
+};
+
+export const tool$morphoRepay: ToolDefinition<typeof args> = {
+  name: "morpho-repay",
+  description: `Repay to Market
+
+Repay borrowed tokens to a market in order to reduce or eliminate debt.
+
+A Morpho Market is a primitive lending pool that pairs one collateral asset with one
+loan asset. Each market is isolated (meaning risks are contained within each
+individual market), immutable (cannot be changed after deployment), and will persist
+as long as the blockchain it is deployed on is live.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoRepay(
+      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/morphoSupplyCollateral.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoSupplyCollateral } from "../../funcs/morphoSupplyCollateral.js";
+import * as components from "../../models/components/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: components.MorphoSupplyCollateralRequest$inboundSchema,
+};
+
+export const tool$morphoSupplyCollateral: ToolDefinition<typeof args> = {
+  name: "morpho-supply-collateral",
+  description: `Supply Collateral to Market
+
+Supply collateral to a Morpho Market in order to borrow against it.
+
+A Morpho Market is a primitive lending pool that pairs one collateral asset with one
+loan asset. Each market is isolated (meaning risks are contained within each
+individual market), immutable (cannot be changed after deployment), and will persist
+as long as the blockchain it is deployed on is live.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoSupplyCollateral(
+      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/morphoVaultPosition.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoVaultPosition } from "../../funcs/morphoVaultPosition.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.MorphoVaultPositionRequest$inboundSchema,
+};
+
+export const tool$morphoVaultPosition: ToolDefinition<typeof args> = {
+  name: "morpho-vault-position",
+  description: `Check Vault Position
+
+Check how many shares you own and the equivalent token amount of a given
+vault.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoVaultPosition(
+      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/morphoVaults.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { morphoVaults } from "../../funcs/morphoVaults.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.MorphoVaultsRequest$inboundSchema,
+};
+
+export const tool$morphoVaults: ToolDefinition<typeof args> = {
+  name: "morpho-vaults",
+  description: `Get Vaults
+
+Query a list of vaults you can deposit into.
+
+Each vault has one unique token that can be deposited. In exchange for depositing
+tokens into a vault you receive shares. You earn yield on these shares by their
+exchange value increasing over time.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await morphoVaults(
+      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);
+  },
+};