@compass-labs/api-sdk 2.2.79 → 2.2.80

package/src/models/components/rebalancetarget.ts

@@ -0,0 +1,178 @@
+/*
+ * 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 {
+  CreditProtocol,
+  CreditProtocol$outboundSchema,
+} from "./creditprotocol.js";
+
+/**
+ * SIZE knob: the net value (collateral − debt, in USD) to commit to this position; total collateral ≈ target_equity_usd × target_multiplier. To remove a position use close=true, never target_equity_usd=0.
+ */
+export type TargetEquityUsd = number | string;
+
+/**
+ * LEVERAGE knob: total collateral exposure ÷ equity. 1 means unlevered supplied collateral. The protocol maximum is enforced when the plan is built.
+ */
+export type RebalanceTargetTargetMultiplier = number | string;
+
+/**
+ * Per-target override of the request-level per-swap slippage tolerance in percent.
+ */
+export type RebalanceTargetMaxSlippagePercent = number | string;
+
+/**
+ * The desired end-state of ONE position in the Credit Account.
+ *
+ * @remarks
+ *
+ * Scoped-declarative: only positions named in ``targets`` are touched; anything
+ * unlisted is left as-is. Set ``close=true`` to fully unwind a position — never
+ * ``target_equity_usd=0``.
+ */
+export type RebalanceTarget = {
+  /**
+   * Which lending protocol a credit action targets.
+   *
+   * @remarks
+   *
+   * ``AAVE`` is the default so existing callers (which never send a ``protocol``
+   * field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+   * Euler V2 path, where the market is identified by EVK vault address(es).
+   * ``MORPHO`` identifies Morpho Blue lending markets (bytes32 market id) and is
+   * currently read-only: positions and market discovery only — transaction
+   * builders land with the looping work (COM-7106/7107/7108), so transact
+   * endpoints reject it with a 422.
+   */
+  protocol?: CreditProtocol | undefined;
+  /**
+   * Morpho only: the bytes32 market id (from /v2/credit/morpho_markets). Required when protocol=MORPHO.
+   */
+  marketId?: string | null | undefined;
+  /**
+   * Token supplied as collateral for this position. For MORPHO it must be the market's collateral token.
+   */
+  collateralToken: string;
+  /**
+   * Token borrowed against the collateral for this position. For MORPHO it must be the market's loan token.
+   */
+  borrowToken: string;
+  /**
+   * SIZE knob: the net value (collateral − debt, in USD) to commit to this position; total collateral ≈ target_equity_usd × target_multiplier. To remove a position use close=true, never target_equity_usd=0.
+   */
+  targetEquityUsd?: number | string | null | undefined;
+  /**
+   * LEVERAGE knob: total collateral exposure ÷ equity. 1 means unlevered supplied collateral. The protocol maximum is enforced when the plan is built.
+   */
+  targetMultiplier?: number | string | null | undefined;
+  /**
+   * If true, fully unwind this position: the debt is cleared exactly (accrued interest included) and the pair collateral is returned to the Credit Account.
+   */
+  close?: boolean | undefined;
+  /**
+   * Per-target override of the request-level per-swap slippage tolerance in percent.
+   */
+  maxSlippagePercent?: number | string | null | undefined;
+};
+
+/** @internal */
+export type TargetEquityUsd$Outbound = number | string;
+
+/** @internal */
+export const TargetEquityUsd$outboundSchema: z.ZodType<
+  TargetEquityUsd$Outbound,
+  z.ZodTypeDef,
+  TargetEquityUsd
+> = z.union([z.number(), z.string()]);
+
+export function targetEquityUsdToJSON(
+  targetEquityUsd: TargetEquityUsd,
+): string {
+  return JSON.stringify(TargetEquityUsd$outboundSchema.parse(targetEquityUsd));
+}
+
+/** @internal */
+export type RebalanceTargetTargetMultiplier$Outbound = number | string;
+
+/** @internal */
+export const RebalanceTargetTargetMultiplier$outboundSchema: z.ZodType<
+  RebalanceTargetTargetMultiplier$Outbound,
+  z.ZodTypeDef,
+  RebalanceTargetTargetMultiplier
+> = z.union([z.number(), z.string()]);
+
+export function rebalanceTargetTargetMultiplierToJSON(
+  rebalanceTargetTargetMultiplier: RebalanceTargetTargetMultiplier,
+): string {
+  return JSON.stringify(
+    RebalanceTargetTargetMultiplier$outboundSchema.parse(
+      rebalanceTargetTargetMultiplier,
+    ),
+  );
+}
+
+/** @internal */
+export type RebalanceTargetMaxSlippagePercent$Outbound = number | string;
+
+/** @internal */
+export const RebalanceTargetMaxSlippagePercent$outboundSchema: z.ZodType<
+  RebalanceTargetMaxSlippagePercent$Outbound,
+  z.ZodTypeDef,
+  RebalanceTargetMaxSlippagePercent
+> = z.union([z.number(), z.string()]);
+
+export function rebalanceTargetMaxSlippagePercentToJSON(
+  rebalanceTargetMaxSlippagePercent: RebalanceTargetMaxSlippagePercent,
+): string {
+  return JSON.stringify(
+    RebalanceTargetMaxSlippagePercent$outboundSchema.parse(
+      rebalanceTargetMaxSlippagePercent,
+    ),
+  );
+}
+
+/** @internal */
+export type RebalanceTarget$Outbound = {
+  protocol?: string | undefined;
+  market_id?: string | null | undefined;
+  collateral_token: string;
+  borrow_token: string;
+  target_equity_usd?: number | string | null | undefined;
+  target_multiplier?: number | string | null | undefined;
+  close?: boolean | undefined;
+  max_slippage_percent?: number | string | null | undefined;
+};
+
+/** @internal */
+export const RebalanceTarget$outboundSchema: z.ZodType<
+  RebalanceTarget$Outbound,
+  z.ZodTypeDef,
+  RebalanceTarget
+> = z.object({
+  protocol: CreditProtocol$outboundSchema.optional(),
+  marketId: z.nullable(z.string()).optional(),
+  collateralToken: z.string(),
+  borrowToken: z.string(),
+  targetEquityUsd: z.nullable(z.union([z.number(), z.string()])).optional(),
+  targetMultiplier: z.nullable(z.union([z.number(), z.string()])).optional(),
+  close: z.boolean().optional(),
+  maxSlippagePercent: z.nullable(z.union([z.number(), z.string()])).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    marketId: "market_id",
+    collateralToken: "collateral_token",
+    borrowToken: "borrow_token",
+    targetEquityUsd: "target_equity_usd",
+    targetMultiplier: "target_multiplier",
+    maxSlippagePercent: "max_slippage_percent",
+  });
+});
+
+export function rebalanceTargetToJSON(
+  rebalanceTarget: RebalanceTarget,
+): string {
+  return JSON.stringify(RebalanceTarget$outboundSchema.parse(rebalanceTarget));
+}

package/src/models/components/rebalancetargetpreview.ts

@@ -0,0 +1,163 @@
+/*
+ * 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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CreditProtocol,
+  CreditProtocol$inboundSchema,
+} from "./creditprotocol.js";
+import {
+  LoopLegPreview,
+  LoopLegPreview$inboundSchema,
+} from "./looplegpreview.js";
+import {
+  RebalanceDirection,
+  RebalanceDirection$inboundSchema,
+} from "./rebalancedirection.js";
+import {
+  UnloopLegPreview,
+  UnloopLegPreview$inboundSchema,
+} from "./unlooplegpreview.js";
+
+/**
+ * 'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account.
+ */
+export const RebalanceTargetPreviewHealthFactorScope = {
+  Market: "market",
+  Account: "account",
+} as const;
+/**
+ * 'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account.
+ */
+export type RebalanceTargetPreviewHealthFactorScope = ClosedEnum<
+  typeof RebalanceTargetPreviewHealthFactorScope
+>;
+
+/**
+ * Projected end state of ONE named target, computed on guaranteed swap floors.
+ */
+export type RebalanceTargetPreview = {
+  /**
+   * Which lending protocol a credit action targets.
+   *
+   * @remarks
+   *
+   * ``AAVE`` is the default so existing callers (which never send a ``protocol``
+   * field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+   * Euler V2 path, where the market is identified by EVK vault address(es).
+   * ``MORPHO`` identifies Morpho Blue lending markets (bytes32 market id) and is
+   * currently read-only: positions and market discovery only — transaction
+   * builders land with the looping work (COM-7106/7107/7108), so transact
+   * endpoints reject it with a 422.
+   */
+  protocol: CreditProtocol;
+  /**
+   * Morpho only: the bytes32 market id of this position.
+   */
+  marketId?: string | null | undefined;
+  /**
+   * Collateral token address (echoes the request target; joins against /v2/credit/looped_positions).
+   */
+  collateralToken: string;
+  /**
+   * Borrow token address (echoes the request target).
+   */
+  borrowToken: string;
+  /**
+   * What the plan does to one named target.
+   */
+  direction: RebalanceDirection;
+  /**
+   * On-chain legs planned for this target (loop + unloop iterations); 0 for a noop.
+   */
+  legs: number;
+  /**
+   * Per-iteration unwind breakdown — populated for releasers (close / shrink / lever_down).
+   */
+  unloopLegs?: Array<UnloopLegPreview> | undefined;
+  /**
+   * Per-iteration loop breakdown — populated for consumers (open / grow / lever_up).
+   */
+  loopLegs?: Array<LoopLegPreview> | undefined;
+  /**
+   * Guaranteed minimum collateral supplied to this position after the rebalance (token units).
+   */
+  resultingCollateral: string;
+  /**
+   * Projected debt owed by this position after the rebalance (borrow-token units); 0 on a close.
+   */
+  resultingDebt: string;
+  /**
+   * Projected leverage of this position after the rebalance; 1 when the debt is cleared. Never promises more leverage (or, when deleveraging, more deleverage) than is guaranteed.
+   */
+  resultingMultiplier: string;
+  /**
+   * Projected health factor of this position after the rebalance. Never overstated at the 1.0 boundary — a liquidatable position is never presented as safe. See health_factor_scope for what it covers.
+   */
+  resultingHealthFactor: string;
+  /**
+   * 'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account.
+   */
+  healthFactorScope: RebalanceTargetPreviewHealthFactorScope;
+  /**
+   * Upper bound of surplus this target's own swaps can leave in the Credit Account (sum of each swap's quote minus its guaranteed floor). Routing swaps are counted book-level, not here. It accumulates in the Credit Account, is recoverable, and is never lost.
+   */
+  estimatedMaxDust: string;
+};
+
+/** @internal */
+export const RebalanceTargetPreviewHealthFactorScope$inboundSchema:
+  z.ZodNativeEnum<typeof RebalanceTargetPreviewHealthFactorScope> = z
+    .nativeEnum(RebalanceTargetPreviewHealthFactorScope);
+
+/** @internal */
+export const RebalanceTargetPreview$inboundSchema: z.ZodType<
+  RebalanceTargetPreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  protocol: CreditProtocol$inboundSchema,
+  market_id: z.nullable(z.string()).optional(),
+  collateral_token: z.string(),
+  borrow_token: z.string(),
+  direction: RebalanceDirection$inboundSchema,
+  legs: z.number().int(),
+  unloop_legs: z.array(UnloopLegPreview$inboundSchema).optional(),
+  loop_legs: z.array(LoopLegPreview$inboundSchema).optional(),
+  resulting_collateral: z.string(),
+  resulting_debt: z.string(),
+  resulting_multiplier: z.string(),
+  resulting_health_factor: z.string(),
+  health_factor_scope: RebalanceTargetPreviewHealthFactorScope$inboundSchema,
+  estimated_max_dust: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "market_id": "marketId",
+    "collateral_token": "collateralToken",
+    "borrow_token": "borrowToken",
+    "unloop_legs": "unloopLegs",
+    "loop_legs": "loopLegs",
+    "resulting_collateral": "resultingCollateral",
+    "resulting_debt": "resultingDebt",
+    "resulting_multiplier": "resultingMultiplier",
+    "resulting_health_factor": "resultingHealthFactor",
+    "health_factor_scope": "healthFactorScope",
+    "estimated_max_dust": "estimatedMaxDust",
+  });
+});
+
+export function rebalanceTargetPreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<RebalanceTargetPreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RebalanceTargetPreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RebalanceTargetPreview' from JSON`,
+  );
+}

