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

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/index.js

@@ -704,8 +704,6 @@ exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_acc
 exports.toNetTransfers = require_onchain_market_adapters_transferHelpers.toNetTransfers;
 exports.toPendingWithdrawal = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.toPendingWithdrawal;
 exports.toRequestableWithdrawal = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.toRequestableWithdrawal;
-exports.toShares = require_onchain_pools_PoolService.toShares;
-exports.toSharesUp = require_onchain_pools_PoolService.toSharesUp;
 exports.toSignificant = require_onchain_utils_formatter.toSignificant;
 exports.toToken = require_onchain_validation_token.toToken;
 exports.toTokenAmount = require_onchain_validation_token.toTokenAmount;

package/dist/cjs/onchain/market/MarketSuite.js

@@ -128,6 +128,14 @@ var MarketSuite = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		};
 	}
 	/**
+	* Whether `token` is this market's pool underlying or the asset it wraps
+	* (dcUSDC or USDC on an RWA pool). Amounts in either unit are 1:1 with the
+	* figure {@link toUnderlyingAmount} reports.
+	*/
+	isUnderlyingLike(token) {
+		return (0, viem.isAddressEqual)(token, this.underlying) || (0, viem.isAddressEqual)(token, this.unwrappedUnderlying);
+	}
+	/**
 	* Prices a figure already denominated in this market's underlying — a debt,
 	* a TVL, a payout — as the read model reports one.
 	*
@@ -166,7 +174,7 @@ var MarketSuite = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		seen.upsert(this.unwrappedUnderlying, this.underlyingToken);
 		for (const zapper of this.sdk.marketRegister.poolZappers(this.pool.pool.address)) {
 			const tokenIn = zapper.tokenIn.addr;
-			if ((0, viem.isAddressEqual)(tokenIn, this.pool.underlying) || (0, viem.isAddressEqual)(tokenIn, this.unwrappedUnderlying)) continue;
+			if (this.isUnderlyingLike(tokenIn)) continue;
 			seen.upsert(tokenIn, this.tokensMeta.mustGetToken(tokenIn));
 		}
 		return seen.values();

package/dist/cjs/onchain/market/credit/CreditSuite.js

@@ -392,8 +392,7 @@ var CreditSuite = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 	*/
 	#allowedDepositTokens(targetCollateral) {
 		const unwrappedUnderlying = this.market.unwrappedUnderlying;
-		const contractUnderlying = this.underlying;
-		const skip = (token) => (0, viem.isAddressEqual)(token, unwrappedUnderlying) || (0, viem.isAddressEqual)(token, contractUnderlying) || (0, viem.isAddressEqual)(token, targetCollateral);
+		const skip = (token) => this.market.isUnderlyingLike(token) || (0, viem.isAddressEqual)(token, targetCollateral);
 		return [
 			unwrappedUnderlying,
 			targetCollateral,

package/dist/cjs/onchain/market/pool/PoolV310Contract.js

@@ -51,6 +51,31 @@ var PoolV310Contract = class extends require_onchain_base_BaseContract.BaseContr
 		return this.totalSupply * this.dieselRate / require_onchain_constants_math.RAY;
 	}
 	/**
+	* {@inheritDoc IPoolContract.getShareBalance}
+	*/
+	async getShareBalance(wallet, blockNumber) {
+		return this.client.readContract({
+			address: this.address,
+			abi: this.abi,
+			functionName: "balanceOf",
+			args: [wallet],
+			blockNumber
+		});
+	}
+	/**
+	* {@inheritDoc IPoolContract.sharesToUnderlying}
+	*/
+	sharesToUnderlying(shares) {
+		return this.dieselRate === 0n ? shares : shares * this.dieselRate / require_onchain_constants_math.RAY;
+	}
+	/**
+	* {@inheritDoc IPoolContract.underlyingToShares}
+	*/
+	underlyingToShares(underlying, roundUp = false) {
+		if (this.dieselRate === 0n) return underlying;
+		return roundUp ? (underlying * require_onchain_constants_math.RAY + this.dieselRate - 1n) / this.dieselRate : underlying * require_onchain_constants_math.RAY / this.dieselRate;
+	}
+	/**
 	* {@inheritDoc IPoolContract.unwrappedUnderlying}
 	*/
 	get unwrappedUnderlying() {

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

@@ -146,7 +146,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		const { zapper } = this.getDepositMetadata(poolAddr, tokenIn, tokenOut);
 		return {
 			tokenIn: toTokenAmount(tokenIn, amount),
-			tokenOut: toTokenAmount(tokenOut, toShares(pool.pool, amount)),
+			tokenOut: toTokenAmount(tokenOut, pool.pool.underlyingToShares(amount)),
 			zapper: zapper?.baseParams.addr
 		};
 	}
