@compass-labs/api-sdk 2.2.76 → 2.2.77-rc.1

package/src/models/components/aavelooprequest.ts

@@ -21,22 +21,22 @@ export type AaveLoopRequestChain = ClosedEnum<typeof AaveLoopRequestChain>;
 /**
  * Amount of collateral token to supply to Aave
  */
-export type InitialCollateralAmount = number | string;
+export type AaveLoopRequestInitialCollateralAmount = number | string;
 
 /**
  * Leverage multiplier. Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`
  */
-export type Multiplier = number | string;
+export type AaveLoopRequestMultiplier = number | string;
 
 /**
  * Maximum allowed slippage for token swaps in percentage
  */
-export type MaxSlippagePercent = number | string;
+export type AaveLoopRequestMaxSlippagePercent = number | string;
 
 /**
  * Loan To Value percentage of the loop
  */
-export type LoanToValue = number | string;
+export type AaveLoopRequestLoanToValue = number | string;
 
 /**
  * Request model for executing an Aave loop strategy.
@@ -99,67 +99,80 @@ export const AaveLoopRequestChain$outboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(AaveLoopRequestChain);
 
 /** @internal */
-export type InitialCollateralAmount$Outbound = number | string;
+export type AaveLoopRequestInitialCollateralAmount$Outbound = number | string;
 
 /** @internal */
-export const InitialCollateralAmount$outboundSchema: z.ZodType<
-  InitialCollateralAmount$Outbound,
+export const AaveLoopRequestInitialCollateralAmount$outboundSchema: z.ZodType<
+  AaveLoopRequestInitialCollateralAmount$Outbound,
   z.ZodTypeDef,
-  InitialCollateralAmount
+  AaveLoopRequestInitialCollateralAmount
 > = z.union([z.number(), z.string()]);
 
-export function initialCollateralAmountToJSON(
-  initialCollateralAmount: InitialCollateralAmount,
+export function aaveLoopRequestInitialCollateralAmountToJSON(
+  aaveLoopRequestInitialCollateralAmount:
+    AaveLoopRequestInitialCollateralAmount,
 ): string {
   return JSON.stringify(
-    InitialCollateralAmount$outboundSchema.parse(initialCollateralAmount),
+    AaveLoopRequestInitialCollateralAmount$outboundSchema.parse(
+      aaveLoopRequestInitialCollateralAmount,
+    ),
   );
 }
 
 /** @internal */
-export type Multiplier$Outbound = number | string;
+export type AaveLoopRequestMultiplier$Outbound = number | string;
 
 /** @internal */
-export const Multiplier$outboundSchema: z.ZodType<
-  Multiplier$Outbound,
+export const AaveLoopRequestMultiplier$outboundSchema: z.ZodType<
+  AaveLoopRequestMultiplier$Outbound,
   z.ZodTypeDef,
-  Multiplier
+  AaveLoopRequestMultiplier
 > = z.union([z.number(), z.string()]);
 
-export function multiplierToJSON(multiplier: Multiplier): string {
-  return JSON.stringify(Multiplier$outboundSchema.parse(multiplier));
+export function aaveLoopRequestMultiplierToJSON(
+  aaveLoopRequestMultiplier: AaveLoopRequestMultiplier,
+): string {
+  return JSON.stringify(
+    AaveLoopRequestMultiplier$outboundSchema.parse(aaveLoopRequestMultiplier),
+  );
 }
 
 /** @internal */
-export type MaxSlippagePercent$Outbound = number | string;
+export type AaveLoopRequestMaxSlippagePercent$Outbound = number | string;
 
 /** @internal */
-export const MaxSlippagePercent$outboundSchema: z.ZodType<
-  MaxSlippagePercent$Outbound,
+export const AaveLoopRequestMaxSlippagePercent$outboundSchema: z.ZodType<
+  AaveLoopRequestMaxSlippagePercent$Outbound,
   z.ZodTypeDef,
-  MaxSlippagePercent
+  AaveLoopRequestMaxSlippagePercent
 > = z.union([z.number(), z.string()]);
 
-export function maxSlippagePercentToJSON(
-  maxSlippagePercent: MaxSlippagePercent,
+export function aaveLoopRequestMaxSlippagePercentToJSON(
+  aaveLoopRequestMaxSlippagePercent: AaveLoopRequestMaxSlippagePercent,
 ): string {
   return JSON.stringify(
-    MaxSlippagePercent$outboundSchema.parse(maxSlippagePercent),
+    AaveLoopRequestMaxSlippagePercent$outboundSchema.parse(
+      aaveLoopRequestMaxSlippagePercent,
+    ),
   );
 }
 
 /** @internal */
-export type LoanToValue$Outbound = number | string;
+export type AaveLoopRequestLoanToValue$Outbound = number | string;
 
 /** @internal */
-export const LoanToValue$outboundSchema: z.ZodType<
-  LoanToValue$Outbound,
+export const AaveLoopRequestLoanToValue$outboundSchema: z.ZodType<
+  AaveLoopRequestLoanToValue$Outbound,
   z.ZodTypeDef,
-  LoanToValue
+  AaveLoopRequestLoanToValue
 > = z.union([z.number(), z.string()]);
 
-export function loanToValueToJSON(loanToValue: LoanToValue): string {
-  return JSON.stringify(LoanToValue$outboundSchema.parse(loanToValue));
+export function aaveLoopRequestLoanToValueToJSON(
+  aaveLoopRequestLoanToValue: AaveLoopRequestLoanToValue,
+): string {
+  return JSON.stringify(
+    AaveLoopRequestLoanToValue$outboundSchema.parse(aaveLoopRequestLoanToValue),
+  );
 }
 
 /** @internal */

package/src/models/components/accountsummary.ts

@@ -30,6 +30,10 @@ export type AccountSummary = {
    * ``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;
   /**

package/src/models/components/collateralposition.ts

@@ -33,12 +33,24 @@ export type CollateralPosition = {
    * ``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;
   /**
    * Euler only: the EVK collateral vault holding this position.
    */
   vault?: string | null | undefined;
+  /**
+   * Morpho only: the bytes32 id of the isolated market holding this position.
+   */
+  marketId?: string | null | undefined;
+  /**
+   * Morpho only: true when this is a loan-asset supply position (earning supply APY) rather than collateral backing borrows.
+   */
+  isPureSupply?: boolean | null | undefined;
   /**
    * Current on-chain collateral balance (the vault's underlying asset for Euler).
    */
@@ -83,6 +95,8 @@ export const CollateralPosition$inboundSchema: z.ZodType<
   symbol: z.string(),
   protocol: CreditProtocol$inboundSchema.optional(),
   vault: z.nullable(z.string()).optional(),
+  market_id: z.nullable(z.string()).optional(),
+  is_pure_supply: z.nullable(z.boolean()).optional(),
   amount_supplied: z.nullable(z.string()),
   usd_value: z.nullable(z.string()).optional(),
   supply_apy: z.nullable(z.string()).optional(),
@@ -93,6 +107,8 @@ export const CollateralPosition$inboundSchema: z.ZodType<
   events: z.array(CreditEvent$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
+    "market_id": "marketId",
+    "is_pure_supply": "isPureSupply",
     "amount_supplied": "amountSupplied",
     "usd_value": "usdValue",
     "supply_apy": "supplyApy",

package/src/models/components/createaccountrequest.ts

@@ -9,6 +9,7 @@ import { ClosedEnum } from "../../types/enums.js";
 export const CreateAccountRequestChain = {
   Arbitrum: "arbitrum",
   Base: "base",
+  Bsc: "bsc",
   Ethereum: "ethereum",
   Tempo: "tempo",
 } as const;

package/src/models/components/createcreditaccountrequest.ts

@@ -9,6 +9,7 @@ import { ClosedEnum } from "../../types/enums.js";
 export const CreateCreditAccountRequestChain = {
   Arbitrum: "arbitrum",
   Base: "base",
+  Bsc: "bsc",
   Ethereum: "ethereum",
   Tempo: "tempo",
 } as const;

package/src/models/components/creditborrowparams.ts

@@ -56,12 +56,20 @@ export type CreditBorrowParams = {
    * ``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;
   /**
    * Euler only: the EVK vault to borrow from. Required when protocol=EULER.
    */
   borrowVault?: string | null | undefined;
+  /**
+   * Morpho only: the bytes32 market id (from /v2/credit/morpho_markets). Required when protocol=MORPHO.
+   */
+  marketId?: string | null | undefined;
 };
 
 /** @internal */
@@ -91,6 +99,7 @@ export type CreditBorrowParams$Outbound = {
   fee?: CreditFee$Outbound | null | undefined;
   protocol?: string | undefined;
   borrow_vault?: string | null | undefined;
+  market_id?: string | null | undefined;
 };
 
 /** @internal */
@@ -106,11 +115,13 @@ export const CreditBorrowParams$outboundSchema: z.ZodType<
   fee: z.nullable(CreditFee$outboundSchema).optional(),
   protocol: CreditProtocol$outboundSchema.optional(),
   borrowVault: z.nullable(z.string()).optional(),
+  marketId: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     actionType: "action_type",
     interestRateMode: "interest_rate_mode",
     borrowVault: "borrow_vault",
+    marketId: "market_id",
   });
 });
 

package/src/models/components/creditborrowrequest.ts

@@ -51,6 +51,10 @@ export type CreditBorrowRequest = {
    * ``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;
   /**
@@ -61,6 +65,10 @@ export type CreditBorrowRequest = {
    * Euler only: the EVK vault to borrow from. Required when protocol=EULER.
    */
   borrowVault?: string | null | undefined;
+  /**
+   * Morpho only: the bytes32 market id (from /v2/credit/morpho_markets). Required when protocol=MORPHO.
+   */
+  marketId?: string | null | undefined;
   /**
    * Token currently held in the Credit Account to use as input. If the same as collateral_token, no swap is performed. Omit together with amount_in and collateral_token to borrow against existing collateral.
    */
@@ -176,6 +184,7 @@ export type CreditBorrowRequest$Outbound = {
   protocol?: string | undefined;
   collateral_vault?: string | null | undefined;
   borrow_vault?: string | null | undefined;
+  market_id?: string | null | undefined;
   token_in?: string | null | undefined;
   amount_in?: number | string | null | undefined;
   collateral_token?: string | null | undefined;
@@ -201,6 +210,7 @@ export const CreditBorrowRequest$outboundSchema: z.ZodType<
   protocol: CreditProtocol$outboundSchema.optional(),
   collateralVault: z.nullable(z.string()).optional(),
   borrowVault: z.nullable(z.string()).optional(),
+  marketId: z.nullable(z.string()).optional(),
   tokenIn: z.nullable(z.string()).optional(),
   amountIn: z.nullable(z.union([z.number(), z.string()])).optional(),
   collateralToken: z.nullable(z.string()).optional(),
@@ -217,6 +227,7 @@ export const CreditBorrowRequest$outboundSchema: z.ZodType<
   return remap$(v, {
     collateralVault: "collateral_vault",
     borrowVault: "borrow_vault",
+    marketId: "market_id",
     tokenIn: "token_in",
     amountIn: "amount_in",
     collateralToken: "collateral_token",

package/src/models/components/creditenablecollateralparams.ts

@@ -31,6 +31,10 @@ export type CreditEnableCollateralParams = {
    * ``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;
   /**

package/src/models/components/creditloopedpositionsresponse.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 {
+  AccountSummary,
+  AccountSummary$inboundSchema,
+} from "./accountsummary.js";
+import {
+  LoopedPosition,
+  LoopedPosition$inboundSchema,
+} from "./loopedposition.js";
+
+/**
+ * Looped positions across Aave V3 and Morpho Blue for a credit account.
+ */
+export type CreditLoopedPositionsResponse = {
+  /**
+   * The credit product account address derived from the owner.
+   */
+  creditAccountAddress: string;
+  /**
+   * All looped positions, on both Aave and Morpho.
+   */
+  positions?: Array<LoopedPosition> | undefined;
+  /**
+   * Aave account-level summary (health factor, LTV, borrow capacity). Present when the account holds any open Aave looped position, since Aave collateral is pooled and health is account-level. Null for Morpho-only accounts.
+   */
+  aaveAccountSummary?: AccountSummary | null | undefined;
+};
+
+/** @internal */
+export const CreditLoopedPositionsResponse$inboundSchema: z.ZodType<
+  CreditLoopedPositionsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  credit_account_address: z.string(),
+  positions: z.array(LoopedPosition$inboundSchema).optional(),
+  aave_account_summary: z.nullable(AccountSummary$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "credit_account_address": "creditAccountAddress",
+    "aave_account_summary": "aaveAccountSummary",
+  });
+});
+
+export function creditLoopedPositionsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditLoopedPositionsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditLoopedPositionsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditLoopedPositionsResponse' from JSON`,
+  );
+}

package/src/models/components/creditlooppreview.ts

@@ -0,0 +1,86 @@
+/*
+ * 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 {
+  LoopLegPreview,
+  LoopLegPreview$inboundSchema,
+} from "./looplegpreview.js";
+
+/**
+ * Projected end state of the loop, computed on GUARANTEED swap floors.
+ */
+export type CreditLoopPreview = {
+  /**
+   * Number of loop iterations bundled.
+   */
+  iterations: number;
+  /**
+   * Guaranteed minimum total collateral supplied (token units); actual can only be higher (swap fills above the floor become dust).
+   */
+  totalCollateralSupplied: string;
+  /**
+   * Total loan tokens borrowed across iterations.
+   */
+  totalBorrowed: string;
+  /**
+   * Guaranteed leverage floor: total_collateral_supplied / initial_collateral_amount.
+   */
+  achievedMultiplier: string;
+  /**
+   * Projected end loan-to-value in percent, at the sizing oracle prices.
+   */
+  projectedLtv: string;
+  /**
+   * Projected health factor (liquidation threshold / projected LTV). Below 1 would be liquidatable — the request is rejected long before that.
+   */
+  projectedHealthFactor: string;
+  /**
+   * Upper bound of collateral-token surplus the swaps can leave in the Credit Account (sum of quote − guaranteed floor per swap). It is bounded by max_slippage_percent per iteration, stays in the account, and is never lost.
+   */
+  estimatedMaxDust: string;
+  /**
+   * Per-iteration breakdown.
+   */
+  legs?: Array<LoopLegPreview> | undefined;
+};
+
+/** @internal */
+export const CreditLoopPreview$inboundSchema: z.ZodType<
+  CreditLoopPreview,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  iterations: z.number().int(),
+  total_collateral_supplied: z.string(),
+  total_borrowed: z.string(),
+  achieved_multiplier: z.string(),
+  projected_ltv: z.string(),
+  projected_health_factor: z.string(),
+  estimated_max_dust: z.string(),
+  legs: z.array(LoopLegPreview$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "total_collateral_supplied": "totalCollateralSupplied",
+    "total_borrowed": "totalBorrowed",
+    "achieved_multiplier": "achievedMultiplier",
+    "projected_ltv": "projectedLtv",
+    "projected_health_factor": "projectedHealthFactor",
+    "estimated_max_dust": "estimatedMaxDust",
+  });
+});
+
+export function creditLoopPreviewFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditLoopPreview, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditLoopPreview$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditLoopPreview' from JSON`,
+  );
+}