@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

package/dist/esm/sdk/accounts/intents/index.js

@@ -1,389 +1,245 @@
 import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { assembleOperationCalls } from "./utils/assemble-operation-calls.js";
-import { simulateState } from "./utils/simulate-adjust-state.js";
-import { getOperationsWithQuotaUpdate } from "./utils/with-quota-update.js";
-import "./utils/index.js";
-import { primaryInstantOutput } from "./operations/claim-delayed/index.js";
-import "./operations/index.js";
-import { buildResumeAddCollateralOperations } from "./intents/resume/add-collateral/add-collateral.js";
-import { buildResumeCloseOperations } from "./intents/resume/close/close.js";
-import { buildResumeDecreaseLeverageOperations } from "./intents/resume/decrease-leverage/decrease-leverage.js";
-import { buildResumeDepositOperations } from "./intents/resume/deposit/deposit.js";
-import { buildResumeIncreaseLeverageOperations } from "./intents/resume/increase-leverage/increase-leverage.js";
-import { buildResumeWithdrawOperations } from "./intents/resume/withdraw/withdraw.js";
-import "./intents/resume/index.js";
-import { createCloseOracleQuoter, createRouterCloseQuoter } from "./quoters/close.js";
-import { createOracleSwapQuoter, createRouterSwapQuoter } from "./quoters/swap.js";
-import "./quoters/index.js";
+import { IntentPreviewError } from "./types.js";
+import { assertMarketOperable } from "./guards.js";
+import { maxProportionalWithdrawal } from "./math.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
+import { previewOpenStrategy } from "./open-strategy.js";
+import { instantOutput } from "./operations.js";
+import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
+import { realize } from "./realize.js";
+import { accountView } from "./view.js";
 //#region src/sdk/accounts/intents/index.ts
+/**
+* Previews of everything a wallet can do to an existing credit account.
+*
+* Two halves, deliberately kept apart: `plan.ts` turns an intent into a few
+* steps with pure arithmetic, `realize.ts` turns the steps into router-backed
+* operations. This class only picks the planner and wraps the outcome.
+*/
 var CreditAccountOperationsService = class extends SDKConstruct {
-	async finishIntent(props) {
-		const intent = props.intent;
-		switch (intent.type) {
-			case "ADD_COLLATERAL": return this.#finishAddCollateralIntent({
-				...props,
-				intent
-			});
-			case "INCREASE_LEVERAGE": return this.#finishIncreaseLeverageIntent({
-				...props,
-				intent
-			});
-			case "DEPOSIT": return this.#finishDepositIntent({
-				...props,
-				intent
-			});
-			case "DEPOSIT_AND_INCREASE_LEVERAGE": return this.#finishDepositAndIncreaseLeverageIntent({
-				...props,
-				intent
-			});
-			case "CLOSE_ACCOUNT": return this.#finishCloseAccountIntent({
-				...props,
-				intent
-			});
-			case "WITHDRAW_COLLATERAL": return this.#finishWithdrawCollateralIntent({
-				...props,
-				intent
-			});
-			case "DECREASE_LEVERAGE": return this.#finishDecreaseLeverageIntent({
-				...props,
-				intent
-			});
-			default: throw new Error(`${props.intent.type} - not implemented`);
-		}
+	/**
+	* Previews an operation on an existing account.
+	*
+	* @param props - Intent plus account slice, quota reserve and slippage
+	* @returns Operations, projected state and calldata, or `{ ok: false, reason }`
+	* when the intent cannot be satisfied (e.g. the account lacks the source
+	* balance)
+	*/
+	async startIntent(props) {
+		return plain(await this.#preview(props, () => {
+			const { intent } = props;
+			const view = accountView(props.creditAccount, props.sdk);
+			switch (intent.type) {
+				case "ADD_COLLATERAL": return planAddCollateral(intent);
+				case "WITHDRAW_ASSET": return planWithdrawAsset(intent, view);
+				case "ADJUST_LEVERAGE": return planAdjustLeverage(intent, view);
+				case "DEPOSIT": return planDeposit(intent, view);
+				case "REPAY": return planRepay(intent, view);
+				case "WITHDRAW": return planWithdraw(intent, view);
+				default: throw new Error(`${intent.type} - not implemented`);
+			}
+		}));
 	}
 	/**
-	* Shared resume flow for claim-only intents (add collateral, increase
-	* leverage, deposit, deposit+increase): claim op + trailing changeQuota.
-	* If any implementations change, respective handler should be implemented separately
+	* 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.
+	*
+	* @param props - Account slice and the SDK holding its market
+	* @returns Amount in underlying units; `0n` when nothing can leave
 	*/
-	#finishClaimOnlyIntent = (buildOperations) => async (props) => {
-		switch (props.options.kind) {
-			case "offchain": return this.#finishClaimOnlyIntentOffchain(props, props.options, buildOperations);
-			default: return this.#finishClaimOnlyIntentOnchain(props, props.options, buildOperations);
-		}
-	};
-	#finishClaimOnlyIntentOffchain(props, options, buildOperations) {
-		const baseOperations = buildOperations(props.creditAccount, options, this.sdk);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		return {
-			ok: true,
-			instant: {
-				operations: getOperationsWithQuotaUpdate({
-					operations: baseOperations,
-					state,
-					creditAccount: props.creditAccount,
-					sdk: this.sdk,
-					options
-				}),
-				preview: { min: state.state },
-				calls: []
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
-		};
+	maxWithdraw(props) {
+		const view = accountView(props.creditAccount, props.sdk);
+		return maxProportionalWithdrawal(view, view.band);
 	}
-	async #finishClaimOnlyIntentOnchain(props, options, buildOperations) {
-		const baseOperations = buildOperations(props.creditAccount, options, this.sdk);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		const operations = getOperationsWithQuotaUpdate({
-			operations: baseOperations,
-			state,
-			creditAccount: props.creditAccount,
-			sdk: this.sdk,
-			options
-		});
-		const calls = await assembleOperationCalls({
-			...props,
-			operations
-		});
-		return {
-			ok: true,
-			instant: {
-				operations,
-				preview: { min: state.state },
-				calls
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
-		};
+	/**
+	* Debt a `REPAY` would have to cover to settle the account, in underlying
+	* units: principal plus the interest and fees accrued as of the read.
+	*
+	* A repayment of exactly this leaves nothing behind at the block it was read
+	* at, and a little behind at any later one, since interest does not stop —
+	* so a wallet meaning to clear the account sends this with a buffer on top,
+	* which the intent caps at the debt rather than spending. `REPAY` with
+	* `MAX_UINT256` sizes that buffer itself.
+	*
+	* @param props - Account slice and the SDK holding its market
+	* @returns Amount in underlying units; `0n` on an account that owes nothing
+	*/
+	maxRepay(props) {
+		return accountView(props.creditAccount, props.sdk).debt;
 	}
-	#finishAddCollateralIntent = this.#finishClaimOnlyIntent(buildResumeAddCollateralOperations);
-	#finishIncreaseLeverageIntent = this.#finishClaimOnlyIntent(buildResumeIncreaseLeverageOperations);
-	#finishDepositIntent = this.#finishClaimOnlyIntent(buildResumeDepositOperations);
-	#finishDepositAndIncreaseLeverageIntent = this.#finishClaimOnlyIntent(buildResumeDepositOperations);
 	/**
-	* Resume close: claim, then close against quoted post-claim balances.
-	* Offchain quotes equity by oracle prices, onchain — router close path.
-	* Router miss soft-fails to the oracle quote with `calls: []` (legacy parity).
+	* Previews the same operation when its source only redeems through its
+	* issuer: a Securitize dsToken, a Mellow share.
+	*
+	* Sits apart from {@link startIntent} because it is a different trade route,
+	* not a different intent: the request goes to the issuer instead of the
+	* router, and the proceeds — hence the repayment and the payout — arrive days
+	* later. Both routes of one intent are quoted together by
+	* {@link intentRoutes}; this is the one to call when the delayed route is the
+	* only one of interest.
+	*
+	* @param props - Intent plus account slice, quota reserve and slippage
+	* @returns The request transaction and what it recorded for the tail, or
+	* `{ ok: false, reason }` — `noDelayedRoute` when this route does not exist
+	* for the account at all
 	*/
-	async #finishCloseAccountIntent({ options, ...props }) {
-		switch (options.kind) {
-			case "offchain": return this.#finishCloseAccountIntentOffchain({
-				...props,
-				options
-			});
-			default: try {
-				return await this.#finishCloseAccountIntentOnchain({
-					...props,
-					options
-				});
-			} catch {
-				return this.#finishCloseAccountIntentOffchain({
-					...props,
-					options
-				});
+	async startDelayedIntent(props) {
+		const { intent } = props;
+		const result = await this.#preview(props, () => {
+			const view = accountView(props.creditAccount, props.sdk);
+			switch (intent.type) {
+				case "ADJUST_LEVERAGE": return planAdjustLeverageDelayed(intent, view);
+				case "WITHDRAW": return planWithdrawDelayed(intent, view);
+				default: throw new Error(`${intent.type} - cannot be delayed`);
 			}
-		}
-	}
-	async #finishCloseAccountIntentOffchain({ options, ...props }) {
-		const quoter = createCloseOracleQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount
 		});
-		const { operations, quote } = await buildResumeCloseOperations({
-			...props,
-			options
-		}, quoter);
+		if (!result.ok) return result;
+		if (!result.delayed) throw new Error("startDelayedIntent: plan started no withdrawal");
 		return {
-			ok: true,
-			instant: {
-				operations,
-				preview: { min: {
-					kind: "close",
-					amount: quote.amount,
-					minAmount: quote.minAmount,
-					underlyingBalance: quote.underlyingBalance
-				} },
-				calls: []
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
-		};
-	}
-	async #finishCloseAccountIntentOnchain({ options, slippage = 0, ...props }) {
-		const quoter = createRouterCloseQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount,
-			slippage
-		});
-		const { operations, quote } = await buildResumeCloseOperations({
-			...props,
-			options
-		}, quoter);
-		const calls = await assembleOperationCalls({
-			...props,
-			operations
-		});
-		return {
-			ok: true,
-			instant: {
-				operations,
-				preview: { min: {
-					kind: "close",
-					amount: quote.amount,
-					minAmount: quote.minAmount,
-					underlyingBalance: quote.underlyingBalance
-				} },
-				calls
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
+			...result,
+			delayed: result.delayed
 		};
 	}
 	/**
-	* Resume withdraw: claim → (swap?) → decreaseDebt? → (unwrapRwa?) →
-	* withdrawCollateral + trailing changeQuota. Offchain prices swaps by
-	* oracle, onchain — router swap paths (leftover-aware).
+	* Previews a delayable intent both ways at once: settled by the router now,
+	* and started as a redemption that finishes days later.
+	*
+	* Which routes an account has depends on the intent and the token it sells,
+	* and a form has to know before it can offer a choice — so both are quoted
+	* from the same request and each is reported on its own. A route the account
+	* cannot take comes back `undefined` with its refusal in `refused`; only when
+	* neither answers is the whole result `{ ok: false }`.
+	*
+	* A route that could not be quoted at all — a pathfinder with no path out of
+	* the source, a read that failed — counts as missing rather than fatal, since
+	* the other route may be the one the caller wanted. With nothing left to
+	* report the failure is rethrown, as {@link startIntent} would have.
+	*
+	* @param props - A withdraw or adjust-leverage intent plus account slice,
+	* quota reserve and slippage
+	* @returns Whichever routes are viable, or `{ ok: false, reason }` when none is
 	*/
-	async #finishWithdrawCollateralIntent({ options, ...props }) {
-		switch (options.kind) {
-			case "offchain": return this.#finishWithdrawCollateralIntentOffchain({
-				...props,
-				options
-			});
-			default: try {
-				return await this.#finishWithdrawCollateralIntentOnchain({
-					...props,
-					options
-				});
-			} catch {
-				return this.#finishWithdrawCollateralIntentOffchain({
-					...props,
-					options
-				});
-			}
-		}
-	}
-	async #finishWithdrawCollateralIntentOffchain({ options, ...props }) {
-		const quoter = createOracleSwapQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount
-		});
-		const baseOperations = await buildResumeWithdrawOperations({
-			...props,
-			options
-		}, quoter);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		return {
+	async intentRoutes(props) {
+		const [instant, delayed] = await Promise.allSettled([this.startIntent(props), this.startDelayedIntent(props)]);
+		const instantRoute = instant.status === "fulfilled" && instant.value.ok ? instant.value : void 0;
+		const delayedRoute = delayed.status === "fulfilled" && delayed.value.ok ? delayed.value : void 0;
+		const refused = {
+			instant: instant.status === "fulfilled" && !instant.value.ok ? instant.value.reason : void 0,
+			delayed: delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value.reason : void 0
+		};
+		if (instantRoute || delayedRoute) return {
 			ok: true,
-			instant: {
-				operations: getOperationsWithQuotaUpdate({
-					operations: baseOperations,
-					state,
-					creditAccount: props.creditAccount,
-					sdk: this.sdk,
-					options
-				}),
-				preview: { min: state.state },
-				calls: []
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
+			instant: instantRoute,
+			delayed: delayedRoute,
+			refused
 		};
-	}
-	async #finishWithdrawCollateralIntentOnchain({ options, slippage = 0, ...props }) {
-		const quoter = createRouterSwapQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount,
-			slippage
-		});
-		const baseOperations = await buildResumeWithdrawOperations({
-			...props,
-			options
-		}, quoter);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		const operations = getOperationsWithQuotaUpdate({
-			operations: baseOperations,
-			state,
-			creditAccount: props.creditAccount,
-			sdk: this.sdk,
-			options
-		});
-		const calls = await assembleOperationCalls({
-			...props,
-			operations
-		});
+		const failed = [instant, delayed].find((s) => s.status === "rejected");
+		if (failed?.status === "rejected") throw failed.reason;
+		const reason = refused.instant ?? refused.delayed;
+		if (reason === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
 		return {
-			ok: true,
-			instant: {
-				operations,
-				preview: { min: state.state },
-				calls
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
+			ok: false,
+			reason,
+			refused
 		};
 	}
 	/**
-	* Resume decrease leverage: claim → (wrapRwa | swap)? → decreaseDebt +
-	* trailing changeQuota. Offchain prices swaps by oracle, onchain — router
-	* swap paths. Router miss soft-fails to the oracle quote (legacy parity).
+	* Previews the tail of a delayed intent, once the withdrawal it started has
+	* matured: the claim, then whatever the intent still owes.
+	*
+	* Serves the two operations that can genuinely be interrupted by a delay — a
+	* withdrawal and a deleveraging. For the rest, the claim is the whole tail:
+	* the tokens land on the account and only their quota has to catch up.
+	*
+	* @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
 	*/
-	async #finishDecreaseLeverageIntent({ options, ...props }) {
-		switch (options.kind) {
-			case "offchain": return this.#finishDecreaseLeverageIntentOffchain({
-				...props,
-				options
-			});
-			default: try {
-				return await this.#finishDecreaseLeverageIntentOnchain({
-					...props,
-					options
-				});
-			} catch {
-				return this.#finishDecreaseLeverageIntentOffchain({
-					...props,
-					options
-				});
+	async finishIntent(props) {
+		const { intent, claimable } = props;
+		return plain(await this.#preview(props, () => {
+			const view = accountView(props.creditAccount, props.sdk);
+			const claimed = () => {
+				const output = instantOutput(claimable.outputs);
+				if (!output) throw new IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
+				return output;
+			};
+			switch (intent.type) {
+				case "WITHDRAW_COLLATERAL": return planFinishWithdraw(intent, claimable, claimed(), view);
+				case "DECREASE_LEVERAGE": return planFinishDecreaseLeverage(claimable, claimed(), view);
+				case "ADD_COLLATERAL":
+				case "INCREASE_LEVERAGE":
+				case "DEPOSIT":
+				case "DEPOSIT_AND_INCREASE_LEVERAGE": return planFinishClaimOnly(claimable);
+				default: throw new Error(`${intent.type} - not implemented`);
 			}
-		}
+		}));
 	}
-	async #finishDecreaseLeverageIntentOffchain({ options, ...props }) {
-		const quoter = createOracleSwapQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount
-		});
-		const baseOperations = await buildResumeDecreaseLeverageOperations({
-			...props,
-			options
-		}, quoter);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		return {
-			ok: true,
-			instant: {
-				operations: getOperationsWithQuotaUpdate({
-					operations: baseOperations,
-					state,
-					creditAccount: props.creditAccount,
-					sdk: this.sdk,
-					options
-				}),
-				preview: { min: state.state },
-				calls: []
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
-		};
+	/**
+	* Previews opening a brand-new leveraged position.
+	*
+	* Sits apart from {@link startIntent} because there is no account yet: nothing
+	* can be projected from existing balances, and the output feeds
+	* `sdk.accounts.openCA` rather than a facade multicall assembled here.
+	*
+	* @param props - Credit manager, wallet collateral, target token and leverage
+	* @returns Debt, position size, projected balances and quotas for both the
+	* expected and the floor branch, or `{ ok: false, reason }` when the requested
+	* leverage or the resulting debt is not viable
+	*/
+	async openStrategyIntent(props) {
+		try {
+			return {
+				ok: true,
+				preview: await previewOpenStrategy(props)
+			};
+		} catch (e) {
+			return asFailure(e);
+		}
 	}
-	async #finishDecreaseLeverageIntentOnchain({ options, slippage = 0, ...props }) {
-		const quoter = createRouterSwapQuoter({
-			sdk: this.sdk,
-			creditAccount: props.creditAccount,
-			slippage
-		});
-		const baseOperations = await buildResumeDecreaseLeverageOperations({
-			...props,
-			options
-		}, quoter);
-		const state = simulateState({
-			...props,
-			operations: baseOperations
-		});
-		const operations = getOperationsWithQuotaUpdate({
-			operations: baseOperations,
-			state,
-			creditAccount: props.creditAccount,
-			sdk: this.sdk,
-			options
-		});
-		const calls = await assembleOperationCalls({
-			...props,
-			operations
-		});
-		return {
-			ok: true,
-			instant: {
+	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
+	async #preview(props, plan) {
+		try {
+			assertMarketOperable(props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager));
+			const { operations, state, calls, delayed } = await realize(plan(), {
+				creditAccount: props.creditAccount,
+				sdk: props.sdk,
+				slippage: props.slippage ?? 0,
+				quotaReserve: props.quotaReserve
+			});
+			return {
+				ok: true,
 				operations,
-				preview: { min: state.state },
-				calls
-			},
-			instantError: void 0,
-			delayedBranch: void 0,
-			delayedError: void 0
-		};
+				preview: state,
+				calls,
+				delayed
+			};
+		} catch (e) {
+			return asFailure(e);
+		}
 	}
 };
+/** Drops the delayed half for the flows that cannot produce one. */
+function plain(result) {
+	if (!result.ok) return result;
+	const { operations, preview, calls } = result;
+	return {
+		ok: true,
+		operations,
+		preview,
+		calls
+	};
+}
+/** Unviable requests are values; anything else is a genuine failure. */
+function asFailure(e) {
+	if (e instanceof IntentPreviewError) return {
+		ok: false,
+		reason: e.reason
+	};
+	throw e;
+}
 //#endregion
-export { CreditAccountOperationsService, primaryInstantOutput };
+export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, toCreditAccountSlice };

package/dist/esm/sdk/accounts/intents/math.js

@@ -0,0 +1,51 @@
+import { LEVERAGE_DECIMALS } from "../../constants/math.js";
+import { IntentPreviewError } from "./types.js";
+//#region src/sdk/accounts/intents/math.ts
+/** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
+function debtForLeverage(collateral, leverage) {
+	return collateral * (leverage - LEVERAGE_DECIMALS) / LEVERAGE_DECIMALS;
+}
+/**
+* Debt change that keeps leverage fixed while collateral moves by
+* `collateralDelta`: `dD = D0 · dC / C0`.
+*
+* Computed on the ratio directly rather than by recovering `L` and reapplying
+* it, so no rounding is introduced on the way.
+*/
+function proportionalDebt(position, collateralDelta) {
+	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "cannot preserve leverage on an account with no collateral");
+	return position.debt * collateralDelta / position.collateral;
+}
+/**
+* Largest withdrawal (in underlying) that {@link proportionalDebt} can still
+* pay for: the repayment it implies leaves debt at or above `minDebt`, and
+* strictly less than the collateral goes — the last unit closes the account
+* rather than shrinks it. `0n` when the debt already sits below the band.
+*
+* Solves `floor(D0 · W / C0) ≤ D0 − minDebt` for `W`.
+*/
+function maxProportionalWithdrawal(position, band) {
+	const { debt, collateral } = position;
+	if (collateral <= 0n) return 0n;
+	const allButLast = collateral - 1n;
+	if (debt === 0n) return allButLast;
+	const repayable = debt - band.minDebt;
+	if (repayable < 0n) return 0n;
+	const bound = ceilDiv(collateral * (repayable + 1n), debt) - 1n;
+	return bound < allButLast ? bound : allButLast;
+}
+const ceilDiv = (a, b) => (a + b - 1n) / b;
+/** Total leverage cannot drop below 1x — that would be negative debt. */
+function assertLeverageAtLeastOne(leverage) {
+	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+}
+/**
+* Rejects a debt the facade would revert on: zero is always fine (no loan at
+* all), anything else has to sit inside `[minDebt, maxDebt]`.
+*/
+function assertDebtInBand(debt, band) {
+	if (debt > band.maxDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
+	if (debt > 0n && debt < band.minDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+}
+//#endregion
+export { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };