@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

package/dist/types/onchain/accounts/intents/tail.d.ts

@@ -1,10 +1,16 @@
 import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
 import { OnchainSDK } from "../../OnchainSDK.js";
-import { CreditAccountSlice, DelayedStart, OperationState, ResumableIntent } from "./types.js";
 import { AccountCalculatorOperation, StartDelayedWithdrawalOperation } from "./operations.js";
+import { ClaimRemainder, CreditAccountSlice, DelayedStart, OperationState, ResumableIntent } from "./types.js";
 import "../../index.js";
 import { AccountView, Step } from "./plan.js";
 //#region src/onchain/accounts/intents/tail.d.ts
+/** The steps a claim leads to, and what it left behind for a later one. */
+interface TailPlan {
+  steps: Step[];
+  /** {@inheritDoc ClaimRemainder} */
+  remainder: ClaimRemainder | undefined;
+}
 /**
  * The second half of a delayed intent: the claim, then whatever the intent
  * still owes.
@@ -12,12 +18,16 @@ import { AccountView, Step } from "./plan.js";
  * Shared by the two callers that need it and must not disagree — the tail as
  * it is previewed days later against the account that really exists, and the
  * tail as it is projected the moment the request is made.
+ *
+ * A claim that brought only part of what was queued is served in proportion,
+ * see {@link partialTail}: the intent's payout and its repayment are cut to the
+ * share that arrived, and the rest of both is handed to the next claim.
  */
 declare function planTail(args: {
   intent: ResumableIntent;
   claimable: ClaimableWithdrawal;
   view: AccountView;
-}): Step[];
+}): TailPlan;
 /**
  * Where a delayed intent ends up, worked out at the moment it is started.
  *
@@ -49,4 +59,4 @@ declare function projectTail(args: {
   operations: AccountCalculatorOperation[];
 }>;
 //#endregion
-export { planTail, projectTail };
+export { TailPlan, planTail, projectTail };

package/dist/types/onchain/accounts/intents/testing/expect.d.ts

@@ -1,8 +1,8 @@
 import { TokenAmount } from "../../../../model/primitives.js";
 import "../../../../model/index.js";
 import { MultiCall } from "../../../types/transactions.js";
-import { DelayedStartResult, IntentPreviewResult, OperationState } from "../types.js";
 import { AccountCalculatorOperation } from "../operations.js";
+import { DelayedStartResult, IntentPreviewResult, OperationState } from "../types.js";
 import "../../../index.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/testing/expect.d.ts
@@ -34,7 +34,7 @@ declare function expectCallsArrayExact(calls: MultiCall[], expected: MultiCall[]
  */
 declare function expectAdjustPreview(result: IntentPreviewResult | DelayedStartResult, args: {
   totalValue: bigint;
-  accountDebt: bigint;
+  totalDebt: bigint;
   expectedOps: ExpectedFlowOp[];
   expectedCalls?: MultiCall[];
 }): OperationState;
@@ -42,7 +42,11 @@ declare function expectAdjustPreview(result: IntentPreviewResult | DelayedStartR
 declare function expectPreviewError(result: IntentPreviewResult | DelayedStartResult, reason: Extract<IntentPreviewResult, {
   ok: false;
 }>["reason"]): void;
-/** What a priced holdings list says the account holds of `token`. */
+/**
+ * What a priced list — holdings or quotas — says the account stands at for
+ * `token`. A quota is denominated in the market underlying, so this reads the
+ * quota bought *for* `token`, not an amount of it.
+ */
 declare function assetBalance(assets: Array<TokenAmount>, token: Address): bigint;
 //#endregion
 export { ExpectedFlowOp };

package/dist/types/onchain/accounts/intents/testing/market.d.ts

@@ -42,7 +42,11 @@ interface MarketSdkExtras {
   rwaAssets?: Record<Address, Address>;
   /** Additional / overriding token prices (PRICE_DECIMALS_POW-scaled). */
   extraPrices?: Record<Address, bigint>;
-  /** Reserve feed prices; the fixture market has none by default. */
+  /**
+   * Reserve feed prices. Defaults to the same map as the main feeds, i.e.
+   * trusted tokens. Pass `{}` for a market with no reserve feeds, or a
+   * partial map for a mix of trusted and untrusted tokens.
+   **/
   reservePrices?: Record<Address, bigint>;
   /** Additional / overriding token decimals. */
   extraDecimals?: Record<Address, number>;
@@ -72,6 +76,9 @@ interface MarketSdkExtras {
   maxDebtPerBlockMultiplier?: number;
   /** Tokens the facade forbids. */
   forbiddenTokens?: Address[];
+  /** What a routed swap returns; linear when omitted. */
+  routeQuote?: (amount: bigint) => bigint;
+  routeFloor?: (amount: bigint) => bigint;
 }
 /** Mock SDK on the shared fixture market. */
 declare function buildMarketSdk(extras?: MarketSdkExtras): OnchainSDK;
@@ -84,7 +91,7 @@ declare function valueInUnd(amount: bigint, token: Address, overrides?: {
 declare function caToken(token: Address, balance: bigint, quota?: bigint): CreditAccountSlice["tokens"][number];
 /** Bare CA slice on the fixture market. */
 declare function buildFixtureCreditAccount(args: {
-  accountDebt: bigint;
+  totalDebt: bigint;
   tokens: CreditAccountSlice["tokens"];
 }): CreditAccountSlice;
 //#endregion

package/dist/types/onchain/accounts/intents/testing/sdk-mock.d.ts

@@ -1,3 +1,5 @@
+import { Curator } from "../../../../model/curators.js";
+import "../../../../model/index.js";
 import { MultiCall } from "../../../types/transactions.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
 import { CreditAccountSlice } from "../types.js";
@@ -13,6 +15,21 @@ import { Address } from "viem";
  * from their inputs, so `result.calls` pins down which ops reached the
  * assembler and in which order.
  */
+/**
+ * Curator of the mock market: an unknown market configurator, so it carries no
+ * display name and no page — what the on-chain source answers for a
+ * configurator outside the curated table.
+ */
+declare const MOCK_CURATOR: Curator;
+/**
+ * Liquidation fees of the mock suite: a 3% premium (the manager reports its
+ * complement) on top of a 1.5% protocol fee, so the discount a screen shows is
+ * 450bps.
+ */
+declare const MOCK_LIQUIDATION_FEES: {
+  feeLiquidation: number;
+  liquidationDiscount: number;
+};
 /** Recognizable router call embedded in routed leg results. */
 declare const MOCK_ROUTER_CALL: MultiCall;
 /** Router call of the many-to-one leg an exit routes. */
@@ -111,9 +128,23 @@ interface BuildMockSdkArgs {
   /**
    * Accounts `accounts.getCreditAccountData` knows, keyed by address. What the
    * prepare layer reads on its own instead of taking a slice from the caller;
-   * `accountDebt` lands as the principal with no interest or fees accrued.
+   * `totalDebt` lands as the principal with no interest or fees accrued.
    */
   creditAccounts?: CreditAccountSlice[];
+  /**
+   * What a routed swap returns for a given input, so a case can quote a market
+   * with depth. The default is linear — every route returns its input — which
+   * reports no price impact at all, since the probe scales down in exactly the
+   * same proportion.
+   */
+  routeQuote?: (amount: bigint) => bigint;
+  /**
+   * The floor a route guarantees, from what it expects to return. The default
+   * quotes no slippage at all — floor and expectation coincide — which is what
+   * every case that is not about the difference between the two wants, since it
+   * keeps the projected state and the amounts in the calls one number.
+   */
+  routeFloor?: (amount: bigint) => bigint;
 }
 /** One redemption venue of the mock compressor. */
 interface MockDelayedVenue {
@@ -135,8 +166,7 @@ interface MockDelayedVenue {
 /**
  * Mock `OnchainSDK` covering exactly what the intent-service touches:
  * price conversion, quota params, CM/facade lookup and call assembly.
- * Conversion mirrors the legacy price-based math:
- * `amount * price[from] * 10^dec(to) / (price[to] * 10^dec(from))`.
+ * Conversion is a real {@link TestPriceOracle} seeded from the fixture records.
  */
 declare function buildMockSdk(args: BuildMockSdkArgs): OnchainSDK;
 //#endregion

package/dist/types/onchain/accounts/intents/tests/add-collateral.fixtures.d.ts

@@ -21,7 +21,7 @@ interface AddCollateralCase {
   intent: AddCollateralIntent;
   /** Balances already on the account. */
   tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
+  totalDebt: bigint;
   /** Expected TVL in UND after the operation. */
   totalValue: bigint;
   ops: ExpectedFlowOp[];

package/dist/types/onchain/accounts/intents/tests/adjust-leverage.fixtures.d.ts

@@ -24,9 +24,9 @@ declare const QUOTA_DOWN: bigint;
 interface AdjustLeverageCase {
   intent: AdjustLeverageIntent;
   tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
+  totalDebt: bigint;
   totalValue: bigint;
-  accountDebtAfter: bigint;
+  totalDebtAfter: bigint;
   ops: ExpectedFlowOp[];
   rwaAssets?: Record<Address, Address>;
 }

package/dist/types/onchain/accounts/intents/tests/deposit.fixtures.d.ts

@@ -18,9 +18,9 @@ declare const LEV_3X = 300n;
 interface DepositCase {
   intent: DepositStrategyIntent;
   tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
+  totalDebt: bigint;
   totalValue: bigint;
-  accountDebtAfter: bigint;
+  totalDebtAfter: bigint;
   ops: ExpectedFlowOp[];
   rwaAssets?: Record<Address, Address>;
 }
@@ -52,7 +52,7 @@ declare const NATIVE_VALUE = 1000000000000000000n;
  * the addCollateral op.
  */
 declare const case_native_coin: DepositCase;
-declare function buildDepositSdk(c: DepositCase): OnchainSDK;
+declare function buildDepositSdk(c: DepositCase, routeQuote?: (amount: bigint) => bigint): OnchainSDK;
 declare function buildDepositProps(c: DepositCase, sdk: OnchainSDK): {
   intent: DepositStrategyIntent;
   creditAccount: CreditAccountSlice;

package/dist/types/onchain/accounts/intents/tests/withdraw-asset.fixtures.d.ts

@@ -34,7 +34,7 @@ declare const QUOTA_ANY_DELTA: bigint;
 interface WithdrawAssetCase {
   intent: WithdrawAssetIntent;
   tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
+  totalDebt: bigint;
   totalValue: bigint;
   ops: ExpectedFlowOp[];
   rwaAssets?: Record<Address, Address>;

package/dist/types/onchain/accounts/intents/tests/withdraw.fixtures.d.ts

@@ -20,9 +20,9 @@ declare const QUOTA_DELTA: bigint;
 interface WithdrawCase {
   intent: WithdrawStrategyIntent;
   tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
+  totalDebt: bigint;
   totalValue: bigint;
-  accountDebtAfter: bigint;
+  totalDebtAfter: bigint;
   ops: ExpectedFlowOp[];
   rwaAssets?: Record<Address, Address>;
 }

package/dist/types/onchain/accounts/intents/types.d.ts

@@ -1,12 +1,12 @@
-import { Bps, Leverage, TokenAmount } from "../../../model/primitives.js";
+import { TokenAmount } from "../../../model/primitives.js";
 import { DelayedIntent } from "../../../model/delayed-intents.js";
-import { BorrowRateBreakdown } from "../../../model/positions.js";
+import { AccountProjection } from "../../../model/previews.js";
 import "../../../model/index.js";
 import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
-import { Asset } from "../../base/types.js";
 import { RouterCASlice } from "../../router/types.js";
 import { MultiCall } from "../../types/transactions.js";
 import { OnchainSDK } from "../../OnchainSDK.js";
+import { PreviewErrorReason, PreviewRefusal } from "../../validation/refusal.js";
 import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Address } from "viem";
@@ -18,120 +18,98 @@ import { Address } from "viem";
  */
 type CreditAccountSlice = Omit<RouterCASlice, "debt"> & {
   /** either base debt or debt plus interest and fees */
-  accountDebt: bigint;
+  totalDebt: bigint;
 };
-/** Projected account metrics once the operations execute. */
-interface OperationState {
-  /**
-   * Health factor in basis points: below `10000` the account is liquidatable.
-   *
-   * @example `12500` for a health factor of 1.25
-   **/
-  healthFactor: Bps;
-  /**
-   * Cost of the debt, broken down by source.
-   **/
-  borrowRate: BorrowRateBreakdown;
-  /**
-   * Estimated milliseconds until the health factor decays to `10000` under
-   * the current borrow rate, or `null` when the debt carries no rate (or the
-   * account is already liquidatable).
-   **/
-  timeToLiquidation: bigint | null;
-  /**
-   * Price of the single non-underlying collateral at which the account
-   * becomes liquidatable, in the oracle's 8-decimal fixed point, or `null`
-   * when the account holds zero or several non-underlying assets.
-   **/
-  liquidationPrice: bigint | null;
-  /** Account TVL after operation */
-  totalValue: bigint;
-  /**
-   * Account debt after operation: principal plus accrued interest and fees,
-   * the amount it would take to settle the loan — the same quantity the
-   * preview module reports as `debt`.
-   */
-  accountDebt: bigint;
-  /**
-   * Leverage after operation in the read model's convention — `debt / equity`,
-   * as `Position.leverage` reports it — not the calculator's `TVL / collateral`.
-   */
-  leverage: Leverage;
-  /**
-   * What the account holds after the operation, priced: the same shape the
-   * read model and the transaction previews report holdings in, so a caller
-   * showing them needs no registry or oracle of its own.
-   */
-  assets: TokenAmount[];
-  /**
-   * Every quota the account stands at after the operation: the ones the plan
-   * resized as well as the ones it left alone. Tokens it leaves unquoted are
-   * absent rather than present at zero.
-   */
-  quotas: Record<Address, Asset>;
-}
 /**
- * Why a preview could not be produced.
+ * Price impact against three bases: the routed output, net value, total value.
  *
- * Every member is thrown by the engine as an {@link IntentPreviewError}, with
- * the exception of `unsupportedTokenPair` and `noRecordedIntent`, which the
- * prepare namespace reports for a request it can refuse before planning: a
- * route the market does not offer, a claim naming no operation.
+ * In `PERCENTAGE_FACTOR_1KK` (1_000_000 = 100%), negative for a loss — the
+ * legacy 1e6 scale, not the `Bps` the rest of this module speaks.
  */
-type PreviewErrorReason = "debtOutOfRange" | "leverageOutOfRange" | "insufficientSourceBalance" |
-/** Input token is not accepted by the flow (e.g. deposit of a non-underlying). */
-"unsupportedCollateralToken" |
-/**
- * No route for the trade the plan needs: no pool pair between the tokens
- * requested, several and none was picked, or the pathfinder itself found no
- * path for the amounts involved.
- */
-"unsupportedTokenPair" |
+interface PathLossRate {
+  pathPriceImpact: bigint;
+  netValuePriceImpact: bigint;
+  totalValuePriceImpact: bigint;
+}
 /**
- * The intent cannot settle with a delay: the source has no redemption config,
- * the chain has no compressor, or the payout is one the tail cannot serve.
+ * The two prices only a planned walk can quote, carried by every simulation
+ * result beside its projection.
+ *
+ * A calldata preview is asked for neither: it reads a transaction that already
+ * names its amounts, and it reports what that transaction does rather than what
+ * the market charges while a form is open.
  */
-"noDelayedRoute" |
-/** Several redemption venues for the source, and nothing says which. */
-"multipleDelayedWithdrawals" |
-/** A redemption of the same asset is already in flight. */
-"withdrawalInProgress" |
+interface SimulationPrices {
+  /**
+   * What the routed legs lost to market depth. `undefined` where nothing was
+   * routed or nothing could be measured — never a manufactured zero.
+   */
+  priceImpact: PathLossRate | undefined;
+  /**
+   * What the position's collateral costs in the market underlying right now, in
+   * the oracle's 8-decimal fixed point — the same scale and the same pair as
+   * {@link AccountMetrics.liquidationPrice}, so a screen showing both reads
+   * them as one pair.
+   *
+   * `null` where there is no pair to quote: an account holding zero or several
+   * non-underlying assets, or one whose collateral the oracle cannot price.
+   */
+  currentPrice: bigint | null;
+}
 /**
- * The claim names no operation to resume: requested without an intent, or
- * read through a compressor too old to report one.
+ * What the operations leave the account at, in the shared
+ * {@link AccountProjection} vocabulary, plus the prices only a routed walk can
+ * report.
  */
-"noRecordedIntent" |
-/** The facade or the pool behind it is paused: nothing can be done at all. */
-"marketPaused" |
-/** The facade is past its expiration date and takes no more multicalls. */
-"marketExpired" |
+interface OperationState extends AccountProjection, SimulationPrices {}
 /**
- * The pool cannot lend what the plan draws right now — its free liquidity,
- * the manager's debt limit or the per-block cap stands in the way.
+ * What planning an intent yields: the operation chain, the state it projects,
+ * and the calldata that realises it — or the reason the request is not viable.
  */
-"insufficientPoolLiquidity" |
-/** The market takes no more quota for a token the plan wants to hold. */
-"quotaLimitReached" |
-/** The plan would increase the balance of a token the market forbids. */
-"forbiddenToken" |
+type IntentPreviewResult = {
+  ok: true;
+  operations: AccountCalculatorOperation[];
+  state: OperationState;
+  calls: MultiCall[];
+} | PreviewRefusal;
 /**
- * The account would end the transaction owing more than its collateral is
- * worth under liquidation thresholds, which the facade refuses to allow.
+ * What a claim did not bring, when the venue served part of a matured
+ * withdrawal and left the rest of it queued.
+ *
+ * Every issuer the engine was written for answers a redemption whole: one
+ * request, one claim, one tail. A legacy Mellow multivault does not — it pays
+ * out whatever its subvaults hold liquid and queues the remainder, so the claim
+ * burns the phantom it names and mints a fresh one for what is still maturing.
+ * The tail then serves the share that arrived, and this says what is left to
+ * serve later.
  */
-"insufficientCollateral";
+interface ClaimRemainder {
+  /**
+   * The withdrawal position the claim left on the account: the phantom token
+   * standing for the part that has not matured.
+   */
+  inFlight: TokenAmount;
+  /**
+   * The intent to finish with once it does — this one minus what the tail
+   * beside it already served, so finalising twice pays the wallet and the loan
+   * once between them.
+   */
+  intent: ResumableIntent;
+}
 /**
- * What a preview yields: the operation chain, the state it projects, and the
- * calldata that realises it — or the reason the request is not viable.
+ * What finishing a delayed intent yields: {@link IntentPreviewResult}, plus
+ * whether the claim it was built on settled the withdrawal whole.
  */
-type IntentPreviewResult = {
+type FinishIntentResult = (Extract<IntentPreviewResult, {
   ok: true;
-  operations: AccountCalculatorOperation[];
-  preview: OperationState;
-  calls: MultiCall[];
-} | {
-  ok: false;
-  reason: PreviewErrorReason;
-};
+}> & {
+  /**
+   * `undefined` when the claim brought everything the request queued,
+   * which is every venue but a legacy Mellow one, see
+   * {@link ClaimRemainder}.
+   */
+  remainder: ClaimRemainder | undefined;
+}) | PreviewRefusal;
 /** What the request recorded, and when the tail can be run. */
 interface DelayedStart {
   /**
@@ -166,7 +144,7 @@ interface DelayedStart {
    * the phantom of the in-flight redemption in its place, the debt untouched.
    *
    * This is the state the facade judges when the transaction lands, so it is
-   * the one the engine's guards are applied to — while the `preview` beside it
+   * the one the engine's guards are applied to — while the `state` beside it
    * is where the intent ends up, tail included, which is what a caller asking
    * "what does this do to my position" means.
    */
@@ -177,7 +155,7 @@ interface DelayedStart {
  * plus what it recorded for the tail.
  *
  * `operations` and `calls` are the request and nothing else — that is the only
- * transaction there is to send now. `preview`, though, is where the intent
+ * transaction there is to send now. `state`, though, is where the intent
  * ends: the state the account reaches once the redemption matures, is claimed
  * and the tail runs, since that is what the caller asked for when they asked
  * to withdraw. The half-way state the request itself lands in is
@@ -191,13 +169,10 @@ interface DelayedStart {
 type DelayedStartResult = {
   ok: true;
   operations: AccountCalculatorOperation[];
-  preview: OperationState;
+  state: OperationState;
   calls: MultiCall[];
   delayed: DelayedStart;
-} | {
-  ok: false;
-  reason: PreviewErrorReason;
-};
+} | PreviewRefusal;
 /** An intent previewed through the router: one transaction, settled now. */
 type InstantRoute = Extract<IntentPreviewResult, {
   ok: true;
@@ -235,11 +210,10 @@ type IntentRoutesResult = {
   instant: InstantRoute | undefined;
   delayed: DelayedRoute | undefined;
   refused: RouteRefusals;
-} | {
-  ok: false;
-  reason: PreviewErrorReason;
+} | (PreviewRefusal & {
+  /** {@inheritDoc IntentRoutesResult.refused} */
   refused: RouteRefusals;
-};
+});
 /**
  * The intents the engine previews.
  *
@@ -436,6 +410,40 @@ interface WithdrawStrategyIntent {
    */
   sourceToken?: Address;
 }
+/**
+ * Where a withdraw form's scale ends, in underlying units — and it ends twice.
+ *
+ * A withdrawal is not one continuous range. Holding leverage flat costs a
+ * proportional repayment, and the loan left behind has to clear the facade's
+ * `minDebt`, so the partial flow stops at {@link partial}. Leaving entirely
+ * settles the loan instead of shrinking it, so the floor does not apply and
+ * the whole net value can go. Between the two the flow refuses with
+ * `debtOutOfRange` rather than quietly rounding the request to one end.
+ *
+ * An account borrowing at the floor therefore reports a `partial` of almost
+ * nothing — only the interest accrued above `minDebt` can be repaid — beside
+ * an `exit` of its entire net value. That gap is the market's rule showing
+ * through, not a miscount: such a position frees real money only by leaving.
+ */
+interface WithdrawCeilings {
+  /**
+   * Largest partial withdrawal {@link WithdrawStrategyIntent} accepts: the one
+   * whose proportional repayment leaves the debt at `minDebt`. `0n` when the
+   * debt already sits below the floor, and always at least one unit under
+   * `exit` — the last unit closes the account rather than shrinking it.
+   */
+  partial: bigint;
+  /**
+   * What leaving hands over: the account's net value, which is also the amount
+   * at which a withdrawal turns into an exit. `0n` on an account whose debt
+   * has caught up with its collateral.
+   *
+   * A Max button is better served by sending `MAX_UINT256` than this figure —
+   * the exit is then named outright, and no rounding in the payout token's
+   * price can drop the request back into the refused gap.
+   */
+  exit: bigint;
+}
 type StartIntent = AddCollateralIntent | WithdrawAssetIntent | AdjustLeverageIntent | DepositStrategyIntent | RepayStrategyIntent | WithdrawStrategyIntent;
 /**
  * The intents that can be started as a redemption rather than a swap: the two
@@ -459,14 +467,5 @@ type FinishIntentProps = StartIntentProps & {
    */
   claimable: ClaimableWithdrawal;
 };
-/**
- * Validation failure that maps onto {@link PreviewErrorReason} rather than
- * crashing the caller: thrown by builders, converted to `{ ok: false }` by
- * `CreditAccountOperationsService.startIntent`.
- */
-declare class IntentPreviewError extends Error {
-  readonly reason: PreviewErrorReason;
-  constructor(reason: PreviewErrorReason, message?: string);
-}
 //#endregion
-export { AddCollateralIntent, AdjustLeverageIntent, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, InstantRoute, IntentPreviewError, IntentPreviewResult, IntentRoutesResult, OperationState, PreviewErrorReason, RepayStrategyIntent, ResumableIntent, RouteRefusals, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawStrategyIntent };
+export { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, FinishIntentResult, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, PathLossRate, RepayStrategyIntent, ResumableIntent, RouteRefusals, SimulationPrices, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawCeilings, WithdrawStrategyIntent };

package/dist/types/onchain/accounts/intents/utils/adjust-state-to-snapshot.d.ts

@@ -5,8 +5,8 @@ import { Address } from "viem";
 //#region src/onchain/accounts/intents/utils/adjust-state-to-snapshot.d.ts
 /**
  * Maps an intents {@link OperationState} onto the {@link AccountSnapshot} that
- * position-metric functions take. `accountDebt` is treated as total debt
- * (principal plus accrued interest and fees).
+ * position-metric functions take: the state prices what it reports, a snapshot
+ * only names it.
  **/
 declare function adjustStateToSnapshot(creditManager: Address, state: OperationState): AccountSnapshot;
 //#endregion

package/dist/types/onchain/accounts/intents/utils/credit-account-slice.d.ts

@@ -7,9 +7,9 @@ import { Address } from "viem";
 /**
  * Narrows full account data down to the slice the intent engine operates on.
  *
- * `accountDebt` is the total repayable debt (principal + accrued interest +
- * accrued fees) rather than the principal, because every debt-touching intent
- * settles the full outstanding amount.
+ * `totalDebt` is the total repayable debt (principal + accrued interest +
+ * accrued fees) rather than `CreditAccountData.debt`'s principal, because every
+ * debt-touching intent settles the full outstanding amount.
  *
  * Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
  * behave consistently everywhere downstream.
@@ -19,7 +19,7 @@ declare function toCreditAccountSlice(ca: CreditAccountDataPayload): CreditAccou
  * Reads an account by address and narrows it to {@link CreditAccountSlice}.
  *
  * The shared read model's `StrategyPosition` carries neither `tokens` nor
- * `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so simulating against
+ * `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so preparing against
  * an existing position costs one account read.
  *
  * @throws When the account is not found in the connected markets.

package/dist/types/onchain/accounts/intents/utils/index.d.ts

@@ -1,11 +1,11 @@
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.js";
+import { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
+import { LegProbe, collectPriceImpact, lossRate, startProbe } from "./price-impact.js";
 import { OpenStrategyLeg, RouterPaths, SwapLeg, createOraclePaths, createRouterPaths } from "./router-path.js";
 import { adjustStateToSnapshot } from "./adjust-state-to-snapshot.js";
 import { assembleOperationCalls } from "./assemble-operation-calls.js";
 import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-interest-and-fees.js";
 import { eq, toRouterCaSlice, toTargetDecimals } from "./common.js";
-import { convertAmount } from "./convert-amount.js";
-import { ConvertFn, LedgerSnapshot, OperationLedger } from "./ledger.js";
-import { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
+import { LedgerSnapshot, OperationLedger } from "./ledger.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./quotas-for-update.js";
-export { CandidateToken, ConvertFn, LedgerSnapshot, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, convertAmount, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };
+export { CandidateToken, LedgerSnapshot, LegProbe, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };

package/dist/types/onchain/accounts/intents/utils/ledger.d.ts

@@ -1,9 +1,9 @@
 import { Asset } from "../../../base/types.js";
+import { ConvertFn } from "../../../market/oracle/types.js";
 import { AccountCalculatorOperation } from "../operations.js";
 import "../../../index.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/utils/ledger.d.ts
-type ConvertFn = (token: Address, to: Address, amount: bigint) => bigint;
 /** Account state at one point in an operation chain. */
 interface LedgerSnapshot {
   /** Non-zero balances only, lowercased, in insertion order. */
@@ -38,4 +38,4 @@ declare class OperationLedger {
   apply(op: AccountCalculatorOperation): this;
 }
 //#endregion
-export { ConvertFn, LedgerSnapshot, OperationLedger };
+export { LedgerSnapshot, OperationLedger };