@gearbox-protocol/sdk 15.1.0-next.22 → 15.1.0-next.23

package/dist/types/new-sdk/prepare/types.d.ts

@@ -73,10 +73,12 @@ type StrategySimulate = {
 };
 /**
  * What the leading half of a delayed operation would yield: the request
- * transaction, plus what it recorded for the tail.
+ * transaction, plus what it recorded for the tail and where that tail leads.
  *
  * Shaped like {@link StrategySimulate} with one field more, so the instant and
- * the delayed route of the same request are compared side by side.
+ * the delayed route of the same request are compared side by side — and they
+ * are meant to be compared on the same footing, so `preview` is the end of the
+ * operation in both, not the end of the transaction.
  **/
 type DelayedStrategySimulate = {
   ok: true;
@@ -85,9 +87,14 @@ type DelayedStrategySimulate = {
    **/
   operations: AccountCalculatorOperation[];
   /**
-   * State once the request executes: the source token is gone and the
-   * withdrawal position stands in its place, with debt untouched — the
-   * repayment belongs to the tail.
+   * Where the operation ends: the account once the redemption has matured,
+   * been claimed and the tail has run — the same place the instant route
+   * reaches in one transaction, which is what makes the two comparable.
+   *
+   * The tail's half of it is an estimate priced by the oracle: the funds it
+   * trades do not exist yet, so no route can be quoted for them. The state
+   * the request alone lands in — source spent, withdrawal position in its
+   * place, debt untouched — is `delayed.afterRequest`.
    **/
   preview: OperationState;
   /**
@@ -398,7 +405,13 @@ interface OpportunitiesPrepare {
    * many-to-one route, the debt is settled in full and every balance left goes
    * to `to`. `tokenOut` is ignored, since the proceeds are already the
    * underlying (unwrapped on an RWA market). The account stays open with
-   * nothing on it. An exit has no delayed route.
+   * nothing on it.
+   *
+   * An exit has both routes as well, which is what lets an account whose
+   * position only redeems through its issuer leave at all: the delayed route
+   * redeems `sourceToken` whole and records the exit, and {@link finalize}
+   * rebuilds it against the account the claim finds — the debt as it stands by
+   * then, whatever else is on the account, everything sold in one route.
    *
    * @see withdrawCollateral to move an asset out without touching debt, which
    * raises leverage instead.
@@ -463,8 +476,9 @@ interface OpportunitiesPrepare {
   /**
    * The tail of a delayed route: claim the matured withdrawal, then whatever the
    * operation that requested it still owes — repaying debt and paying the wallet
-   * out for a withdrawal, repaying alone for a deleveraging, nothing beyond the
-   * claim for the rest.
+   * out for a withdrawal, repaying alone for a deleveraging, selling the rest of
+   * the account and settling the loan for an exit, nothing beyond the claim for
+   * the rest.
    *
    * The route is requested by {@link withdrawStrategy} or
    * {@link adjustLeverage}, whose `delayed` branch is the transaction that

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

@@ -75,10 +75,16 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * {@link intentRoutes}; this is the one to call when the delayed route is the
    * only one of interest.
    *
+   * `preview` is where the intent ends — the account once the redemption has
+   * matured, been claimed and the tail has run — because that is what the
+   * caller asked for; the half-way state the request itself lands in is
+   * `delayed.afterRequest`. Both are validated, so a request whose tail could
+   * not be completed is refused instead of started.
+   *
    * @param props - Intent plus account slice, quota reserve and slippage
-   * @returns The request transaction and what it recorded for the tail, or
-   * `{ ok: false, reason }` — `noDelayedRoute` when this route does not exist
-   * for the account at all
+   * @returns The request transaction, the state it ends in and what it recorded
+   * for the tail, or `{ ok: false, reason }` — `noDelayedRoute` when this route
+   * does not exist for the account at all
    */
   startDelayedIntent(props: StartIntentProps & {
     intent: DelayableIntent;
@@ -109,9 +115,10 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * Previews the tail of a delayed intent, once the withdrawal it started has
    * matured: the claim, then whatever the intent still owes.
    *
-   * Serves the two operations that can genuinely be interrupted by a delay — a
-   * withdrawal and a deleveraging. For the rest, the claim is the whole tail:
-   * the tokens land on the account and only their quota has to catch up.
+   * Serves the three operations that can genuinely be interrupted by a delay —
+   * a withdrawal, a deleveraging and an exit. For the rest, the claim is the
+   * whole tail: the tokens land on the account and only their quota has to
+   * catch up.
    *
    * @param props - The recorded intent, the account slice as it stands now, and
    * the matured claimable

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

@@ -153,7 +153,8 @@ declare function planWithdraw(intent: Omit<WithdrawStrategyIntent, "type">, view
  *
  * 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.
+ * 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[];
 /**
@@ -185,7 +186,22 @@ declare function planFinishWithdraw(intent: {
   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, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };
+export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -4,6 +4,7 @@ import { CreditAccountSlice, DelayedStart, OperationState } from "./types.js";
 import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Step } from "./plan.js";
+import { RouterPaths } from "./utils/router-path.js";
 //#region src/sdk/accounts/intents/realize.d.ts
 interface RealizeProps {
   creditAccount: CreditAccountSlice;
@@ -12,6 +13,12 @@ interface RealizeProps {
   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[];

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

@@ -0,0 +1,52 @@
+import { ClaimableWithdrawal } from "../withdrawal-compressor/types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice, DelayedStart, OperationState, ResumableIntent } from "./types.js";
+import { AccountCalculatorOperation, StartDelayedWithdrawalOperation } from "./operations.js";
+import "../../index.js";
+import { AccountView, Step } from "./plan.js";
+//#region src/sdk/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/sdk/accounts/intents/types.d.ts

@@ -81,7 +81,11 @@ interface OperationState {
 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. */
+/**
+ * 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,
@@ -93,9 +97,8 @@ type PreviewErrorReason = "debtOutOfRange" | "leverageOutOfRange" | "insufficien
 /** 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.
+ * 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. */
@@ -146,10 +149,44 @@ interface DelayedStart {
    * 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;
@@ -406,14 +443,13 @@ type StartIntent = AddCollateralIntent | WithdrawAssetIntent | AdjustLeverageInt
  */
 type DelayableIntent = AdjustLeverageIntent | WithdrawStrategyIntent;
 /**
- * A delayed intent this engine knows how to finish.
+ * A delayed intent this engine knows how to finish — every one of them.
  *
- * `CLOSE_ACCOUNT` is absent on purpose: closing goes through the facade's own
- * entry point, which this engine no longer builds.
+ * `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 = Exclude<DelayedIntent, {
-  type: "CLOSE_ACCOUNT";
-}>;
+type ResumableIntent = DelayedIntent;
 /** Shared inputs plus the matured withdrawal the tail is built around. */
 type FinishIntentProps = StartIntentProps & {
   intent: ResumableIntent;

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

@@ -1,4 +1,5 @@
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.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";
@@ -7,5 +8,4 @@ import { convertAmount } from "./convert-amount.js";
 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 };
+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 };

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

@@ -66,5 +66,19 @@ declare function createRouterPaths(args: {
   creditAccount: CreditAccountSlice;
   slippage: number;
 }): RouterPaths;
+/**
+ * The same door, priced by the oracle and opening onto no calldata.
+ *
+ * For a leg that cannot be quoted yet: the tail of a redemption trades funds
+ * that do not exist, along a route the pathfinder will only be able to build
+ * once they do. Asking it now would price a swap of nothing, so the amounts
+ * come from the oracle instead — an estimate with no slippage floor, which is
+ * all a projection days out can honestly be — and the walk yields a state
+ * rather than a transaction.
+ */
+declare function createOraclePaths(args: {
+  sdk: OnchainSDK;
+  creditAccount: CreditAccountSlice;
+}): RouterPaths;
 //#endregion
-export { OpenStrategyLeg, RouterPaths, SwapLeg, createRouterPaths };
+export { OpenStrategyLeg, RouterPaths, SwapLeg, createOraclePaths, createRouterPaths };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "15.1.0-next.22",
+  "version": "15.1.0-next.23",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {