@gearbox-protocol/sdk 16.0.0-next.42 → 16.0.0-next.44

package/dist/types/preview/parse/parsePoolOperationCalldata.d.ts

@@ -1,8 +1,11 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
 import { PoolV310Contract } from "../../onchain/market/pool/PoolV310Contract.js";
 import { OnchainSDK } from "../../onchain/OnchainSDK.js";
 import "../../onchain/index.js";
 import { PoolOperation } from "./types-pools.js";
 import "./types.js";
+import { UnsupportedPoolFunctionError } from "./errors.js";
 import { Hex } from "viem";
 //#region src/preview/parse/parsePoolOperationCalldata.d.ts
 /**
@@ -11,8 +14,8 @@ import { Hex } from "viem";
  * @param sdk - The SDK instance.
  * @param pool - The pool contract.
  * @param calldata - The calldata to parse.
- * @returns The parsed operation.
+ * @returns The parsed operation behind `ok`, or the refusal.
  */
-declare function parsePoolOperationCalldata(sdk: OnchainSDK, pool: PoolV310Contract, calldata: Hex): PoolOperation;
+declare function parsePoolOperationCalldata(sdk: OnchainSDK, pool: PoolV310Contract, calldata: Hex): SDKReturn<PoolOperation, UnsupportedPoolFunctionError>;
 //#endregion
 export { parsePoolOperationCalldata };

package/dist/types/preview/prerequisites/checkPrerequisites.d.ts

@@ -1,6 +1,11 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
+import { UnsupportedZapperFunctionError } from "../../onchain/market/zapper/errors.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import "../../onchain/index.js";
+import { UnsupportedPoolFunctionError, UnsupportedTargetError } from "../parse/errors.js";
 import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import "../parse/index.js";
 import { PrerequisiteResult } from "./types.js";
 //#region src/preview/prerequisites/checkPrerequisites.d.ts
 /**
@@ -18,6 +23,6 @@ import { PrerequisiteResult } from "./types.js";
  * (e.g. pool is paused) is intentionally out of scope, since the user cannot
  * resolve it.
  */
-declare function checkPrerequisites<P extends PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<PrerequisiteResult[]>;
+declare function checkPrerequisites<P extends PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<SDKReturn<PrerequisiteResult[], UnsupportedTargetError | UnsupportedPoolFunctionError | UnsupportedZapperFunctionError>>;
 //#endregion
 export { checkPrerequisites };

package/dist/types/preview/preview/detectDelayedClaim.d.ts

@@ -1,5 +1,7 @@
 import { DelayedIntent } from "../../model/delayed-intents.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
+import { InvalidDelayedIntentError } from "../../onchain/accounts/withdrawal-compressor/errors.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import { OnchainSDK } from "../../onchain/OnchainSDK.js";
 import "../../onchain/index.js";
@@ -41,12 +43,11 @@ declare function detectDelayedClaim<P extends PluginsMap>(sdk: OnchainSDK<P>, mu
  * @param sdk - Attached SDK.
  * @param multicall - Parsed inner operations of the multicall.
  * @param blockNumber - Optional block number to read the log at.
- * @returns The decoded intent, or `undefined` when the multicall claims
- * nothing, the redemption logger is not deployed, or the log carries no
- * intent.
- * @throws InvalidDelayedIntentError when the logged `extraData` is non-empty
- * but cannot be decoded as a `DelayedIntent`.
+ * @returns The decoded intent behind `ok` (`undefined` when the multicall
+ * claims nothing, the redemption logger is not deployed, or the log carries
+ * no intent), or the `invalidDelayedIntent` refusal when the logged
+ * `extraData` is non-empty but cannot be decoded as a `DelayedIntent`.
  */
-declare function resolveDelayedClaimIntent<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[], blockNumber?: bigint): Promise<DelayedIntent | undefined>;
+declare function resolveDelayedClaimIntent<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[], blockNumber?: bigint): Promise<SDKReturn<DelayedIntent | undefined, InvalidDelayedIntentError>>;
 //#endregion
 export { DetectedDelayedClaim, detectDelayedClaim, resolveDelayedClaimIntent };

package/dist/types/preview/preview/detectDelayedOperation.d.ts

@@ -1,5 +1,7 @@
 import { DelayedIntent } from "../../model/delayed-intents.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
+import { InvalidDelayedIntentError } from "../../onchain/accounts/withdrawal-compressor/errors.js";
 import { DelayedWithdrawalRequest } from "../../onchain/market/adapters/types.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import { OnchainSDK } from "../../onchain/OnchainSDK.js";
@@ -32,6 +34,6 @@ interface DetectedDelayedOperation {
  * @throws InvalidDelayedIntentError when a request carries non-empty
  * `extraData` that cannot be decoded as a `DelayedIntent`.
  */
-declare function detectDelayedOperation<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[]): DetectedDelayedOperation | undefined;
+declare function detectDelayedOperation<P extends PluginsMap>(sdk: OnchainSDK<P>, multicall: InnerOperation[]): SDKReturn<DetectedDelayedOperation | undefined, InvalidDelayedIntentError>;
 //#endregion
 export { DetectedDelayedOperation, detectDelayedOperation };

package/dist/types/preview/preview/errors.d.ts

@@ -1,12 +1,15 @@
+import { IGearboxError } from "../../model/errors.js";
+import "../../model/index.js";
 //#region src/preview/preview/errors.d.ts
 /**
- * Thrown by `previewOperation` for parsed operations it cannot preview yet.
- * Currently only pool operations and credit account opening are supported.
+ * Refusal answered by `previewOperation` for parsed operations it cannot
+ * preview yet. A plain returned object per the SDK's refusal vocabulary —
+ * not a thrown `Error`.
  */
-declare class UnsupportedOperationError extends Error {
+interface UnsupportedOperationError extends IGearboxError {
+  code: "unsupportedOperation";
   /** The parsed operation kind (the `operation` discriminant). */
-  readonly operation: string;
-  constructor(operation: string);
+  operation: string;
 }
 //#endregion
 export { UnsupportedOperationError };

package/dist/types/preview/preview/index.d.ts

@@ -7,7 +7,7 @@ import { UnsupportedOperationError } from "./errors.js";
 import { estimateClaimableAt } from "./estimateClaimableAt.js";
 import { previewAdjustStrategyPosition } from "./previewAdjustStrategyPosition.js";
 import { CloseOrRepayOperation, previewExitOrRepayStrategyPosition } from "./previewExitOrRepayStrategyPosition.js";
-import { previewOperation } from "./previewOperation.js";
+import { PreviewOperationError, previewOperation } from "./previewOperation.js";
 import { ReplayState, makeReplayState, replayInnerOperations } from "./replayInnerOperations.js";
 import { ReplayMulticallResult, ReplayableOperation, replayMulticall } from "./replayMulticall.js";
-export { CloseOrRepayOperation, CreditAccountState, CreditAccountStateProps, DetectedDelayedClaim, DetectedDelayedOperation, ReplayMulticallResult, ReplayState, ReplayableOperation, UnsupportedOperationError, buildDelayedStrategyPositionOperationPreview, classifyCloseOrRepay, detectDelayedClaim, detectDelayedOperation, estimateClaimableAt, isCloseOrRepay, makeReplayState, previewAdjustStrategyPosition, previewExitOrRepayStrategyPosition, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };
+export { CloseOrRepayOperation, CreditAccountState, CreditAccountStateProps, DetectedDelayedClaim, DetectedDelayedOperation, PreviewOperationError, ReplayMulticallResult, ReplayState, ReplayableOperation, UnsupportedOperationError, buildDelayedStrategyPositionOperationPreview, classifyCloseOrRepay, detectDelayedClaim, detectDelayedOperation, estimateClaimableAt, isCloseOrRepay, makeReplayState, previewAdjustStrategyPosition, previewExitOrRepayStrategyPosition, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };

package/dist/types/preview/preview/previewOperation.d.ts

@@ -1,13 +1,32 @@
 import { OperationPreview } from "../../model/previews.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
+import { InvalidDelayedIntentError } from "../../onchain/accounts/withdrawal-compressor/errors.js";
+import { UnsupportedZapperFunctionError } from "../../onchain/market/zapper/errors.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import "../../onchain/index.js";
+import { UnsupportedPoolFunctionError, UnsupportedTargetError } from "../parse/errors.js";
 import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import "../parse/index.js";
+import { UnsupportedOperationError } from "./errors.js";
+import { PreviewSimulationError } from "../simulate/errors.js";
 //#region src/preview/preview/previewOperation.d.ts
+/**
+ * Everything {@link previewOperation} can refuse with: the refusal errors
+ * its pipeline raises, discriminated by `code`. Each is a plain object —
+ * never a thrown `Error` — per the SDK's refusal vocabulary.
+ */
+type PreviewOperationError = UnsupportedTargetError | UnsupportedPoolFunctionError | UnsupportedZapperFunctionError | UnsupportedOperationError | InvalidDelayedIntentError | PreviewSimulationError;
 /**
  * Previews a raw operation calldata: decodes it into a typed operation and
  * assembles an operation-specific, human-displayable preview.
+ *
+ * Answers an {@link SDKReturn} envelope: the preview behind `ok: true`, or —
+ * when the transaction is one the previewer refuses to read — a
+ * {@link PreviewOperationError} behind `ok: false`. A thrown exception
+ * still means the SDK could not do its job (a read failed, the targeted
+ * credit account could not be resolved), not a refusal of the transaction.
  */
-declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<OperationPreview>;
+declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<SDKReturn<OperationPreview, PreviewOperationError>>;
 //#endregion
-export { previewOperation };
+export { PreviewOperationError, previewOperation };

package/dist/types/preview/preview/previewPoolPositionOperation.d.ts

@@ -1,11 +1,13 @@
 import { PoolPositionOperationPreview } from "../../model/previews.js";
+import { SDKReturn } from "../../model/result.js";
 import "../../model/index.js";
 import { PluginsMap } from "../../onchain/plugins/types.js";
 import "../../onchain/index.js";
 import { PoolOperation } from "../parse/types-pools.js";
 import { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
 import "../parse/index.js";
+import { PreviewSimulationError } from "../simulate/errors.js";
 //#region src/preview/preview/previewPoolPositionOperation.d.ts
-declare function previewPoolPositionOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: PreviewOperationOptions): Promise<PoolPositionOperationPreview>;
+declare function previewPoolPositionOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: PreviewOperationOptions): Promise<SDKReturn<PoolPositionOperationPreview, PreviewSimulationError>>;
 //#endregion
 export { previewPoolPositionOperation };

package/dist/types/preview/simulate/errors.d.ts

@@ -1,4 +1,6 @@
-import { BaseError, Hex } from "viem";
+import { IGearboxError } from "../../model/errors.js";
+import "../../model/index.js";
+import { Hex } from "viem";
 //#region src/preview/simulate/errors.d.ts
 /** Which simulation flow produced a failure. */
 type SimulationFlowSource = "multicall" | "unknown";
@@ -8,14 +10,16 @@ interface SimulationFlowFailure {
   detail: SimulationError;
 }
 /**
- * Error returned by the pool simulation when it fails. It wraps the flow's
- * decoded revert reason (see {@link failures}).
+ * Refusal answered when the pool simulation fails. It wraps each flow's
+ * decoded revert reason (see {@link failures}). A plain returned object per
+ * the SDK's refusal vocabulary — not a thrown `Error`.
  */
-declare class PreviewSimulationError extends BaseError {
-  name: string;
-  /** Per-flow decoded failures behind this error. */
-  readonly failures: SimulationFlowFailure[];
-  constructor(failures: SimulationFlowFailure[]);
+interface PreviewSimulationError extends IGearboxError {
+  code: "previewSimulationFailed";
+  /** Per-flow decoded failures behind this refusal. */
+  failures: SimulationFlowFailure[];
+  /** First flow failure that was itself an `Error`, kept for debugging. */
+  cause?: Error;
 }
 /**
  * Normalises an unknown rejection reason into a {@link PreviewSimulationError}.

package/dist/types/preview/simulate/index.d.ts

@@ -1,7 +1,7 @@
-import { PreviewSimulationError, SimulationError, SimulationFlowFailure, SimulationFlowSource } from "./errors.js";
+import { PreviewSimulationError, SimulationError, SimulationFlowFailure, SimulationFlowSource, asPreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateOperation } from "./simulateOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
 import { simulateRWAOperation } from "./simulateRWAOperation.js";
-export { type PoolOperationSimulationResult, PreviewSimulationError, type SimulationError, type SimulationFlowFailure, type SimulationFlowSource, type SimulationInput, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };
+export { type PoolOperationSimulationResult, type PreviewSimulationError, type SimulationError, type SimulationFlowFailure, type SimulationFlowSource, type SimulationInput, asPreviewSimulationError, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };

package/dist/types/preview/simulate/simulateOperation.d.ts

@@ -1,9 +1,12 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
 import { PreviewOperationOptions } from "../types.js";
+import { PreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 //#region src/preview/simulate/simulateOperation.d.ts
 /**
  * Simulates a parsed pool or credit account operation
  */
-declare function simulateOperation(input: SimulationInput, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;
+declare function simulateOperation(input: SimulationInput, options?: PreviewOperationOptions): Promise<SDKReturn<PoolOperationSimulationResult, PreviewSimulationError>>;
 //#endregion
 export { simulateOperation };

package/dist/types/preview/simulate/simulatePoolOperation.d.ts

@@ -1,6 +1,9 @@
+import { SDKReturn } from "../../model/result.js";
+import "../../model/index.js";
 import { PoolOperation } from "../parse/types-pools.js";
 import { PreviewOperationOptions } from "../types.js";
 import "../parse/index.js";
+import { PreviewSimulationError } from "./errors.js";
 import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 //#region src/preview/simulate/simulatePoolOperation.d.ts
 /**
@@ -17,6 +20,6 @@ import { PoolOperationSimulationResult, SimulationInput } from "./types.js";
  * It does not execute the calldata, so it ignores balance/allowance
  * prerequisites (preview reads succeed regardless).
  */
-declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;
+declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<SDKReturn<PoolOperationSimulationResult, PreviewSimulationError>>;
 //#endregion
 export { simulatePoolOperation };

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

@@ -1,10 +1,11 @@
 import { ChainId } from "../../model/primitives.js";
+import { SDKResult } from "../../model/result.js";
 import "../../model/index.js";
 import { Asset } from "../../onchain/base/types.js";
 import { SecuritizeRegisterMessage } from "../../onchain/market/rwa/securitize/types.js";
 import { RawTx } from "../../onchain/types/transactions.js";
 import "../../onchain/index.js";
-import { LpPrepare, OpenStrategyPrepare, StrategyPrepare } from "../prepare/types.js";
+import { LpResult, OpenStrategyResult, StrategyResult } from "../prepare/types.js";
 import "../prepare/index.js";
 import { Address } from "viem";
 //#region src/sdk/execute/types.d.ts
@@ -21,9 +22,7 @@ interface PoolPrepareRequest {
   pool: Address;
   wallet: Address;
   op: "deposit" | "withdraw" | "redeem";
-  sim: Extract<LpPrepare, {
-    success: true;
-  }>;
+  sim: SDKResult<LpResult>;
 }
 /**
  * Opening a new position, from a viable
@@ -36,9 +35,7 @@ interface OpenPrepareRequest {
   chainId: ChainId;
   creditManager: Address;
   wallet: Address;
-  sim: Extract<OpenStrategyPrepare, {
-    success: true;
-  }>;
+  sim: SDKResult<OpenStrategyResult>;
   /** What leaves the wallet, token by token. */
   collateral: Asset[];
   /** Native value to attach when paying a wrapped-native market in the coin. */
@@ -56,16 +53,14 @@ interface OpenPrepareRequest {
 }
 /**
  * Any of the five operations on an existing account, from a viable
- * {@link StrategyPrepare}: the facade multicall is the result's `calls`.
+ * {@link StrategyResult}: the facade multicall is the result's `calls`.
  **/
 interface AccountPrepareRequest {
   kind: "account";
   chainId: ChainId;
   creditAccount: Address;
   wallet: Address;
-  sim: Extract<StrategyPrepare, {
-    success: true;
-  }>;
+  sim: SDKResult<StrategyResult>;
 }
 /**
  * What {@link IOpportunitiesExecute.buildTx} turns into a transaction: a

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

@@ -2,8 +2,8 @@ import { BorrowLimitBinding, IntentPreviewError, PreviewErrorDetails, PreviewErr
 import { LeverageBand } from "../onchain/accounts/intents/leverage-band.js";
 import { OperationState, PathLossRate } from "../onchain/accounts/intents/types.js";
 import { ILiquidations, ILiquidationsByMode } from "./liquidations/types.js";
-import { CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, PoolSunsetError, PrepareError, QuotaCountExceededError, QuotaLimitReachedError, RoutesPrepareError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toPrepareError, unexpectedFailure } from "./prepare/errors.js";
-import { AddCollateralParams, AdjustLeverageParams, AmountPrepare, DelayedStrategyPlan, DelayedStrategyPrepare, DepositStrategyParams, FinalizeParams, IOpportunitiesPrepare, LpParams, LpPlan, LpPrepare, LpRedeemParams, OpenStrategyParams, OpenStrategyPlan, OpenStrategyPrepare, PoolInput, PositionInput, PrepareOptions, RepayStrategyParams, StrategyInput, StrategyPlan, StrategyPrepare, StrategyRoutes, StrategyRoutesPrepare, WithdrawCollateralParams, WithdrawStrategyParams } from "./prepare/types.js";
+import { AccountFlowError, CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./prepare/errors.js";
+import { AddCollateralParams, AdjustLeverageParams, DelayedStrategyResult, DepositStrategyParams, FinalizeParams, IOpportunitiesPrepare, LpParams, LpRedeemParams, LpResult, OpenStrategyParams, OpenStrategyResult, PoolInput, PositionInput, PrepareOptions, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, WithdrawCollateralParams, WithdrawStrategyParams } from "./prepare/types.js";
 import { ChainOf, PrepareApi } from "./prepare/PrepareApi.js";
 import "./prepare/index.js";
 import { AccountPrepareRequest, IOpportunitiesExecute, OpenPrepareRequest, PoolPrepareRequest, PrepareRequest } from "./execute/types.js";
@@ -35,4 +35,4 @@ import { SourceUnavailableError } from "./errors/SourceUnavailableError.js";
 import { assertSameChains } from "./errors/assertSameChains.js";
 import { everyChainFailed } from "./errors/everyChainFailed.js";
 import "./errors/index.js";
-export { AbstractNamespace, AccountPrepareRequest, AddCollateralParams, AdjustLeverageParams, AllSourcesFailedError, AmountPrepare, BorrowLimitBinding, ChainOf, ChainRef, CreditAccountNotFoundError, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, DebtOutOfRangeError, DelayedStrategyPlan, DelayedStrategyPrepare, DepositStrategyParams, EnsureFreshChains, type EntityMerger, ExecuteApi, type FilterResult, FinalizeParams, ForbiddenTokenError, GearboxSDK, GearboxSDKOptions, IGearboxSDK, ILiquidations, ILiquidationsByMode, INotices, INoticesByMode, IOpportunities, IOpportunitiesBase, IOpportunitiesByMode, IOpportunitiesExecute, IOpportunitiesOffchainBranch, IOpportunitiesOffchainOnly, IOpportunitiesOnchainBranch, IOpportunitiesOnchainOnly, IOpportunitiesPrepare, IOpportunityMergers, IPositionMergers, IPositions, IPositionsBase, IPositionsByMode, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly, IPreview, IPreviewByMode, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, IntentPreviewError, type LeverageBand, LeverageOutOfRangeError, LiquidationsNamespace, type ListMerger, LpParams, LpPlan, LpPrepare, LpRedeemParams, MalformedTransactionError, MarketExpiredError, MarketPausedError, type MergeListResult, MergedQuery, MissingSourceError, Mode, MultipleDelayedWithdrawalsError, NamespaceOptions, NoDelayedRouteError, NoRecordedIntentError, NoSourceServedError, NoStrategyTargetCollateralError, OffchainByMode, OffchainSource, OnchainByMode, OnchainSource, OpenPrepareRequest, OpenStrategyParams, OpenStrategyPlan, OpenStrategyPrepare, type OperationState, OpportunitiesNamespace, type PathLossRate, PlainMultichainSDKOptions, PoolInput, PoolPrepareRequest, PoolSunsetError, PositionInput, PositionsNamespace, PrepareApi, PrepareError, PrepareOptions, PrepareRequest, PreviewErrorDetails, PreviewErrorReason, PreviewIssue, PreviewNamespace, PreviewRefusal, QuotaCountExceededError, QuotaLimitReachedError, RepayStrategyParams, RoutesPrepareError, SourceChainMismatchError, SourceUnavailableError, StrategyInput, StrategyPlan, StrategyPrepare, StrategyRoutes, StrategyRoutesPrepare, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithdrawCollateralParams, WithdrawStrategyParams, WithdrawalInProgressError, assertSameChains, creditAccountNotFound, everyChainFailed, filterResponse, mergeChainList, mergeChainOne, noStrategyTargetCollateral, raise, refuse, toPrepareError, unexpectedFailure };
+export { AbstractNamespace, AccountFlowError, AccountPrepareRequest, AddCollateralParams, AdjustLeverageParams, AllSourcesFailedError, BorrowLimitBinding, ChainOf, ChainRef, CreditAccountNotFoundError, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, DebtOutOfRangeError, DelayedStrategyResult, DepositStrategyParams, EnsureFreshChains, type EntityMerger, ExecuteApi, type FilterResult, FinalizeParams, ForbiddenTokenError, GearboxSDK, GearboxSDKOptions, IGearboxSDK, ILiquidations, ILiquidationsByMode, INotices, INoticesByMode, IOpportunities, IOpportunitiesBase, IOpportunitiesByMode, IOpportunitiesExecute, IOpportunitiesOffchainBranch, IOpportunitiesOffchainOnly, IOpportunitiesOnchainBranch, IOpportunitiesOnchainOnly, IOpportunitiesPrepare, IOpportunityMergers, IPositionMergers, IPositions, IPositionsBase, IPositionsByMode, IPositionsOffchainBranch, IPositionsOffchainOnly, IPositionsOnchainBranch, IPositionsOnchainOnly, IPreview, IPreviewByMode, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, IntentPreviewError, type LeverageBand, LeverageOutOfRangeError, LiquidationsNamespace, type ListMerger, LpParams, LpRedeemParams, LpResult, MalformedTransactionError, MarketExpiredError, MarketPausedError, type MergeListResult, MergedQuery, MissingSourceError, Mode, MultipleDelayedWithdrawalsError, NamespaceOptions, NoDelayedRouteError, NoRecordedIntentError, NoSourceServedError, NoStrategyTargetCollateralError, OffchainByMode, OffchainSource, OnchainByMode, OnchainSource, OpenFlowError, OpenPrepareRequest, OpenStrategyParams, OpenStrategyResult, type OperationState, OpportunitiesNamespace, type PathLossRate, PlainMultichainSDKOptions, PoolInput, PoolPrepareRequest, PoolSunsetError, PositionInput, PositionsNamespace, PrepareApi, PrepareOptions, PrepareRequest, PreviewErrorDetails, PreviewErrorReason, PreviewIssue, PreviewNamespace, PreviewRefusal, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, RepayStrategyParams, SourceChainMismatchError, SourceUnavailableError, StrategyInput, StrategyResult, StrategyRoutesResult, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawCollateralParams, WithdrawStrategyParams, WithdrawalInProgressError, assertSameChains, creditAccountNotFound, everyChainFailed, filterResponse, mergeChainList, mergeChainOne, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };

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

@@ -1,14 +1,15 @@
 import { Bps, ChainId } from "../../model/primitives.js";
 import { PositionCollateral, StrategyPosition } from "../../model/positions.js";
-import { DataResponse } from "../../model/response.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 "../../onchain/index.js";
-import { AddCollateralParams, AdjustLeverageParams, AmountPrepare, DepositStrategyParams, FinalizeParams, IOpportunitiesPrepare, LpParams, LpPrepare, LpRedeemParams, OpenStrategyParams, OpenStrategyPrepare, PoolInput, PositionInput, RepayStrategyParams, StrategyInput, StrategyPrepare, StrategyRoutesPrepare, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
+import { AccountFlowError, DebtOutOfRangeError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
+import { AddCollateralParams, AdjustLeverageParams, DepositStrategyParams, FinalizeParams, IOpportunitiesPrepare, LpParams, LpRedeemParams, LpResult, OpenStrategyParams, OpenStrategyResult, PoolInput, PositionInput, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
 import { EnsureFreshChains } from "../types.js";
 import { Address } from "viem";
 //#region src/sdk/prepare/PrepareApi.d.ts
@@ -28,72 +29,74 @@ type ChainOf = (chainId: ChainId) => OnchainSDK;
  * protocol knowledge stays in `CreditAccountOperationsService` and
  * `PoolService`.
  *
- * A prepared operation 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, is a
- * failure of the whole request rather than a thinner answer.
+ * 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 method here throws. Every way a preparation can fail — the market's own
- * refusals, the two the namespace decides itself, and anything the chain or the
- * engine raises — comes back described in the envelope, see {@link PrepareError}.
- * A caller writes one branch, not a branch and a `try`.
+ * 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 IOpportunitiesPrepare {
   #private;
   constructor(sdk: MultichainSDK, ensureFresh?: EnsureFreshChains);
-  protected queryChain<T>(props: ChainQueryOneProps<T>): Promise<DataResponse<T>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.finalize}
    **/
-  finalize(position: PositionInput, params: FinalizeParams): Promise<DataResponse<StrategyPrepare>>;
+  finalize(position: PositionInput, params: FinalizeParams): Promise<SDKReturn<StrategyResult, AccountFlowError | NoRecordedIntentError | NoDelayedRouteError | WithdrawalInProgressError | UnsupportedTokenPairError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.deposit}
    **/
-  deposit(pool: PoolInput, params: LpParams): LpPrepare;
+  deposit(pool: PoolInput, params: LpParams): SDKReturn<LpResult, UnsupportedTokenPairError>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.withdraw}
    **/
-  withdraw(pool: PoolInput, params: LpParams): LpPrepare;
+  withdraw(pool: PoolInput, params: LpParams): SDKReturn<LpResult, UnsupportedTokenPairError>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.redeem}
    **/
-  redeem(pool: PoolInput, params: LpRedeemParams): LpPrepare;
+  redeem(pool: PoolInput, params: LpRedeemParams): SDKReturn<LpResult, UnsupportedTokenPairError>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
    **/
-  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<DataResponse<OpenStrategyPrepare>>;
+  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.depositStrategy}
    **/
-  depositStrategy(position: PositionInput, params: DepositStrategyParams): Promise<DataResponse<StrategyPrepare>>;
+  depositStrategy(position: PositionInput, params: DepositStrategyParams): Promise<SDKReturn<StrategyResult, AccountFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedCollateralTokenError | UnsupportedTokenPairError | InsufficientPoolLiquidityError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.withdrawStrategy}
    **/
-  withdrawStrategy(position: PositionInput, params: WithdrawStrategyParams): Promise<DataResponse<StrategyRoutesPrepare>>;
+  withdrawStrategy(position: PositionInput, params: WithdrawStrategyParams): Promise<SDKReturn<StrategyRoutesResult, (AccountFlowError | DebtOutOfRangeError | UnsupportedTokenPairError | NoDelayedRouteError | MultipleDelayedWithdrawalsError | WithdrawalInProgressError) & WithRouteRefusals>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.maxWithdraw}
    **/
-  maxWithdraw(position: PositionInput): Promise<DataResponse<AmountPrepare>>;
+  maxWithdraw(position: PositionInput): Promise<bigint>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.repayStrategy}
    **/
-  repayStrategy(position: PositionInput, params: RepayStrategyParams): Promise<DataResponse<StrategyPrepare>>;
+  repayStrategy(position: PositionInput, params: RepayStrategyParams): Promise<SDKReturn<StrategyResult, AccountFlowError | DebtOutOfRangeError | UnsupportedCollateralTokenError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.maxRepay}
    **/
-  maxRepay(position: PositionInput): Promise<DataResponse<AmountPrepare>>;
+  maxRepay(position: PositionInput): Promise<bigint>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.adjustLeverage}
    **/
-  adjustLeverage(position: PositionInput, params: AdjustLeverageParams): Promise<DataResponse<StrategyRoutesPrepare>>;
+  adjustLeverage(position: PositionInput, params: AdjustLeverageParams): Promise<SDKReturn<StrategyRoutesResult, (AccountFlowError | DebtOutOfRangeError | UnsupportedTokenPairError | NoDelayedRouteError | MultipleDelayedWithdrawalsError | WithdrawalInProgressError | InsufficientPoolLiquidityError | LeverageOutOfRangeError) & WithRouteRefusals>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.addCollateral}
    **/
-  addCollateral(position: PositionInput, params: AddCollateralParams): Promise<DataResponse<StrategyPrepare>>;
+  addCollateral(position: PositionInput, params: AddCollateralParams): Promise<SDKReturn<StrategyResult, AccountFlowError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.withdrawCollateral}
    **/
-  withdrawCollateral(position: PositionInput, params: WithdrawCollateralParams): Promise<DataResponse<StrategyPrepare>>;
+  withdrawCollateral(position: PositionInput, params: WithdrawCollateralParams): Promise<SDKReturn<StrategyResult, AccountFlowError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.leverageBand}
    **/
@@ -105,7 +108,7 @@ declare class PrepareApi extends MultichainConstruct implements IOpportunitiesPr
   /**
    * {@inheritDoc IOpportunitiesPrepare.maxWithdrawCollateral}
    **/
-  maxWithdrawCollateral(position: PositionInput, token: Address, targetHF?: bigint): Promise<DataResponse<AmountPrepare>>;
+  maxWithdrawCollateral(position: PositionInput, token: Address, targetHF?: bigint): Promise<bigint>;
 }
 //#endregion
 export { ChainOf, PrepareApi };

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

@@ -18,13 +18,20 @@ import { Address } from "viem";
  * `prepare` and `preview` refusing in one vocabulary; what differs is where the
  * numbers sit. The engine keeps them one level down, in `detail`, because it
  * distributes them over `reason`; here they are stated outright, so it is
- * `error.maxDebt` rather than `error.detail.maxDebt`. The last three are the
- * namespace's own, raised before or around the engine.
+ * `error.maxDebt` rather than `error.detail.maxDebt`.
  *
- * Nothing else comes out of a `prepare` method: every failure on the way to an
- * answer, the ones that used to be thrown included, is one of these.
+ * There is deliberately no union of all of them: each `prepare` method names
+ * exactly the codes its own flow can raise, see the signatures in
+ * {@link IOpportunitiesPrepare}. What is shared is the plumbing every flow
+ * goes through, and that is the two base unions below.
  **/
-type PrepareError = DebtOutOfRangeError | LeverageOutOfRangeError | InsufficientSourceBalanceError | UnsupportedCollateralTokenError | UnsupportedTokenPairError | NoDelayedRouteError | MultipleDelayedWithdrawalsError | WithdrawalInProgressError | NoRecordedIntentError | MarketPausedError | MarketExpiredError | InsufficientPoolLiquidityError | QuotaLimitReachedError | ForbiddenTokenError | InsufficientCollateralError | PoolSunsetError | QuotaCountExceededError | MalformedTransactionError | NoStrategyTargetCollateralError | CreditAccountNotFoundError | UnexpectedFailureError;
+/**
+ * What ANY operation on an existing account can refuse with: the engine's
+ * shared guards, the missing account, and a wrapped crash.
+ **/
+type AccountFlowError = MarketPausedError | MarketExpiredError | ForbiddenTokenError | QuotaLimitReachedError | InsufficientCollateralError | InsufficientSourceBalanceError | CreditAccountNotFoundError | UnexpectedFailureError;
+/** Same guards for the account-less open flow. */
+type OpenFlowError = MarketPausedError | MarketExpiredError | ForbiddenTokenError | QuotaLimitReachedError | InsufficientCollateralError | InsufficientSourceBalanceError | UnexpectedFailureError;
 /** The debt the request implies falls outside the facade's band. */
 interface DebtOutOfRangeError extends IGearboxError {
   code: "debtOutOfRange";
@@ -101,15 +108,15 @@ interface WithdrawalInProgressError extends IGearboxError {
 interface NoRecordedIntentError extends IGearboxError {
   code: "noRecordedIntent";
 }
-/** The facade or the pool behind it is paused: nothing can be done at all. */
+/** The facade is paused: nothing can be done at all. */
 interface MarketPausedError extends IGearboxError {
   code: "marketPaused";
   /**
-   * Which contract is paused: a credit account operation names the manager, an
-   * LP operation the pool. Exactly one of the two is present.
+   * The paused credit manager. Always present from `prepare`: the engine's
+   * shared guards check the manager, and the pool-paused variant is raised
+   * only by the preview-side `checkOperation` — it never reaches this union.
    **/
-  creditManager?: Address;
-  pool?: Address;
+  creditManager: Address;
 }
 /** The facade is past its expiration date and takes no more multicalls. */
 interface MarketExpiredError extends IGearboxError {
@@ -228,11 +235,10 @@ interface CreditAccountNotFoundError extends IGearboxError {
  * connected to, a market or token address it knows nothing about, a contract
  * that reverted where nothing should, a bug of ours.
  *
- * The one code that is not a verdict on the request — everything above says
+ * The one code that is not a refusal of the request — everything above says
  * "this cannot be done", this one says "we do not know". It exists so that a
- * `prepare` method always answers: the failure that used to escape as an
- * exception arrives here instead, whole, under `cause`. `meta.chains` marks the
- * chain as failed alongside it.
+ * refusable `prepare` method always answers: the failure that used to escape
+ * as an exception arrives here instead, whole, under `cause`.
  **/
 interface UnexpectedFailureError extends IGearboxError {
   code: "unexpectedFailure";
@@ -240,17 +246,45 @@ interface UnexpectedFailureError extends IGearboxError {
   cause: Error;
 }
 /**
- * The refusal of a request that has two routes to offer, see
- * {@link StrategyRoutesPrepare}.
+ * What every refusal of a two-route request carries on top of its own code,
+ * see {@link StrategyRoutesResult}.
  *
  * `refused` says why each route is missing, which is the answer a form needs
  * even when neither exists: the error itself is the instant route's refusal —
  * the one a caller can usually act on — or the delayed route's when the instant
  * one did not get far enough to have a reason of its own.
  **/
-type RoutesPrepareError = PrepareError & {
+interface WithRouteRefusals {
   refused: RouteRefusals;
-};
+}
+/**
+ * The error each engine reason maps to — the range of {@link toRefusalError},
+ * spelled reason by reason so a narrow issue arrives as a narrow error.
+ *
+ * A lookup table, not a vocabulary: nothing answers with `RefusalErrors[R]`
+ * as a union. The unions callers see are the ones each method's signature
+ * spells out.
+ **/
+interface RefusalErrors {
+  debtOutOfRange: DebtOutOfRangeError;
+  leverageOutOfRange: LeverageOutOfRangeError;
+  insufficientSourceBalance: InsufficientSourceBalanceError;
+  unsupportedCollateralToken: UnsupportedCollateralTokenError;
+  unsupportedTokenPair: UnsupportedTokenPairError;
+  noDelayedRoute: NoDelayedRouteError;
+  multipleDelayedWithdrawals: MultipleDelayedWithdrawalsError;
+  withdrawalInProgress: WithdrawalInProgressError;
+  noRecordedIntent: NoRecordedIntentError;
+  marketPaused: MarketPausedError;
+  marketExpired: MarketExpiredError;
+  insufficientPoolLiquidity: InsufficientPoolLiquidityError;
+  quotaLimitReached: QuotaLimitReachedError;
+  forbiddenToken: ForbiddenTokenError;
+  insufficientCollateral: InsufficientCollateralError;
+  poolSunset: PoolSunsetError;
+  quotaCountExceeded: QuotaCountExceededError;
+  malformedTransaction: MalformedTransactionError;
+}
 /**
  * The engine's refusal, as the error the namespace answers with.
  *
@@ -259,8 +293,11 @@ type RoutesPrepareError = PrepareError & {
  * {@link MESSAGES}. A malformed transaction is spelled out rather than spread,
  * because its detail names a `code` and a `message` of its own and they are not
  * the envelope's.
+ *
+ * Generic over the issue it is handed, so a call site that already knows the
+ * reason gets that reason's error back rather than a union to narrow again.
  **/
-declare function toPrepareError(issue: PreviewIssue): PrepareError;
+declare function toRefusalError<I extends PreviewIssue>(issue: I): RefusalErrors[I["reason"]];
 /**
  * {@inheritDoc NoStrategyTargetCollateralError}
  **/
@@ -277,4 +314,4 @@ declare function creditAccountNotFound(creditAccount: Address): CreditAccountNot
  **/
 declare function unexpectedFailure(thrown: unknown): UnexpectedFailureError;
 //#endregion
-export { CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, PoolSunsetError, PrepareError, QuotaCountExceededError, QuotaLimitReachedError, RoutesPrepareError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toPrepareError, unexpectedFailure };
+export { AccountFlowError, CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };