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

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,13 +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 "./refusal.js";
+import { PreviewErrorReason, PreviewRefusal } from "../../validation/refusal.js";
 import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Address } from "viem";
@@ -19,68 +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;
+/**
+ * Price impact against three bases: the routed output, net value, total value.
+ *
+ * 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.
+ */
+interface PathLossRate {
+  pathPriceImpact: bigint;
+  netValuePriceImpact: bigint;
+  totalValuePriceImpact: bigint;
+}
+/**
+ * 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.
+ */
+interface SimulationPrices {
   /**
-   * 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.
+   * What the routed legs lost to market depth. `undefined` where nothing was
+   * routed or nothing could be measured — never a manufactured zero.
    */
-  assets: TokenAmount[];
+  priceImpact: PathLossRate | undefined;
   /**
-   * 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.
+   * 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.
    */
-  quotas: Record<Address, Asset>;
+  currentPrice: bigint | null;
 }
 /**
- * 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 the operations leave the account at, in the shared
+ * {@link AccountProjection} vocabulary, plus the prices only a routed walk can
+ * report.
+ */
+interface OperationState extends AccountProjection, SimulationPrices {}
+/**
+ * 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.
  */
 type IntentPreviewResult = {
   ok: true;
   operations: AccountCalculatorOperation[];
-  preview: OperationState;
+  state: OperationState;
   calls: MultiCall[];
 } | PreviewRefusal;
