@compass-labs/api-sdk 2.2.100 → 2.2.102

package/src/models/components/creditunloopresponse.ts

@@ -22,14 +22,14 @@ import {
 } from "./unsignedtransaction.js";
 
 /**
- * Which venue priced the swap leg(s): 'one_inch' (market route, slippage-bounded floors) or 'bebop' (firm quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses, 'bebop' means the numbers are INDICATIVE, computed from the firm venue's live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks.
+ * Identifies which route priced the swap leg(s): a DEX AGGREGATOR (pool liquidity, slippage-bounded floors) or a FIRM provider (quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses a firm value means the numbers are INDICATIVE, computed from live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks. This is the authoritative firm-vs-market signal and clients do need to read it: `pricing` is only what was REQUESTED (under 'auto' a firm build can fall back to market transparently), and `quote_expires_at` is absent on every preview — so neither substitutes for this field.
  */
 export const CreditUnloopResponseSwapProvider = {
   OneInch: "one_inch",
   Bebop: "bebop",
 } as const;
 /**
- * Which venue priced the swap leg(s): 'one_inch' (market route, slippage-bounded floors) or 'bebop' (firm quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses, 'bebop' means the numbers are INDICATIVE, computed from the firm venue's live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks.
+ * Identifies which route priced the swap leg(s): a DEX AGGREGATOR (pool liquidity, slippage-bounded floors) or a FIRM provider (quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses a firm value means the numbers are INDICATIVE, computed from live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks. This is the authoritative firm-vs-market signal and clients do need to read it: `pricing` is only what was REQUESTED (under 'auto' a firm build can fall back to market transparently), and `quote_expires_at` is absent on every preview — so neither substitutes for this field.
  */
 export type CreditUnloopResponseSwapProvider = ClosedEnum<
   typeof CreditUnloopResponseSwapProvider
@@ -40,7 +40,7 @@ export type CreditUnloopResponseSwapProvider = ClosedEnum<
  */
 export type CreditUnloopResponse = {
   /**
-   * Unsigned transaction for direct execution by the owner. Present when gas_sponsorship=false — except firm-priced previews (preview=true with swap_provider='bebop'), which carry numbers only: the firm quotes are fetched at execution time, so there is no payload to sign yet.
+   * Unsigned transaction for direct execution by the owner. Present when gas_sponsorship=false — except firm-priced previews (preview=true on a firm-priced build), which carry numbers only: the firm quotes are fetched at execution time, so there is no payload to sign yet.
    */
   transaction?: UnsignedTransaction | null | undefined;
   /**
@@ -48,19 +48,19 @@ export type CreditUnloopResponse = {
    */
   eip712?: BatchedSafeOperationsResponseOutput | null | undefined;
   /**
-   * Projected end state of the unwind, computed on GUARANTEED swap floors.
+   * Projected end state, computed on guaranteed swap floors. Null only on pricing='firm' preview responses whose unwind the firm venue cannot serve: no leg was priced on any venue, and the response carries the firm_available advisory alone.
    */
-  preview: CreditUnloopPreview;
+  preview: CreditUnloopPreview | null;
   /**
-   * Which venue priced the swap leg(s): 'one_inch' (market route, slippage-bounded floors) or 'bebop' (firm quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses, 'bebop' means the numbers are INDICATIVE, computed from the firm venue's live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks.
+   * Identifies which route priced the swap leg(s): a DEX AGGREGATOR (pool liquidity, slippage-bounded floors) or a FIRM provider (quotes, one per swap leg, each partially filled at the leg's size). On preview=true responses a firm value means the numbers are INDICATIVE, computed from live maker price levels without spending any quote; execution fetches the firm quotes at signing time. Always present, including on fallbacks. This is the authoritative firm-vs-market signal and clients do need to read it: `pricing` is only what was REQUESTED (under 'auto' a firm build can fall back to market transparently), and `quote_expires_at` is absent on every preview — so neither substitutes for this field.
    */
   swapProvider?: CreditUnloopResponseSwapProvider | undefined;
   /**
-   * Deadline of the firm swap quotes (the earliest across the unwind's swap legs) — sign and broadcast before it or the transaction reverts on-chain; refresh by re-calling this endpoint (discard the previous payload). Present only on executable swap_provider='bebop' builds; null on previews (no quote is spent for a preview).
+   * Deadline of the firm swap quotes (the earliest across the unwind's swap legs) — sign and broadcast before it or the transaction reverts on-chain; refresh by re-calling this endpoint (discard the previous payload). Present only on executable firm-priced builds; null on previews (no quote is spent for a preview).
    */
   quoteExpiresAt?: Date | null | undefined;
   /**
-   * Preview-only advisory: whether a firm-quote venue can serve this unwind's swap legs (estimated without spending any quote). Present only on preview=true responses; null otherwise.
+   * Preview-only advisory: whether a firm-quote venue can serve this unwind's swap legs (estimated without spending any quote). Present only on preview=true responses; null otherwise. Computed on every policy — including pricing='market', whose preview numbers stay market-priced — so a client that opted out can keep the boundary visible.
    */
   firmAvailable?: boolean | null | undefined;
 };
