@compass-labs/api-sdk 2.2.105 → 2.2.106

package/src/models/components/stockmetadata.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * The issuer's side of a tokenized stock.
+ *
+ * @remarks
+ *
+ * `ui_multiplier` is the ERC-8056 corporate-action factor. It matters because
+ * balances do **not** rebase on a split: the token count stays put and this
+ * number changes, so a price quoted for the underlying has to be multiplied by
+ * it to mean anything about the token a pool holds.
+ */
+export type StockMetadata = {
+  ticker: string;
+  uiMultiplier?: string | null | undefined;
+  pendingUiMultiplier?: string | null | undefined;
+  pendingEffectiveAt?: Date | null | undefined;
+  chainlinkFeed?: string | null | undefined;
+  tokenPaused?: boolean | null | undefined;
+  status?: string | null | undefined;
+  logoUrl?: string | null | undefined;
+};
+
+/** @internal */
+export const StockMetadata$inboundSchema: z.ZodType<
+  StockMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ticker: z.string(),
+  ui_multiplier: z.nullable(z.string()).optional(),
+  pending_ui_multiplier: z.nullable(z.string()).optional(),
+  pending_effective_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  chainlink_feed: z.nullable(z.string()).optional(),
+  token_paused: z.nullable(z.boolean()).optional(),
+  status: z.nullable(z.string()).optional(),
+  logo_url: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ui_multiplier": "uiMultiplier",
+    "pending_ui_multiplier": "pendingUiMultiplier",
+    "pending_effective_at": "pendingEffectiveAt",
+    "chainlink_feed": "chainlinkFeed",
+    "token_paused": "tokenPaused",
+    "logo_url": "logoUrl",
+  });
+});
+
+export function stockMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<StockMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StockMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StockMetadata' from JSON`,
+  );
+}

package/src/models/components/stockreference.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * The pool price against the stock's own reference price.
+ *
+ * @remarks
+ *
+ * A tokenized stock trades in its pool around the clock while the underlying
+ * trades in a session. The gap between them is real information — it is what
+ * an LP is quoting against overnight — and it is not visible from either
+ * number alone.
+ */
+export type StockReference = {
+  ticker: string;
+  /**
+   * From the Chainlink feed, multiplier applied.
+   */
+  referencePriceUsd?: string | null | undefined;
+  referenceSource?: string | null | undefined;
+  referenceUpdatedAt?: Date | null | undefined;
+  poolImpliedPriceUsd?: string | null | undefined;
+  /**
+   * How far above (or below) the reference the pool is trading.
+   */
+  premiumPct?: string | null | undefined;
+  /**
+   * True when the feed has not posted for over two heartbeats — normal over a weekend, when the stock is not trading and the pool is.
+   */
+  referenceIsStale?: boolean | undefined;
+};
+
+/** @internal */
+export const StockReference$inboundSchema: z.ZodType<
+  StockReference,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ticker: z.string(),
+  reference_price_usd: z.nullable(z.string()).optional(),
+  reference_source: z.nullable(z.string()).optional(),
+  reference_updated_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  pool_implied_price_usd: z.nullable(z.string()).optional(),
+  premium_pct: z.nullable(z.string()).optional(),
+  reference_is_stale: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "reference_price_usd": "referencePriceUsd",
+    "reference_source": "referenceSource",
+    "reference_updated_at": "referenceUpdatedAt",
+    "pool_implied_price_usd": "poolImpliedPriceUsd",
+    "premium_pct": "premiumPct",
+    "reference_is_stale": "referenceIsStale",
+  });
+});
+
+export function stockReferenceFromJSON(
+  jsonString: string,
+): SafeParseResult<StockReference, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StockReference$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StockReference' from JSON`,
+  );
+}

