@gearbox-protocol/sdk 16.0.0-next.45 → 16.0.0-next.46

package/dist/cjs/model/index.js

@@ -155,3 +155,4 @@ exports.tokenSchema = require_model_primitives_schema.tokenSchema;
 exports.tolerance = require_model_compare_schema.tolerance;
 exports.txCallSchema = require_model_primitives_schema.txCallSchema;
 exports.underlyingTokenSchema = require_model_primitives_schema.underlyingTokenSchema;
+exports.withdrawalOutputAmountSchema = require_model_withdrawals_schema.withdrawalOutputAmountSchema;

package/dist/cjs/model/withdrawals.schema.js

@@ -5,12 +5,16 @@ const require_model_delayed_intent_schema = require("./delayed-intent.schema.js"
 let zod_v4 = require("zod/v4");
 //#region src/model/withdrawals.schema.ts
 /**
+* {@link WithdrawalOutputAmount}
+**/
+const withdrawalOutputAmountSchema = require_model_primitives_schema.tokenAmountSchema.extend({ isDelayed: zod_v4.z.boolean() });
+/**
 * {@link PositionClaimableWithdrawal}
 **/
 const positionClaimableWithdrawalSchema = zod_v4.z.object({
 	sourceToken: require_model_primitives_schema.tokenSchema,
 	withdrawalPhantomToken: require_model_primitives_schema.tokenAmountSchema,
-	outputs: zod_v4.z.array(require_model_primitives_schema.tokenAmountSchema),
+	outputs: zod_v4.z.array(withdrawalOutputAmountSchema),
 	claimCall: require_model_primitives_schema.txCallSchema,
 	redeemer: require_onchain_utils_zod.ZodAddress().optional(),
 	intent: require_model_delayed_intent_schema.delayedIntentSchema.optional()
@@ -21,7 +25,7 @@ const positionClaimableWithdrawalSchema = zod_v4.z.object({
 const positionPendingWithdrawalSchema = zod_v4.z.object({
 	sourceToken: require_model_primitives_schema.tokenSchema,
 	withdrawalPhantomToken: require_model_primitives_schema.tokenSchema,
-	expectedOutputs: zod_v4.z.array(require_model_primitives_schema.tokenAmountSchema),
+	expectedOutputs: zod_v4.z.array(withdrawalOutputAmountSchema),
 	claimableAt: require_model_primitives_schema.timestampSchema,
 	redeemer: require_onchain_utils_zod.ZodAddress().optional(),
 	intent: require_model_delayed_intent_schema.delayedIntentSchema.optional()
@@ -37,3 +41,4 @@ const positionWithdrawalsSchema = zod_v4.z.object({
 exports.positionClaimableWithdrawalSchema = positionClaimableWithdrawalSchema;
 exports.positionPendingWithdrawalSchema = positionPendingWithdrawalSchema;
 exports.positionWithdrawalsSchema = positionWithdrawalsSchema;
+exports.withdrawalOutputAmountSchema = withdrawalOutputAmountSchema;

package/dist/cjs/onchain/accounts/intents/index.js

@@ -46,21 +46,27 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		}));
 	}
 	/**
-	* Largest `WITHDRAW` amount (in underlying) the account can take out while
-	* keeping leverage and staying inside the facade's debt band — the ceiling a
-	* withdraw form should offer. Taking everything out is the same intent with
-	* `MAX_UINT256` for an amount, and needs none of this arithmetic.
+	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
+	* partial withdrawal that keeps leverage and stays inside the facade's debt
+	* band, and the net value an exit hands over. They are reported together
+	* because a withdraw form needs both — the range it may offer, and the one
+	* amount past it that is allowed — and because the distance between them is
+	* the account's own, not a constant a caller could assume.
 	*
 	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
 	* proportional withdrawal leaves the factor where it found it, and the
 	* facade's `minDebt` is what bounds it.
 	*
 	* @param props - Account slice and the SDK holding its market
-	* @returns Amount in underlying units; `0n` when nothing can leave
+	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
+	* them
 	*/
 	maxWithdraw(props) {
 		const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
-		return require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.band);
+		return {
+			partial: require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.band),
+			exit: view.collateral > 0n ? view.collateral : 0n
+		};
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying
@@ -230,17 +236,36 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* whole tail: the tokens land on the account and only their quota has to
 	* catch up.
 	*
+	* A claim that brought only part of what the request queued — a legacy Mellow
+	* multivault, which pays out what it holds liquid and re-queues the rest — is
+	* served in proportion, and what it did not settle comes back as `remainder`:
+	* the withdrawal still in flight and the intent to finish it with.
+	*
 	* @param props - The recorded intent, the account slice as it stands now, and
 	* the matured claimable
-	* @returns Shaped exactly like {@link startIntent}'s result, so both halves of
-	* an operation are consumed the same way
+	* @returns Shaped exactly like {@link startIntent}'s result with the remainder
+	* beside it, so both halves of an operation are consumed the same way
 	*/
 	async finishIntent(props) {
-		return plain(await this.#preview(props, () => require_onchain_accounts_intents_tail.planTail({
-			intent: props.intent,
-			claimable: props.claimable,
-			view: require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk)
-		})));
+		let remainder;
+		const result = await this.#preview(props, () => {
+			const tail = require_onchain_accounts_intents_tail.planTail({
+				intent: props.intent,
+				claimable: props.claimable,
+				view: require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk)
+			});
+			remainder = tail.remainder;
+			return tail.steps;
+		});
+		if (!result.ok) return result;
+		const { operations, state, calls } = result;
+		return {
+			ok: true,
+			operations,
+			state,
+			calls,
+			remainder
+		};
 	}
 	/**
 	* Previews opening a brand-new leveraged position.

package/dist/cjs/onchain/accounts/intents/tail.js

@@ -1,5 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
 const require_onchain_accounts_intents_operations = require("./operations.js");
@@ -13,6 +15,10 @@ const require_onchain_accounts_intents_view = require("./view.js");
 * 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.
+*
+* A claim that brought only part of what was queued is served in proportion,
+* see {@link partialTail}: the intent's payout and its repayment are cut to the
+* share that arrived, and the rest of both is handed to the next claim.
 */
 function planTail(args) {
 	const { intent, claimable, view } = args;
@@ -21,17 +27,118 @@ function planTail(args) {
 		if (!output) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
+	const queued = claimable.outputs.find((o) => o.isDelayed && o.amount > 0n);
+	if (queued) return partialTail({
+		intent,
+		claimable,
+		queued,
+		view
+	});
 	switch (intent.type) {
-		case "WITHDRAW_COLLATERAL": return require_onchain_accounts_intents_plan.planFinishWithdraw(intent, claimable, claimed(), view);
-		case "DECREASE_LEVERAGE": return require_onchain_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed(), view);
-		case "CLOSE_ACCOUNT": return require_onchain_accounts_intents_plan.planFinishCloseAccount(intent, claimable, claimed(), view);
+		case "WITHDRAW_COLLATERAL": return whole(require_onchain_accounts_intents_plan.planFinishWithdraw(intent, claimable, claimed(), view));
+		case "DECREASE_LEVERAGE": return whole(require_onchain_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed(), view));
+		case "CLOSE_ACCOUNT": return whole(require_onchain_accounts_intents_plan.planFinishCloseAccount(intent, claimable, claimed(), view));
 		case "ADD_COLLATERAL":
 		case "INCREASE_LEVERAGE":
 		case "DEPOSIT":
-		case "DEPOSIT_AND_INCREASE_LEVERAGE": return require_onchain_accounts_intents_plan.planFinishClaimOnly(claimable);
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return whole(require_onchain_accounts_intents_plan.planFinishClaimOnly(claimable));
 		default: throw new Error(`${intent.type} - not implemented`);
 	}
 }