@@ -79,7 +79,7 @@ export const CreditUnloopResponse$inboundSchema: z.ZodType<
   transaction: z.nullable(UnsignedTransaction$inboundSchema).optional(),
   eip_712: z.nullable(BatchedSafeOperationsResponseOutput$inboundSchema)
     .optional(),
-  preview: CreditUnloopPreview$inboundSchema,
+  preview: z.nullable(CreditUnloopPreview$inboundSchema),
   swap_provider: CreditUnloopResponseSwapProvider$inboundSchema.optional(),
   quote_expires_at: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),

package/src/models/components/creditwithdrawparams.ts

@@ -33,11 +33,24 @@ export type CreditWithdrawParams = {
    * @remarks
    *
    * ``AAVE`` is the default so existing callers (which never send a ``protocol``
-   * field) keep hitting the unchanged Aave code path. ``MORPHO`` identifies Morpho
-   * Blue lending markets by their bytes32 ``market_id``. ``EULER`` identifies Euler
-   * V2 markets by their EVK ``collateral_vault`` + ``borrow_vault`` addresses and
-   * supports isolated per-sub-account positions (``sub_account_id``). All three
-   * support the loop/unloop leverage endpoints.
+   * field) keep hitting the unchanged Aave code path; markets are named by token
+   * symbol. ``MORPHO`` identifies Morpho Blue lending markets by their bytes32
+   * ``market_id``. ``EULER`` identifies Euler V2 markets by their EVK
+   * ``collateral_vault`` + ``borrow_vault`` addresses and supports isolated
+   * per-sub-account positions (``sub_account_id``).
+   *
+   * Deployment is per chain, so a valid protocol can still 422 on a given chain:
+   * AAVE on Ethereum, Base, Arbitrum, BSC and HyperEVM (where it is Hyperlend, the
+   * chain's Aave V3 deployment); MORPHO on Ethereum, Base, Arbitrum and HyperEVM
+   * (where it is Felix); EULER on Ethereum, Base, Arbitrum and BSC.
+   *
+   * All three support ``/v2/credit/loop`` and ``/v2/credit/unloop``. EULER does
+   * NOT: ``/v2/credit/rebalance`` rejects it with a 422, and
+   * ``/v2/credit/looped_positions`` covers only AAVE and MORPHO — an Euler loop is
+   * silently absent there rather than an error, so read it from
+   * ``/v2/credit/positions`` instead. (EULER still appears in the
+   * ``looped_positions`` response enum because this enum is shared; it is never
+   * emitted.)
    */
   protocol?: CreditProtocol | undefined;
   /**

package/src/models/components/debtposition.ts

@@ -31,11 +31,24 @@ export type DebtPosition = {
    * @remarks
    *
    * ``AAVE`` is the default so existing callers (which never send a ``protocol``
-   * field) keep hitting the unchanged Aave code path. ``MORPHO`` identifies Morpho
-   * Blue lending markets by their bytes32 ``market_id``. ``EULER`` identifies Euler
-   * V2 markets by their EVK ``collateral_vault`` + ``borrow_vault`` addresses and
-   * supports isolated per-sub-account positions (``sub_account_id``). All three
-   * support the loop/unloop leverage endpoints.
+   * field) keep hitting the unchanged Aave code path; markets are named by token
+   * symbol. ``MORPHO`` identifies Morpho Blue lending markets by their bytes32
+   * ``market_id``. ``EULER`` identifies Euler V2 markets by their EVK
+   * ``collateral_vault`` + ``borrow_vault`` addresses and supports isolated
+   * per-sub-account positions (``sub_account_id``).
+   *
+   * Deployment is per chain, so a valid protocol can still 422 on a given chain:
+   * AAVE on Ethereum, Base, Arbitrum, BSC and HyperEVM (where it is Hyperlend, the
+   * chain's Aave V3 deployment); MORPHO on Ethereum, Base, Arbitrum and HyperEVM
+   * (where it is Felix); EULER on Ethereum, Base, Arbitrum and BSC.
+   *
+   * All three support ``/v2/credit/loop`` and ``/v2/credit/unloop``. EULER does
+   * NOT: ``/v2/credit/rebalance`` rejects it with a 422, and
+   * ``/v2/credit/looped_positions`` covers only AAVE and MORPHO — an Euler loop is
+   * silently absent there rather than an error, so read it from
+   * ``/v2/credit/positions`` instead. (EULER still appears in the
+   * ``looped_positions`` response enum because this enum is shared; it is never
+   * emitted.)
    */
   protocol?: CreditProtocol | undefined;
   /**

package/src/models/components/loopedposition.ts

@@ -47,11 +47,24 @@ export type LoopedPosition = {
    * @remarks
    *
    * ``AAVE`` is the default so existing callers (which never send a ``protocol``
-   * field) keep hitting the unchanged Aave code path. ``MORPHO`` identifies Morpho
-   * Blue lending markets by their bytes32 ``market_id``. ``EULER`` identifies Euler
-   * V2 markets by their EVK ``collateral_vault`` + ``borrow_vault`` addresses and
-   * supports isolated per-sub-account positions (``sub_account_id``). All three
-   * support the loop/unloop leverage endpoints.
+   * field) keep hitting the unchanged Aave code path; markets are named by token
+   * symbol. ``MORPHO`` identifies Morpho Blue lending markets by their bytes32
+   * ``market_id``. ``EULER`` identifies Euler V2 markets by their EVK
+   * ``collateral_vault`` + ``borrow_vault`` addresses and supports isolated
+   * per-sub-account positions (``sub_account_id``).
+   *
+   * Deployment is per chain, so a valid protocol can still 422 on a given chain:
+   * AAVE on Ethereum, Base, Arbitrum, BSC and HyperEVM (where it is Hyperlend, the
+   * chain's Aave V3 deployment); MORPHO on Ethereum, Base, Arbitrum and HyperEVM
+   * (where it is Felix); EULER on Ethereum, Base, Arbitrum and BSC.
+   *
+   * All three support ``/v2/credit/loop`` and ``/v2/credit/unloop``. EULER does
+   * NOT: ``/v2/credit/rebalance`` rejects it with a 422, and
+   * ``/v2/credit/looped_positions`` covers only AAVE and MORPHO — an Euler loop is
+   * silently absent there rather than an error, so read it from
+   * ``/v2/credit/positions`` instead. (EULER still appears in the
+   * ``looped_positions`` response enum because this enum is shared; it is never
+   * emitted.)
    */
   protocol: CreditProtocol;
   /**

package/src/models/components/rebalancetarget.ts

@@ -40,11 +40,24 @@ export type RebalanceTarget = {
    * @remarks
    *
    * ``AAVE`` is the default so existing callers (which never send a ``protocol``
-   * field) keep hitting the unchanged Aave code path. ``MORPHO`` identifies Morpho
-   * Blue lending markets by their bytes32 ``market_id``. ``EULER`` identifies Euler
-   * V2 markets by their EVK ``collateral_vault`` + ``borrow_vault`` addresses and
-   * supports isolated per-sub-account positions (``sub_account_id``). All three
-   * support the loop/unloop leverage endpoints.
+   * field) keep hitting the unchanged Aave code path; markets are named by token
+   * symbol. ``MORPHO`` identifies Morpho Blue lending markets by their bytes32
+   * ``market_id``. ``EULER`` identifies Euler V2 markets by their EVK
+   * ``collateral_vault`` + ``borrow_vault`` addresses and supports isolated
+   * per-sub-account positions (``sub_account_id``).
+   *
+   * Deployment is per chain, so a valid protocol can still 422 on a given chain:
+   * AAVE on Ethereum, Base, Arbitrum, BSC and HyperEVM (where it is Hyperlend, the
+   * chain's Aave V3 deployment); MORPHO on Ethereum, Base, Arbitrum and HyperEVM
+   * (where it is Felix); EULER on Ethereum, Base, Arbitrum and BSC.
+   *
+   * All three support ``/v2/credit/loop`` and ``/v2/credit/unloop``. EULER does
+   * NOT: ``/v2/credit/rebalance`` rejects it with a 422, and
+   * ``/v2/credit/looped_positions`` covers only AAVE and MORPHO — an Euler loop is
+   * silently absent there rather than an error, so read it from
+   * ``/v2/credit/positions`` instead. (EULER still appears in the
+   * ``looped_positions`` response enum because this enum is shared; it is never
+   * emitted.)
    */
   protocol?: CreditProtocol | undefined;
   /**

package/src/models/components/rebalancetargetpreview.ts

@@ -49,11 +49,24 @@ export type RebalanceTargetPreview = {
    * @remarks
    *
    * ``AAVE`` is the default so existing callers (which never send a ``protocol``
-   * field) keep hitting the unchanged Aave code path. ``MORPHO`` identifies Morpho
-   * Blue lending markets by their bytes32 ``market_id``. ``EULER`` identifies Euler
-   * V2 markets by their EVK ``collateral_vault`` + ``borrow_vault`` addresses and
-   * supports isolated per-sub-account positions (``sub_account_id``). All three
-   * support the loop/unloop leverage endpoints.
+   * field) keep hitting the unchanged Aave code path; markets are named by token
+   * symbol. ``MORPHO`` identifies Morpho Blue lending markets by their bytes32
+   * ``market_id``. ``EULER`` identifies Euler V2 markets by their EVK
+   * ``collateral_vault`` + ``borrow_vault`` addresses and supports isolated
+   * per-sub-account positions (``sub_account_id``).
+   *
+   * Deployment is per chain, so a valid protocol can still 422 on a given chain:
+   * AAVE on Ethereum, Base, Arbitrum, BSC and HyperEVM (where it is Hyperlend, the
+   * chain's Aave V3 deployment); MORPHO on Ethereum, Base, Arbitrum and HyperEVM
+   * (where it is Felix); EULER on Ethereum, Base, Arbitrum and BSC.
+   *
+   * All three support ``/v2/credit/loop`` and ``/v2/credit/unloop``. EULER does
+   * NOT: ``/v2/credit/rebalance`` rejects it with a 422, and
+   * ``/v2/credit/looped_positions`` covers only AAVE and MORPHO — an Euler loop is
+   * silently absent there rather than an error, so read it from
+   * ``/v2/credit/positions`` instead. (EULER still appears in the
+   * ``looped_positions`` response enum because this enum is shared; it is never
+   * emitted.)
    */
   protocol: CreditProtocol;
   /**

package/src/models/components/swapinfo.ts

@@ -15,7 +15,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  *
  * Evidence is token-filtered and executor-proof: the sold (debt) token left the
  * account to a non-protocol counterparty and the bought (collateral) token
- * arrived from a non-protocol counterparty. 1inch fills often settle from an
+ * arrived from a non-protocol counterparty. Aggregator fills often settle from an
  * executor contract, so the router is recorded only when it happens to be the
  * outbound counterparty — it is never required for detection.
  */
@@ -45,7 +45,7 @@ export type SwapInfo = {
    */
   boughtAmount: string;
   /**
-   * The outbound counterparty when it is the 1inch aggregation router. Null when the swap settled from an executor contract (informational only — never required to detect the swap).
+   * The outbound counterparty when it is the swap router itself. Null when the swap settled from an executor contract (informational only — never required to detect the swap).
    */
   router?: string | null | undefined;
 };

package/src/sdk/credit.ts

@@ -65,14 +65,15 @@ export class Credit extends ClientSDK {
    * List looped (leveraged) credit positions
    *
    * @remarks
-   * List looped (leveraged) positions for a credit account owner.
-   *
-   * Detects loops from the account's on-chain history: a transaction containing
-   * lending + borrowing + swap legs is a loop transaction. Returns one position
-   * per Morpho market / Aave collateral+debt reserve pair, each with its complete
-   * per-transaction history, lifetime totals, and live on-chain state (health
-   * factor, USD values, leverage) for open positions. Covers Aave V3 and Morpho
-   * Blue.
+   * List the leveraged positions held by an owner's Credit Account.
+   *
+   * Positions are reconstructed from on-chain history rather than from API calls,
+   * so a loop assembled by hand through /v2/credit/bundle is recognised the same
+   * way as one opened through /v2/credit/loop. Only activity inside the Credit
+   * Account is visible — leverage the owner holds directly in their wallet is not.
+   *
+   * See the [Leveraged Looping guide](https://docs.compasslabs.ai/v2/Products/Looping)
+   * for protocol coverage and how to read leverage, health factor and net APY.
    */
   async creditLoopedPositions(
     request: operations.V2CreditLoopedPositionsRequest,
@@ -163,7 +164,7 @@ export class Credit extends ClientSDK {
    * Bundles an optional swap, collateral supply, and borrow into a single atomic Safe transaction.
    *
    * - If `token_in` equals `collateral_token`, the tokens are supplied directly as collateral.
-   * - If `token_in` differs from `collateral_token`, a swap is performed first via 1inch.
+   * - If `token_in` differs from `collateral_token`, a market swap is performed first.
    *
    * The Credit Account must already be created via `/v2/credit/create_account` and funded with `token_in`.
    */
@@ -182,30 +183,16 @@ export class Credit extends ClientSDK {
    * Open a leveraged loop
    *
    * @remarks
-   * Open a leveraged loop into an Aave or Morpho market in ONE atomic transaction.
-   *
-   * Repeatedly supplies collateral, borrows at the requested loan-to-value, and
-   * swaps the borrow back to collateral. Each iteration's supply uses the swap's
-   * GUARANTEED minimum output (enforced on-chain), so a fill anywhere within the
-   * slippage tolerance can never break a later step; any positive surplus stays
-   * in the Credit Account (the preview reports the bound as estimated_max_dust).
-   * Very large loops relative to pool depth can still exceed the slippage
-   * tolerance through their own cumulative price impact — size accordingly or
-   * raise max_slippage_percent. Conversely, the geometric tail can shrink below
-   * the swap router's minimum routable size; when it does the loop simply ends
-   * early on that supply — the achieved multiplier is still guaranteed within
-   * 0.5% of the request or the call returns a clean 400.
-   *
-   * When the collateral token is itself an ERC-4626 vault share (e.g. a Morpho
-   * vault token like steakUSDC), each conversion swaps the borrow token to the
-   * vault's underlying asset and mints the shares via the vault's own deposit at
-   * net asset value instead of swapping the share token on a DEX — share tokens
-   * have no honest DEX route. A direct share-token route is only ever used when
-   * it prices within 1% of net asset value.
-   *
-   * The Credit Account must already hold initial_collateral_amount of
-   * collateral_token. For protocol=MORPHO pass a market_id from
-   * /v2/credit/morpho_markets.
+   * Open a leveraged position in ONE atomic transaction.
+   *
+   * Supply collateral, borrow against it, swap the borrowed token back to
+   * collateral, repeat — until total collateral reaches multiplier x
+   * initial_collateral_amount. If any step fails the whole transaction reverts,
+   * so a position is never left half-built.
+   *
+   * See the [Leveraged Looping guide](https://docs.compasslabs.ai/v2/Products/Looping)
+   * for chain coverage, market discovery, vault-share collateral, HyperEVM
+   * specifics and the full error list.
    */
   async creditLoop(
     request: components.CreditLoopRequest,
@@ -222,46 +209,15 @@ export class Credit extends ClientSDK {
    * Unwind a leveraged loop
    *
    * @remarks
-   * Unwind an Aave or Morpho loop in ONE atomic transaction.
-   *
-   * Repeatedly withdraws collateral, swaps it to the borrow token at a GUARANTEED
-   * minimum output (enforced on-chain), and repays. The floor discipline means a
-   * swap filling anywhere within the slippage tolerance can never break a later
-   * step; any positive surplus stays in the Credit Account as borrow-token dust
-   * (the preview reports the bound as estimated_max_dust).
-   *
-   * When the collateral token is itself an ERC-4626 vault share (e.g. a Morpho
-   * vault token like steakUSDC), each conversion redeems the shares through the
-   * vault at net asset value and swaps the underlying asset to the borrow token
-   * instead of swapping the share token on a DEX; a direct share-token route is
-   * only ever used when it prices within 1% of net asset value.
-   *
-   * Omit target_multiplier for a full close: the debt is cleared exactly —
-   * accrued interest included — and the pair collateral is returned to the Credit
-   * Account. Pass 1 to clear the debt but keep the collateral supplied, or a value
-   * above 1 to delever to that multiplier (it must be below the position's current
-   * multiplier).
-   *
-   * Each withdrawal is sized to keep the position's health factor ≥ 1.02 at that
-   * step, so a position opened very close to the liquidation threshold may need
-   * more than one transaction to fully close — set allow_partial=true to return
-   * the maximum single-transaction progress (preview.fully_unwound=false), then
-   * call unloop again to finish. Very large unwinds relative to pool depth can
-   * still exceed the slippage tolerance through their own cumulative price impact.
-   *
-   * Positions are unwound as far as the swap router can route; on a router-minimum
-   * stop the engine still withdraws all collateral not needed to back the residual,
-   * and completes a true full close whenever the unwind's own guaranteed swap
-   * surpluses (or the Credit Account's idle balance) cover the remainder — a
-   * residual below the router's minimum routable size never fails the call, it is
-   * reported honestly in the preview (fully_unwound=false).
-   *
-   * When other open Aave loops share this position's collateral reserve, a full
-   * close withdraws only this position's attributed share of the pooled collateral
-   * (event-ledger bookkeeping), leaving the rest supplied for the other positions.
-   *
-   * For protocol=MORPHO pass a market_id from /v2/credit/morpho_markets; inspect
-   * open loops via /v2/credit/looped_positions.
+   * Unwind a leveraged position in ONE atomic transaction.
+   *
+   * Withdraw collateral, swap it back to the borrow token, repay, repeat — until
+   * the position reaches target_multiplier, or until the debt is cleared exactly
+   * if you omit it. If any step fails the whole transaction reverts.
+   *
+   * See the [Leveraged Looping guide](https://docs.compasslabs.ai/v2/Products/Looping)
+   * for chain coverage, vault-share collateral, shared Aave reserves and the full
+   * error list.
    */
   async creditUnloop(
     request: components.CreditUnloopRequest,
@@ -278,43 +234,20 @@ 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. Conversions involving an
-   * ERC-4626 vault-share token (e.g. a Morpho vault token like steakUSDC) go
-   * through the vault's own deposit/redeem at net asset value rather than a DEX
-   * swap of the share token.
-   *
-   * 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.
-   *
-   * Dust tails and routing swaps below the swap router's minimum routable size do
-   * not fail the call: a releasing target that cannot fully unwind returns its
-   * honest residual in the preview, and an unroutable routing swap is skipped
-   * (its uncovered amount only 422s the rebalance if it breaches the funding
-   * tolerance).
-   *
-   * For protocol=MORPHO pass a market_id from /v2/credit/morpho_markets; inspect the
-   * current book via /v2/credit/looped_positions.
+   * Move one or more leveraged positions to the state you want, in ONE atomic
+   * transaction.
+   *
+   * List the positions to change and the end state you want for each. The API
+   * works out whether that means opening, growing, shrinking, delevering or
+   * closing, and does them all together.
+   *
+   * Money freed by shrinking or closing one position pays for growing or opening
+   * another, so shifting funds between positions needs no new deposit. Any
+   * shortfall is taken from the Credit Account's idle balance, and the call
+   * returns 422 if that does not cover it either.
+   *
+   * See the [Leveraged Looping guide](https://docs.compasslabs.ai/v2/Products/Looping)
+   * for protocol and chain coverage, capital routing and the full error list.
    */
   async creditRebalance(
     request: components.CreditRebalanceRequest,
@@ -363,7 +296,7 @@ export class Credit extends ClientSDK {
    * Bundles repayment, collateral withdrawal, and an optional swap into a single atomic Safe transaction.
    *
    * - If `token_out` is None or equals `withdraw_token`, the withdrawn collateral is kept as-is.
-   * - If `token_out` differs from `withdraw_token`, a swap is performed after withdrawal via 1inch.
+   * - If `token_out` differs from `withdraw_token`, a market swap is performed after withdrawal.
    *
    * The Credit Account must already have a borrow position created via `/v2/credit/borrow`.
    * The repay_token must be available in the Credit Account (or pulled from EOA via Permit2).