@compass-labs/api-sdk 2.2.105-rc.0 → 2.2.106

package/src/models/components/lpposition.ts

@@ -0,0 +1,191 @@
+/*
+ * 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";
+import { CostBasis, CostBasis$inboundSchema } from "./costbasis.js";
+import { DexTokenRef, DexTokenRef$inboundSchema } from "./dextokenref.js";
+import { DexVersion, DexVersion$inboundSchema } from "./dexversion.js";
+import {
+  PositionStatus,
+  PositionStatus$inboundSchema,
+} from "./positionstatus.js";
+import {
+  RebalanceReason,
+  RebalanceReason$inboundSchema,
+} from "./rebalancereason.js";
+import { ResolvedRange, ResolvedRange$inboundSchema } from "./resolvedrange.js";
+
+export type LpPosition = {
+  /**
+   * The position NFT's id.
+   */
+  tokenId: number;
+  /**
+   * 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: DexVersion;
+  poolId?: number | null | undefined;
+  poolAddress?: string | null | undefined;
+  /**
+   * A token as every Risk Yield response describes it.
+   */
+  token0: DexTokenRef;
+  /**
+   * A token as every Risk Yield response describes it.
+   */
+  token1: DexTokenRef;
+  feePpm: number;
+  /**
+   * A range after the API has snapped it to the pool's tick spacing.
+   *
+   * @remarks
+   *
+   * Returned because the range you asked for is rarely the range you get: ticks
+   * are discrete, and a 30% band becomes whichever usable ticks bracket it.
+   */
+  range: ResolvedRange;
+  liquidity: string;
+  currentTick?: number | null | undefined;
+  currentPrice?: string | null | undefined;
+  inRange: boolean;
+  /**
+   * `below` or `above`: which asset the position is now all of.
+   */
+  outOfRangeSide?: string | null | undefined;
+  amount0: string;
+  amount1: string;
+  valueUsd?: string | null | undefined;
+  unclaimedFees0: string;
+  unclaimedFees1: string;
+  unclaimedFeesUsd?: string | null | undefined;
+  feesCollected0?: string | null | undefined;
+  feesCollected1?: string | null | undefined;
+  /**
+   * What the position cost to open.
+   *
+   * @remarks
+   *
+   * Not readable from the chain: a position reports its liquidity, never the
+   * amounts that bought it. This comes from recorded events, and when there are
+   * none the PnL fields are null rather than guessed — an invented cost basis
+   * would make every number derived from it quietly wrong.
+   */
+  costBasis: CostBasis;
+  /**
+   * What the deposited amounts would be worth had they simply been held. The comparison that makes impermanent loss meaningful.
+   */
+  holdValueUsd?: string | null | undefined;
+  ilUsd?: string | null | undefined;
+  ilPct?: string | null | undefined;
+  /**
+   * Collected plus unclaimed.
+   */
+  feesEarnedUsd?: string | null | undefined;
+  /**
+   * Position value plus fees earned, less what it cost to open.
+   */
+  pnlUsd?: string | null | undefined;
+  feeAprSinceOpenPct?: string | null | undefined;
+  ageDays?: string | null | undefined;
+  status: PositionStatus;
+  needsRebalance?: boolean | undefined;
+  rebalanceReasons?: Array<RebalanceReason> | undefined;
+  needsCollect?: boolean | undefined;
+  /**
+   * False when this pool's hook keeps the swap fee. Such a position accrues impermanent loss and earns nothing against it.
+   */
+  lpEarnsFees?: boolean | undefined;
+};
+
+/** @internal */
+export const LpPosition$inboundSchema: z.ZodType<
+  LpPosition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token_id: z.number().int(),
+  dex_version: DexVersion$inboundSchema,
+  pool_id: z.nullable(z.number().int()).optional(),
+  pool_address: z.nullable(z.string()).optional(),
+  token0: DexTokenRef$inboundSchema,
+  token1: DexTokenRef$inboundSchema,
+  fee_ppm: z.number().int(),
+  range: ResolvedRange$inboundSchema,
+  liquidity: z.string(),
+  current_tick: z.nullable(z.number().int()).optional(),
+  current_price: z.nullable(z.string()).optional(),
+  in_range: z.boolean(),
+  out_of_range_side: z.nullable(z.string()).optional(),
+  amount0: z.string(),
+  amount1: z.string(),
+  value_usd: z.nullable(z.string()).optional(),
+  unclaimed_fees0: z.string(),
+  unclaimed_fees1: z.string(),
+  unclaimed_fees_usd: z.nullable(z.string()).optional(),
+  fees_collected0: z.nullable(z.string()).optional(),
+  fees_collected1: z.nullable(z.string()).optional(),
+  cost_basis: CostBasis$inboundSchema,
+  hold_value_usd: z.nullable(z.string()).optional(),
+  il_usd: z.nullable(z.string()).optional(),
+  il_pct: z.nullable(z.string()).optional(),
+  fees_earned_usd: z.nullable(z.string()).optional(),
+  pnl_usd: z.nullable(z.string()).optional(),
+  fee_apr_since_open_pct: z.nullable(z.string()).optional(),
+  age_days: z.nullable(z.string()).optional(),
+  status: PositionStatus$inboundSchema,
+  needs_rebalance: z.boolean().optional(),
+  rebalance_reasons: z.array(RebalanceReason$inboundSchema).optional(),
+  needs_collect: z.boolean().optional(),
+  lp_earns_fees: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "token_id": "tokenId",
+    "dex_version": "dexVersion",
+    "pool_id": "poolId",
+    "pool_address": "poolAddress",
+    "fee_ppm": "feePpm",
+    "current_tick": "currentTick",
+    "current_price": "currentPrice",
+    "in_range": "inRange",
+    "out_of_range_side": "outOfRangeSide",
+    "value_usd": "valueUsd",
+    "unclaimed_fees0": "unclaimedFees0",
+    "unclaimed_fees1": "unclaimedFees1",
+    "unclaimed_fees_usd": "unclaimedFeesUsd",
+    "fees_collected0": "feesCollected0",
+    "fees_collected1": "feesCollected1",
+    "cost_basis": "costBasis",
+    "hold_value_usd": "holdValueUsd",
+    "il_usd": "ilUsd",
+    "il_pct": "ilPct",
+    "fees_earned_usd": "feesEarnedUsd",
+    "pnl_usd": "pnlUsd",
+    "fee_apr_since_open_pct": "feeAprSinceOpenPct",
+    "age_days": "ageDays",
+    "needs_rebalance": "needsRebalance",
+    "rebalance_reasons": "rebalanceReasons",
+    "needs_collect": "needsCollect",
+    "lp_earns_fees": "lpEarnsFees",
+  });
+});
+
+export function lpPositionFromJSON(
+  jsonString: string,
+): SafeParseResult<LpPosition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LpPosition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LpPosition' from JSON`,
+  );
+}

package/src/models/components/pairclass.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * What kind of pair a pool is, which is what the product is sorted by.
+ */
+export const PairClass = {
+  MemeStock: "MEME_STOCK",
+  StockStable: "STOCK_STABLE",
+  StockEth: "STOCK_ETH",
+  StockStock: "STOCK_STOCK",
+  MemeEth: "MEME_ETH",
+  MemeStable: "MEME_STABLE",
+  EthStable: "ETH_STABLE",
+  Other: "OTHER",
+} as const;
+/**
+ * What kind of pair a pool is, which is what the product is sorted by.
+ */
+export type PairClass = ClosedEnum<typeof PairClass>;
+
+/** @internal */
+export const PairClass$inboundSchema: z.ZodNativeEnum<typeof PairClass> = z
+  .nativeEnum(PairClass);
+/** @internal */
+export const PairClass$outboundSchema: z.ZodNativeEnum<typeof PairClass> =
+  PairClass$inboundSchema;

package/src/models/components/planstep.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { PlanStepKind, PlanStepKind$inboundSchema } from "./planstepkind.js";
+
+/**
+ * One leg of a bundled transaction, in the order it executes.
+ *
+ * @remarks
+ *
+ * Every transact endpoint returns a single transaction; this is what is inside
+ * it, so a caller can show a person what they are about to sign.
+ */
+export type PlanStep = {
+  kind: PlanStepKind;
+  description: string;
+  contract?: string | null | undefined;
+  token?: string | null | undefined;
+  amount?: string | null | undefined;
+};
+
+/** @internal */
+export const PlanStep$inboundSchema: z.ZodType<
+  PlanStep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: PlanStepKind$inboundSchema,
+  description: z.string(),
+  contract: z.nullable(z.string()).optional(),
+  token: z.nullable(z.string()).optional(),
+  amount: z.nullable(z.string()).optional(),
+});
+
+export function planStepFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanStep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanStep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanStep' from JSON`,
+  );
+}

