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

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/dist/types/sdk/market/oracle/PriceOracleBaseContract.d.ts

@@ -92,6 +92,10 @@ declare abstract class PriceOracleBaseContract<abi extends Abi | readonly unknow
    * {@inheritDoc IPriceOracleContract.convertFromUSD}
    **/
   convertFromUSD(to: Address, amount: bigint, reserve?: boolean): bigint;
+  /**
+   * {@inheritDoc IPriceOracleContract.safeConvert}
+   **/
+  safeConvert(from: Address, to: Address, amount: bigint): bigint | null;
   /**
    * {@inheritDoc IPriceOracleContract.safeConvertToUSD}
    **/

package/dist/types/sdk/market/oracle/types.d.ts

@@ -131,6 +131,15 @@ interface IPriceOracleContract extends IBaseContract {
    * @param reserve - Use reserve feeds instead of main.
    **/
   convert: (from: Address, to: Address, amount: bigint, reserve?: boolean) => bigint;
+  /**
+   * Like {@link convert}, but returns `null` instead of throwing when either
+   * token cannot be priced (missing or unsuccessful feed).
+   *
+   * @param from - Source token address.
+   * @param to - Destination token address.
+   * @param amount - Amount in source-token decimals.
+   **/
+  safeConvert: (from: Address, to: Address, amount: bigint) => bigint | null;
   /**
    * Converts a token amount to its USD value using latest known prices.
    *

package/package.json

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