@gearbox-protocol/sdk 16.0.0-next.4 → 16.0.0-next.41

package/dist/types/sdk/accounts/intents/tests/open-strategy.fixtures.d.ts

@@ -1,56 +0,0 @@
-import { Asset } from "../../../base/types.js";
-import { OnchainSDK } from "../../../OnchainSDK.js";
-import { OpenStrategyProps } from "../open-strategy.js";
-import "../../../index.js";
-import { MarketSdkExtras } from "../testing/market.js";
-import { Address } from "viem";
-//#region src/sdk/accounts/intents/tests/open-strategy.fixtures.d.ts
-/**
- * Open-strategy fixtures.
- *
- * `POS` is the target throughout: it is 1:1 with `UND`, so the mock router's
- * oracle-priced output stays readable while the `ANY` leg (18 decimals, half the
- * price) still exercises the rescaling.
- */
-declare const LT = 9200n;
-/** Quota bought for a projected balance: value in UND scaled by its LT. */
-declare function quotaFor(amount: bigint, token: Address): bigint;
-/** 1000 UND of margin. */
-declare const MARGIN_UND: bigint;
-/** 500 UND. */
-declare const HALF_UND: bigint;
-/** 1000 ANY = 500 UND at fixture prices. */
-declare const COLLATERAL_ANY: bigint;
-/** ANY balance to keep unswapped: 400 ANY = 200 UND. */
-declare const KEEP_ANY: bigint;
-declare const LEVERAGE_1X = 100n;
-declare const LEVERAGE_2X = 200n;
-declare const LEVERAGE_3X = 300n;
-interface OpenStrategyCase {
-  collateral: Asset[];
-  targetToken: Address;
-  leverage: bigint;
-  leftoverBalances?: Asset[];
-  /** Margin in UND. */
-  expectedCollateral: bigint;
-  expectedDebt: bigint;
-  /** Balances the account should hold once the path executes. */
-  expectedAssets: Asset[];
-  /** Balances the router should be asked to route (collateral + debt). */
-  expectedRouterBalances: Asset[];
-}
-/** Plain 3x on underlying margin: everything routes into the position token. */
-declare const case_underlying_3x: OpenStrategyCase;
-/** 1x — no loan at all, just a spot conversion of the margin. */
-declare const case_underlying_1x: OpenStrategyCase;
-/**
- * Mixed margin with a leftover: 500 UND + 1000 ANY (= 500 UND) at 2x.
- *
- * 400 ANY stays put, so only 600 ANY (= 300 UND) plus the whole 1500 UND is
- * routed, and the kept ANY needs a quota of its own.
- */
-declare const case_mixed_with_leftover: OpenStrategyCase;
-declare function buildOpenStrategySdk(extras?: MarketSdkExtras): OnchainSDK;
-declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyProps;
-//#endregion
-export { COLLATERAL_ANY, HALF_UND, KEEP_ANY, LEVERAGE_1X, LEVERAGE_2X, LEVERAGE_3X, LT, MARGIN_UND, OpenStrategyCase, buildOpenStrategyProps, buildOpenStrategySdk, case_mixed_with_leftover, case_underlying_1x, case_underlying_3x, quotaFor };

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

