@compass-labs/api-sdk 2.2.79 → 2.2.80

package/src/funcs/creditCreditRebalance.ts

@@ -0,0 +1,198 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { CompassApiSDKCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as components from "../models/components/index.js";
+import { CompassAPISDKError } from "../models/errors/compassapisdkerror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * 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.
+ */
+export function creditCreditRebalance(
+  client: CompassApiSDKCore,
+  request: components.CreditRebalanceRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    components.CreditRebalanceResponse,
+    | errors.HTTPValidationError
+    | CompassAPISDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: CompassApiSDKCore,
+  request: components.CreditRebalanceRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      components.CreditRebalanceResponse,
+      | errors.HTTPValidationError
+      | CompassAPISDKError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => components.CreditRebalanceRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/v2/credit/rebalance")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "v2_credit_rebalance",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    components.CreditRebalanceResponse,
+    | errors.HTTPValidationError
+    | CompassAPISDKError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, components.CreditRebalanceResponse$inboundSchema),
+    M.jsonErr(422, errors.HTTPValidationError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -62,7 +62,7 @@ export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.1",
   sdkVersion: "2.0.0",
-  genVersion: "2.915.1",
+  genVersion: "2.916.2",
   userAgent:
-    "speakeasy-sdk/typescript 2.0.0 2.915.1 0.0.1 @compass-labs/api-sdk",
+    "speakeasy-sdk/typescript 2.0.0 2.916.2 0.0.1 @compass-labs/api-sdk",
 } as const;

package/src/models/components/creditrebalancepreview.ts

@@ -0,0 +1,80 @@
+/*
+ * 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 {
+  RebalanceTargetPreview,
+  RebalanceTargetPreview$inboundSchema,
+} from "./rebalancetargetpreview.js";
+import {
+  RoutingSwapPreview,
+  RoutingSwapPreview$inboundSchema,
+} from "./routingswappreview.js";
+
+/**
+ * Projected end state of the whole rebalance, computed on GUARANTEED swap floors.
+ */
+export type CreditRebalancePreview = {
+  /**
+   * Signed net equity moved: Σ(target − current equity, in USD) over the named targets. Positive = net book growth funded from the Credit Account's idle balance; negative = surplus equity released to idle. Truncated toward zero, so the reported magnitude is never larger than the true amount in either sign.
+   */
+  netEquityMovedUsd: string;
+  /**
+   * Total on-chain legs across the whole transaction, including capital-routing swaps. A rebalance too large for one transaction is rejected with a 422.
+   */
+  totalLegs: number;
+  /**
+   * The capital-routing swaps that move freed tokens between positions, at a guaranteed minimum output enforced on-chain.
+   */
+  routingSwaps?: Array<RoutingSwapPreview> | undefined;
+  /**
+   * Upper bound of surplus all swaps (per-target and routing) can leave in the Credit Account (sum of each swap's quote minus its guaranteed floor). It accumulates in the Credit Account, is recoverable, and is never lost.
+   */
+  estimatedMaxDust: string;
+  /**
+   * Projected account-level Aave health factor after the rebalance — Aave collateral is pooled, so this is shared by every Aave target. Present whenever the end state holds any Aave collateral or debt; null for Morpho-only books. Never overstated at the 1.0 boundary.
+   */
+  aaveAccountHealthFactor?: string | null | undefined;
+  /**
+   * Per-target end state, in the same order as the request targets.
+   */
+  perTarget: Array<RebalanceTargetPreview>;
+};
+
+/** @internal */
+export const CreditRebalancePreview$inboundSchema: z.ZodType<
+  CreditRebalancePreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  net_equity_moved_usd: z.string(),
+  total_legs: z.number().int(),
+  routing_swaps: z.array(RoutingSwapPreview$inboundSchema).optional(),
+  estimated_max_dust: z.string(),
+  aave_account_health_factor: z.nullable(z.string()).optional(),
+  per_target: z.array(RebalanceTargetPreview$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "net_equity_moved_usd": "netEquityMovedUsd",
+    "total_legs": "totalLegs",
+    "routing_swaps": "routingSwaps",
+    "estimated_max_dust": "estimatedMaxDust",
+    "aave_account_health_factor": "aaveAccountHealthFactor",
+    "per_target": "perTarget",
+  });
+});
+
+export function creditRebalancePreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditRebalancePreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditRebalancePreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditRebalancePreview' from JSON`,
+  );
+}

package/src/models/components/creditrebalancerequest.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 { Chain, Chain$outboundSchema } from "./chain.js";
+import {
+  RebalanceTarget,
+  RebalanceTarget$Outbound,
+  RebalanceTarget$outboundSchema,
+} from "./rebalancetarget.js";
+
+/**
+ * Request-level per-swap slippage tolerance in percent (including routing swaps). A per-target max_slippage_percent overrides it where set.
+ */
+export type CreditRebalanceRequestMaxSlippagePercent = number | string;
+
+/**
+ * Rebalance one or more Credit Account positions to their named end-states —
+ *
+ * @remarks
+ * lever up or down, grow or shrink equity, open a new position, close an existing
+ * one, or migrate (close one and open another) — all in ONE atomic transaction
+ * from the Credit Account.
+ */
+export type CreditRebalanceRequest = {
+  /**
+   * The address that owns the Credit Account.
+   */
+  owner: string;
+  /**
+   * The chain to use.
+   */
+  chain: Chain;
+  /**
+   * The positions to change. Scoped: only positions named here are touched; any position not listed is left untouched.
+   */
+  targets: Array<RebalanceTarget>;
+  /**
+   * Request-level per-swap slippage tolerance in percent (including routing swaps). A per-target max_slippage_percent overrides it where set.
+   */
+  maxSlippagePercent?: number | string | undefined;
+  /**
+   * If true, returns EIP-712 typed data for gas-sponsored execution instead of an unsigned transaction.
+   */
+  gasSponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export type CreditRebalanceRequestMaxSlippagePercent$Outbound = number | string;
+
+/** @internal */
+export const CreditRebalanceRequestMaxSlippagePercent$outboundSchema: z.ZodType<
+  CreditRebalanceRequestMaxSlippagePercent$Outbound,
+  z.ZodTypeDef,
+  CreditRebalanceRequestMaxSlippagePercent
+> = z.union([z.number(), z.string()]);
+
+export function creditRebalanceRequestMaxSlippagePercentToJSON(
+  creditRebalanceRequestMaxSlippagePercent:
+    CreditRebalanceRequestMaxSlippagePercent,
+): string {
+  return JSON.stringify(
+    CreditRebalanceRequestMaxSlippagePercent$outboundSchema.parse(
+      creditRebalanceRequestMaxSlippagePercent,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditRebalanceRequest$Outbound = {
+  owner: string;
+  chain: string;
+  targets: Array<RebalanceTarget$Outbound>;
+  max_slippage_percent?: number | string | undefined;
+  gas_sponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export const CreditRebalanceRequest$outboundSchema: z.ZodType<
+  CreditRebalanceRequest$Outbound,
+  z.ZodTypeDef,
+  CreditRebalanceRequest
+> = z.object({
+  owner: z.string(),
+  chain: Chain$outboundSchema,
+  targets: z.array(RebalanceTarget$outboundSchema),
+  maxSlippagePercent: z.union([z.number(), z.string()]).optional(),
+  gasSponsorship: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxSlippagePercent: "max_slippage_percent",
+    gasSponsorship: "gas_sponsorship",
+  });
+});
+
+export function creditRebalanceRequestToJSON(
+  creditRebalanceRequest: CreditRebalanceRequest,
+): string {
+  return JSON.stringify(
+    CreditRebalanceRequest$outboundSchema.parse(creditRebalanceRequest),
+  );
+}

package/src/models/components/creditrebalanceresponse.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 {
+  BatchedSafeOperationsResponseOutput,
+  BatchedSafeOperationsResponseOutput$inboundSchema,
+} from "./batchedsafeoperationsresponseoutput.js";
+import {
+  CreditRebalancePreview,
+  CreditRebalancePreview$inboundSchema,
+} from "./creditrebalancepreview.js";
+import {
+  UnsignedTransaction,
+  UnsignedTransaction$inboundSchema,
+} from "./unsignedtransaction.js";
+
+/**
+ * The atomic rebalance transaction plus its guaranteed-floor preview.
+ */
+export type CreditRebalanceResponse = {
+  /**
+   * Unsigned transaction for direct execution by the owner. Present when gas_sponsorship=false. Null when the book is already at its target — nothing to execute.
+   */
+  transaction?: UnsignedTransaction | null | undefined;
+  /**
+   * EIP-712 typed data for gas-sponsored execution. Present when gas_sponsorship=true.
+   */
+  eip712?: BatchedSafeOperationsResponseOutput | null | undefined;
+  /**
+   * Projected end state of the whole rebalance, computed on GUARANTEED swap floors.
+   */
+  preview: CreditRebalancePreview;
+};
+
+/** @internal */
+export const CreditRebalanceResponse$inboundSchema: z.ZodType<
+  CreditRebalanceResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  transaction: z.nullable(UnsignedTransaction$inboundSchema).optional(),
+  eip_712: z.nullable(BatchedSafeOperationsResponseOutput$inboundSchema)
+    .optional(),
+  preview: CreditRebalancePreview$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "eip_712": "eip712",
+  });
+});
+
+export function creditRebalanceResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditRebalanceResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditRebalanceResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditRebalanceResponse' from JSON`,
+  );
+}

package/src/models/components/creditunlooprequest.ts

@@ -13,7 +13,7 @@ import {
 /**
  * Target leverage after the unwind. Omit (null) for a FULL unwind: the debt is cleared exactly — accrued interest included — and all pair collateral is withdrawn back to the Credit Account. `1` runs the same exact debt close but leaves the collateral supplied (earning). A value greater than 1 delevers the position to that multiplier. Must be below the position's current multiplier.
  */
-export type TargetMultiplier = number | string;
+export type CreditUnloopRequestTargetMultiplier = number | string;
 
 /**
  * Per-swap slippage tolerance in percent. Unwind dust is bounded by this per iteration, so tighter slippage means less dust.
@@ -81,20 +81,22 @@ export type CreditUnloopRequest = {
 };
 
 /** @internal */
-export type TargetMultiplier$Outbound = number | string;
+export type CreditUnloopRequestTargetMultiplier$Outbound = number | string;
 
 /** @internal */
-export const TargetMultiplier$outboundSchema: z.ZodType<
-  TargetMultiplier$Outbound,
+export const CreditUnloopRequestTargetMultiplier$outboundSchema: z.ZodType<
+  CreditUnloopRequestTargetMultiplier$Outbound,
   z.ZodTypeDef,
-  TargetMultiplier
+  CreditUnloopRequestTargetMultiplier
 > = z.union([z.number(), z.string()]);
 
-export function targetMultiplierToJSON(
-  targetMultiplier: TargetMultiplier,
+export function creditUnloopRequestTargetMultiplierToJSON(
+  creditUnloopRequestTargetMultiplier: CreditUnloopRequestTargetMultiplier,
 ): string {
   return JSON.stringify(
-    TargetMultiplier$outboundSchema.parse(targetMultiplier),
+    CreditUnloopRequestTargetMultiplier$outboundSchema.parse(
+      creditUnloopRequestTargetMultiplier,
+    ),
   );
 }
 

package/src/models/components/index.ts

@@ -108,6 +108,9 @@ export * from "./creditlooprequest.js";
 export * from "./creditloopresponse.js";
 export * from "./creditpositionsresponse.js";
 export * from "./creditprotocol.js";
+export * from "./creditrebalancepreview.js";
+export * from "./creditrebalancerequest.js";
+export * from "./creditrebalanceresponse.js";
 export * from "./creditrepayparams.js";
 export * from "./creditrepayrequest.js";
 export * from "./creditrepayresponse.js";
@@ -276,11 +279,15 @@ export * from "./pricepoint.js";
 export * from "./protocol.js";
 export * from "./quote.js";
 export * from "./quotefee.js";
+export * from "./rebalancedirection.js";
+export * from "./rebalancetarget.js";
+export * from "./rebalancetargetpreview.js";
 export * from "./redemption.js";
 export * from "./redemptionsresponse.js";
 export * from "./repay.js";
 export * from "./reserve.js";
 export * from "./reserveinfo.js";
+export * from "./routingswappreview.js";
 export * from "./safemessageeip712response.js";
 export * from "./safemessageeip712types.js";
 export * from "./safemessagefield.js";

package/src/models/components/loopedpositioncurrentstate.ts

@@ -12,14 +12,16 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.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 — see aave_account_summary for the account-level figures.
  */
-export const HealthFactorScope = {
+export const LoopedPositionCurrentStateHealthFactorScope = {
   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 — see aave_account_summary for the account-level figures.
  */
-export type HealthFactorScope = ClosedEnum<typeof HealthFactorScope>;
+export type LoopedPositionCurrentStateHealthFactorScope = ClosedEnum<
+  typeof LoopedPositionCurrentStateHealthFactorScope
+>;
 
 /**
  * Live on-chain state of an OPEN looped position.
@@ -56,13 +58,13 @@ export type LoopedPositionCurrentState = {
   /**
    * '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 — see aave_account_summary for the account-level figures.
    */
-  healthFactorScope: HealthFactorScope;
+  healthFactorScope: LoopedPositionCurrentStateHealthFactorScope;
 };
 
 /** @internal */
-export const HealthFactorScope$inboundSchema: z.ZodNativeEnum<
-  typeof HealthFactorScope
-> = z.nativeEnum(HealthFactorScope);
+export const LoopedPositionCurrentStateHealthFactorScope$inboundSchema:
+  z.ZodNativeEnum<typeof LoopedPositionCurrentStateHealthFactorScope> = z
+    .nativeEnum(LoopedPositionCurrentStateHealthFactorScope);
 
 /** @internal */
 export const LoopedPositionCurrentState$inboundSchema: z.ZodType<
@@ -77,7 +79,8 @@ export const LoopedPositionCurrentState$inboundSchema: z.ZodType<
   net_usd_value: z.nullable(z.string()).optional(),
   leverage: z.nullable(z.string()).optional(),
   health_factor: z.nullable(z.string()).optional(),
-  health_factor_scope: HealthFactorScope$inboundSchema,
+  health_factor_scope:
+    LoopedPositionCurrentStateHealthFactorScope$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "collateral_amount": "collateralAmount",

package/src/models/components/rebalancedirection.ts

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * What the plan does to one named target.
+ */
+export const RebalanceDirection = {
+  Open: "open",
+  Close: "close",
+  Grow: "grow",
+  Shrink: "shrink",
+  LeverUp: "lever_up",
+  LeverDown: "lever_down",
+  Noop: "noop",
+} as const;
+/**
+ * What the plan does to one named target.
+ */
+export type RebalanceDirection = ClosedEnum<typeof RebalanceDirection>;
+
+/** @internal */
+export const RebalanceDirection$inboundSchema: z.ZodNativeEnum<
+  typeof RebalanceDirection
+> = z.nativeEnum(RebalanceDirection);