package/src/models/components/planstepkind.ts

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const PlanStepKind = {
+  Approve: "APPROVE",
+  Permit2Approve: "PERMIT2_APPROVE",
+  Swap: "SWAP",
+  Mint: "MINT",
+  Increase: "INCREASE",
+  Decrease: "DECREASE",
+  Collect: "COLLECT",
+  Burn: "BURN",
+  Transfer: "TRANSFER",
+} as const;
+export type PlanStepKind = ClosedEnum<typeof PlanStepKind>;
+
+/** @internal */
+export const PlanStepKind$inboundSchema: z.ZodNativeEnum<typeof PlanStepKind> =
+  z.nativeEnum(PlanStepKind);

package/src/models/components/poolhourlypoint.ts

@@ -0,0 +1,62 @@
+/*
+ * 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";
+
+export type PoolHourlyPoint = {
+  hourStart: Date;
+  open?: string | null | undefined;
+  high?: string | null | undefined;
+  low?: string | null | undefined;
+  close?: string | null | undefined;
+  /**
+   * SWAP when the hour traded, SNAPSHOT when it did not — an hour with no trades still has a price, and a series with holes cannot be used to measure volatility.
+   */
+  closeSource?: string | null | undefined;
+  volumeUsd?: string | null | undefined;
+  lpFeesUsd?: string | null | undefined;
+  swapCount?: number | undefined;
+  tvlUsdEnd?: string | null | undefined;
+};
+
+/** @internal */
+export const PoolHourlyPoint$inboundSchema: z.ZodType<
+  PoolHourlyPoint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  hour_start: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  open: z.nullable(z.string()).optional(),
+  high: z.nullable(z.string()).optional(),
+  low: z.nullable(z.string()).optional(),
+  close: z.nullable(z.string()).optional(),
+  close_source: z.nullable(z.string()).optional(),
+  volume_usd: z.nullable(z.string()).optional(),
+  lp_fees_usd: z.nullable(z.string()).optional(),
+  swap_count: z.number().int().optional(),
+  tvl_usd_end: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "hour_start": "hourStart",
+    "close_source": "closeSource",
+    "volume_usd": "volumeUsd",
+    "lp_fees_usd": "lpFeesUsd",
+    "swap_count": "swapCount",
+    "tvl_usd_end": "tvlUsdEnd",
+  });
+});
+
+export function poolHourlyPointFromJSON(
+  jsonString: string,
+): SafeParseResult<PoolHourlyPoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PoolHourlyPoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PoolHourlyPoint' from JSON`,
+  );
+}

package/src/models/components/poolonchainstate.ts

@@ -0,0 +1,68 @@
+/*
+ * 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";
+
+/**
+ * Read live, at request time.
+ *
+ * @remarks
+ *
+ * The indexer's numbers are minutes old, which is fine for ranking and not
+ * fine for sizing a position on an asset that moves this fast.
+ */
+export type PoolOnChainState = {
+  blockNumber: number;
+  sqrtPriceX96: string;
+  tick: number;
+  price?: string | null | undefined;
+  liquidity: string;
+  /**
+   * The fee the pool charges right now. A dynamic-fee pool can quote zero, which is what LPs earning nothing looks like from the chain.
+   */
+  lpFeePpm?: number | null | undefined;
+  feeGrowthGlobal0X128?: string | null | undefined;
+  feeGrowthGlobal1X128?: string | null | undefined;
+  fetchedAt: Date;
+};
+
+/** @internal */
+export const PoolOnChainState$inboundSchema: z.ZodType<
+  PoolOnChainState,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  block_number: z.number().int(),
+  sqrt_price_x96: z.string(),
+  tick: z.number().int(),
+  price: z.nullable(z.string()).optional(),
+  liquidity: z.string(),
+  lp_fee_ppm: z.nullable(z.number().int()).optional(),
+  fee_growth_global0_x128: z.nullable(z.string()).optional(),
+  fee_growth_global1_x128: z.nullable(z.string()).optional(),
+  fetched_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "block_number": "blockNumber",
+    "sqrt_price_x96": "sqrtPriceX96",
+    "lp_fee_ppm": "lpFeePpm",
+    "fee_growth_global0_x128": "feeGrowthGlobal0X128",
+    "fee_growth_global1_x128": "feeGrowthGlobal1X128",
+    "fetched_at": "fetchedAt",
+  });
+});
+
+export function poolOnChainStateFromJSON(
+  jsonString: string,
+): SafeParseResult<PoolOnChainState, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PoolOnChainState$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PoolOnChainState' from JSON`,
+  );
+}

package/src/models/components/poolselector.ts

@@ -0,0 +1,91 @@
+/*
+ * 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 { DexVersion, DexVersion$outboundSchema } from "./dexversion.js";
+
+/**
+ * Which pool, by id or by its key.
+ *
+ * @remarks
+ *
+ * A pool id is stable and is what the list endpoints return. The long form
+ * exists so a caller who knows the pair can address a pool without a lookup —
+ * on a chain minting twenty thousand pools a day, a client should not have to
+ * search for one it just created.
+ */
+export type PoolSelector = {
+  /**
+   * The pool's id, as returned by `GET /pools`.
+   */
+  poolId?: number | null | undefined;
+  /**
+   * Lower-sorting token address.
+   */
+  token0?: string | null | undefined;
+  /**
+   * Higher-sorting token address.
+   */
+  token1?: string | null | undefined;
+  /**
+   * Fee tier in hundredths of a bip (3000 = 0.30%).
+   */
+  feePpm?: number | null | undefined;
+  /**
+   * Required for v4, where it is part of the pool key.
+   */
+  tickSpacing?: number | null | undefined;
+  /**
+   * v4 hook address; part of the pool key.
+   */
+  hooks?: 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?: DexVersion | undefined;
+};
+
+/** @internal */
+export type PoolSelector$Outbound = {
+  pool_id?: number | null | undefined;
+  token0?: string | null | undefined;
+  token1?: string | null | undefined;
+  fee_ppm?: number | null | undefined;
+  tick_spacing?: number | null | undefined;
+  hooks?: string | null | undefined;
+  dex_version?: string | undefined;
+};
+
+/** @internal */
+export const PoolSelector$outboundSchema: z.ZodType<
+  PoolSelector$Outbound,
+  z.ZodTypeDef,
+  PoolSelector
+> = z.object({
+  poolId: z.nullable(z.number().int()).optional(),
+  token0: z.nullable(z.string()).optional(),
+  token1: z.nullable(z.string()).optional(),
+  feePpm: z.nullable(z.number().int()).optional(),
+  tickSpacing: z.nullable(z.number().int()).optional(),
+  hooks: z.nullable(z.string()).optional(),
+  dexVersion: DexVersion$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    poolId: "pool_id",
+    feePpm: "fee_ppm",
+    tickSpacing: "tick_spacing",
+    dexVersion: "dex_version",
+  });
+});
+
+export function poolSelectorToJSON(poolSelector: PoolSelector): string {
+  return JSON.stringify(PoolSelector$outboundSchema.parse(poolSelector));
+}

package/src/models/components/positionstatus.ts

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const PositionStatus = {
+  Active: "ACTIVE",
+  OutOfRange: "OUT_OF_RANGE",
+  Empty: "EMPTY",
+  Closed: "CLOSED",
+} as const;
+export type PositionStatus = ClosedEnum<typeof PositionStatus>;
+
+/** @internal */
+export const PositionStatus$inboundSchema: z.ZodNativeEnum<
+  typeof PositionStatus
+> = z.nativeEnum(PositionStatus);

package/src/models/components/pricerange.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";
+
+export type PriceLower = number | string;
+
+export type PriceUpper = number | string;
+
+/**
+ * Bounds as prices (token1 per token0, decimals-adjusted).
+ */
+export type PriceRange = {
+  type: "prices";
+  priceLower: number | string;
+  priceUpper: number | string;
+};
+
+/** @internal */
+export type PriceLower$Outbound = number | string;
+
+/** @internal */
+export const PriceLower$outboundSchema: z.ZodType<
+  PriceLower$Outbound,
+  z.ZodTypeDef,
+  PriceLower
+> = z.union([z.number(), z.string()]);
+
+export function priceLowerToJSON(priceLower: PriceLower): string {
+  return JSON.stringify(PriceLower$outboundSchema.parse(priceLower));
+}
+
+/** @internal */
+export type PriceUpper$Outbound = number | string;
+
+/** @internal */
+export const PriceUpper$outboundSchema: z.ZodType<
+  PriceUpper$Outbound,
+  z.ZodTypeDef,
+  PriceUpper
+> = z.union([z.number(), z.string()]);
+
+export function priceUpperToJSON(priceUpper: PriceUpper): string {
+  return JSON.stringify(PriceUpper$outboundSchema.parse(priceUpper));
+}
+
+/** @internal */
+export type PriceRange$Outbound = {
+  type: "prices";
+  price_lower: number | string;
+  price_upper: number | string;
+};
+
+/** @internal */
+export const PriceRange$outboundSchema: z.ZodType<
+  PriceRange$Outbound,
+  z.ZodTypeDef,
+  PriceRange
+> = z.object({
+  type: z.literal("prices"),
+  priceLower: z.union([z.number(), z.string()]),
+  priceUpper: z.union([z.number(), z.string()]),
+}).transform((v) => {
+  return remap$(v, {
+    priceLower: "price_lower",
+    priceUpper: "price_upper",
+  });
+});
+
+export function priceRangeToJSON(priceRange: PriceRange): string {
+  return JSON.stringify(PriceRange$outboundSchema.parse(priceRange));
+}

package/src/models/components/pricesource.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Where a USD price came from, best first.
+ *
+ * @remarks
+ *
+ * Returned with every price because they are not equally trustworthy: a
+ * Chainlink feed is a measurement, a price read off a shallow pool is closer
+ * to a rumour.
+ */
+export const PriceSource = {
+  Chainlink: "CHAINLINK",
+  RhRest: "RH_REST",
+  Llama: "LLAMA",
+  Pool: "POOL",
+  Peg: "PEG",
+} as const;
+/**
+ * Where a USD price came from, best first.
+ *
+ * @remarks
+ *
+ * Returned with every price because they are not equally trustworthy: a
+ * Chainlink feed is a measurement, a price read off a shallow pool is closer
+ * to a rumour.
+ */
+export type PriceSource = ClosedEnum<typeof PriceSource>;
+
+/** @internal */
+export const PriceSource$inboundSchema: z.ZodNativeEnum<typeof PriceSource> = z
+  .nativeEnum(PriceSource);