@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

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

@@ -0,0 +1,79 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, WithdrawStrategyIntent } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "../testing/expect.js";
+import { caToken } from "../testing/market.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/tests/withdraw.fixtures.d.ts
+/** 100 UND of value leaving the account. */
+declare const W = 10000000000n;
+/** Payout plus proportional repayment. */
+declare const SPEND: bigint;
+declare const TVL_BEFORE = 200000000000n;
+declare const DEBT_BEFORE = 100000000000n;
+declare const TVL_AFTER: bigint;
+declare const DEBT_AFTER: bigint;
+declare const QUOTA_BEFORE: bigint;
+declare const QUOTA_AFTER: bigint;
+/** Quota ops carry signed deltas. */
+declare const QUOTA_DELTA: bigint;
+interface WithdrawCase {
+  intent: WithdrawStrategyIntent;
+  tokens: ReturnType<typeof caToken>[];
+  accountDebt: bigint;
+  totalValue: bigint;
+  accountDebtAfter: bigint;
+  ops: ExpectedFlowOp[];
+  rwaAssets?: Record<Address, Address>;
+}
+/** Row 1 — S = U, T = U: repay, then hand over the underlying. */
+declare const case_und_und: WithdrawCase;
+/** Row 2 — S = U, T = POS: repay, then route the payout out of the underlying. */
+declare const case_und_pos: WithdrawCase;
+/** Row 3 — S = POS, T = U: both legs land in the underlying, so one swap covers them. */
+declare const case_pos_und: WithdrawCase;
+/** Row 4 — S = T = POS: only the repayment needs routing. */
+declare const case_pos_pos: WithdrawCase;
+/** Row 5 — S = POS, T = POS2: two independent legs out of the same source. */
+declare const case_pos_pos2: WithdrawCase;
+/** RWA market: the underlying payout is force-unwrapped to the asset. */
+declare const case_rwa_payout: WithdrawCase;
+/** Matrix baseline: 10A of position against 8U of debt (2U collateral at 5x). */
+declare const M4_BALANCE = 1000000000n;
+declare const M4_DEBT = 800000000n;
+/** Matrix payout W: 1U. */
+declare const M4_W = 100000000n;
+/** Proportional repayment `dD = D0 * W / C0` = 4U. */
+declare const M4_DD = 400000000n;
+/** Payout plus repayment: 5U liquidated in total. */
+declare const M4_SPEND: bigint;
+/**
+ * Matrix 4.1 — withdraw 1U, source `POS`, payout `UND`.
+ *
+ * MATRIX MISMATCH: the matrix pays out first — `swap → withdrawCollateral →
+ * decreaseDebt → changeQuota`. The engine repays before paying out
+ * (`repay(dD, keep: W)` precedes the payout leg in `planWithdraw`):
+ * `swap → decreaseDebt → withdrawCollateral → changeQuota`. Amounts are
+ * identical; only the order differs.
+ */
+declare const case_matrix_4_1: WithdrawCase;
+/**
+ * Matrix 4.2 — 4.1 on the RWA market: the payout is unwrapped on the way out.
+ *
+ * MATRIX MISMATCH: same ordering divergence as 4.1 — the matrix expects
+ * `swap → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
+ * changeQuota`, the engine repays first:
+ * `swap → decreaseDebt → unwrapRwaCollateral → withdrawCollateral(RWA) →
+ * changeQuota`.
+ */
+declare const case_matrix_4_2: WithdrawCase;
+declare function buildWithdrawSdk(c: WithdrawCase): OnchainSDK;
+declare function buildWithdrawProps(c: WithdrawCase, sdk: OnchainSDK): {
+  intent: WithdrawStrategyIntent;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  slippage: undefined;
+};
+//#endregion
+export { DEBT_AFTER, DEBT_BEFORE, M4_BALANCE, M4_DD, M4_DEBT, M4_SPEND, M4_W, QUOTA_AFTER, QUOTA_BEFORE, QUOTA_DELTA, SPEND, TVL_AFTER, TVL_BEFORE, W, WithdrawCase, buildWithdrawProps, buildWithdrawSdk, case_matrix_4_1, case_matrix_4_2, case_pos_pos, case_pos_pos2, case_pos_und, case_rwa_payout, case_und_pos, case_und_und };

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

@@ -1,14 +1,18 @@
-import { DelayedIntent, RequestableWithdrawal } from "../withdrawal-compressor/types.js";
+import { Bps, Leverage } from "../../../model/primitives.js";
+import { DelayedIntent } from "../../../model/delayed-intents.js";
+import { BorrowRateBreakdown } from "../../../model/positions.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 { AccountCalculatorOperation } from "./operations/types.js";
-import "./operations/index.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Address } from "viem";
 //#region src/sdk/accounts/intents/types.d.ts
 /**
- * Minimal credit-account data needed by resume previews:
+ * Minimal credit-account data an intent is previewed against:
  * account address, CM lookup, underlying for conversion, debt, token balances
  * and initial quotas.
  */
@@ -16,60 +20,417 @@ type CreditAccountSlice = Omit<RouterCASlice, "debt"> & {
   /** either base debt or debt plus interest and fees */
   accountDebt: bigint;
 };
-/** Post-adjust CA metrics. */
-type AdjustState = {
-  kind: "adjust";
+/** 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;
+  /**
+   * Net rate the whole position earns, collateral yield minus borrow cost.
+   **/
+  overallApy: 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 */
+  /**
+   * 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;
   /** Account assets after operation */
   assets: Asset[];
-  /** Account quotas after operation */
+  /**
+   * 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>;
-};
-/** Close state result. */
-type CloseState = {
-  kind: "close";
-  /** Received amount */
-  amount: bigint;
-  /** Conservative receive (min branch / pathfinder floor). */
-  minAmount: bigint;
-  /** Pathfinder underlying on CA after close path; 0n when unknown (instant). */
-  underlyingBalance: bigint;
-};
-type OperationState = AdjustState | CloseState;
-type DelayedBranchKind = "instantSettle" | "partialSettle" | "delayedSettle";
-type DelayedBranchResult = {
-  kind: DelayedBranchKind;
+}
+/**
+ * Why a preview could not be produced.
+ *
+ * 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.
+ */
+type PreviewErrorReason = "debtOutOfRange" | "leverageOutOfRange" | "insufficientSourceBalance" |
+/** Input token is not accepted by the flow (e.g. deposit of a non-underlying). */
+"unsupportedCollateralToken" |
+/** No pool route between the requested pair, or several and none was picked. */
+"unsupportedTokenPair" |
+/**
+ * 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.
+ */
+"noDelayedRoute" |
+/** Several redemption venues for the source, and nothing says which. */
+"multipleDelayedWithdrawals" |
+/** A redemption of the same asset is already in flight. */
+"withdrawalInProgress" |
+/**
+ * The claim names no operation to resume: requested without an intent, read
+ * through a compressor too old to report one, or a full close, which the
+ * engine no longer previews.
+ */
+"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" |
+/**
+ * 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.
+ */
+"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" |
+/**
+ * The account would end the transaction owing more than its collateral is
+ * worth under liquidation thresholds, which the facade refuses to allow.
+ */
+"insufficientCollateral";
+/**
+ * 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.
+ */
+type IntentPreviewResult = {
+  ok: true;
   operations: AccountCalculatorOperation[];
-  preview: {
-    min: OperationState;
-  };
+  preview: OperationState;
   calls: MultiCall[];
-  intent: DelayedIntent;
-  request?: RequestableWithdrawal;
+} | {
+  ok: false;
+  reason: PreviewErrorReason;
 };
-type DelayedErrorReason = "multipleDelayedWithdrawals" | "withdrawalInProgress";
-type InstantBranchResult = {
+/** What the request recorded, and when the tail can be run. */
+interface DelayedStart {
+  /**
+   * The intent written into the request, and decoded back from the claimable
+   * withdrawal at claim time. `prepare.finalize` picks it up from there, and
+   * `CreditAccountOperationsService.finishIntent` is what it feeds.
+   */
+  record: DelayedIntent;
+  /** Unix seconds after which the delayed outputs can be claimed. */
+  claimableAt: bigint;
+  /**
+   * `instant` when the venue served the whole request on the spot, so no claim
+   * will ever arrive to carry the tail. The intent is then left half-done —
+   * nothing repaid, nothing paid out — and the caller wants `startIntent`
+   * instead, which settles all of it in one transaction.
+   */
+  settlement: "instant" | "delayed";
+}
+/**
+ * What the leading half of a delayed intent yields: the request transaction,
+ * plus what it recorded for the tail.
+ */
+type DelayedStartResult = {
+  ok: true;
   operations: AccountCalculatorOperation[];
-  preview: {
-    min: OperationState;
-  };
+  preview: OperationState;
   calls: MultiCall[];
-};
-type InstantErrorReason = "pathNotFound";
-type PreviewErrorResult = {
+  delayed: DelayedStart;
+} | {
   ok: false;
-  reason: "unsupportedFieldPair" | "debtOutOfRange" | "leverageOutOfRange" | "multipleDelayedWithdrawals" | "unsupportedMixedDelayedWithdrawal" | "unsupportedCloseClaimOutput" | "insufficientSourceBalance";
+  reason: PreviewErrorReason;
 };
-interface IntentPreviewSuccessResult {
+/** An intent previewed through the router: one transaction, settled now. */
+type InstantRoute = Extract<IntentPreviewResult, {
+  ok: true;
+}>;
+/** An intent previewed as a redemption: the request now, the tail later. */
+type DelayedRoute = Extract<DelayedStartResult, {
+  ok: true;
+}>;
+/**
+ * Why a route is missing from an {@link IntentRoutesResult}.
+ *
+ * A reason is the engine's refusal — `noDelayedRoute` for a source with no
+ * redemption venue or for a leverage move that settles at once,
+ * `insufficientSourceBalance` for a payout the account cannot fund. `undefined`
+ * next to a missing route means the route could not be quoted at all: the
+ * pathfinder found no way out of the source, or the read behind it failed.
+ */
+interface RouteRefusals {
+  instant: PreviewErrorReason | undefined;
+  delayed: PreviewErrorReason | undefined;
+}
+/**
+ * Both ways one intent can be served, previewed side by side: traded through
+ * the router, which settles in a single transaction, or redeemed through the
+ * source's issuer, which answers now and pays out days later.
+ *
+ * Which of them an account can take depends on the intent and the token it
+ * sells, so both are quoted and a route it cannot take comes back `undefined`
+ * with its refusal in `refused`. Only when neither answers is the request itself
+ * unviable, and then `reason` is the instant route's refusal — the route every
+ * account is expected to have — falling back to the delayed one's.
+ */
+type IntentRoutesResult = {
   ok: true;
-  instant: InstantBranchResult | undefined;
-  instantError: InstantErrorReason | undefined;
-  delayedBranch: DelayedBranchResult | undefined;
-  delayedError: DelayedErrorReason | undefined;
+  instant: InstantRoute | undefined;
+  delayed: DelayedRoute | undefined;
+  refused: RouteRefusals;
+} | {
+  ok: false;
+  reason: PreviewErrorReason;
+  refused: RouteRefusals;
+};
+/**
+ * The intents the engine previews.
+ *
+ * Naming avoids the `withdrawCollateral` collision that exists elsewhere in the
+ * repo. Mapping to the public prepare API:
+ *
+ * | Intent type        | Public name                  | Debt    |
+ * | ------------------ | ---------------------------- | ------- |
+ * | `ADD_COLLATERAL`   | `prepare.addCollateral`      | fixed   |
+ * | `WITHDRAW_ASSET`   | `prepare.withdrawCollateral` | fixed   |
+ * | `ADJUST_LEVERAGE`  | `prepare.adjustLeverage`     | changes |
+ * | `DEPOSIT`          | `prepare.depositStrategy`    | grows   |
+ * | `WITHDRAW`         | `prepare.withdrawStrategy`   | shrinks |
+ * | `REPAY`            | `prepare.repayStrategy`      | shrinks |
+ */
+/** Shared inputs for every start intent. */
+type StartIntentProps = {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /**
+   * Extra quota headroom in PERCENTAGE_FORMAT, to survive price drift between
+   * preview and execution.
+   */
+  quotaReserve: number | undefined;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number | undefined;
+};
+/**
+ * Intent 5 — put the position token straight onto the account.
+ *
+ * Only the position token is accepted (e.g. ACRED): there is no swap and no
+ * RWA wrap leg, so whatever is sent lands as-is. Debt is untouched, therefore
+ * leverage drops and the health factor improves.
+ */
+interface AddCollateralIntent {
+  type: "ADD_COLLATERAL";
+  /** Position token to deposit. */
+  token: Address;
+  amount: bigint;
+  /**
+   * Native value to attach when the deposited token is the market's wrapped
+   * native token and the caller is paying in the native coin.
+   */
+  value?: bigint;
+}
+/**
+ * Intent 4 — move one asset that already sits on the account to the wallet.
+ *
+ * Atomic: no swaps, no debt change, so leverage rises. The only special case is
+ * withdrawing the wrapped underlying of an RWA market, which is force-unwrapped
+ * to `rwa.asset` first because the wrapper itself cannot leave the account.
+ *
+ * @see AdjustLeverageIntent and the `WITHDRAW` intent for the deleveraging
+ * withdrawals, which do change debt.
+ */
+interface WithdrawAssetIntent {
+  type: "WITHDRAW_ASSET";
+  /** Token to withdraw; must already be on the account. */
+  token: Address;
+  amount: bigint;
+  /** Wallet receiving the tokens. */
+  to: Address;
+}
+/**
+ * Intent 6 — retarget leverage while collateral (own funds) stays fixed.
+ *
+ * Because collateral is the invariant, the target leverage pins the new debt:
+ * raising it borrows more and buys the position token, lowering it sells the
+ * position token and repays. TVL moves with the debt; net value does not.
+ */
+interface AdjustLeverageIntent {
+  type: "ADJUST_LEVERAGE";
+  /**
+   * Target total leverage scaled by `LEVERAGE_DECIMALS` (300n = 3x). 100n (1x)
+   * means "no debt".
+   */
+  targetLeverage: bigint;
+  /**
+   * Position token to buy into or sell out of. Defaults to the most valuable
+   * non-phantom, non-underlying balance on the account.
+   */
+  token?: Address;
+}
+/**
+ * Intents 1.1 / 1.2 — deposit into a strategy, growing the position.
+ *
+ * Fresh collateral arrives, debt is drawn on top of it, and the combined
+ * underlying is converted into the position token. The two spec variants differ
+ * only in how much debt is drawn:
+ *
+ * - 1.1, `targetLeverage` omitted: debt grows in proportion, leverage unchanged
+ * - 1.2, `targetLeverage` set: debt grows to hit the new, higher leverage
+ *
+ * Only the market underlying may be deposited. Two exceptions: a wrapped-native
+ * market also accepts the native coin (pass the wrapped token plus `value`), and
+ * an RWA market takes the unwrapped asset (USDC rather than dcUSDC), which this
+ * flow wraps for you.
+ */
+interface DepositStrategyIntent {
+  type: "DEPOSIT";
+  /** Collateral token: the market underlying, or `rwa.asset` on an RWA market. */
+  token: Address;
+  amount: bigint;
+  /** Native value to attach when paying with the native coin. */
+  value?: bigint;
+  /**
+   * Token the position ends up in. Defaults to the most valuable non-phantom,
+   * non-underlying balance already on the account.
+   */
+  positionToken?: Address;
+  /**
+   * Target total leverage scaled by `LEVERAGE_DECIMALS`. Omit to preserve the
+   * account's current leverage.
+   */
+  targetLeverage?: bigint;
+}
+/**
+ * Intent 3 — repay debt with funds from the wallet.
+ *
+ * The mirror of {@link DepositStrategyIntent}: money arrives from outside and
+ * nothing on the account is sold, so collateral value stands still while debt
+ * shrinks. Net value grows by what was repaid, leverage falls, and the health
+ * factor improves — this is the flow that rescues an account, and the only one
+ * that lowers debt without touching the position.
+ *
+ * The market underlying is what a loan is denominated in, so sending it needs
+ * no conversion: it lands and is repaid. Two more forms are accepted, as for a
+ * deposit: a wrapped-native market also takes the native coin (pass the wrapped
+ * token plus `value`), and an RWA market takes the unwrapped asset behind its
+ * underlying, which this flow wraps for you.
+ */
+interface RepayStrategyIntent {
+  type: "REPAY";
+  /** Funding token: the market underlying, or `rwa.asset` on an RWA market. */
+  token: Address;
+  /**
+   * Amount of `token` taken from the wallet. More than the outstanding debt is
+   * allowed — the debt is settled in full and the excess stays on the account
+   * as collateral — which is what lets a caller cover the interest that accrues
+   * between this preview and the transaction.
+   *
+   * `MAX_UINT256` asks for exactly that settlement without naming a figure: the
+   * wallet is charged the debt plus a small margin for the interest still to
+   * come, the facade is told to repay everything outstanding, and the quotas go
+   * with the loan.
+   */
+  amount: bigint;
+  /** Native value to attach when paying with the native coin. */
+  value?: bigint;
+}
+/**
+ * Intent 2.1 — withdraw part of the position's net value at fixed leverage.
+ *
+ * The requested amount leaves the account, and debt is repaid in the same
+ * proportion so leverage is unchanged: `dD = D0 * W / C0`. Both the payout and
+ * the repayment are funded by liquidating the source token, which means the
+ * account must give up `W + dD` of value in total.
+ *
+ * The payout leg and the repayment leg are quoted separately and do not share a
+ * pool, so a shortfall on the payout leg does not eat into the repayment.
+ *
+ * Asking for the whole net value is the exit instead — there is no leverage
+ * left to hold — and the shape changes with it: the quotas are dropped, the
+ * position is sold whole in one many-to-one route, the loan is settled in full
+ * and every remaining balance goes to the wallet. The account survives it,
+ * empty and owing nothing.
+ *
+ * @see WithdrawAssetIntent for moving a single asset out at fixed debt, and
+ * AdjustLeverageIntent for changing leverage without withdrawing.
+ */
+interface WithdrawStrategyIntent {
+  type: "WITHDRAW";
+  /**
+   * Amount the wallet receives, denominated in `tokenOut`. At or above the
+   * account's net value this is an exit, which pays out the underlying the
+   * position was sold into rather than in `tokenOut`.
+   *
+   * `MAX_UINT256` is that exit stated outright, and the amount a "close
+   * position" form sends: no net value has to be read to name it, and no
+   * rounding can turn it back into a withdrawal that leaves dust behind.
+   */
+  amount: bigint;
+  /** Wallet receiving the payout. */
+  to: Address;
+  /**
+   * Token the wallet receives. Defaults to the market underlying — which, on an
+   * RWA market, is force-unwrapped to `rwa.asset` on the way out.
+   */
+  tokenOut?: Address;
+  /**
+   * Token liquidated to fund the withdrawal. Defaults to the most valuable
+   * non-phantom balance on the account, and is ignored by an exit — that sells
+   * every balance there is.
+   */
+  sourceToken?: Address;
+}
+type StartIntent = AddCollateralIntent | WithdrawAssetIntent | AdjustLeverageIntent | DepositStrategyIntent | RepayStrategyIntent | WithdrawStrategyIntent;
+/**
+ * The intents that can be started as a redemption rather than a swap: the two
+ * that sell a position asset. The others buy one, and buying settles at once.
+ */
+type DelayableIntent = AdjustLeverageIntent | WithdrawStrategyIntent;
+/**
+ * A delayed intent this engine knows how to finish.
+ *
+ * `CLOSE_ACCOUNT` is absent on purpose: closing goes through the facade's own
+ * entry point, which this engine no longer builds.
+ */
+type ResumableIntent = Exclude<DelayedIntent, {
+  type: "CLOSE_ACCOUNT";
+}>;
+/** Shared inputs plus the matured withdrawal the tail is built around. */
+type FinishIntentProps = StartIntentProps & {
+  intent: ResumableIntent;
+  /**
+   * The matured withdrawal, as reported by
+   * `sdk.accounts.getPendingWithdrawals`.
+   */
+  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);
 }
-type IntentPreviewResult = IntentPreviewSuccessResult | PreviewErrorResult;
 //#endregion
-export { AdjustState, CloseState, CreditAccountSlice, IntentPreviewResult, OperationState };
+export { AddCollateralIntent, AdjustLeverageIntent, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, InstantRoute, IntentPreviewError, IntentPreviewResult, IntentRoutesResult, OperationState, PreviewErrorReason, RepayStrategyIntent, ResumableIntent, RouteRefusals, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawStrategyIntent };

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

@@ -0,0 +1,13 @@
+import { AccountSnapshot } from "../../../positions/types.js";
+import "../../../positions/index.js";
+import { OperationState } from "../types.js";
+import { Address } from "viem";
+//#region src/sdk/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).
+ **/
+declare function adjustStateToSnapshot(creditManager: Address, state: OperationState): AccountSnapshot;
+//#endregion
+export { adjustStateToSnapshot };

package/dist/types/sdk/accounts/intents/utils/assemble-operation-calls.d.ts

@@ -1,5 +1,5 @@
 import { MultiCall } from "../../../types/transactions.js";
-import { AccountCalculatorOperation } from "../operations/types.js";
+import { AccountCalculatorOperation } from "../operations.js";
 import "../../../index.js";
 //#region src/sdk/accounts/intents/utils/assemble-operation-calls.d.ts
 interface Props {

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

@@ -0,0 +1,29 @@
+import { CreditAccountDataPayload } from "../../../base/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/utils/credit-account-slice.d.ts
+/**
+ * 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.
+ *
+ * Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
+ * behave consistently everywhere downstream.
+ */
+declare function toCreditAccountSlice(ca: CreditAccountDataPayload): CreditAccountSlice;
+/**
+ * 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
+ * an existing position costs one account read.
+ *
+ * @throws When the account is not found in the connected markets.
+ */
+declare function fetchCreditAccountSlice(sdk: OnchainSDK, creditAccount: Address): Promise<CreditAccountSlice>;
+//#endregion
+export { fetchCreditAccountSlice, toCreditAccountSlice };

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

@@ -1,9 +1,11 @@
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.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, simulateOperationAssets } from "./simulate-assets.js";
-import { getQuotasForUpdate } from "./quotas-for-update.js";
-import { SimulateStateReturn, simulateState } from "./simulate-adjust-state.js";
-import { getOperationsWithQuotaUpdate } from "./with-quota-update.js";
-export { ConvertFn, SimulateStateReturn, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, convertAmount, eq, getOperationsWithQuotaUpdate, getQuotasForUpdate, simulateOperationAssets, simulateState, toRouterCaSlice, toTargetDecimals };
+import { ConvertFn, LedgerSnapshot, OperationLedger } from "./ledger.js";
+import { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
+import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./quotas-for-update.js";
+import { OpenStrategyLeg, RouterPaths, SwapLeg, createRouterPaths } from "./router-path.js";
+export { CandidateToken, ConvertFn, LedgerSnapshot, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, convertAmount, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };

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

@@ -0,0 +1,41 @@
+import { Asset } from "../../../base/types.js";
+import { AccountCalculatorOperation } from "../operations.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/sdk/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. */
+  assets: Asset[];
+  /** Sum of `assets` priced in the underlying. */
+  totalValue: bigint;
+  debt: bigint;
+}
+/**
+ * Running account state, advanced one operation at a time.
+ *
+ * Exists because the amounts an operation is built from depend on the balances
+ * the previous ones left behind: a swap has to know how much of its input token
+ * is genuinely swap input, so the router does not sweep collateral that must
+ * stay put. Applying each op as it is built keeps that a single forward pass —
+ * a builder that re-simulated the chain from the start for every leg would be
+ * quadratic in the number of legs and easy to desynchronise.
+ */
+declare class OperationLedger {
+  #private;
+  constructor(args: {
+    initialAssets: readonly Asset[] | Asset[];
+    underlying: Address;
+    debt: bigint;
+    convert: ConvertFn;
+  });
+  get debt(): bigint;
+  balanceOf(token: Address): bigint;
+  applyAll(operations: readonly AccountCalculatorOperation[]): this;
+  snapshot(): LedgerSnapshot;
+  /** Advances the state by one operation; quota changes move no balance. */
+  apply(op: AccountCalculatorOperation): this;
+}
+//#endregion
+export { ConvertFn, LedgerSnapshot, OperationLedger };