@@ -1,60 +0,0 @@
-import { OnchainSDK } from "../../../OnchainSDK.js";
-import { CreditAccountSlice, WithdrawAssetIntent } 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-asset.fixtures.d.ts
-/**
- * Start withdraw-asset fixtures (intent 4), covering the cases from the spec's
- * "withdraw collateral intent" section.
- *
- * Debt never moves, so every case is `withdrawCollateral` plus the quota
- * decrease implied by the smaller balance. The one branch is the RWA market
- * forced unwrap when the withdrawn token is the wrapped underlying.
- */
-declare const LT_ANY = 9200n;
-/** 2000 ANY = 1000 UND at fixture prices. */
-declare const HELD_ANY = 2000000000000000000000n;
-/** 1000 UND. */
-declare const HELD_UND = 100000000000n;
-declare const DEBT = 50000000000n;
-/** Half the ANY position. */
-declare const OUT_ANY = 1000000000000000000000n;
-/**
- * 300 of the 1000 UND held. Not half: the underlying is weighted at 98% in this
- * fixture, so leaving 500 against 500 of debt would end below water and the
- * facade would refuse the withdrawal.
- */
-declare const OUT_UND = 30000000000n;
-declare const QUOTA_ANY_BEFORE: bigint;
-declare const QUOTA_ANY_AFTER: bigint;
-/** Quota ops carry signed deltas, so a release is negative. */
-declare const QUOTA_ANY_DELTA: bigint;
-interface WithdrawAssetCase {
-  intent: WithdrawAssetIntent;
-  tokens: ReturnType<typeof caToken>[];
-  accountDebt: bigint;
-  totalValue: bigint;
-  ops: ExpectedFlowOp[];
-  rwaAssets?: Record<Address, Address>;
-}
-/** Quota token out: withdraw, then release the freed quota. */
-declare const case_any_token: WithdrawAssetCase;
-/** Underlying out on a plain market: no quota, no unwrap. */
-declare const case_underlying: WithdrawAssetCase;
-/**
- * Underlying out on an RWA market: the wrapper cannot leave the account, so it
- * is force-unwrapped and the rwa asset is withdrawn instead.
- */
-declare const case_rwa_underlying: WithdrawAssetCase;
-declare function buildWithdrawAssetSdk(c: WithdrawAssetCase): OnchainSDK;
-declare function buildWithdrawAssetProps(c: WithdrawAssetCase, sdk: OnchainSDK): {
-  intent: WithdrawAssetIntent;
-  creditAccount: CreditAccountSlice;
-  sdk: OnchainSDK<{}>;
-  quotaReserve: undefined;
-  slippage: undefined;
-};
-//#endregion
-export { DEBT, HELD_ANY, HELD_UND, LT_ANY, OUT_ANY, OUT_UND, QUOTA_ANY_AFTER, QUOTA_ANY_BEFORE, QUOTA_ANY_DELTA, WithdrawAssetCase, buildWithdrawAssetProps, buildWithdrawAssetSdk, case_any_token, case_rwa_underlying, case_underlying };

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

@@ -1,79 +0,0 @@
-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,472 +0,0 @@
-import { Bps, Leverage, TokenAmount } 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 { 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 an intent is previewed against:
- * account address, CM lookup, underlying for conversion, debt, token balances
- * and initial quotas.
- */
-type CreditAccountSlice = Omit<RouterCASlice, "debt"> & {
-  /** either base debt or debt plus interest and fees */
-  accountDebt: 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.
- *
- * 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 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" |
-/**
- * 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, or
- * read through a compressor too old to report one.
- */
-"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: OperationState;
-  calls: MultiCall[];
-} | {
-  ok: false;
-  reason: PreviewErrorReason;
-};
-/** 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 claim is expected to credit the account with once the redemption
-   * matures: the venue's payout token and the amount the request queued.
-   * `undefined` when the request settled on the spot and nothing is coming.
-   *
-   * An estimate, not a quote — the issuer prices the redemption when it pays
-   * out, and the state the intent is previewed against was read now.
-   */
-  claim: {
-    token: Address;
-    amount: bigint;
-  } | undefined;
-  /**
-   * The account as the request transaction alone leaves it: the source spent,
-   * 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
-   * is where the intent ends up, tail included, which is what a caller asking
-   * "what does this do to my position" means.
-   */
-  afterRequest: OperationState;
-}
-/**
- * What the leading half of a delayed intent yields: the request transaction,
- * 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
- * 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
- * {@link DelayedStart.afterRequest}, and both are validated before either is
- * reported.
- *
- * The tail is projected from oracle prices rather than from a route — the funds
- * it trades do not exist yet — so its half of the numbers is an estimate. What
- * the transaction on offer does is not.
- */
-type DelayedStartResult = {
-  ok: true;
-  operations: AccountCalculatorOperation[];
-  preview: OperationState;
-  calls: MultiCall[];
-  delayed: DelayedStart;
-} | {
-  ok: false;
-  reason: PreviewErrorReason;
-};
-/** 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: 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 — every one of them.
- *
- * `CLOSE_ACCOUNT` included: an exit is a plain multicall like any other
- * operation here (sell everything, settle the loan, hand the rest over), not
- * the facade's own close entry point, so the engine can build its tail too.
- */
-type ResumableIntent = DelayedIntent;
-/** 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);
-}
-//#endregion
-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

@@ -1,13 +0,0 @@
-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 };