@gearbox-protocol/sdk 16.0.0-next.44 → 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/market/adapters/contracts/BalancerV3RouterAdapterContract.js

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../../../utils/AddressMap.js");
+require("../../../utils/index.js");
 const require_onchain_base_errors = require("../../../base/errors.js");
 require("../../../base/index.js");
 const require_onchain_market_adapters_abi_adapters_iBalancerV3RouterAdapter = require("../abi/adapters/iBalancerV3RouterAdapter.js");
@@ -7,6 +9,30 @@ const require_onchain_market_adapters_abi_targetContractAbi = require("../abi/ta
 const require_onchain_market_adapters_contracts_AbstractAdapter = require("./AbstractAdapter.js");
 let viem = require("viem");
 //#region src/onchain/market/adapters/contracts/BalancerV3RouterAdapterContract.ts
+const BALANCER_V3_POOL_TOKENS = {
+	Mainnet: new require_onchain_utils_AddressMap.AddressMap([
+		["0x121edB0bADc036F5FC610D015EE14093C142313B", ["0x775F661b0bD1739349b9A2A3EF60be277c5d2D29", "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a"]],
+		["0x1ea5870f7C037930CE1d5d8d9317c670e89e13E3", ["0x0bfc9d54Fc184518A81162F8fB99c2eACa081202", "0xae78736Cd615f374D3085123A210448E74Fc6393"]],
+		["0x57c23c58B1D8C3292c15BEcF07c62C5c52457A42", ["0x0bfc9d54Fc184518A81162F8fB99c2eACa081202", "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38"]],
+		["0x6b31a94029fd7840d780191B6D63Fa0D269bd883", ["0x2411802D8BEA09be0aF8fD8D08314a63e706b29C", "0x90551c1795392094FE6D29B758EcCD233cFAa260"]],
+		["0x85B2b559bC2D21104C4DEFdd6EFcA8A20343361D", [
+			"0x7Bc3485026Ac48b6cf9BaF0A377477Fff5703Af8",
+			"0xC71Ea051a5F82c67ADcF634c36FFE6334793D24C",
+			"0xD4fa2D31b7968E448877f69A96DE69f5de8cD23E"
+		]],
+		["0x9ED5175aeCB6653C1BDaa19793c16fd74fBeEB37", ["0x775F661b0bD1739349b9A2A3EF60be277c5d2D29", "0xD11c452fc99cF405034ee446803b6F6c1F6d5ED8"]],
+		["0xc4Ce391d82D164c166dF9c8336DDF84206b2F812", ["0x0FE906e030a44eF24CA8c7dC7B7c53A6C4F00ce9", "0x775F661b0bD1739349b9A2A3EF60be277c5d2D29"]]
+	]),
+	Plasma: new require_onchain_utils_AddressMap.AddressMap([
+		["0x01E2C7fCde2B8D5d1413732c4e274Ba5B06B1E54", ["0x0A1a1A107E45b7Ced86833863f482BC5f4ed82EF", "0xE0126F0c4451B2B917064A93040fd4770D6774b5"]],
+		["0x694c009aa31B3F80EE18C218B02390ca2D7151e7", ["0x6eAf19b2FC24552925dB245F9Ff613157a7dbb4C", "0xE0126F0c4451B2B917064A93040fd4770D6774b5"]],
+		["0x6a74BE33B5393D8A3EbA4D69B78f9D9da947C48c", ["0xC63F1a8c0cD4493E18f6f3371182BE01Ce0BeF02", "0xE0126F0c4451B2B917064A93040fd4770D6774b5"]],
+		["0xB3Ca3ead1c59dEd552cD30a6992038284B418b65", ["0x0B2b2B2076d95dda7817e785989fE353fe955ef9", "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb"]],
+		["0xD931775d9AcA9859c9fDc53C63ae32EF21551492", ["0x9c46EE1f01d2b551048F5fF99a4659D98d04BED1", "0xC8A8DF9B210243c55D31c73090F06787aD0A1Bf6"]],
+		["0xd9c4e277c93374a9f8C877a9D06707a88092E8F0", ["0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2", "0xE0126F0c4451B2B917064A93040fd4770D6774b5"]],
+		["0xDE0cfD933D2036d99048a04acF5Bacfb45492377", ["0x76309A9a56309104518847BbA321c261B7B4a43f", "0xA29420057F3e3B9512D4786df135Da1674BD74D4"]]
+	])
+};
 let BalancerV3PoolStatus = /* @__PURE__ */ function(BalancerV3PoolStatus) {
 	BalancerV3PoolStatus[BalancerV3PoolStatus["NOT_ALLOWED"] = 0] = "NOT_ALLOWED";
 	BalancerV3PoolStatus[BalancerV3PoolStatus["ALLOWED"] = 1] = "ALLOWED";
@@ -99,7 +125,13 @@ var BalancerV3RouterAdapterContract = class extends require_onchain_market_adapt
 				this.setLeftover(balances, pool, leftoverAmount);
 				break;
 			}
-			case "addLiquidityUnbalancedDiff": throw new Error(`previewBalanceChanges cannot resolve pool tokens for addLiquidityUnbalancedDiff on ${this.contractType} adapter at ${this.address}`);
+			case "addLiquidityUnbalancedDiff": {
+				const [pool, leftoverAmounts] = decoded.args;
+				const tokens = BALANCER_V3_POOL_TOKENS[this.networkType]?.get(pool);
+				if (!tokens || tokens.length !== leftoverAmounts.length) throw new Error(`previewBalanceChanges cannot resolve pool tokens for addLiquidityUnbalancedDiff on ${this.contractType} adapter at ${this.address} (pool ${pool})`);
+				for (let i = 0; i < leftoverAmounts.length; i++) this.setLeftover(balances, tokens[i], leftoverAmounts[i]);
+				break;
+			}
 			default: super.applyBalanceChanges(balances, decoded);
 		}
 	}

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/dev/AccountOpener.js

@@ -1,5 +1,5 @@
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
 import { ierc20Abi } from "../abi/iERC20.js";
+import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
 import { AddressMap } from "../onchain/utils/AddressMap.js";
 import { AddressSet } from "../onchain/utils/AddressSet.js";
 import { AssetsMap } from "../onchain/utils/AssetsMap.js";

package/dist/esm/dev/withdrawalUtils.js

@@ -1,6 +1,6 @@
+import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import { getNetworkType } from "../onchain/chain/chains.js";
 import { getWithdrawalCompressorAddress } from "../onchain/accounts/withdrawal-compressor/addresses.js";
-import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import "../onchain/index.js";
 import { iMidasDataFeedAbi, iMidasRedemptionVaultAbi, midasGatewayAbi, midasRedeemerAbi, midasRedemptionVaultPhantomTokenAbi, securitizeRedeemerAbi, securitizeRedemptionGatewayAbi, securitizeRedemptionPhantomTokenAbi } from "./withdrawalAbi.js";
 import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";