+/**
+ * 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.
+ */
+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 finishing a delayed intent yields: {@link IntentPreviewResult}, plus
+ * whether the claim it was built on settled the withdrawal whole.
+ */
+type FinishIntentResult = (Extract<IntentPreviewResult, {
+  ok: true;
+}> & {
+  /**
+   * `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 {
   /**
@@ -115,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.
    */
@@ -126,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
@@ -140,7 +169,7 @@ interface DelayedStart {
 type DelayedStartResult = {
   ok: true;
   operations: AccountCalculatorOperation[];
-  preview: OperationState;
+  state: OperationState;
   calls: MultiCall[];
   delayed: DelayedStart;
 } | PreviewRefusal;
@@ -381,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
@@ -405,4 +468,4 @@ type FinishIntentProps = StartIntentProps & {
   claimable: ClaimableWithdrawal;
 };
 //#endregion
-export { AddCollateralIntent, AdjustLeverageIntent, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, 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 };

package/dist/types/onchain/accounts/intents/utils/price-impact.d.ts

@@ -0,0 +1,49 @@
+import { Asset } from "../../../base/types.js";
+import { IPriceOracleContract } from "../../../market/oracle/types.js";
+import { PathLossRate } from "../types.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/utils/price-impact.d.ts
+/** One leg's contribution to the preview's impact. */
+interface LegProbe {
+  tokenOut: Address;
+  /**
+   * The real route's `amount`, never its `minAmount`: the floor is a tolerance
+   * the caller chose, not a cost the market charged.
+   */
+  realAmount: bigint;
+  basketWad: bigint;
+  probeWad: bigint;
+  /** Already in flight, and already neutralised — see {@link startProbe}. */
+  probe: Promise<bigint | undefined>;
+}
+/** Fires the marginal-price quote for one leg; `undefined` if it cannot be measured. */
+declare function startProbe(args: {
+  basket: Asset[];
+  tokenOut: Address;
+  oracle: IPriceOracleContract;
+  route: (basket: Asset[]) => Promise<bigint | undefined>;
+}): Omit<LegProbe, "realAmount"> | undefined;
+/**
+ * In `PERCENTAGE_FACTOR_1KK` (1_000_000 = 100%), negative for a loss. A base
+ * that is not positive falls back to the routed output.
+ */
+declare function lossRate(args: {
+  lossUnd: bigint;
+  expectedUnd: bigint;
+  totalValue: bigint;
+  netValue: bigint;
+}): PathLossRate;
+/**
+ * Folds every leg into one rate, in the underlying — the unit its bases are in.
+ *
+ * All or nothing: a partial sum would understate the loss and draw a better
+ * price than the route offers.
+ */
+declare function collectPriceImpact(probes: LegProbe[], ctx: {
+  totalValue: bigint;
+  netValue: bigint;
+  toUnderlying: (from: Address, amount: bigint) => bigint;
+}): Promise<PathLossRate | undefined>;
+//#endregion
+export { LegProbe, collectPriceImpact, lossRate, startProbe };

package/dist/types/onchain/accounts/intents/utils/quotas-for-update.d.ts

@@ -1,8 +1,8 @@
 import { AddressMap } from "../../../utils/AddressMap.js";
 import { Asset } from "../../../base/types.js";
+import { ConvertFn } from "../../../market/oracle/types.js";
 import { QuotaUpdateState } from "../operations.js";
 import "../../../index.js";
-import { ConvertFn } from "./ledger.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/utils/quotas-for-update.d.ts
 interface InitialQuota {

package/dist/types/onchain/accounts/intents/utils/router-path.d.ts

@@ -3,6 +3,7 @@ import { MultiCall } from "../../../types/transactions.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
 import { CreditAccountSlice } from "../types.js";
 import "../../../index.js";
+import { LegProbe } from "./price-impact.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/utils/router-path.d.ts
 /** One routed conversion leg. */
@@ -12,6 +13,14 @@ interface SwapLeg {
   /** Conservative output — the pathfinder floor after slippage. */
   minAmount: bigint;
   calls: MultiCall[];
+  /**
+   * The marginal-price quote this leg is measured against, already in flight.
+   *
+   * Produced here, not by the caller, so the basket cannot drift from the trade
+   * it prices and the quote is always fired before the leg is awaited.
+   * `undefined` where there is nothing to measure.
+   */
+  probe: LegProbe | undefined;
 }
 /** A routed leg that also projects the balances it leaves behind. */
 interface OpenStrategyLeg extends SwapLeg {

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

@@ -7,8 +7,8 @@ import { AccountView } from "./plan.js";
  * The account as the planners see it: a handful of numbers in underlying units
  * plus balance / price lookups. Read once per preview.
  *
- * TVL uses the RWA-aware conversion so an `rwa.asset` balance without a direct
- * pool price still counts at its wrapped value instead of throwing.
+ * TVL uses the market oracle: an unpriceable token contributes 0n rather
+ * than throwing.
  */
 declare function accountView(creditAccount: CreditAccountSlice, sdk: OnchainSDK): AccountView;
 //#endregion

package/dist/types/onchain/accounts/liquidations/LiquidationsService.d.ts

@@ -14,7 +14,6 @@ declare class LiquidationsService extends SDKConstruct {
   /**
    * Returns all liquidatable credit accounts: accounts with health factor
    * below 1 plus accounts of expired credit managers with outstanding debt.
-   * Accounts whose collateral computation failed are excluded.
    **/
   getLiquidatableAccounts(props?: GetLiquidatableAccountsProps): Promise<LiquidatableAccount[]>;
   /**

package/dist/types/onchain/accounts/liquidations/skipLiquidatableAccount.d.ts

@@ -0,0 +1,11 @@
+import { CreditAccountData } from "../../base/types.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/liquidations/skipLiquidatableAccount.d.ts
+/**
+ * Whether a credit account should be dropped from the liquidatable list:
+ * collateral computation failed, or it holds a Mellow withdrawal phantom
+ * token above dust (no liquidation subcompressor for that type).
+ **/
+declare function skipLiquidatableAccount(account: Pick<CreditAccountData, "success" | "tokens">, getContractType: (token: Address) => string | undefined): boolean;
+//#endregion
+export { skipLiquidatableAccount };

package/dist/types/{common-utils/utils/creditAccount → onchain/accounts}/quota-utils.d.ts

@@ -1,8 +1,7 @@
-import { Asset } from "../../../onchain/base/types.js";
-import { QuotaSlice } from "../strategies/strategy-info/types.js";
-import { AssetWithAmountInTarget } from "./types.js";
+import { Asset, AssetWithAmountInTarget } from "../base/types.js";
+import { QuotaSlice } from "../market/credit/types.js";
 import { Address } from "viem";
-//#region src/common-utils/utils/creditAccount/quota-utils.d.ts
+//#region src/onchain/accounts/quota-utils.d.ts
 interface CalcDefaultQuotaProps {
   amount: bigint;
   lt: bigint;