@@ -166,7 +166,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		});
 		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
 		return {
-			tokenIn: toTokenAmount(tokenIn, toSharesUp(pool.pool, amount)),
+			tokenIn: toTokenAmount(tokenIn, pool.pool.underlyingToShares(amount * require_onchain_constants_math.PERCENTAGE_FACTOR / (require_onchain_constants_math.PERCENTAGE_FACTOR - pool.pool.withdrawFee), true)),
 			tokenOut: toTokenAmount(tokenOut, amount),
 			zapper: zapper?.baseParams.addr,
 			availableLiquidity: payoutCeiling(market)
@@ -189,7 +189,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
 		return {
 			tokenIn: toTokenAmount(tokenIn, amount),
-			tokenOut: toTokenAmount(tokenOut, toAssets(pool.pool, amount)),
+			tokenOut: toTokenAmount(tokenOut, pool.pool.sharesToUnderlying(amount) * (require_onchain_constants_math.PERCENTAGE_FACTOR - pool.pool.withdrawFee) / require_onchain_constants_math.PERCENTAGE_FACTOR),
 			zapper: zapper?.baseParams.addr,
 			availableLiquidity: payoutCeiling(market)
 		};
@@ -221,7 +221,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		}
 		const poolContract = this.sdk.marketRegister.findByPool(pool).pool.pool;
 		if (meta.zapper instanceof require_onchain_market_zapper_IETHZapperContract.IETHZapperContract || meta.zapper instanceof require_onchain_market_zapper_IERC20ZapperContract.IERC20ZapperContract) {
-			const shares = mode === "withdraw" ? toSharesUp(poolContract, amount) : amount;
+			const shares = mode === "withdraw" ? poolContract.underlyingToShares(amount * require_onchain_constants_math.PERCENTAGE_FACTOR / (require_onchain_constants_math.PERCENTAGE_FACTOR - poolContract.withdrawFee), true) : amount;
 			const tx = permit ? meta.zapper.redeemWithPermit(shares, wallet, permit.deadline, permit.v, permit.r, permit.s) : meta.zapper.redeem(shares, wallet);
 			return {
 				tx,
@@ -415,45 +415,10 @@ 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: market.toUnderlyingAmount(pool.sharesToUnderlying(shares)),
 			apy: { organicApy: require_onchain_market_math.rayToBps(pool.supplyRate) }
 		};
 	}
 };
-/**
-* Shares minted for `assets`, as `previewDeposit` would report them.
-*
-* Both directions convert through the diesel rate — underlying per RAY of
-* shares — because that is the rate the pool itself divides by, and the only
-* exact one the SDK holds: `totalAssets` is this rate multiplied out, so
-* converting back through it costs a wei on large amounts. Rounds down, as
-* minting does.
-*/
-function toShares(pool, assets) {
-	const { dieselRate } = pool;
-	return dieselRate === 0n ? assets : assets * require_onchain_constants_math.RAY / dieselRate;
-}
-/**
-* Shares a withdrawal of `assets` burns, as `previewWithdraw` would report
-* them: {@link toShares} rounded the other way, since the burn has to cover
-* the payout the caller asked for.
-*/
-function toSharesUp(pool, assets) {
-	const { dieselRate } = pool;
-	return dieselRate === 0n ? assets : (assets * require_onchain_constants_math.RAY + dieselRate - 1n) / dieselRate;
-}
-/**
-* Underlying paid out for `shares`, as `previewRedeem` would report it:
-* {@link toShares} run backwards, less the pool's withdrawal fee.
-*/
-function toAssets(pool, shares) {
-	const { dieselRate, withdrawFee } = pool;
-	return (dieselRate === 0n ? shares : shares * dieselRate / require_onchain_constants_math.RAY) * (require_onchain_constants_math.PERCENTAGE_FACTOR - withdrawFee) / require_onchain_constants_math.PERCENTAGE_FACTOR;
-}
 //#endregion
 exports.PoolService = PoolService;
-exports.toShares = toShares;
-exports.toSharesUp = toSharesUp;

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

@@ -2,5 +2,3 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_pools_PoolService = require("./PoolService.js");
 require("./types.js");
 exports.PoolService = require_onchain_pools_PoolService.PoolService;
-exports.toShares = require_onchain_pools_PoolService.toShares;
-exports.toSharesUp = require_onchain_pools_PoolService.toSharesUp;

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/preview/preview/previewPoolPositionOperation.js

@@ -1,29 +1,48 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_iERC20 = require("../../abi/iERC20.js");
 const require_model_result = require("../../model/result.js");
 require("../../model/index.js");
+const require_preview_simulate_errors = require("../simulate/errors.js");
 const require_preview_simulate_simulatePoolOperation = require("../simulate/simulatePoolOperation.js");
-require("../simulate/index.js");
 //#region src/preview/preview/previewPoolPositionOperation.ts
 async function previewPoolPositionOperation(input, operation, options) {
-	const { sdk, to, calldata } = input;
+	const { sdk } = input;
 	const { tokenIn, tokenOut } = operation;
 	const market = sdk.marketRegister.findByPool(operation.pool);
-	const answer = await require_preview_simulate_simulatePoolOperation.simulatePoolOperation({
-		sdk,
-		operation,
-		to,
-		calldata
-	}, options);
-	if (require_model_result.isSDKError(answer)) return answer;
-	const sim = answer.data;
+	const pool = market.pool.pool;
+	const holder = "owner" in operation ? operation.owner : operation.receiver;
+	let previewAmount;
+	let shares;
+	try {
+		[previewAmount, shares] = await sdk.client.multicall({
+			contracts: [require_preview_simulate_simulatePoolOperation.previewContract(operation), {
+				address: operation.pool,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "balanceOf",
+				args: [holder]
+			}],
+			allowFailure: false,
+			batchSize: 0,
+			blockNumber: options?.blockNumber
+		});
+	} catch (cause) {
+		const error = require_preview_simulate_errors.asPreviewSimulationError(cause, "multicall");
+		options?.logger?.error(error, "pool operation simulation failed");
+		return require_model_result.sdkErr(error);
+	}
+	const sim = require_preview_simulate_simulatePoolOperation.amountsInOut(operation, previewAmount);
+	const inflow = operation.operation === "Deposit" || operation.operation === "Mint";
+	const after = shares + (inflow ? sim.amountOut : -sim.amountIn);
 	return require_model_result.sdkOk({
 		operation: operation.operation,
 		pool: operation.pool,
 		name: sdk.tokensMeta.mustGetToken(operation.pool).name,
 		underlyingToken: market.underlyingToken,
-		shareRate: market.pool.pool.dieselRate,
+		shareRate: pool.dieselRate,
 		tokenIn: market.priceOracle.toTokenAmount(tokenIn, sim.amountIn),
-		tokenOut: market.priceOracle.toTokenAmount(tokenOut, sim.amountOut)
+		tokenOut: market.priceOracle.toTokenAmount(tokenOut, sim.amountOut),
+		curator: market.curator,
+		netValue: market.toUnderlyingAmount(pool.sharesToUnderlying(after > 0n ? after : 0n))
 	});
 }
 //#endregion

package/dist/cjs/preview/simulate/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_preview_simulate_errors = require("./errors.js");
-const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulatePoolOperation = require("./simulatePoolOperation.js");
+const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulateRWAOperation = require("./simulateRWAOperation.js");
 const require_preview_simulate_simulateOperation = require("./simulateOperation.js");
 exports.asPreviewSimulationError = require_preview_simulate_errors.asPreviewSimulationError;

package/dist/cjs/preview/simulate/simulateOperation.js

@@ -3,8 +3,8 @@ const require_model_result = require("../../model/result.js");
 require("../../model/index.js");
 const require_preview_parse_types = require("../parse/types.js");
 require("../parse/index.js");
-const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulatePoolOperation = require("./simulatePoolOperation.js");
+const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulateRWAOperation = require("./simulateRWAOperation.js");
 //#region src/preview/simulate/simulateOperation.ts
 /**

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -104,4 +104,6 @@ async function simulatePoolOperation(input, options = {}) {
 	}
 }
 //#endregion
+exports.amountsInOut = amountsInOut;
+exports.previewContract = previewContract;
 exports.simulatePoolOperation = simulatePoolOperation;