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

package/dist/types/onchain/accounts/intents/open-strategy.d.ts

@@ -0,0 +1,90 @@
+import { Bps, TokenAmount } from "../../../model/primitives.js";
+import { BorrowRateBreakdown } from "../../../model/positions.js";
+import "../../../model/index.js";
+import { Asset } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { PathLossRate } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/open-strategy.d.ts
+interface OpenStrategyProps {
+  sdk: OnchainSDK;
+  /** Credit manager to open the account in. */
+  creditManager: Address;
+  /** Collateral coming from the wallet, in their own tokens. */
+  collateral: Asset[];
+  /** Token the position ends up in. */
+  targetToken: Address;
+  /** Target total leverage scaled by `LEVERAGE_DECIMALS` (300n = 3x). */
+  leverage: bigint;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number | undefined;
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+  /** Balances to leave unswapped; everything else is routed into the target. */
+  leftoverBalances?: Asset[];
+}
+/**
+ * Projected result of opening a brand-new leveraged position.
+ *
+ * Unlike every other flow this one reports **both** branches: the pathfinder
+ * hands back expected and floor balances from a single call, and `openCA` wants
+ * both `minQuota` and `averageQuota`, so there is nothing to gain by dropping one.
+ */
+interface OpenStrategyPreview {
+  /**
+   * 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;
+  /** Debt drawn, in underlying. */
+  debt: bigint;
+  /** Collateral supplied, valued in underlying. */
+  collateral: bigint;
+  /** Position size — collateral plus debt, in underlying. */
+  totalValue: bigint;
+  /** What the routed leg lost to market depth; `undefined` if not measured. */
+  priceImpact: PathLossRate | undefined;
+  /** Expected post-open balances. */
+  averageAssets: TokenAmount[];
+  /** Floor post-open balances after slippage. */
+  minAssets: TokenAmount[];
+  /** Quotas to buy against `averageAssets`; feeds `openCA.averageQuota`. */
+  averageQuota: Asset[];
+  /** Quotas to buy against `minAssets`; feeds `openCA.minQuota`. */
+  minQuota: Asset[];
+  /** Router path; feeds `openCA.calls`. */
+  calls: MultiCall[];
+}
+/**
+ * Previews opening a leveraged position out of wallet collateral.
+ *
+ * Debt follows from the target leverage against the supplied margin
+ * (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
+ * borrowed underlying are then routed into the target token in one pathfinder call.
+ *
+ * There is no account yet, so this does not go through `startIntent` and produces
+ * no operation list — the caller passes the numbers and calls straight to
+ * `sdk.accounts.openCA`.
+ */
+declare function previewOpenStrategy(props: OpenStrategyProps): Promise<OpenStrategyPreview>;
+//#endregion
+export { OpenStrategyPreview, OpenStrategyProps, previewOpenStrategy };

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

@@ -0,0 +1,215 @@
+import { ClaimableWithdrawal, RequestableWithdrawal, WithdrawalOutput } from "../withdrawal-compressor/types.js";
+import { Asset } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { EncodableCreditAccountOperation } from "../types.js";
+import { calcQuotaUpdate } from "../../../common-utils/utils/creditAccount/quota-utils.js";
+import { CreditAccountSlice } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/operations.d.ts
+/**
+ * The operation vocabulary: one logical step of an intent, carrying both the
+ * calldata that realises it and the amounts it was computed from.
+ *
+ * A superset of {@link EncodableCreditAccountOperation}: same discriminants,
+ * plus the quoted amounts the preview and the tests read, plus the RWA legs
+ * that come from their own assemblers rather than from `assembleCaOperations`.
+ */
+type AccountCalculatorOperation = AddCollateralOperation | IncreaseDebtOperation | DecreaseDebtOperation | SwapOperation | WithdrawCollateralOperation | QuotaUpdateOperation | WrapRwaCollateralOperation | UnwrapRwaCollateralOperation | StartDelayedWithdrawalOperation | ClaimDelayedWithdrawalOperation;
+/**
+ * Compile-time proof that the engine's operations really are the SDK's own
+ * encodable ones with the quoted amounts attached, so the two cannot drift into
+ * parallel vocabularies for the same facade calls.
+ */
+type Extends<A extends B, B> = A;
+type _EngineOpsAreEncodable = Extends<Extract<AccountCalculatorOperation, {
+  type: EncodableCreditAccountOperation["type"];
+}>, EncodableCreditAccountOperation>;
+interface AddCollateralOperation {
+  type: "addCollateral";
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  calls: MultiCall[];
+}
+declare function buildAddCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): AddCollateralOperation;
+interface IncreaseDebtOperation {
+  type: "increaseDebt";
+  amount: bigint;
+  calls: MultiCall[];
+}
+declare function buildIncreaseDebtOperation(input: {
+  amount: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): IncreaseDebtOperation;
+interface DecreaseDebtOperation {
+  type: "decreaseDebt";
+  amount: bigint;
+  /**
+   * The repayment settles the loan rather than shrinking it, so the call names
+   * no amount and the facade takes everything outstanding. `amount` is still
+   * the debt as it was read, which is what the projection is built on; the
+   * difference is the interest that accrues before the transaction lands.
+   */
+  full?: boolean;
+  calls: MultiCall[];
+}
+declare function buildDecreaseDebtOperation(input: {
+  amount: bigint;
+  full?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): DecreaseDebtOperation;
+interface WithdrawCollateralOperation {
+  type: "withdrawCollateral";
+  token: Address;
+  amount: bigint;
+  /** Wallet recipient for withdrawn tokens — never a token address. */
+  to: Address;
+  /**
+   * The call names no amount and the facade hands over the whole balance, so a
+   * swap that beat its floor does not strand the surplus on the account.
+   * `amount` remains the figure the projection was built on.
+   */
+  all?: boolean;
+  calls: MultiCall[];
+}
+declare function buildWithdrawCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  to: Address;
+  all?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): WithdrawCollateralOperation;
+/** Routed conversion: one or more tokens in, one token out. */
+interface SwapOperation {
+  type: "swap";
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+/** One routed leg, with the amounts it was quoted at. */
+declare function buildSwapOperation(input: {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+/**
+ * The many-to-one leg an exit routes: every balance listed goes in, and the
+ * underlying comes out.
+ */
+declare function buildCloseSwapOperation(input: {
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+interface QuotaUpdateOperation {
+  type: "changeQuota";
+  desiredQuota: Record<Address, Asset>;
+  quotaIncrease: Asset[];
+  quotaDecrease: Asset[];
+  calls: MultiCall[];
+}
+type QuotaUpdateState = ReturnType<typeof calcQuotaUpdate>;
+declare function buildQuotaUpdateOperation(input: {
+  update: QuotaUpdateState;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): QuotaUpdateOperation;
+interface WrapRwaCollateralOperation {
+  type: "wrapRwaCollateral";
+  /** Amount of RWA asset wrapped. */
+  amount: bigint;
+  /** RWA asset token (wrap source). */
+  tokenIn: Address;
+  /** Underlying received after wrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface UnwrapRwaCollateralOperation {
+  type: "unwrapRwaCollateral";
+  /** Amount of wrapped underlying unwrapped. */
+  amount: bigint;
+  /** Wrapped underlying token (unwrap source). */
+  tokenIn: Address;
+  /** RWA asset received after unwrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface RwaLegInput {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}
+/** Wraps an RWA asset into the market underlying. */
+declare function buildWrapRwaCollateralOperation(input: RwaLegInput): Promise<WrapRwaCollateralOperation>;
+/** Unwraps the market underlying back into its RWA asset. */
+declare function buildUnwrapRwaCollateralOperation(input: RwaLegInput): Promise<UnwrapRwaCollateralOperation>;
+/**
+ * The request that starts a redemption: spends the source token and receives
+ * the phantom token standing in for the payout until it matures.
+ */
+interface StartDelayedWithdrawalOperation {
+  type: "startDelayedWithdrawal";
+  /** Source token the redemption is requested from. */
+  token: Address;
+  /** Amount of `token` the issuer burns; capped at the account balance. */
+  amountIn: bigint;
+  /** Request outputs; a delayed one is the phantom token, not the payout. */
+  outputs: WithdrawalOutput[];
+  /** Whether anything at all has to be waited for. */
+  settlement: "instant" | "delayed";
+  calls: MultiCall[];
+}
+declare function buildStartDelayedWithdrawalOperation(input: {
+  preview: RequestableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): StartDelayedWithdrawalOperation;
+/**
+ * The claim of a matured delayed withdrawal: burns the phantom and credits the
+ * outputs the compressor reports.
+ */
+interface ClaimDelayedWithdrawalOperation {
+  type: "claimDelayedWithdrawal";
+  /** Source token the delayed withdrawal was requested from. */
+  token: Address;
+  withdrawalPhantomToken: Address;
+  withdrawalTokenSpent: bigint;
+  /** Claim outputs as returned by the compressor (incl. `isDelayed`). */
+  outputs: WithdrawalOutput[];
+  calls: MultiCall[];
+}
+declare function buildClaimDelayedWithdrawalOperation(input: {
+  claimable: ClaimableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): ClaimDelayedWithdrawalOperation;
+/**
+ * What a request or a claim puts on the account right away, as opposed to what
+ * only the phantom token represents.
+ */
+declare function instantOutput(outputs: WithdrawalOutput[], token?: Address): {
+  token: Address;
+  amount: bigint;
+} | undefined;
+//#endregion
+export { AccountCalculatorOperation, AddCollateralOperation, ClaimDelayedWithdrawalOperation, DecreaseDebtOperation, IncreaseDebtOperation, QuotaUpdateOperation, QuotaUpdateState, RwaLegInput, StartDelayedWithdrawalOperation, SwapOperation, UnwrapRwaCollateralOperation, WithdrawCollateralOperation, WrapRwaCollateralOperation, _EngineOpsAreEncodable, buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput };

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

@@ -0,0 +1,210 @@
+import { DelayedIntent } from "../../../model/delayed-intents.js";
+import "../../../model/index.js";
+import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { AddCollateralIntent, AdjustLeverageIntent, DepositStrategyIntent, RepayStrategyIntent, WithdrawAssetIntent, WithdrawStrategyIntent } from "./types.js";
+import { DebtBand } from "./math.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/plan.d.ts
+/**
+ * Planning: an intent becomes a short list of {@link Step}s.
+ *
+ * Every intent is a walk along the same chain —
+ *
+ * ```
+ * wallet ─add─▶ account ─convert(in→U)─▶ borrow | repay ─convert(U→out)─▶ ─withdraw─▶ wallet
+ * ```
+ *
+ * — so a plan is just which slots are filled and by how much. Planners are
+ * pure: they read an {@link AccountView} and return steps; nothing here touches
+ * the router or the chain. Identity converts (`from === to`) are legitimate
+ * plan entries — the realiser drops them after checking the balance — which is
+ * what lets one planner cover every "S is / is not the underlying" shape.
+ */
+/** Amount of a step: fixed, or whatever the previous step produced. */
+type Amount = bigint | {
+  raised: true;
+  max?: bigint;
+};
+/** Whatever the previous convert produced. */
+declare const RAISED: Amount;
+type Step = {
+  kind: "add";
+  token: Address;
+  amount: bigint;
+  value: bigint | undefined;
+} | {
+  kind: "borrow";
+  amount: bigint;
+} |
+/**
+ * Repays up to `amount`, never more than the underlying on the account minus
+ * `keep` — a routing shortfall shows up as slightly less debt repaid.
+ */
+{
+  kind: "repay";
+  amount: Amount;
+  keep?: bigint;
+} | {
+  kind: "convert";
+  from: Address;
+  to: Address;
+  amount: Amount;
+} | {
+  kind: "withdraw";
+  token: Address;
+  amount: Amount;
+  to: Address;
+} |
+/**
+ * Sells every balance the account holds into the underlying in one
+ * many-to-one route. Only an exit asks for this: the whole position is
+ * leaving, so the router is given all of it at once rather than one leg per
+ * token, and there is nothing left to price a fixed input against.
+ */
+{
+  kind: "closeAll";
+} |
+/**
+ * Redeems `amount` of `token` through its issuer instead of a DEX, keeping
+ * `reserve` of it on the account. `record` is written into the request and
+ * read back at claim time, which is what lets the tail be planned then.
+ */
+{
+  kind: "request";
+  token: Address;
+  amount: bigint;
+  reserve: bigint;
+  record: DelayedIntent;
+} | {
+  kind: "claim";
+  claimable: ClaimableWithdrawal;
+} |
+/**
+ * Hands whatever is left on the account to `to`, each balance in the token it
+ * stands in. Only an exit asks for this: the amounts are whatever the legs
+ * before it happen to leave, which no planner can name in advance.
+ */
+{
+  kind: "sweep";
+  to: Address;
+} |
+/**
+ * Drops every quota the account holds, in the same transaction and before
+ * whatever follows. Only a plan that leaves no debt behind asks for this:
+ * quota fees accrue on the quota, not on the loan, so a quota outliving the
+ * debt it backed would keep charging an account that owes nothing.
+ */
+{
+  kind: "clearQuotas";
+};
+/** What a planner is allowed to know about the account. */
+interface AccountView {
+  underlying: Address;
+  /** The attached SDK, for the guards that inline a token into a refusal. */
+  sdk: OnchainSDK;
+  /** Raw asset of an RWA market (e.g. USDC behind dcUSDC); undefined otherwise. */
+  rwaAsset: Address | undefined;
+  debt: bigint;
+  /** TVL − debt, in underlying. */
+  collateral: bigint;
+  band: DebtBand;
+  balanceOf(token: Address): bigint;
+  /** Oracle conversion; unpriceable tokens contribute 0n. */
+  price(from: Address, to: Address, amount: bigint): bigint;
+  /** Most valuable non-phantom balance, or undefined when there is none. */
+  fattest(exclude?: Address[]): Address | undefined;
+}
+/** Intent 5: the token lands as is; debt is untouched. */
+declare function planAddCollateral(intent: Omit<AddCollateralIntent, "type">): Step[];
+/** Intent 4: one asset out at fixed debt. */
+declare function planWithdrawAsset(intent: Omit<WithdrawAssetIntent, "type">, view: AccountView): Step[];
+/** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
+declare function planAdjustLeverage(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
+declare function planDeposit(intent: Omit<DepositStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 3: funding comes in from the wallet and goes straight into the debt.
+ * Collateral never moves, so the whole plan is the funding's way to `U`.
+ *
+ * Funding in `U` needs no way there: it lands and is repaid, which is the whole
+ * plan. An RWA market also takes the raw asset behind its underlying, and that
+ * one is wrapped on the way in.
+ *
+ * `MAX_UINT256` settles the loan: the wallet is asked for the debt as it stands
+ * plus the headroom {@link SETTLE_MARGIN} allows for the interest of the blocks
+ * still to come, since the facade is told to repay everything outstanding
+ * rather than the amount quoted here.
+ */
+declare function planRepay(intent: Omit<RepayStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
+ * holds. Both are funded by the source `S`.
+ */
+declare function planWithdraw(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1 against a source that cannot be sold on a DEX.
+ *
+ * Some collateral only converts through its issuer — a Securitize dsToken, a
+ * Mellow share — which answers a redemption request now and pays out days
+ * later. The trade is unchanged; what changes is that the proceeds do not exist
+ * yet, so this half only requests the redemption:
+ *
+ * ```
+ * request(S, W + dD) → [days] → claim → convert → repay → withdraw
+ * ```
+ *
+ * The tail is planned at claim time by {@link planFinishWithdraw}, from the
+ * intent this request records — only then is the claimed amount, and the token
+ * it arrived in, known. An exit records {@link planFinishCloseAccount}'s intent
+ * instead, and rebuilds itself from the account rather than from the request.
+ */
+declare function planWithdrawDelayed(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 6.2 against a position token that only redeems through its issuer.
+ *
+ * Only deleveraging can be delayed: raising leverage borrows and buys, both of
+ * which settle at once. The request covers whatever idle underlying does not
+ * already, and the tail repays from the claim.
+ */
+declare function planAdjustLeverageDelayed(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Everything claimed goes into the debt. */
+declare function planFinishDecreaseLeverage(claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/**
+ * The claim is split between the promised payout `W` and the debt the leading
+ * half deferred: the payout is served first, the debt gets what is left, so a
+ * routing shortfall shows as leverage a touch above target rather than as a
+ * payout the wallet was promised and did not get.
+ */
+declare function planFinishWithdraw(intent: {
+  withdrawToken: Address;
+  withdrawAmount: bigint;
+  debtRepaid: bigint;
+  sourceToken: Address;
+  to: Address;
+}, claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/**
+ * The tail of an exit: the claim lands, everything the account holds is sold
+ * into the underlying, the loan is settled out of the proceeds and the rest
+ * goes to the wallet. The account survives it, empty and owing nothing.
+ *
+ * Nothing is quoted from the request — the same shape {@link planWithdraw}
+ * builds for an instant exit is rebuilt here against the account as it stands
+ * now, which is the only state that can name these amounts.
+ */
+declare function planFinishCloseAccount(intent: {
+  to: Address;
+}, claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
+declare function planFinishClaimOnly(claimable: ClaimableWithdrawal): Step[];
+//#endregion
+export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -0,0 +1,42 @@
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { AccountCalculatorOperation } from "./operations.js";
+import { CreditAccountSlice, DelayedStart, OperationState } from "./types.js";
+import "../../index.js";
+import { Step } from "./plan.js";
+import { RouterPaths } from "./utils/router-path.js";
+//#region src/onchain/accounts/intents/realize.d.ts
+interface RealizeProps {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number;
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+  /**
+   * Where routed legs are quoted. Defaults to the pathfinder, which is what
+   * anything that will be sent needs; a walk that only projects a state passes
+   * `createOraclePaths` instead.
+   */
+  paths?: RouterPaths;
+}
+interface Realized {
+  operations: AccountCalculatorOperation[];
+  state: OperationState;
+  calls: MultiCall[];
+  /** Set when the plan started a redemption, i.e. it needs a tail. */
+  delayed: DelayedStart | undefined;
+}
+/**
+ * Turns a plan into operations: the one place that talks to the router, knows
+ * how an RWA leg differs from a swap, and keeps the running balances.
+ *
+ * Steps are applied to a ledger as they are built, so every leg sees the
+ * balances the previous ones left behind: a swap only spends what the plan
+ * says and keeps the rest of its input token in place, a repayment never
+ * exceeds the underlying actually raised. Once the walk is done the projected
+ * balances yield the quota update and the reported state.
+ */
+declare function realize(steps: Step[], props: RealizeProps): Promise<Realized>;
+//#endregion
+export { RealizeProps, Realized, realize };

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

@@ -0,0 +1,52 @@
+import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { AccountCalculatorOperation, StartDelayedWithdrawalOperation } from "./operations.js";
+import { 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 second half of a delayed intent: the claim, then whatever the intent
+ * still owes.
+ *
+ * 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.
+ */
+declare function planTail(args: {
+  intent: ResumableIntent;
+  claimable: ClaimableWithdrawal;
+  view: AccountView;
+}): Step[];
+/**
+ * Where a delayed intent ends up, worked out at the moment it is started.
+ *
+ * A request is only half a withdrawal, so the state it lands in is not the
+ * answer to "what does this do to my position": the debt is still there, the
+ * payout has not been made, and the position sits in a phantom token. What the
+ * caller means is the far side — and that side can be walked now, because the
+ * request already fixes the claim it will be finished from.
+ *
+ * So the same tail {@link planTail} builds at claim time is built here against
+ * the account as the request leaves it, with the claim it is expected to bring,
+ * and walked by the same realiser — with one substitution: routed legs are
+ * priced by the oracle rather than the pathfinder, since the funds they trade
+ * do not exist yet and no calldata is being produced. The result is an
+ * estimate that the engine's guards are nevertheless applied to, so a request
+ * that would strand the account is refused before it is sent rather than
+ * discovered days later.
+ */
+declare function projectTail(args: {
+  /** The request as realised: the source spent, the phantom it produced. */
+  request: StartDelayedWithdrawalOperation;
+  delayed: DelayedStart;
+  /** The account the request was previewed against, for masks and market. */
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  quotaReserve: number | undefined;
+}): Promise<{
+  state: OperationState;
+  operations: AccountCalculatorOperation[];
+}>;
+//#endregion
+export { planTail, projectTail };

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

@@ -0,0 +1,50 @@
+import { ClaimableWithdrawal } from "../../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice, ResumableIntent } from "../types.js";
+import "../../../index.js";
+import { ExpectedFlowOp } from "./expect.js";
+import { ANY, MarketSdkExtras, RWA_ASSET, UND } from "./market.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/testing/delayed.d.ts
+declare const FIXTURE_PHANTOM: Address;
+interface TailCase {
+  claimedToken: Address;
+  claimedAmount: bigint;
+  postClaimTotalValue: bigint;
+  postClaimDebt: bigint;
+  /** The operations the tail is expected to produce. */
+  tailOps: ExpectedFlowOp[];
+  expectedQuotaBalance?: bigint;
+  /**
+   * Pre-existing balances besides the withdrawal phantom. Defaults to
+   * `postClaimTotalValue − claimed value` in UND. Cases claiming UND override
+   * it with another token so the claimed balance stays distinguishable.
+   */
+  baseAssets?: CreditAccountSlice["tokens"];
+}
+/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
+declare function claimedValueInUnd(amount: bigint, token: Address): bigint;
+/**
+ * Mock sdk for a tail case. The phantom token inherits the claimed token's
+ * decimals, so any 1:1 rescale through it stays the identity.
+ */
+declare function buildTailSdk(c: Pick<TailCase, "claimedToken">, extras?: MarketSdkExtras & {
+  phantom?: Address;
+}): OnchainSDK;
+/** The matured withdrawal a tail case claims. */
+declare function buildClaimable(c: Pick<TailCase, "claimedToken" | "claimedAmount">): ClaimableWithdrawal;
+/** Props for `finishIntent`: the account after the delay, plus the claimable. */
+declare function buildFinishProps<T extends ResumableIntent>(args: {
+  intent: T;
+  case: TailCase;
+  sdk: OnchainSDK;
+}): {
+  intent: T;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK<{}>;
+  quotaReserve: undefined;
+  claimable: ClaimableWithdrawal;
+  slippage: undefined;
+};
+//#endregion
+export { ANY, RWA_ASSET, TailCase, UND };