package/src/models/components/routingswappreview.ts

@@ -0,0 +1,64 @@
+/*
+ * 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";
+
+/**
+ * One Phase-B capital-routing swap that moves freed tokens between positions.
+ *
+ * @remarks
+ *
+ * Book-level: it is not attributable to a single target.
+ */
+export type RoutingSwapPreview = {
+  /**
+   * Token sold by the Credit Account into this routing swap.
+   */
+  tokenIn: string;
+  /**
+   * Token bought and delivered to fund a consuming position.
+   */
+  tokenOut: string;
+  /**
+   * Token-in amount the Credit Account gives up to this swap.
+   */
+  amountIn: string;
+  /**
+   * Guaranteed minimum output (token-out units), enforced on-chain by the swap's minimum-return. Any fill above it stays in the Credit Account as recoverable dust.
+   */
+  minAmountOut: string;
+};
+
+/** @internal */
+export const RoutingSwapPreview$inboundSchema: z.ZodType<
+  RoutingSwapPreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token_in: z.string(),
+  token_out: z.string(),
+  amount_in: z.string(),
+  min_amount_out: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "token_in": "tokenIn",
+    "token_out": "tokenOut",
+    "amount_in": "amountIn",
+    "min_amount_out": "minAmountOut",
+  });
+});
+
+export function routingSwapPreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<RoutingSwapPreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoutingSwapPreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoutingSwapPreview' from JSON`,
+  );
+}

package/src/sdk/credit.ts

@@ -11,6 +11,7 @@ import { creditCreditLoop } from "../funcs/creditCreditLoop.js";
 import { creditCreditLoopedPositions } from "../funcs/creditCreditLoopedPositions.js";
 import { creditCreditMorphoMarkets } from "../funcs/creditCreditMorphoMarkets.js";
 import { creditCreditPositions } from "../funcs/creditCreditPositions.js";
+import { creditCreditRebalance } from "../funcs/creditCreditRebalance.js";
 import { creditCreditRepay } from "../funcs/creditCreditRepay.js";
 import { creditCreditTransfer } from "../funcs/creditCreditTransfer.js";
 import { creditCreditUnloop } from "../funcs/creditCreditUnloop.js";
@@ -246,6 +247,50 @@ export class Credit extends ClientSDK {
     ));
   }
 
+  /**
+   * Rebalance the leveraged credit book
+   *
+   * @remarks
+   * Rebalance the leveraged credit book in ONE atomic transaction.
+   *
+   * List only the positions to change — anything not named is left untouched;
+   * remove a position with close=true. Each target states an end state:
+   * target_equity_usd (net USD committed) × target_multiplier.
+   *
+   * Releasing targets run first (each unwind/delever frees tokens into the Credit
+   * Account), the freed tokens are then routed by swaps at a GUARANTEED minimum
+   * output (enforced on-chain), and consuming targets run last — so moving a
+   * levered position between markets, token pairs, or protocols (Aave ↔ Morpho) is
+   * simply a close plus an open in the same transaction.
+   *
+   * Net book growth is funded from the Credit Account's existing idle balance —
+   * fund it first via /v2/credit/transfer; a net release stays in the Credit
+   * Account as idle balance. Any swap surplus above the guaranteed floors also
+   * stays in the Credit Account (preview.estimated_max_dust) — recoverable, never
+   * lost.
+   *
+   * A book already at its target returns transaction: null with the preview — the
+   * call is idempotent and safe to drive from a converge-to-target loop.
+   *
+   * A rebalance too large for one transaction is rejected with a 422 — split it
+   * into two calls. Every deleveraging step keeps the health factor ≥ 1.02 and
+   * every leveraging step respects the protocol's borrow limits; Aave targets share
+   * one account-level health factor, which the preview reports.
+   *
+   * For protocol=MORPHO pass a market_id from /v2/credit/morpho_markets; inspect the
+   * current book via /v2/credit/looped_positions.
+   */
+  async creditRebalance(
+    request: components.CreditRebalanceRequest,
+    options?: RequestOptions,
+  ): Promise<components.CreditRebalanceResponse> {
+    return unwrapAsync(creditCreditRebalance(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Transfer tokens to/from Credit Account
    *