package/src/models/components/swapplan.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * The swap leg of an entry or a rebalance.
+ */
+export type SwapPlan = {
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: string;
+  amountOutQuoted: string;
+  /**
+   * The floor the transaction enforces, after slippage.
+   */
+  amountOutMin: string;
+  priceImpactPct?: string | null | undefined;
+  poolFeePpm?: number | null | undefined;
+};
+
+/** @internal */
+export const SwapPlan$inboundSchema: z.ZodType<
+  SwapPlan,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token_in: z.string(),
+  token_out: z.string(),
+  amount_in: z.string(),
+  amount_out_quoted: z.string(),
+  amount_out_min: z.string(),
+  price_impact_pct: z.nullable(z.string()).optional(),
+  pool_fee_ppm: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "token_in": "tokenIn",
+    "token_out": "tokenOut",
+    "amount_in": "amountIn",
+    "amount_out_quoted": "amountOutQuoted",
+    "amount_out_min": "amountOutMin",
+    "price_impact_pct": "priceImpactPct",
+    "pool_fee_ppm": "poolFeePpm",
+  });
+});
+
+export function swapPlanFromJSON(
+  jsonString: string,
+): SafeParseResult<SwapPlan, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SwapPlan$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SwapPlan' from JSON`,
+  );
+}

package/src/models/components/symmetricrange.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+/**
+ * Half-width either side of the current price, in percent.
+ */
+export type SymmetricRangeWidthPct = number | string;
+
+/**
+ * A range centred on the current price, given as a percentage either side.
+ *
+ * @remarks
+ *
+ * The usual way to ask for a position: narrow earns more fees per dollar while
+ * the price stays inside it, and stops earning entirely when it leaves.
+ */
+export type SymmetricRange = {
+  type: "symmetric_pct";
+  /**
+   * Half-width either side of the current price, in percent.
+   */
+  widthPct: number | string;
+};
+
+/** @internal */
+export type SymmetricRangeWidthPct$Outbound = number | string;
+
+/** @internal */
+export const SymmetricRangeWidthPct$outboundSchema: z.ZodType<
+  SymmetricRangeWidthPct$Outbound,
+  z.ZodTypeDef,
+  SymmetricRangeWidthPct
+> = z.union([z.number(), z.string()]);
+
+export function symmetricRangeWidthPctToJSON(
+  symmetricRangeWidthPct: SymmetricRangeWidthPct,
+): string {
+  return JSON.stringify(
+    SymmetricRangeWidthPct$outboundSchema.parse(symmetricRangeWidthPct),
+  );
+}
+
+/** @internal */
+export type SymmetricRange$Outbound = {
+  type: "symmetric_pct";
+  width_pct: number | string;
+};
+
+/** @internal */
+export const SymmetricRange$outboundSchema: z.ZodType<
+  SymmetricRange$Outbound,
+  z.ZodTypeDef,
+  SymmetricRange
+> = z.object({
+  type: z.literal("symmetric_pct"),
+  widthPct: z.union([z.number(), z.string()]),
+}).transform((v) => {
+  return remap$(v, {
+    widthPct: "width_pct",
+  });
+});
+
+export function symmetricRangeToJSON(symmetricRange: SymmetricRange): string {
+  return JSON.stringify(SymmetricRange$outboundSchema.parse(symmetricRange));
+}

package/src/models/components/tickrange.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+/**
+ * Exact tick bounds, for a caller who has already done the maths.
+ */
+export type TickRange = {
+  type: "ticks";
+  tickLower: number;
+  tickUpper: number;
+};
+
+/** @internal */
+export type TickRange$Outbound = {
+  type: "ticks";
+  tick_lower: number;
+  tick_upper: number;
+};
+
+/** @internal */
+export const TickRange$outboundSchema: z.ZodType<
+  TickRange$Outbound,
+  z.ZodTypeDef,
+  TickRange
+> = z.object({
+  type: z.literal("ticks"),
+  tickLower: z.number().int(),
+  tickUpper: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    tickLower: "tick_lower",
+    tickUpper: "tick_upper",
+  });
+});
+
+export function tickRangeToJSON(tickRange: TickRange): string {
+  return JSON.stringify(TickRange$outboundSchema.parse(tickRange));
+}

package/src/models/components/usddeposit.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type ValueUsd = number | string;
+
+/**
+ * A dollar figure, for analytics only.
+ *
+ * @remarks
+ *
+ * Enough to answer "what would this look like", not enough to build a
+ * transaction — the API will not choose which of your tokens to spend.
+ */
+export type UsdDeposit = {
+  type: "usd";
+  valueUsd: number | string;
+};
+
+/** @internal */
+export type ValueUsd$Outbound = number | string;
+
+/** @internal */
+export const ValueUsd$outboundSchema: z.ZodType<
+  ValueUsd$Outbound,
+  z.ZodTypeDef,
+  ValueUsd
+> = z.union([z.number(), z.string()]);
+
+export function valueUsdToJSON(valueUsd: ValueUsd): string {
+  return JSON.stringify(ValueUsd$outboundSchema.parse(valueUsd));
+}
+
+/** @internal */
+export type UsdDeposit$Outbound = {
+  type: "usd";
+  value_usd: number | string;
+};
+
+/** @internal */
+export const UsdDeposit$outboundSchema: z.ZodType<
+  UsdDeposit$Outbound,
+  z.ZodTypeDef,
+  UsdDeposit
+> = z.object({
+  type: z.literal("usd"),
+  valueUsd: z.union([z.number(), z.string()]),
+}).transform((v) => {
+  return remap$(v, {
+    valueUsd: "value_usd",
+  });
+});
+
+export function usdDepositToJSON(usdDeposit: UsdDeposit): string {
+  return JSON.stringify(UsdDeposit$outboundSchema.parse(usdDeposit));
+}

package/src/models/operations/index.ts

@@ -57,6 +57,10 @@ export * from "./v2perpetualtradingactivity.js";
 export * from "./v2perpetualtradingcandles.js";
 export * from "./v2perpetualtradingopportunities.js";
 export * from "./v2perpetualtradingpositions.js";
+export * from "./v2riskyieldpools.js";
+export * from "./v2riskyieldpoolspoolid.js";
+export * from "./v2riskyieldpositions.js";
+export * from "./v2riskyieldtokens.js";
 export * from "./v2tokenizedassetsbalances.js";
 export * from "./v2tokenizedassetsmarkets.js";
 export * from "./v2tokenizedassetsmarketssymbol.js";

package/src/models/operations/v2earnswapquote.ts

@@ -16,6 +16,7 @@ export const V2EarnSwapQuoteChain = {
   Hyperevm: "hyperevm",
   Tempo: "tempo",
   Bsc: "bsc",
+  Robinhood: "robinhood",
   EthereumSepolia: "ethereum_sepolia",
 } as const;
 /**

package/src/models/operations/v2earnvaults.ts

@@ -27,7 +27,7 @@ export type V2EarnVaultsMinTvlUsd = number | string;
 /**
  * Minimum available liquidity in USD. Vaults below this are excluded.
  */
-export type MinLiquidityUsd = number | string;
+export type V2EarnVaultsMinLiquidityUsd = number | string;
 
 /**
  * Minimum deposit capacity in USD. Vaults below this are excluded. Set to 0 to exclude paused vaults.
@@ -97,19 +97,23 @@ export function v2EarnVaultsMinTvlUsdToJSON(
 }
 
 /** @internal */
-export type MinLiquidityUsd$Outbound = number | string;
+export type V2EarnVaultsMinLiquidityUsd$Outbound = number | string;
 
 /** @internal */
-export const MinLiquidityUsd$outboundSchema: z.ZodType<
-  MinLiquidityUsd$Outbound,
+export const V2EarnVaultsMinLiquidityUsd$outboundSchema: z.ZodType<
+  V2EarnVaultsMinLiquidityUsd$Outbound,
   z.ZodTypeDef,
-  MinLiquidityUsd
+  V2EarnVaultsMinLiquidityUsd
 > = z.union([z.number(), z.string()]);
 
-export function minLiquidityUsdToJSON(
-  minLiquidityUsd: MinLiquidityUsd,
+export function v2EarnVaultsMinLiquidityUsdToJSON(
+  v2EarnVaultsMinLiquidityUsd: V2EarnVaultsMinLiquidityUsd,
 ): string {
-  return JSON.stringify(MinLiquidityUsd$outboundSchema.parse(minLiquidityUsd));
+  return JSON.stringify(
+    V2EarnVaultsMinLiquidityUsd$outboundSchema.parse(
+      v2EarnVaultsMinLiquidityUsd,
+    ),
+  );
 }
 
 /** @internal */

package/src/models/operations/v2riskyieldpools.ts

@@ -0,0 +1,195 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+import * as components from "../components/index.js";
+
+export const V2RiskYieldPoolsChain = {
+  Robinhood: "robinhood",
+} as const;
+export type V2RiskYieldPoolsChain = ClosedEnum<typeof V2RiskYieldPoolsChain>;
+
+export type V2RiskYieldPoolsMinTvlUsd = number | string;
+
+export type MinVolume24HUsd = number | string;
+
+export const PoolOrderBy = {
+  IlAdjustedApr7d: "il_adjusted_apr_7d",
+  FeeApr24h: "fee_apr_24h",
+  FeeApr7d: "fee_apr_7d",
+  TvlUsd: "tvl_usd",
+  Volume24hUsd: "volume_24h_usd",
+  Volume7dUsd: "volume_7d_usd",
+  RealizedVol24h: "realized_vol_24h",
+  RealizedVol7d: "realized_vol_7d",
+  CreatedAt: "created_at",
+} as const;
+export type PoolOrderBy = ClosedEnum<typeof PoolOrderBy>;
+
+export const V2RiskYieldPoolsDirection = {
+  Asc: "asc",
+  Desc: "desc",
+} as const;
+export type V2RiskYieldPoolsDirection = ClosedEnum<
+  typeof V2RiskYieldPoolsDirection
+>;
+
+export type V2RiskYieldPoolsRequest = {
+  /**
+   * The offset of the first item to return.
+   */
+  offset?: number | undefined;
+  /**
+   * The number of items to return.
+   */
+  limit?: number | undefined;
+  chain: V2RiskYieldPoolsChain;
+  /**
+   * What kind of pair a pool is, which is what the product is sorted by.
+   */
+  pairClass?: components.PairClass | null | undefined;
+  /**
+   * Pools holding this token, on either side.
+   */
+  token?: string | null | undefined;
+  stockTicker?: string | null | undefined;
+  /**
+   * Which Uniswap deployment a pool belongs to.
+   *
+   * @remarks
+   *
+   * v3 pools hold their own tokens and pay LPs the fee tier. v4 pools live in a
+   * shared PoolManager and may route the fee through a hook, which is where the
+   * launchpad pools' zero LP yield comes from.
+   */
+  dexVersion?: components.DexVersion | null | undefined;
+  launchpad?: components.Launchpad | null | undefined;
+  /**
+   * Leave unset to see everything. Set true to hide the pools whose hook keeps the fee — most of this chain's volume, and none of its yield.
+   */
+  lpEarnsFees?: boolean | null | undefined;
+  /**
+   * Whether liquidity may be added at all.
+   */
+  lpOpen?: boolean | null | undefined;
+  /**
+   * Only pools the indexer follows closely, which are the only ones with trailing metrics.
+   */
+  watched?: boolean | null | undefined;
+  minTvlUsd?: number | string | null | undefined;
+  minVolume24hUsd?: number | string | null | undefined;
+  orderBy?: PoolOrderBy | undefined;
+  direction?: V2RiskYieldPoolsDirection | undefined;
+};
+
+/** @internal */
+export const V2RiskYieldPoolsChain$outboundSchema: z.ZodNativeEnum<
+  typeof V2RiskYieldPoolsChain
+> = z.nativeEnum(V2RiskYieldPoolsChain);
+
+/** @internal */
+export type V2RiskYieldPoolsMinTvlUsd$Outbound = number | string;
+
+/** @internal */
+export const V2RiskYieldPoolsMinTvlUsd$outboundSchema: z.ZodType<
+  V2RiskYieldPoolsMinTvlUsd$Outbound,
+  z.ZodTypeDef,
+  V2RiskYieldPoolsMinTvlUsd
+> = z.union([z.number(), z.string()]);
+
+export function v2RiskYieldPoolsMinTvlUsdToJSON(
+  v2RiskYieldPoolsMinTvlUsd: V2RiskYieldPoolsMinTvlUsd,
+): string {
+  return JSON.stringify(
+    V2RiskYieldPoolsMinTvlUsd$outboundSchema.parse(v2RiskYieldPoolsMinTvlUsd),
+  );
+}
+
+/** @internal */
+export type MinVolume24HUsd$Outbound = number | string;
+
+/** @internal */
+export const MinVolume24HUsd$outboundSchema: z.ZodType<
+  MinVolume24HUsd$Outbound,
+  z.ZodTypeDef,
+  MinVolume24HUsd
+> = z.union([z.number(), z.string()]);
+
+export function minVolume24HUsdToJSON(
+  minVolume24HUsd: MinVolume24HUsd,
+): string {
+  return JSON.stringify(MinVolume24HUsd$outboundSchema.parse(minVolume24HUsd));
+}
+
+/** @internal */
+export const PoolOrderBy$outboundSchema: z.ZodNativeEnum<typeof PoolOrderBy> = z
+  .nativeEnum(PoolOrderBy);
+
+/** @internal */
+export const V2RiskYieldPoolsDirection$outboundSchema: z.ZodNativeEnum<
+  typeof V2RiskYieldPoolsDirection
+> = z.nativeEnum(V2RiskYieldPoolsDirection);
+
+/** @internal */
+export type V2RiskYieldPoolsRequest$Outbound = {
+  offset?: number | undefined;
+  limit?: number | undefined;
+  chain: string;
+  pair_class?: string | null | undefined;
+  token?: string | null | undefined;
+  stock_ticker?: string | null | undefined;
+  dex_version?: string | null | undefined;
+  launchpad?: string | null | undefined;
+  lp_earns_fees?: boolean | null | undefined;
+  lp_open?: boolean | null | undefined;
+  watched?: boolean | null | undefined;
+  min_tvl_usd?: number | string | null | undefined;
+  min_volume_24h_usd?: number | string | null | undefined;
+  order_by?: string | undefined;
+  direction?: string | undefined;
+};
+
+/** @internal */
+export const V2RiskYieldPoolsRequest$outboundSchema: z.ZodType<
+  V2RiskYieldPoolsRequest$Outbound,
+  z.ZodTypeDef,
+  V2RiskYieldPoolsRequest
+> = z.object({
+  offset: z.number().int().optional(),
+  limit: z.number().int().optional(),
+  chain: V2RiskYieldPoolsChain$outboundSchema,
+  pairClass: z.nullable(components.PairClass$outboundSchema).optional(),
+  token: z.nullable(z.string()).optional(),
+  stockTicker: z.nullable(z.string()).optional(),
+  dexVersion: z.nullable(components.DexVersion$outboundSchema).optional(),
+  launchpad: z.nullable(components.Launchpad$outboundSchema).optional(),
+  lpEarnsFees: z.nullable(z.boolean()).optional(),
+  lpOpen: z.nullable(z.boolean()).optional(),
+  watched: z.nullable(z.boolean()).optional(),
+  minTvlUsd: z.nullable(z.union([z.number(), z.string()])).optional(),
+  minVolume24hUsd: z.nullable(z.union([z.number(), z.string()])).optional(),
+  orderBy: PoolOrderBy$outboundSchema.optional(),
+  direction: V2RiskYieldPoolsDirection$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    pairClass: "pair_class",
+    stockTicker: "stock_ticker",
+    dexVersion: "dex_version",
+    lpEarnsFees: "lp_earns_fees",
+    lpOpen: "lp_open",
+    minTvlUsd: "min_tvl_usd",
+    minVolume24hUsd: "min_volume_24h_usd",
+    orderBy: "order_by",
+  });
+});
+
+export function v2RiskYieldPoolsRequestToJSON(
+  v2RiskYieldPoolsRequest: V2RiskYieldPoolsRequest,
+): string {
+  return JSON.stringify(
+    V2RiskYieldPoolsRequest$outboundSchema.parse(v2RiskYieldPoolsRequest),
+  );
+}