@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

package/dist/types/sdk/opportunities/types.d.ts

@@ -1,27 +1,27 @@
+import { Opportunity, OpportunityFilter, OpportunityTotals, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef } from "../../model/opportunities.js";
 import { ChartBundle, ChartRange, PoolOpportunityChartMetric, StrategyOpportunityChartMetric } from "../../model/charts.js";
-import { Opportunity, OpportunityFilter, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef } from "../../model/opportunities.js";
 import { DataResponse } from "../../model/response.js";
 import "../../model/index.js";
-import { MultichainOpportunitiesService } from "../../onchain/opportunities/MultichainOpportunitiesService.js";
+import { IMultichainOpportunitiesService } from "../../onchain/opportunities/types.js";
 import "../../onchain/index.js";
-import { OffchainOpportunities } from "../../offchain/opportunities/OffchainOpportunities.js";
+import { IOffchainOpportunities } from "../../offchain/opportunities/types.js";
 import "../../offchain/index.js";
-import { Mode } from "../types.js";
-import { EntityMerger, FilterResult, ListMerger } from "../utils/types.js";
-import "../utils/index.js";
-import { OpportunitiesPrepare } from "../prepare/types.js";
+import { IOpportunitiesPrepare } from "../prepare/types.js";
 import "../prepare/index.js";
-import { OpportunitiesExecute } from "../execute/ExecuteApi.js";
+import { IOpportunitiesExecute } from "../execute/types.js";
 import "../execute/index.js";
+import { EntityMerger, FilterResult, ListMerger } from "../utils/types.js";
+import "../utils/index.js";
+import { Mode } from "../types.js";
 //#region src/sdk/opportunities/types.d.ts
 /**
  * What the `opportunities` namespace offers in every mode.
  **/
-interface OpportunitiesBase {
+interface IOpportunitiesBase {
   /**
    * All pool and strategy opportunities, optionally narrowed. In `both` mode
    * each chain is served by whichever source is fresh enough, see
-   * {@link OpportunityMergers}.
+   * {@link IOpportunityMergers}.
    **/
   list(filter?: OpportunityFilter): Promise<DataResponse<Opportunity[]>>;
   /**
@@ -38,26 +38,24 @@ interface OpportunitiesBase {
    * narrows to a list.
    **/
   filter<R extends DataResponse<Opportunity[]> | undefined>(response: R, filter?: OpportunityFilter): FilterResult<R, Opportunity>;
-  /**
-   * The chain on its own, for a consumer that shows each source as it arrives.
-   * Throws in `offchain` mode.
-   **/
-  readonly onchain: MultichainOpportunitiesService;
-  /**
-   * The backend on its own, see {@link OpportunitiesBase.onchain}. Throws in
-   * `onchain` mode.
-   **/
-  readonly offchain: OffchainOpportunities;
   /**
    * Merge policy of each read, for a consumer combining the two branches
-   * itself, see {@link OpportunityMergers}.
+   * itself, see {@link IOpportunityMergers}.
    **/
-  readonly merge: OpportunityMergers;
+  readonly merge: IOpportunityMergers;
 }
 /**
  * Reads only a backend can answer.
  **/
-interface OpportunitiesOffchainOnly {
+interface IOpportunitiesOffchainOnly {
+  /**
+   * Protocol-wide totals across every opportunity: the TVL, total borrowed and
+   * total supplied the landing page shows.
+   *
+   * Absent in `onchain` mode: it is served by the backend rather than summed
+   * from the chain.
+   **/
+  totals(): Promise<DataResponse<OpportunityTotals>>;
   /**
    * Historical charts of one opportunity, one series per metric on a shared
    * axis: `charts(key, ["depositApy", "depositApyAvg7d"], "1m")`.
@@ -72,40 +70,42 @@ interface OpportunitiesOffchainOnly {
 /**
  * Reads only the chain can answer.
  **/
-interface OpportunitiesOnchainOnly {
+interface IOpportunitiesOnchainOnly {
   /**
-   * Simulations of what a deposit, withdrawal or leverage change would do.
+   * What a deposit, withdrawal or leverage change would do, and the calldata
+   * that does it.
    *
    * Absent in `offchain` mode: every one of them reads live account and pool
    * state, and the strategy flows additionally need the pathfinder for real swap
    * paths, so there is nothing the backend could answer with.
    **/
-  readonly prepare: OpportunitiesPrepare;
+  readonly prepare: IOpportunitiesPrepare;
   /**
    * The transaction a prepared operation stands for, see
-   * {@link OpportunitiesExecute.buildTx}. Absent in `offchain` mode for the
+   * {@link IOpportunitiesExecute.buildTx}. Absent in `offchain` mode for the
    * same reason as {@link prepare}: it encodes against live chain state.
    **/
-  readonly execute: OpportunitiesExecute;
+  readonly execute: IOpportunitiesExecute;
 }
 /**
- * Which reads the `opportunities` namespace has in each mode. A widened mode
- * offers what every mode has, i.e. {@link OpportunitiesBase} alone.
+ * The chain on its own, for a consumer that shows each source as it arrives.
+ * Absent in `offchain` mode.
  **/
-interface OpportunitiesOnchainBranch {
-  readonly onchain: MultichainOpportunitiesService;
+interface IOpportunitiesOnchainBranch {
+  readonly onchain: IMultichainOpportunitiesService;
 }
 /**
- * The backend on its own, see {@link OpportunitiesOnchainBranch}.
+ * The backend on its own, see {@link IOpportunitiesOnchainBranch}. Absent in
+ * `onchain` mode.
  **/
-interface OpportunitiesOffchainBranch {
-  readonly offchain: OffchainOpportunities;
+interface IOpportunitiesOffchainBranch {
+  readonly offchain: IOffchainOpportunities;
 }
 /**
  * Merge policy of each read, exposed so that a consumer reading the two
  * branches itself combines them exactly as `both` mode would.
  **/
-interface OpportunityMergers {
+interface IOpportunityMergers {
   list: ListMerger<Opportunity[]>;
   pool: EntityMerger<PoolOpportunityDetail>;
   strategy: EntityMerger<StrategyOpportunityDetail>;
@@ -113,14 +113,14 @@ interface OpportunityMergers {
 /**
  * Which methods the `opportunities` namespace has in each mode.
  **/
-interface OpportunitiesByMode {
-  onchain: OpportunitiesBase & OpportunitiesOnchainOnly & OpportunitiesOnchainBranch;
-  offchain: OpportunitiesBase & OpportunitiesOffchainOnly & OpportunitiesOffchainBranch;
-  both: OpportunitiesBase & OpportunitiesOnchainOnly & OpportunitiesOffchainOnly;
+interface IOpportunitiesByMode {
+  onchain: IOpportunitiesBase & IOpportunitiesOnchainOnly & IOpportunitiesOnchainBranch;
+  offchain: IOpportunitiesBase & IOpportunitiesOffchainOnly & IOpportunitiesOffchainBranch;
+  both: IOpportunitiesBase & IOpportunitiesOnchainOnly & IOpportunitiesOffchainOnly & IOpportunitiesOnchainBranch & IOpportunitiesOffchainBranch;
 }
 /**
  * The `opportunities` namespace of a {@link GearboxSDK} in mode `M`.
  **/
-type Opportunities<M extends Mode = Mode> = OpportunitiesByMode[M];
+type IOpportunities<M extends Mode = Mode> = IOpportunitiesByMode[M];
 //#endregion
-export { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesOffchainBranch, OpportunitiesOffchainOnly, OpportunitiesOnchainBranch, OpportunitiesOnchainOnly, OpportunityMergers };
+export { IOpportunities, IOpportunitiesBase, IOpportunitiesByMode, IOpportunitiesOffchainBranch, IOpportunitiesOffchainOnly, IOpportunitiesOnchainBranch, IOpportunitiesOnchainOnly, IOpportunityMergers };

package/dist/types/sdk/positions/PositionsNamespace.d.ts

@@ -1,41 +1,55 @@
+import { PoolPositionRef, Position, PositionFilter, PositionTransaction, PositionsTotals, StrategyPositionRef } from "../../model/positions.js";
 import { ChartBundle, ChartRange, PoolPositionChartMetric, StrategyPositionChartMetric } from "../../model/charts.js";
-import { PoolPositionRef, Position, PositionFilter, StrategyPositionRef } from "../../model/positions.js";
 import { DataResponse } from "../../model/response.js";
+import { PositionWithdrawals } from "../../model/withdrawals.js";
 import "../../model/index.js";
+import { GetCurrentWithdrawalsProps } from "../../onchain/positions/types.js";
 import { MultichainSDK } from "../../onchain/MultichainSDK.js";
 import "../../onchain/index.js";
 import { GearboxAPI } from "../../offchain/GearboxAPI.js";
 import "../../offchain/index.js";
-import { NamespaceOptions } from "../types.js";
 import { FilterResult } from "../utils/types.js";
 import "../utils/index.js";
+import { IPositionMergers, IPositionsBase, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly } from "./types.js";
+import { NamespaceOptions } from "../types.js";
 import { AbstractNamespace } from "../AbstractNamespace.js";
-import { PositionMergers, PositionsBase, PositionsOffchainOnly } from "./types.js";
 import { Address } from "viem";
 //#region src/sdk/positions/PositionsNamespace.d.ts
 /**
  * The `positions` namespace of a {@link GearboxSDK}, see
- * {@link PositionsByMode} for what each mode offers.
+ * {@link IPositionsByMode} for what each mode offers.
  **/
-declare class PositionsNamespace extends AbstractNamespace<MultichainSDK["positions"], GearboxAPI["positions"]> implements PositionsBase, PositionsOffchainOnly {
+declare class PositionsNamespace extends AbstractNamespace<MultichainSDK["positions"], GearboxAPI["positions"]> implements IPositionsBase, IPositionsOffchainOnly, IPositionsOnchainOnly, IPositionsOnchainBranch, IPositionsOffchainBranch {
   /**
-   * {@inheritDoc PositionsBase.merge}
+   * {@inheritDoc IPositionsBase.merge}
    **/
-  readonly merge: PositionMergers;
+  readonly merge: IPositionMergers;
   constructor(onchain: MultichainSDK | undefined, offchain: GearboxAPI | undefined, options: NamespaceOptions);
   /**
-   * {@inheritDoc PositionsBase.list}
+   * {@inheritDoc IPositionsBase.list}
    **/
   list(wallet: Address, filter?: PositionFilter): Promise<DataResponse<Position[]>>;
   /**
-   * {@inheritDoc PositionsBase.filter}
+   * {@inheritDoc IPositionsBase.filter}
    **/
   filter<R extends DataResponse<Position[]> | undefined>(response: R, filter?: PositionFilter): FilterResult<R, Position>;
   /**
-   * {@inheritDoc PositionsOffchainOnly.charts}
+   * {@inheritDoc IPositionsOffchainOnly.totals}
+   **/
+  totals(wallet: Address): Promise<DataResponse<PositionsTotals>>;
+  /**
+   * {@inheritDoc IPositionsOffchainOnly.charts}
    **/
   charts<const Metrics extends readonly PoolPositionChartMetric[]>(key: PoolPositionRef, metrics: Metrics, range: ChartRange): Promise<DataResponse<ChartBundle<Metrics>>>;
   charts<const Metrics extends readonly StrategyPositionChartMetric[]>(key: StrategyPositionRef, metrics: Metrics, range: ChartRange): Promise<DataResponse<ChartBundle<Metrics>>>;
+  /**
+   * {@inheritDoc IPositionsOffchainOnly.transactions}
+   **/
+  transactions(key: StrategyPositionRef): Promise<DataResponse<PositionTransaction[]>>;
+  /**
+   * {@inheritDoc IPositionsOnchainOnly.getCurrentWithdrawals}
+   **/
+  getCurrentWithdrawals(props: GetCurrentWithdrawalsProps<true>): Promise<DataResponse<PositionWithdrawals>>;
 }
 //#endregion
 export { PositionsNamespace };

package/dist/types/sdk/positions/index.d.ts

@@ -1,3 +1,3 @@
-import { PositionMergers, Positions, PositionsBase, PositionsByMode, PositionsOffchainBranch, PositionsOffchainOnly, PositionsOnchainBranch, PositionsOnchainOnly } from "./types.js";
+import { IPositionMergers, IPositions, IPositionsBase, IPositionsByMode, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly } from "./types.js";
 import { PositionsNamespace } from "./PositionsNamespace.js";
-export { PositionMergers, Positions, PositionsBase, PositionsByMode, PositionsNamespace, PositionsOffchainBranch, PositionsOffchainOnly, PositionsOnchainBranch, PositionsOnchainOnly };
+export { IPositionMergers, IPositions, IPositionsBase, IPositionsByMode, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly, PositionsNamespace };

package/dist/types/sdk/positions/mergePositionList.d.ts

@@ -9,6 +9,11 @@ import { MergeListResult } from "../utils/types.js";
  * `name` onto every strategy row the backend has — even when that chain was
  * served from on-chain data because the backend was stale.
  *
+ * Liquidation rows are merged independently: the backend does not serve them
+ * yet, so a fresh off-chain list must not drop on-chain liquidations. Once it
+ * does return them, they follow the same freshness rule as the rest of the
+ * list.
+ *
  * The chain resolves `targetCollateral` from a per-account override or the
  * credit manager's single target token. The backend's historical value is
  * still preferred when it has the row. `name` is derived from that collateral,

package/dist/types/sdk/positions/types.d.ts

@@ -1,25 +1,26 @@
+import { PoolPositionRef, Position, PositionFilter, PositionTransaction, PositionsTotals, StrategyPositionRef } from "../../model/positions.js";
 import { ChartBundle, ChartRange, PoolPositionChartMetric, StrategyPositionChartMetric } from "../../model/charts.js";
-import { PoolPositionRef, Position, PositionFilter, StrategyPositionRef } from "../../model/positions.js";
 import { DataResponse } from "../../model/response.js";
+import { PositionWithdrawals } from "../../model/withdrawals.js";
 import "../../model/index.js";
-import { MultichainPositionsService } from "../../onchain/positions/MultichainPositionsService.js";
+import { GetCurrentWithdrawalsProps, IMultichainPositionsService } from "../../onchain/positions/types.js";
 import "../../onchain/index.js";
-import { OffchainPositions } from "../../offchain/positions/OffchainPositions.js";
+import { IOffchainPositions } from "../../offchain/positions/types.js";
 import "../../offchain/index.js";
-import { Mode } from "../types.js";
 import { FilterResult, ListMerger } from "../utils/types.js";
 import "../utils/index.js";
+import { Mode } from "../types.js";
 import { Address } from "viem";
 //#region src/sdk/positions/types.d.ts
 /**
  * What the `positions` namespace offers in every mode.
  **/
-interface PositionsBase {
+interface IPositionsBase {
   /**
    * Everything a wallet holds: its pool shares, its credit accounts and the
    * delayed withdrawals it took over by liquidating, optionally narrowed. In
    * `both` mode each chain is served by whichever source is fresh enough, see
-   * {@link PositionMergers}.
+   * {@link IPositionMergers}.
    **/
   list(wallet: Address, filter?: PositionFilter): Promise<DataResponse<Position[]>>;
   /**
@@ -28,26 +29,24 @@ interface PositionsBase {
    * narrows to a list.
    **/
   filter<R extends DataResponse<Position[]> | undefined>(response: R, filter?: PositionFilter): FilterResult<R, Position>;
-  /**
-   * The chain on its own, for a consumer that shows each source as it arrives.
-   * Throws in `offchain` mode.
-   **/
-  readonly onchain: MultichainPositionsService;
-  /**
-   * The backend on its own, see {@link PositionsBase.onchain}. Throws in
-   * `onchain` mode.
-   **/
-  readonly offchain: OffchainPositions;
   /**
    * Merge policy of each read, for a consumer combining the two branches
-   * itself, see {@link PositionMergers}.
+   * itself, see {@link IPositionMergers}.
    **/
-  readonly merge: PositionMergers;
+  readonly merge: IPositionMergers;
 }
 /**
  * Reads only a backend can answer.
  **/
-interface PositionsOffchainOnly {
+interface IPositionsOffchainOnly {
+  /**
+   * Aggregate over everything a wallet holds: the list screen's badges, see
+   * {@link PositionsTotals}.
+   *
+   * Absent in `onchain` mode: it is served by the backend rather than summed
+   * from the chain.
+   **/
+  totals(wallet: Address): Promise<DataResponse<PositionsTotals>>;
   /**
    * Historical charts of one position, one series per metric on a shared axis:
    * `charts(key, ["apy", "mwr"], "1m")`.
@@ -58,42 +57,59 @@ interface PositionsOffchainOnly {
    **/
   charts<const Metrics extends readonly PoolPositionChartMetric[]>(key: PoolPositionRef, metrics: Metrics, range: ChartRange): Promise<DataResponse<ChartBundle<Metrics>>>;
   charts<const Metrics extends readonly StrategyPositionChartMetric[]>(key: StrategyPositionRef, metrics: Metrics, range: ChartRange): Promise<DataResponse<ChartBundle<Metrics>>>;
+  /**
+   * History of one strategy position: every transaction that touched the
+   * credit account while its current session was open, newest first. There is
+   * no paging, and an account with no open session answers with an empty list.
+   *
+   * Absent in `onchain` mode: the history is indexed by the backend rather
+   * than reconstructed from the chain.
+   **/
+  transactions(key: StrategyPositionRef): Promise<DataResponse<PositionTransaction[]>>;
 }
 /**
- * Reads only the chain can answer. Empty for now.
+ * Reads only the chain can answer.
  **/
-interface PositionsOnchainOnly {}
+interface IPositionsOnchainOnly {
+  /**
+   * Delayed withdrawals of one credit account: claimable rows carry the
+   * adapter call and recorded intent a claim is built from; pending rows
+   * name when they mature. Absent in `offchain` mode.
+   **/
+  getCurrentWithdrawals(props: GetCurrentWithdrawalsProps<true>): Promise<DataResponse<PositionWithdrawals>>;
+}
 /**
- * Which reads the `positions` namespace has in each mode. A widened mode offers
- * what every mode has, i.e. {@link PositionsBase} alone.
+ * The chain on its own, for a consumer that shows each source as it arrives.
+ * Absent in `offchain` mode.
  **/
-interface PositionsOnchainBranch {
-  readonly onchain: MultichainPositionsService;
+interface IPositionsOnchainBranch {
+  readonly onchain: IMultichainPositionsService;
 }
 /**
- * The backend on its own, see {@link PositionsOnchainBranch}.
+ * The backend on its own, see {@link IPositionsOnchainBranch}. Absent in
+ * `onchain` mode.
  **/
-interface PositionsOffchainBranch {
-  readonly offchain: OffchainPositions;
+interface IPositionsOffchainBranch {
+  readonly offchain: IOffchainPositions;
 }
 /**
  * Merge policy of each read, exposed so that a consumer reading the two
  * branches itself combines them exactly as `both` mode would.
  **/
-interface PositionMergers {
+interface IPositionMergers {
   list: ListMerger<Position[]>;
 }
 /**
  * Which methods the `positions` namespace has in each mode.
  **/
-interface PositionsByMode {
-  onchain: PositionsBase & PositionsOnchainOnly;
-  offchain: PositionsBase & PositionsOffchainOnly;
-  both: PositionsBase & PositionsOnchainOnly & PositionsOffchainOnly;
+interface IPositionsByMode {
+  onchain: IPositionsBase & IPositionsOnchainOnly & IPositionsOnchainBranch;
+  offchain: IPositionsBase & IPositionsOffchainOnly & IPositionsOffchainBranch;
+  both: IPositionsBase & IPositionsOnchainOnly & IPositionsOffchainOnly & IPositionsOnchainBranch & IPositionsOffchainBranch;
 }
 /**
  * The `positions` namespace of a {@link GearboxSDK} in mode `M`.
  **/
-type Positions<M extends Mode = Mode> = PositionsByMode[M];
+type IPositions<M extends Mode = Mode> = IPositionsByMode[M];
 //#endregion
-export { PositionMergers, Positions, PositionsBase, PositionsByMode, PositionsOffchainBranch, PositionsOffchainOnly, PositionsOnchainBranch, PositionsOnchainOnly };
+export { IPositionMergers, IPositions, IPositionsBase, IPositionsByMode, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly };

package/dist/types/sdk/prepare/PrepareApi.d.ts

@@ -1,95 +1,115 @@
-import { ChainId } from "../../model/primitives.js";
-import { DataResponse } from "../../model/response.js";
+import { Bps, ChainId } from "../../model/primitives.js";
+import { PositionCollateral, StrategyPosition } from "../../model/positions.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
+import { Asset } from "../../onchain/base/types.js";
 import { OnchainSDK } from "../../onchain/OnchainSDK.js";
 import { MultichainSDK } from "../../onchain/MultichainSDK.js";
-import { ChainQueryOneProps, MultichainConstruct } from "../../onchain/base/MultichainConstruct.js";
+import { MultichainConstruct } from "../../onchain/base/MultichainConstruct.js";
+import { LeverageBand } from "../../onchain/accounts/intents/leverage-band.js";
+import { WithdrawCeilings } from "../../onchain/accounts/intents/types.js";
 import "../../onchain/index.js";
+import { AccountFlowError, DebtOutOfRangeError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
+import { AddCollateralParams, AdjustLeverageParams, DepositStrategyParams, FinalizeParams, FinalizeResult, IOpportunitiesPrepare, LpParams, LpRedeemParams, LpResult, OpenStrategyParams, OpenStrategyResult, PoolInput, PositionInput, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
 import { EnsureFreshChains } from "../types.js";
-import { AddCollateralParams, AdjustLeverageParams, DepositStrategyParams, FinalizeParams, LpParams, LpRedeemParams, LpSimulate, OpenStrategyParams, OpenStrategySimulate, OpportunitiesPrepare, PoolInput, PositionInput, RepayStrategyParams, StrategyInput, StrategyRoutesSimulate, StrategySimulate, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
 import { Address } from "viem";
 //#region src/sdk/prepare/PrepareApi.d.ts
 /**
  * The chain's SDK, resolved on the spot.
  *
- * The LP simulations need it synchronously, because they only do arithmetic on
+ * The LP methods need it synchronously, because they only do arithmetic on
  * loaded state and have nothing to await; the execute namespace resolves its
  * chain the same way.
  **/
 type ChainOf = (chainId: ChainId) => OnchainSDK;
 /**
- * {@inheritDoc OpportunitiesPrepare}
+ * {@inheritDoc IOpportunitiesPrepare}
  *
  * Holds no state of its own: it owns the mapping from the public,
  * read-model-shaped request to the engine's intent, and nothing else. All
  * protocol knowledge stays in `CreditAccountOperationsService` and
  * `PoolService`.
  *
- * A simulation names one chain, so it reads through
- * {@link MultichainConstruct.queryChain}: there is no second source to fall back
- * to, hence a chain the SDK does not cover, or one that fails the read, throws
- * rather than answering with empty metadata.
+ * A prepared operation names one chain and reads it directly: there is no
+ * second source to fall back to, so a chain the SDK does not cover, or one
+ * that fails the read, is a failure of the whole request rather than a thinner
+ * answer.
+ *
+ * No refusable async method here throws. Every way such a preparation can
+ * fail — the market's own refusals, the ones the namespace decides itself, and
+ * anything the chain or the engine raises — comes back in the failure half of
+ * its `SDKReturn`, under the codes that method's signature names. A caller
+ * writes one branch, not a branch and a `try`. The synchronous LP methods and
+ * the bare `max*` reads throw on bugs and lifecycle errors instead, see
+ * {@link IOpportunitiesPrepare}.
  **/
-declare class PrepareApi extends MultichainConstruct implements OpportunitiesPrepare {
+declare class PrepareApi extends MultichainConstruct implements IOpportunitiesPrepare {
   #private;
   constructor(sdk: MultichainSDK, ensureFresh?: EnsureFreshChains);
-  protected queryChain<T>(props: ChainQueryOneProps<T>): Promise<DataResponse<T>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.finalize}
+   * {@inheritDoc IOpportunitiesPrepare.finalize}
+   **/
+  finalize(position: PositionInput, params: FinalizeParams): Promise<SDKReturn<FinalizeResult, AccountFlowError | NoRecordedIntentError | NoDelayedRouteError | WithdrawalInProgressError | UnsupportedTokenPairError>>;
+  /**
+   * {@inheritDoc IOpportunitiesPrepare.deposit}
+   **/
+  deposit(pool: PoolInput, params: LpParams): Promise<SDKReturn<LpResult, UnsupportedTokenPairError | UnexpectedFailureError>>;
+  /**
+   * {@inheritDoc IOpportunitiesPrepare.withdraw}
    **/
-  finalize(position: PositionInput, params: FinalizeParams): Promise<DataResponse<StrategySimulate>>;
+  withdraw(pool: PoolInput, params: LpParams): Promise<SDKReturn<LpResult, UnsupportedTokenPairError | UnexpectedFailureError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.deposit}
+   * {@inheritDoc IOpportunitiesPrepare.redeem}
    **/
-  deposit(pool: PoolInput, params: LpParams): LpSimulate;
+  redeem(pool: PoolInput, params: LpRedeemParams): Promise<SDKReturn<LpResult, UnsupportedTokenPairError | UnexpectedFailureError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.withdraw}
+   * {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
    **/
-  withdraw(pool: PoolInput, params: LpParams): LpSimulate;
+  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.redeem}
+   * {@inheritDoc IOpportunitiesPrepare.depositStrategy}
    **/
-  redeem(pool: PoolInput, params: LpRedeemParams): LpSimulate;
+  depositStrategy(position: PositionInput, params: DepositStrategyParams): Promise<SDKReturn<StrategyResult, AccountFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedCollateralTokenError | UnsupportedTokenPairError | InsufficientPoolLiquidityError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.openNewStrategy}
+   * {@inheritDoc IOpportunitiesPrepare.withdrawStrategy}
    **/
-  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<DataResponse<OpenStrategySimulate>>;
+  withdrawStrategy(position: PositionInput, params: WithdrawStrategyParams): Promise<SDKReturn<StrategyRoutesResult, (AccountFlowError | DebtOutOfRangeError | UnsupportedTokenPairError | NoDelayedRouteError | MultipleDelayedWithdrawalsError | WithdrawalInProgressError) & WithRouteRefusals>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.depositStrategy}
+   * {@inheritDoc IOpportunitiesPrepare.maxWithdraw}
    **/
-  depositStrategy(position: PositionInput, params: DepositStrategyParams): Promise<DataResponse<StrategySimulate>>;
+  maxWithdraw(position: PositionInput): Promise<WithdrawCeilings>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.withdrawStrategy}
+   * {@inheritDoc IOpportunitiesPrepare.repayStrategy}
    **/
-  withdrawStrategy(position: PositionInput, params: WithdrawStrategyParams): Promise<DataResponse<StrategyRoutesSimulate>>;
+  repayStrategy(position: PositionInput, params: RepayStrategyParams): Promise<SDKReturn<StrategyResult, AccountFlowError | DebtOutOfRangeError | UnsupportedCollateralTokenError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.maxWithdraw}
+   * {@inheritDoc IOpportunitiesPrepare.maxRepay}
    **/
-  maxWithdraw(position: PositionInput): Promise<DataResponse<bigint>>;
+  maxRepay(position: PositionInput): Promise<bigint>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.repayStrategy}
+   * {@inheritDoc IOpportunitiesPrepare.adjustLeverage}
    **/
-  repayStrategy(position: PositionInput, params: RepayStrategyParams): Promise<DataResponse<StrategySimulate>>;
+  adjustLeverage(position: PositionInput, params: AdjustLeverageParams): Promise<SDKReturn<StrategyRoutesResult, (AccountFlowError | DebtOutOfRangeError | UnsupportedTokenPairError | NoDelayedRouteError | MultipleDelayedWithdrawalsError | WithdrawalInProgressError | InsufficientPoolLiquidityError | LeverageOutOfRangeError) & WithRouteRefusals>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.maxRepay}
+   * {@inheritDoc IOpportunitiesPrepare.addCollateral}
    **/
-  maxRepay(position: PositionInput): Promise<DataResponse<bigint>>;
+  addCollateral(position: PositionInput, params: AddCollateralParams): Promise<SDKReturn<StrategyResult, AccountFlowError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.adjustLeverage}
+   * {@inheritDoc IOpportunitiesPrepare.withdrawCollateral}
    **/
-  adjustLeverage(position: PositionInput, params: AdjustLeverageParams): Promise<DataResponse<StrategyRoutesSimulate>>;
+  withdrawCollateral(position: PositionInput, params: WithdrawCollateralParams): Promise<SDKReturn<StrategyResult, AccountFlowError>>;
   /**
-   * {@inheritDoc OpportunitiesPrepare.addCollateral}
+   * {@inheritDoc IOpportunitiesPrepare.leverageBand}
    **/
-  addCollateral(position: PositionInput, params: AddCollateralParams): Promise<DataResponse<StrategySimulate>>;
+  leverageBand(strategy: StrategyInput, collateral: readonly Asset[], targetHF?: Bps): LeverageBand | undefined;
   /**
-   * {@inheritDoc OpportunitiesPrepare.withdrawCollateral}
+   * {@inheritDoc IOpportunitiesPrepare.withdrawableCollaterals}
    **/
-  withdrawCollateral(position: PositionInput, params: WithdrawCollateralParams): Promise<DataResponse<StrategySimulate>>;
+  withdrawableCollaterals(position: StrategyPosition): PositionCollateral[];
   /**
-   * {@inheritDoc OpportunitiesPrepare.maxWithdrawCollateral}
+   * {@inheritDoc IOpportunitiesPrepare.maxWithdrawCollateral}
    **/
-  maxWithdrawCollateral(position: PositionInput, token: Address): Promise<DataResponse<bigint>>;
+  maxWithdrawCollateral(position: PositionInput, token: Address, targetHF?: bigint): Promise<bigint>;
 }
 //#endregion
 export { ChainOf, PrepareApi };