+const whole = (steps) => ({
+	steps,
+	remainder: void 0
+});
+/**
+* The tail of a claim that settled only part of the withdrawal it matured.
+*
+* Only a legacy Mellow multivault answers one this way — it pays out what its
+* subvaults hold liquid and queues the rest — and the engine cannot finish an
+* intent it has been given a fraction of the funds for. So the fraction is what
+* it serves: the payout and the repayment are cut in the proportion that
+* arrived, which keeps the withdrawal at the fixed leverage it was asked for
+* instead of paying the wallet out first and deleveraging a claim later, and
+* the untouched half of each is carried to the next claim by the remainder.
+*
+* Two intents cannot be served in part at all. An exit sells the account whole,
+* and it cannot while a withdrawal is in flight — the phantom is neither
+* sellable nor transferable — so a partial claim only repays what it brought
+* and the account is emptied by the claim that brings the last of it. A claim
+* that credited nothing at all leaves nothing to spend, so it is taken alone:
+* it is still worth sending, since it is what moves the queue.
+*/
+function partialTail(args) {
+	const { intent, claimable, queued, view } = args;
+	const inFlight = require_onchain_validation_token.toTokenAmount(view.sdk, queued.token, queued.amount);
+	const claimed = require_onchain_accounts_intents_operations.instantOutput(claimable.outputs);
+	if (!claimed) return {
+		steps: require_onchain_accounts_intents_plan.planFinishClaimOnly(claimable),
+		remainder: {
+			inFlight,
+			intent
+		}
+	};
+	switch (intent.type) {
+		case "WITHDRAW_COLLATERAL": {
+			const served = arrivedShare(claimed, queued, view.sdk);
+			const withdrawAmount = part(intent.withdrawAmount, served);
+			const debtRepaid = part(intent.debtRepaid, served);
+			return {
+				steps: require_onchain_accounts_intents_plan.planFinishWithdraw({
+					...intent,
+					withdrawAmount,
+					debtRepaid
+				}, claimable, claimed, view),
+				remainder: {
+					inFlight,
+					intent: {
+						...intent,
+						withdrawAmount: intent.withdrawAmount - withdrawAmount,
+						debtRepaid: intent.debtRepaid - debtRepaid
+					}
+				}
+			};
+		}
+		case "DECREASE_LEVERAGE":
+		case "CLOSE_ACCOUNT": return {
+			steps: require_onchain_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed, view),
+			remainder: {
+				inFlight,
+				intent
+			}
+		};
+		case "ADD_COLLATERAL":
+		case "INCREASE_LEVERAGE":
+		case "DEPOSIT":
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return {
+			steps: require_onchain_accounts_intents_plan.planFinishClaimOnly(claimable),
+			remainder: {
+				inFlight,
+				intent
+			}
+		};
+		default: throw new Error(`${intent.type} - not implemented`);
+	}
+}
+/**
+* How much of the redemption this claim was: what it credited, over that plus
+* what it left queued.
+*
+* The phantom stands for its payout one for one — the same reading the request
+* side takes when it names the claim it expects — so only the decimals of the
+* two have to be reconciled before they can be added up.
+*/
+function arrivedShare(claimed, queued, sdk) {
+	const rest = require_onchain_accounts_intents_utils_common.toTargetDecimals(queued.amount, queued.token, claimed.token, sdk);
+	return {
+		got: claimed.amount,
+		of: claimed.amount + rest
+	};
+}
+/** A share of an amount, rounded down: a tail never promises more than it has. */
+function part(amount, share) {
+	return share.of > 0n ? amount * share.got / share.of : 0n;
+}
 /**
 * Where a delayed intent ends up, worked out at the moment it is started.
 *
@@ -56,7 +163,7 @@ async function projectTail(args) {
 	const queued = request.outputs.find((o) => o.isDelayed);
 	if (!queued || !claim) throw new require_onchain_validation_refusal.IntentPreviewError("noRecordedIntent", void 0, "projectTail: the request queued nothing to claim");
 	const next = sliceAfter(creditAccount, delayed.afterRequest);
-	const steps = planTail({
+	const { steps } = planTail({
 		intent: delayed.record,
 		claimable: projectedClaimable(request, queued.token, queued.amount, claim),
 		view: require_onchain_accounts_intents_view.accountView(next, sdk)

package/dist/cjs/onchain/pools/PoolService.js

@@ -30,6 +30,25 @@ function payoutCeiling(market) {
 	return market.priceOracle.toAmount(pool.underlying, pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM);
 }
 var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
+	/**
+	* {@inheritDoc IPoolsService.getShareBalance}
+	*/
+	async getShareBalance(props) {
+		return this.client.readContract({
+			address: this.sdk.marketRegister.findByPool(props.pool).pool.pool.address,
+			abi: require_abi_iERC20.ierc20Abi,
+			functionName: "balanceOf",
+			args: [props.wallet],
+			blockNumber: props.blockNumber
+		});
+	}
+	/**
+	* {@inheritDoc IPoolsService.sharesToUnderlying}
+	*/
+	sharesToUnderlying(pool, shares) {
+		const market = this.sdk.marketRegister.findByPool(pool);
+		return market.toUnderlyingAmount(shares * market.pool.pool.dieselRate / require_onchain_constants_math.RAY);
+	}
 	/**
 	* {@inheritDoc IPoolsService.getDepositTokensIn}
 	*/
@@ -415,10 +434,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 			chainId: this.chainId,
 			pool: pool.address,
 			underlyingToken: market.underlyingToken,
-			netValue: {
-				token: this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying),
-				...market.priceOracle.toAmount(market.underlying, shares * pool.dieselRate / require_onchain_constants_math.RAY)
-			},
+			netValue: this.sharesToUnderlying(pool.address, shares),
 			apy: { organicApy: require_onchain_market_math.rayToBps(pool.supplyRate) }
 		};
 	}

package/dist/cjs/onchain/positions/PositionsService.js

@@ -373,7 +373,10 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 		return {
 			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
 			withdrawalPhantomToken: priceOracle.toTokenAmount(w.withdrawalPhantomToken, w.withdrawalTokenSpent),
-			outputs: w.outputs.map((o) => priceOracle.toTokenAmount(o.token, o.amount)),
+			outputs: w.outputs.map((o) => ({
+				...priceOracle.toTokenAmount(o.token, o.amount),
+				isDelayed: o.isDelayed
+			})),
 			claimCall: this.#claimTx(w.claimCalls, w.token),
 			redeemer: w.redeemer,
 			intent: w.intent
@@ -383,7 +386,10 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 		return {
 			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
 			withdrawalPhantomToken: this.sdk.tokensMeta.mustGetToken(w.withdrawalPhantomToken),
-			expectedOutputs: w.expectedOutputs.map((o) => priceOracle.toTokenAmount(o.token, o.amount)),
+			expectedOutputs: w.expectedOutputs.map((o) => ({
+				...priceOracle.toTokenAmount(o.token, o.amount),
+				isDelayed: o.isDelayed
+			})),
 			claimableAt: Number(w.claimableAt),
 			redeemer: w.redeemer,
 			intent: w.intent

package/dist/cjs/sdk/prepare/PrepareApi.js

@@ -59,7 +59,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			}));
 			const creditAccount = await slice(sdk, position.creditAccount);
 			if (!creditAccount) return require_model_result.sdkErr(require_sdk_prepare_errors.creditAccountNotFound(position.creditAccount));
-			return planned(await service(sdk).finishIntent({
+			return finalized(await service(sdk).finishIntent({
 				intent,
 				claimable: toClaimableWithdrawal(params.claimable),
 				creditAccount,
@@ -74,94 +74,106 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.deposit}
 	**/
-	deposit(pool, params) {
-		const chain = this.sdk.chain(pool.chainId);
-		const { marketRegister, pools } = chain;
-		const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
-		const tokenOut = lpRoute(params.tokenOut, () => pools.getDepositTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return unroutable(chain, tokenIn, void 0);
-		const state = pools.simulateDeposit({
-			pool: pool.pool,
-			amount: params.amount,
-			tokenIn,
-			tokenOut
-		});
-		const call = pools.addLiquidity({
-			collateral: {
-				token: state.tokenIn.token.address,
-				balance: state.tokenIn.value
-			},
-			pool: pool.pool,
-			wallet: params.wallet,
-			meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
-		});
-		if (!call) return unroutable(chain, tokenIn, tokenOut);
-		return require_model_result.sdkOk({
-			operations: [],
-			state,
-			calls: call.calls,
-			...stateBlock(chain)
-		});
+	async deposit(pool, params) {
+		try {
+			const chain = await this.#chain(pool.chainId);
+			const { marketRegister, pools } = chain;
+			const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
+			const tokenOut = lpRoute(params.tokenOut, () => pools.getDepositTokensOut(pool.pool, tokenIn));
+			if (!tokenOut) return unroutable(chain, tokenIn, void 0);
+			const state = pools.simulateDeposit({
+				pool: pool.pool,
+				amount: params.amount,
+				tokenIn,
+				tokenOut
+			});
+			const call = pools.addLiquidity({
+				collateral: {
+					token: state.tokenIn.token.address,
+					balance: state.tokenIn.value
+				},
+				pool: pool.pool,
+				wallet: params.wallet,
+				meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
+			});
+			if (!call) return unroutable(chain, tokenIn, tokenOut);
+			return require_model_result.sdkOk({
+				operations: [],
+				state: await lpState(chain, pool.pool, params.wallet, state, { mints: state.tokenOut.value }),
+				calls: call.calls,
+				...stateBlock(chain)
+			});
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.withdraw}
 	**/
-	withdraw(pool, params) {
-		const chain = this.sdk.chain(pool.chainId);
-		const { pools } = chain;
-		const tokenIn = params.tokenIn ?? pool.pool;
-		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return unroutable(chain, tokenIn, void 0);
-		const state = pools.simulateWithdraw({
-			pool: pool.pool,
-			amount: params.amount,
-			tokenIn,
-			tokenOut
-		});
-		const { calls } = pools.removeLiquidity({
-			pool: pool.pool,
-			amount: params.amount,
-			wallet: params.wallet,
-			permit: void 0,
-			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
-			mode: "withdraw"
-		});
-		return require_model_result.sdkOk({
-			operations: [],
-			state,
-			calls,
-			...stateBlock(chain)
-		});
+	async withdraw(pool, params) {
+		try {
+			const chain = await this.#chain(pool.chainId);
+			const { pools } = chain;
+			const tokenIn = params.tokenIn ?? pool.pool;
+			const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+			if (!tokenOut) return unroutable(chain, tokenIn, void 0);
+			const state = pools.simulateWithdraw({
+				pool: pool.pool,
+				amount: params.amount,
+				tokenIn,
+				tokenOut
+			});
+			const { calls } = pools.removeLiquidity({
+				pool: pool.pool,
+				amount: params.amount,
+				wallet: params.wallet,
+				permit: void 0,
+				meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+				mode: "withdraw"
+			});
+			return require_model_result.sdkOk({
+				operations: [],
+				state: await lpState(chain, pool.pool, params.wallet, state, { burns: state.tokenIn.value }),
+				calls,
+				...stateBlock(chain)
+			});
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.redeem}
 	**/
-	redeem(pool, params) {
-		const chain = this.sdk.chain(pool.chainId);
-		const { pools } = chain;
-		const tokenIn = params.tokenIn ?? pool.pool;
-		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return unroutable(chain, tokenIn, void 0);
-		const state = pools.simulateRedeem({
-			pool: pool.pool,
-			amount: params.amount,
-			tokenIn,
-			tokenOut
-		});
-		const { calls } = pools.removeLiquidity({
-			pool: pool.pool,
-			amount: params.amount,
-			wallet: params.wallet,
-			permit: void 0,
-			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
-			mode: "redeem"
-		});
-		return require_model_result.sdkOk({
-			operations: [],
-			state,
-			calls,
-			...stateBlock(chain)
-		});
+	async redeem(pool, params) {
+		try {
+			const chain = await this.#chain(pool.chainId);
+			const { pools } = chain;
+			const tokenIn = params.tokenIn ?? pool.pool;
+			const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+			if (!tokenOut) return unroutable(chain, tokenIn, void 0);
+			const state = pools.simulateRedeem({
+				pool: pool.pool,
+				amount: params.amount,
+				tokenIn,
+				tokenOut
+			});
+			const { calls } = pools.removeLiquidity({
+				pool: pool.pool,
+				amount: params.amount,
+				wallet: params.wallet,
+				permit: void 0,
+				meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+				mode: "redeem"
+			});
+			return require_model_result.sdkOk({
+				operations: [],
+				state: await lpState(chain, pool.pool, params.wallet, state, { burns: state.tokenIn.value }),
+				calls,
+				...stateBlock(chain)
+			});
+		} catch (e) {
+			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));
+		}
 	}
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
@@ -413,7 +425,7 @@ function toClaimableWithdrawal(claimable) {
 		outputs: claimable.outputs.map((o) => ({
 			token: o.token.address,
 			amount: o.value,
-			isDelayed: false
+			isDelayed: o.isDelayed
 		})),
 		claimCalls: [{
 			target: claimable.claimCall.to,
@@ -470,6 +482,23 @@ function planned(result, at) {
 }
 /**
 * {@inheritDoc planned}
+*
+* A tail carries one thing the other results do not: whether the claim it was
+* built on finished the withdrawal, or left part of it queued for another one.
+**/
+function finalized(result, at) {
+	if (!result.ok) return refusal(result);
+	const { operations, state, calls, remainder } = result;
+	return require_model_result.sdkOk({
+		operations,
+		state,
+		calls,
+		remainder,
+		...at
+	});
+}
+/**
+* {@inheritDoc planned}
 **/
 function opened(result, at) {
 	return result.ok ? require_model_result.sdkOk({
@@ -512,6 +541,28 @@ function routed(result, at) {
 	});
 }
 /**
+* The pool's own numbers as the namespace reports them: the trade the service
+* priced, the market it belongs to, and where the wallet's position lands.
+*
+* The position is measured in shares and converted once, rather than added up
+* in underlying, so the figure is exactly what a later
+* `sdk.positions.list()` will report — the same balance through the same rate.
+* A withdrawal larger than the position floors at nothing: the transaction
+* would revert long before it got there, and a negative holding is not a thing
+* a screen can show.
+**/
+async function lpState(sdk, pool, wallet, simulation, moved) {
+	const after = await sdk.pools.getShareBalance({
+		pool,
+		wallet
+	}) + (moved.mints ?? -moved.burns);
+	return {
+		...simulation,
+		curator: sdk.marketRegister.findByPool(pool).curator,
+		positionAfter: sdk.pools.sharesToUnderlying(pool, after > 0n ? after : 0n)
+	};
+}
+/**
 * A pool route the market does not offer, as the refusal a caller reads.
 *
 * `to` is absent where {@link lpRoute} found no output to name at all, which

package/dist/esm/model/index.js

@@ -22,5 +22,5 @@ import "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
 import { isSDKError, sdkErr, sdkOk } from "./result.js";
 import "./withdrawals.js";
-import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema } from "./withdrawals.schema.js";
-export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPRICEABLE_TOKEN, ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, isSDKError, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema };
+import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema, withdrawalOutputAmountSchema } from "./withdrawals.schema.js";
+export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPRICEABLE_TOKEN, ERROR_UNSUPPORTED_OUT_OF_BRACKET_CALL, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, isSDKError, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, withdrawalOutputAmountSchema };

package/dist/esm/model/withdrawals.schema.js

@@ -4,12 +4,16 @@ import { delayedIntentSchema } from "./delayed-intent.schema.js";
 import { z } from "zod/v4";
 //#region src/model/withdrawals.schema.ts
 /**
+* {@link WithdrawalOutputAmount}
+**/
+const withdrawalOutputAmountSchema = tokenAmountSchema.extend({ isDelayed: z.boolean() });
+/**
 * {@link PositionClaimableWithdrawal}
 **/
 const positionClaimableWithdrawalSchema = z.object({
 	sourceToken: tokenSchema,
 	withdrawalPhantomToken: tokenAmountSchema,
-	outputs: z.array(tokenAmountSchema),
+	outputs: z.array(withdrawalOutputAmountSchema),
 	claimCall: txCallSchema,
 	redeemer: ZodAddress().optional(),
 	intent: delayedIntentSchema.optional()
@@ -20,7 +24,7 @@ const positionClaimableWithdrawalSchema = z.object({
 const positionPendingWithdrawalSchema = z.object({
 	sourceToken: tokenSchema,
 	withdrawalPhantomToken: tokenSchema,
-	expectedOutputs: z.array(tokenAmountSchema),
+	expectedOutputs: z.array(withdrawalOutputAmountSchema),
 	claimableAt: timestampSchema,
 	redeemer: ZodAddress().optional(),
 	intent: delayedIntentSchema.optional()
@@ -33,4 +37,4 @@ const positionWithdrawalsSchema = z.object({
 	pending: z.array(positionPendingWithdrawalSchema)
 });
 //#endregion
-export { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema };
+export { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema, withdrawalOutputAmountSchema };