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

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/creditborrowparams.ts

@@ -66,6 +66,10 @@ export type CreditBorrowParams = {
    * 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 */
@@ -95,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 */
@@ -110,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

@@ -65,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.
    */
@@ -180,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;
@@ -205,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(),
@@ -221,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/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`,
+  );
+}

package/src/models/components/creditlooprequest.ts

@@ -0,0 +1,235 @@
+/*
+ * 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 {
+  CreditProtocol,
+  CreditProtocol$outboundSchema,
+} from "./creditprotocol.js";
+
+/**
+ * Collateral (in token units) already held in the Credit Account to seed the loop.
+ */
+export type CreditLoopRequestInitialCollateralAmount = number | string;
+
+/**
+ * Target leverage: total collateral exposure = multiplier × initial_collateral_amount. Must be achievable at the requested loan_to_value (max ≈ 0.9 / (1 − LTV)).
+ */
+export type CreditLoopRequestMultiplier = number | string;
+
+/**
+ * Per-iteration borrow LTV in percent. Must not exceed the protocol's maximum for the market (Aave reserve/e-mode LTV; Morpho LLTV with a safety margin); borrows are sized slightly inside the requested value so no leg sits on the protocol's revert boundary.
+ */
+export type CreditLoopRequestLoanToValue = number | string;
+
+/**
+ * Per-swap slippage tolerance in percent. Loop dust is bounded by this per iteration, so tighter slippage means less dust.
+ */
+export type CreditLoopRequestMaxSlippagePercent = number | string;
+
+/**
+ * Open a leveraged loop: repeatedly supply collateral, borrow, and swap the
+ *
+ * @remarks
+ * borrow back to collateral — all in ONE atomic transaction from the Credit
+ * Account.
+ */
+export type CreditLoopRequest = {
+  /**
+   * The address that owns the Credit Account.
+   */
+  owner: string;
+  /**
+   * The chain to use.
+   */
+  chain: Chain;
+  /**
+   * 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 each iteration. Must already be in the Credit Account for the initial amount. For MORPHO it must be the market's collateral token.
+   */
+  collateralToken: string;
+  /**
+   * Token borrowed each iteration and swapped back to the collateral token. For MORPHO it must be the market's loan token.
+   */
+  borrowToken: string;
+  /**
+   * Collateral (in token units) already held in the Credit Account to seed the loop.
+   */
+  initialCollateralAmount: number | string;
+  /**
+   * Target leverage: total collateral exposure = multiplier × initial_collateral_amount. Must be achievable at the requested loan_to_value (max ≈ 0.9 / (1 − LTV)).
+   */
+  multiplier: number | string;
+  /**
+   * Per-iteration borrow LTV in percent. Must not exceed the protocol's maximum for the market (Aave reserve/e-mode LTV; Morpho LLTV with a safety margin); borrows are sized slightly inside the requested value so no leg sits on the protocol's revert boundary.
+   */
+  loanToValue: number | string;
+  /**
+   * Per-swap slippage tolerance in percent. Loop dust is bounded by this per iteration, so tighter slippage means less dust.
+   */
+  maxSlippagePercent?: number | string | undefined;
+  /**
+   * Aave only: e-mode category to enable before looping (higher LTV for correlated pairs, e.g. ETH-correlated).
+   */
+  emodeCategory?: number | null | undefined;
+  /**
+   * If true, returns EIP-712 typed data for gas-sponsored execution instead of an unsigned transaction.
+   */
+  gasSponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export type CreditLoopRequestInitialCollateralAmount$Outbound = number | string;
+
+/** @internal */
+export const CreditLoopRequestInitialCollateralAmount$outboundSchema: z.ZodType<
+  CreditLoopRequestInitialCollateralAmount$Outbound,
+  z.ZodTypeDef,
+  CreditLoopRequestInitialCollateralAmount
+> = z.union([z.number(), z.string()]);
+
+export function creditLoopRequestInitialCollateralAmountToJSON(
+  creditLoopRequestInitialCollateralAmount:
+    CreditLoopRequestInitialCollateralAmount,
+): string {
+  return JSON.stringify(
+    CreditLoopRequestInitialCollateralAmount$outboundSchema.parse(
+      creditLoopRequestInitialCollateralAmount,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditLoopRequestMultiplier$Outbound = number | string;
+
+/** @internal */
+export const CreditLoopRequestMultiplier$outboundSchema: z.ZodType<
+  CreditLoopRequestMultiplier$Outbound,
+  z.ZodTypeDef,
+  CreditLoopRequestMultiplier
+> = z.union([z.number(), z.string()]);
+
+export function creditLoopRequestMultiplierToJSON(
+  creditLoopRequestMultiplier: CreditLoopRequestMultiplier,
+): string {
+  return JSON.stringify(
+    CreditLoopRequestMultiplier$outboundSchema.parse(
+      creditLoopRequestMultiplier,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditLoopRequestLoanToValue$Outbound = number | string;
+
+/** @internal */
+export const CreditLoopRequestLoanToValue$outboundSchema: z.ZodType<
+  CreditLoopRequestLoanToValue$Outbound,
+  z.ZodTypeDef,
+  CreditLoopRequestLoanToValue
+> = z.union([z.number(), z.string()]);
+
+export function creditLoopRequestLoanToValueToJSON(
+  creditLoopRequestLoanToValue: CreditLoopRequestLoanToValue,
+): string {
+  return JSON.stringify(
+    CreditLoopRequestLoanToValue$outboundSchema.parse(
+      creditLoopRequestLoanToValue,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditLoopRequestMaxSlippagePercent$Outbound = number | string;
+
+/** @internal */
+export const CreditLoopRequestMaxSlippagePercent$outboundSchema: z.ZodType<
+  CreditLoopRequestMaxSlippagePercent$Outbound,
+  z.ZodTypeDef,
+  CreditLoopRequestMaxSlippagePercent
+> = z.union([z.number(), z.string()]);
+
+export function creditLoopRequestMaxSlippagePercentToJSON(
+  creditLoopRequestMaxSlippagePercent: CreditLoopRequestMaxSlippagePercent,
+): string {
+  return JSON.stringify(
+    CreditLoopRequestMaxSlippagePercent$outboundSchema.parse(
+      creditLoopRequestMaxSlippagePercent,
+    ),
+  );
+}
+
+/** @internal */
+export type CreditLoopRequest$Outbound = {
+  owner: string;
+  chain: string;
+  protocol?: string | undefined;
+  market_id?: string | null | undefined;
+  collateral_token: string;
+  borrow_token: string;
+  initial_collateral_amount: number | string;
+  multiplier: number | string;
+  loan_to_value: number | string;
+  max_slippage_percent?: number | string | undefined;
+  emode_category?: number | null | undefined;
+  gas_sponsorship?: boolean | undefined;
+};
+
+/** @internal */
+export const CreditLoopRequest$outboundSchema: z.ZodType<
+  CreditLoopRequest$Outbound,
+  z.ZodTypeDef,
+  CreditLoopRequest
+> = z.object({
+  owner: z.string(),
+  chain: Chain$outboundSchema,
+  protocol: CreditProtocol$outboundSchema.optional(),
+  marketId: z.nullable(z.string()).optional(),
+  collateralToken: z.string(),
+  borrowToken: z.string(),
+  initialCollateralAmount: z.union([z.number(), z.string()]),
+  multiplier: z.union([z.number(), z.string()]),
+  loanToValue: z.union([z.number(), z.string()]),
+  maxSlippagePercent: z.union([z.number(), z.string()]).optional(),
+  emodeCategory: z.nullable(z.number().int()).optional(),
+  gasSponsorship: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    marketId: "market_id",
+    collateralToken: "collateral_token",
+    borrowToken: "borrow_token",
+    initialCollateralAmount: "initial_collateral_amount",
+    loanToValue: "loan_to_value",
+    maxSlippagePercent: "max_slippage_percent",
+    emodeCategory: "emode_category",
+    gasSponsorship: "gas_sponsorship",
+  });
+});
+
+export function creditLoopRequestToJSON(
+  creditLoopRequest: CreditLoopRequest,
+): string {
+  return JSON.stringify(
+    CreditLoopRequest$outboundSchema.parse(creditLoopRequest),
+  );
+}

package/src/models/components/creditloopresponse.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 {
+  CreditLoopPreview,
+  CreditLoopPreview$inboundSchema,
+} from "./creditlooppreview.js";
+import {
+  UnsignedTransaction,
+  UnsignedTransaction$inboundSchema,
+} from "./unsignedtransaction.js";
+
+/**
+ * The atomic loop transaction plus its guaranteed-floor preview.
+ */
+export type CreditLoopResponse = {
+  /**
+   * Unsigned transaction for direct execution by the owner. Present when gas_sponsorship=false.
+   */
+  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 loop, computed on GUARANTEED swap floors.
+   */
+  preview: CreditLoopPreview;
+};
+
+/** @internal */
+export const CreditLoopResponse$inboundSchema: z.ZodType<
+  CreditLoopResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  transaction: z.nullable(UnsignedTransaction$inboundSchema).optional(),
+  eip_712: z.nullable(BatchedSafeOperationsResponseOutput$inboundSchema)
+    .optional(),
+  preview: CreditLoopPreview$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "eip_712": "eip712",
+  });
+});
+
+export function creditLoopResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditLoopResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditLoopResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditLoopResponse' from JSON`,
+  );
+}

package/src/models/components/creditrepayparams.ts

@@ -57,6 +57,10 @@ export type CreditRepayParams = {
    * Euler only: the EVK vault the debt is owed to. 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 */
@@ -85,6 +89,7 @@ export type CreditRepayParams$Outbound = {
   interest_rate_mode?: string | undefined;
   protocol?: string | undefined;
   borrow_vault?: string | null | undefined;
+  market_id?: string | null | undefined;
 };
 
 /** @internal */
@@ -99,11 +104,13 @@ export const CreditRepayParams$outboundSchema: z.ZodType<
   interestRateMode: InterestRateMode$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/creditrepayrequest.ts

@@ -56,6 +56,10 @@ export type CreditRepayRequest = {
    * Euler only: the EVK vault the debt is owed to (repay target). 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;
   /**
    * Euler only: the EVK collateral vault to withdraw from. Required when protocol=EULER and withdrawing collateral.
    */
@@ -162,6 +166,7 @@ export type CreditRepayRequest$Outbound = {
   chain: string;
   protocol?: string | undefined;
   borrow_vault?: string | null | undefined;
+  market_id?: string | null | undefined;
   collateral_vault?: string | null | undefined;
   repay_token: string;
   repay_amount: number | string;
@@ -186,6 +191,7 @@ export const CreditRepayRequest$outboundSchema: z.ZodType<
   chain: Chain$outboundSchema,
   protocol: CreditProtocol$outboundSchema.optional(),
   borrowVault: z.nullable(z.string()).optional(),
+  marketId: z.nullable(z.string()).optional(),
   collateralVault: z.nullable(z.string()).optional(),
   repayToken: z.string(),
   repayAmount: z.union([z.number(), z.string()]),
@@ -201,6 +207,7 @@ export const CreditRepayRequest$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     borrowVault: "borrow_vault",
+    marketId: "market_id",
     collateralVault: "collateral_vault",
     repayToken: "repay_token",
     repayAmount: "repay_amount",

package/src/models/components/creditsupplyparams.ts

@@ -45,6 +45,10 @@ export type CreditSupplyParams = {
    * Euler only: the EVK collateral vault to supply into. Required when protocol=EULER.
    */
   collateralVault?: string | null | undefined;
+  /**
+   * Morpho only: the bytes32 market id (from /v2/credit/morpho_markets). Required when protocol=MORPHO.
+   */
+  marketId?: string | null | undefined;
 };
 
 /** @internal */
@@ -72,6 +76,7 @@ export type CreditSupplyParams$Outbound = {
   amount: number | string;
   protocol?: string | undefined;
   collateral_vault?: string | null | undefined;
+  market_id?: string | null | undefined;
 };
 
 /** @internal */
@@ -85,10 +90,12 @@ export const CreditSupplyParams$outboundSchema: z.ZodType<
   amount: z.union([z.number(), z.string()]),
   protocol: CreditProtocol$outboundSchema.optional(),
   collateralVault: z.nullable(z.string()).optional(),
+  marketId: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     actionType: "action_type",
     collateralVault: "collateral_vault",
+    marketId: "market_id",
   });
 });