@compass-labs/api-sdk 0.0.3

package/src/sdk/uniswapv3.ts

@@ -0,0 +1,250 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { uniswapV3LiquidityProvisionIncrease } from "../funcs/uniswapV3LiquidityProvisionIncrease.js";
+import { uniswapV3LiquidityProvisionInRange } from "../funcs/uniswapV3LiquidityProvisionInRange.js";
+import { uniswapV3LiquidityProvisionMint } from "../funcs/uniswapV3LiquidityProvisionMint.js";
+import { uniswapV3LiquidityProvisionPositions } from "../funcs/uniswapV3LiquidityProvisionPositions.js";
+import { uniswapV3LiquidityProvisionWithdraw } from "../funcs/uniswapV3LiquidityProvisionWithdraw.js";
+import { uniswapV3PoolPrice } from "../funcs/uniswapV3PoolPrice.js";
+import { uniswapV3QuoteBuyExactly } from "../funcs/uniswapV3QuoteBuyExactly.js";
+import { uniswapV3QuoteSellExactly } from "../funcs/uniswapV3QuoteSellExactly.js";
+import { uniswapV3SwapBuyExactly } from "../funcs/uniswapV3SwapBuyExactly.js";
+import { uniswapV3SwapSellExactly } from "../funcs/uniswapV3SwapSellExactly.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class UniswapV3 extends ClientSDK {
+  /**
+   * Get quote - to specified amount
+   *
+   * @remarks
+   * This endpoint calculates the amount of input tokens required to purchase a
+   * specified amount of output tokens from a Uniswap pool.
+   *
+   * It also provides the resulting price after the transaction. The calculation takes
+   * into account the current pool state and the specified fee tier.
+   */
+  async quoteBuyExactly(
+    request: operations.UniswapQuoteBuyExactlyRequest,
+    options?: RequestOptions,
+  ): Promise<components.UniswapBuyQuoteInfoResponse> {
+    return unwrapAsync(uniswapV3QuoteBuyExactly(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get quote - from specified amount
+   *
+   * @remarks
+   * This endpoint calculates the amount of input tokens required to purchase a
+   * specified amount of output tokens from a Uniswap pool.
+   *
+   * It also provides the resulting price after the transaction. The calculation takes
+   * into account the current pool state and the specified fee tier.
+   */
+  async quoteSellExactly(
+    request: operations.UniswapQuoteSellExactlyRequest,
+    options?: RequestOptions,
+  ): Promise<components.UniswapSellQuoteInfoResponse> {
+    return unwrapAsync(uniswapV3QuoteSellExactly(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Pool price
+   *
+   * @remarks
+   * This endpoint calculates the price of a token in a Uniswap pool.
+   *
+   * The price is calculated based on the current pool state and the specified fee tier.
+   */
+  async poolPrice(
+    request: operations.UniswapPoolPriceRequest,
+    options?: RequestOptions,
+  ): Promise<components.UniswapPoolPriceResponse> {
+    return unwrapAsync(uniswapV3PoolPrice(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Check if LP is active.
+   *
+   * @remarks
+   * This endpoint allows users to check whether a specific liquidity provider ()
+   * position is within the active tick range on the uniswap platform.
+   *
+   * by providing the token id associated with the position, users can verify if the
+   * position is currently within the tick range where trading occurs. this information
+   * is essential for users to monitor the status of their lp positions and ensure that
+   * they are actively participating in the trading activities within the liquidity pool
+   * and earning trading fees.
+   */
+  async liquidityProvisionInRange(
+    request: operations.UniswapLiquidityProvisionInRangeRequest,
+    options?: RequestOptions,
+  ): Promise<components.UniswapCheckInRangeResponse> {
+    return unwrapAsync(uniswapV3LiquidityProvisionInRange(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List LP
+   *
+   * @remarks
+   * This endpoint retrieves the number of Liquidity Provider (LP) positions
+   * associated with a specific sender address on the Uniswap platform.
+   *
+   * Users can query this endpoint to obtain detailed information about their LP
+   * positions, including the total number of positions and relevant metadata. This
+   * information is crucial for users to manage and analyze their liquidity provision
+   * activities effectively.
+   */
+  async liquidityProvisionPositions(
+    request: operations.UniswapLiquidityProvisionPositionsRequest,
+    options?: RequestOptions,
+  ): Promise<components.UniswapLPPositionsInfoResponse> {
+    return unwrapAsync(uniswapV3LiquidityProvisionPositions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Buy exact amount
+   *
+   * @remarks
+   * This endpoint allows users to trade a variable amount of one token to receive an
+   * exact amount of 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 buy, the token to
+   * pay with, and the exact amount to receive. If the token being paid with is WETH and
+   * needs to be wrapped, the appropriate amount will be wrapped automatically.
+   */
+  async swapBuyExactly(
+    request: components.UniswapBuyExactlyRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(uniswapV3SwapBuyExactly(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Sell exact amount
+   *
+   * @remarks
+   * 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.
+   */
+  async swapSellExactly(
+    request: components.UniswapSellExactlyRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(uniswapV3SwapSellExactly(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Increase an LP position
+   *
+   * @remarks
+   * This endpoint allows users to increase their existing Liquidity Provider (LP)
+   * positions on the Uniswap platform.
+   *
+   * By providing the necessary parameters, users can add more liquidity to their current
+   * positions, thereby increasing their stake in the liquidity pool. This operation is
+   * beneficial for users who wish to enhance their potential earnings from trading fees
+   * within the pool. The endpoint requires details such as the token pair, additional
+   * amount to be added, and any other parameters necessary for the liquidity increase
+   * process.
+   */
+  async liquidityProvisionIncrease(
+    request: components.UniswapIncreaseLiquidityProvisionRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(uniswapV3LiquidityProvisionIncrease(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Open a new LP position
+   *
+   * @remarks
+   * This endpoint allows users to open a new Liquidity Provider (LP) position on the
+   * Uniswap platform.
+   *
+   * By providing the necessary parameters, users can initiate a minting process to
+   * create a new LP token, which represents their stake in a specific liquidity pool.
+   * This operation is essential for users looking to participate in liquidity provision,
+   * enabling them to earn fees from trades that occur within the pool. The endpoint
+   * requires details such as the token pair, amount, and any additional parameters
+   * needed for the minting process.
+   */
+  async liquidityProvisionMint(
+    request: components.UniswapMintLiquidityProvisionRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(uniswapV3LiquidityProvisionMint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Withdraw an LP position
+   *
+   * @remarks
+   * This endpoint allows users to withdraw their Liquidity Provider (LP) positions
+   * from the Uniswap platform.
+   *
+   * By specifying the necessary parameters, users can initiate the withdrawal process to
+   * remove their stake from a specific liquidity pool. This operation is crucial for
+   * users who wish to reclaim their assets or reallocate their liquidity to different
+   * pools or investments. The endpoint requires details such as the token pair, the
+   * amount to be withdrawn, and any additional parameters needed for the withdrawal
+   * process. Users should ensure they meet any protocol requirements or conditions
+   * before initiating a withdrawal to avoid potential issues or penalties.
+   */
+  async liquidityProvisionWithdraw(
+    request: components.UniswapWithdrawLiquidityProvisionRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(uniswapV3LiquidityProvisionWithdraw(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/universal.ts

@@ -0,0 +1,255 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { universalAllowance } from "../funcs/universalAllowance.js";
+import { universalAllowanceSet } from "../funcs/universalAllowanceSet.js";
+import { universalBalance } from "../funcs/universalBalance.js";
+import { universalEns } from "../funcs/universalEns.js";
+import { universalPortfolio } from "../funcs/universalPortfolio.js";
+import { universalPriceUsd } from "../funcs/universalPriceUsd.js";
+import { universalSupportedTokens } from "../funcs/universalSupportedTokens.js";
+import { universalTransferErc20 } from "../funcs/universalTransferErc20.js";
+import { universalTransferNativeToken } from "../funcs/universalTransferNativeToken.js";
+import { universalUnwrapWeth } from "../funcs/universalUnwrapWeth.js";
+import { universalVisualizePortfolio } from "../funcs/universalVisualizePortfolio.js";
+import { universalWrapEth } from "../funcs/universalWrapEth.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Universal extends ClientSDK {
+  /**
+   * List user portfolio
+   *
+   * @remarks
+   * 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.
+   */
+  async portfolio(
+    request: operations.GenericPortfolioRequest,
+    options?: RequestOptions,
+  ): Promise<components.Portfolio> {
+    return unwrapAsync(universalPortfolio(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Visualize user portfolio
+   *
+   * @remarks
+   * 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.
+   */
+  async visualizePortfolio(
+    request: operations.GenericVisualizePortfolioRequest,
+    options?: RequestOptions,
+  ): Promise<components.Image> {
+    return unwrapAsync(universalVisualizePortfolio(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Token price
+   *
+   * @remarks
+   * 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.
+   */
+  async priceUsd(
+    request: operations.GenericPriceUsdRequest,
+    options?: RequestOptions,
+  ): Promise<components.PriceResponse> {
+    return unwrapAsync(universalPriceUsd(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List supported tokens
+   *
+   * @remarks
+   * Get the list of supported tokens on a chain by the Compass API.
+   */
+  async supportedTokens(
+    request: operations.GenericSupportedTokensRequest,
+    options?: RequestOptions,
+  ): Promise<components.TokenInfo> {
+    return unwrapAsync(universalSupportedTokens(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * User Token Balance
+   *
+   * @remarks
+   * Returns the balance of a specific ERC20 token for a given user address.
+   */
+  async balance(
+    request: operations.GenericBalanceRequest,
+    options?: RequestOptions,
+  ): Promise<components.BalanceInfoResponse> {
+    return unwrapAsync(universalBalance(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get allowance - Protocol
+   *
+   * @remarks
+   * 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.
+   */
+  async allowance(
+    request: operations.GenericAllowanceRequest,
+    options?: RequestOptions,
+  ): Promise<components.AllowanceInfoResponse> {
+    return unwrapAsync(universalAllowance(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Resolve ENS
+   *
+   * @remarks
+   * 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.
+   */
+  async ens(
+    request: operations.GenericEnsRequest,
+    options?: RequestOptions,
+  ): Promise<components.EnsNameInfoResponse> {
+    return unwrapAsync(universalEns(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Wrap ETH
+   *
+   * @remarks
+   * Wrapping ETH creates an ERC-20 compliant form of ETH that is typically needed for
+   * it to be traded on DeFi protocols.
+   */
+  async wrapEth(
+    request: components.WrapEthRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(universalWrapEth(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Unwrap WETH
+   *
+   * @remarks
+   * Unwrapping WETH converts the ERC-20 compliant form of ETH back to native ETH that
+   * can be used for gas and other native purposes.
+   */
+  async unwrapWeth(
+    request: components.UnwrapWethRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(universalUnwrapWeth(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Transfer Token
+   *
+   * @remarks
+   * Sends ERC20 tokens from the sender's address to the specified recipient.
+   */
+  async transferErc20(
+    request: components.TransferErc20Request,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(universalTransferErc20(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Transfer ETH
+   *
+   * @remarks
+   * Sends native ETH from the sender's address to the specified recipient.
+   */
+  async transferNativeToken(
+    request: components.TransferEthRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(universalTransferNativeToken(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Set Allowance - Protocol
+   *
+   * @remarks
+   * 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.
+   */
+  async allowanceSet(
+    request: components.IncreaseAllowanceRequest,
+    options?: RequestOptions,
+  ): Promise<components.UnsignedTransaction> {
+    return unwrapAsync(universalAllowanceSet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> =
+  z.custom<Blob>(isBlobLike, {
+    message: "expected a Blob, File or Blob-like object",
+    fatal: true,
+  });
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/types/constdatetime.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export function constDateTime(
+  val: string,
+): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivelant to ${val}`);
+}

package/src/types/enums.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+declare const __brand: unique symbol;
+export type Unrecognized<T> = T & { [__brand]: "unrecognized" };
+
+export function catchUnrecognizedEnum<T>(value: T): Unrecognized<T> {
+  return value as Unrecognized<T>;
+}
+
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+export type ClosedEnum<T> = T[keyof T];
+export type OpenEnum<T> =
+  | Prettify<T[keyof T]>
+  | Unrecognized<T[keyof T] extends number ? number : string>;

package/src/types/fp.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * A monad that captures the result of a function call or an error if it was not
+ * successful. Railway programming, enabled by this type, can be a nicer
+ * alternative to traditional exception throwing because it allows functions to
+ * declare all _known_ errors with static types and then check for them
+ * exhaustively in application code. Thrown exception have a type of `unknown`
+ * and break out of regular control flow of programs making them harder to
+ * inspect and more verbose work with due to try-catch blocks.
+ */
+export type Result<T, E = unknown> =
+  | { ok: true; value: T; error?: never }
+  | { ok: false; value?: never; error: E };
+
+export function OK<V>(value: V): Result<V, never> {
+  return { ok: true, value };
+}
+
+export function ERR<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+/**
+ * unwrap is a convenience function for extracting a value from a result or
+ * throwing if there was an error.
+ */
+export function unwrap<T>(r: Result<T, unknown>): T {
+  if (!r.ok) {
+    throw r.error;
+  }
+  return r.value;
+}
+
+/**
+ * unwrapAsync is a convenience function for resolving a value from a Promise
+ * of a result or rejecting if an error occurred.
+ */
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
+  const r = await pr;
+  if (!r.ok) {
+    throw r.error;
+  }
+
+  return r.value;
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export { catchUnrecognizedEnum } from "./enums.js";
+export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
+export type { Result } from "./fp.js";
+export type { PageIterator, Paginator } from "./operations.js";
+export { createPageIterator } from "./operations.js";
+export { RFCDate } from "./rfcdate.js";