@gearbox-protocol/sdk 16.0.0-next.57 → 16.0.0-next.58

package/dist/cjs/onchain/accounts/CreditAccountsServiceV310.js

@@ -205,7 +205,7 @@ var CreditAccountsServiceV310 = class extends require_onchain_base_SDKConstruct.
 		else if (typeof withdrawToken === "string") tokenToWithdraw = withdrawToken;
 		const { creditFacade } = cmSuite;
 		let calls = [
-			creditFacade.prepareIncreaseDebt(debt),
+			...debt > 0n ? [creditFacade.prepareIncreaseDebt(debt)] : [],
 			...creditFacade.prepareAddCollateral(collateral, permits),
 			...openPathCalls,
 			...tokenToWithdraw ? [creditFacade.prepareWithdrawCollateral(tokenToWithdraw, require_onchain_constants_math.MAX_UINT256, to)] : [],
@@ -217,7 +217,7 @@ var CreditAccountsServiceV310 = class extends require_onchain_base_SDKConstruct.
 		];
 		calls = await this.#prependMidasReceiveGreenlist(cm.address, calls);
 		calls = await this.prependPriceUpdates(cm.address, calls);
-		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
+		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls, rwaOptions) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
 		tx.value = ethAmount.toString(10);
 		return tx;
 	}

package/dist/cjs/onchain/accounts/intents/open-strategy.js

@@ -7,7 +7,10 @@ const require_onchain_accounts_intents_utils_quotas_for_update = require("./util
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 require("./utils/index.js");
 //#region src/onchain/accounts/intents/open-strategy.ts
-/** Stand-in account address: nothing exists on chain until the tx lands. */
+/**
+* Stand-in account address, used when the opening creates its own account:
+* nothing exists on chain until the tx lands.
+*/
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
@@ -22,7 +25,8 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * `sdk.accounts.openCA`.
 */
 async function buildOpenStrategyState(props) {
-	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (props.empty) return emptyOpenState(props);
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [], creditAccount: existing } = props;
 	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
@@ -32,7 +36,7 @@ async function buildOpenStrategyState(props) {
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
 	if (margin <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
 	const debt = require_onchain_accounts_intents_math.debtForLeverage(margin, leverage);
-	const account = {
+	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
 		creditManager: creditManager.toLowerCase(),
 		creditFacade: suite.creditFacade.address.toLowerCase(),
@@ -101,7 +105,37 @@ async function buildOpenStrategyState(props) {
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls]
+		calls: [...leg.calls],
+		creditAccount: existing?.creditAccount
+	};
+}
+/**
+* The opening that holds an account and nothing else.
+*
+* Taken before the walk rather than threaded through it: the router has no
+* guard for an empty basket and would still make its `eth_call`, and every
+* assertion below reads amounts that are not there.
+*/
+async function emptyOpenState(props) {
+	const { sdk, creditManager } = props;
+	require_onchain_accounts_intents_guards.assertMarketOperable(sdk.marketRegister.findCreditManager(creditManager));
+	const snapshot = {
+		creditManager,
+		assets: [],
+		quotas: [],
+		totalDebt: 0n,
+		totalValue: 0n
+	};
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: 0n });
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact: void 0,
+		averageAssets: [],
+		minAssets: [],
+		averageQuota: [],
+		minQuota: [],
+		calls: []
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */

package/dist/cjs/sdk/execute/ExecuteApi.js

@@ -60,6 +60,7 @@ async function openTx(sdk, request) {
 		calls: state.calls,
 		averageQuota: state.averageQuota,
 		minQuota: state.minQuota,
+		reopenCreditAccount: state.creditAccount,
 		permits: {},
 		referralCode: 0n,
 		rwaOptions: await openRwaOptions(sdk, request)

package/dist/cjs/sdk/index.js

@@ -47,7 +47,9 @@ exports.PreviewNamespace = require_sdk_preview_PreviewNamespace.PreviewNamespace
 exports.SourceChainMismatchError = require_sdk_errors_SourceChainMismatchError.SourceChainMismatchError;
 exports.SourceUnavailableError = require_sdk_errors_SourceUnavailableError.SourceUnavailableError;
 exports.assertSameChains = require_sdk_errors_assertSameChains.assertSameChains;
+exports.creditAccountNotEmpty = require_sdk_prepare_errors.creditAccountNotEmpty;
 exports.creditAccountNotFound = require_sdk_prepare_errors.creditAccountNotFound;
+exports.emptyOpenTakesNothing = require_sdk_prepare_errors.emptyOpenTakesNothing;
 exports.everyChainFailed = require_sdk_errors_everyChainFailed.everyChainFailed;
 exports.filterResponse = require_sdk_utils_filterResponse.filterResponse;
 exports.mergeChainList = require_sdk_utils_mergeChains.mergeChainList;

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

@@ -9,6 +9,7 @@ const require_onchain_accounts_intents_index = require("../../onchain/accounts/i
 require("../../onchain/index.js");
 const require_sdk_prepare_errors = require("./errors.js");
 const require_sdk_prepare_withdrawable_collaterals = require("./withdrawable-collaterals.js");
+let viem = require("viem");
 //#region src/sdk/prepare/PrepareApi.ts
 /**
 * {@inheritDoc IOpportunitiesPrepare}
@@ -182,8 +183,23 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		try {
 			const sdk = await this.#chain(strategy.chainId);
 			const at = stateBlock(sdk);
+			if (params.empty) {
+				if (params.collateral.length > 0 || params.creditAccount || params.leverage !== 0n) return require_model_result.sdkErr(require_sdk_prepare_errors.emptyOpenTakesNothing());
+				return opened(await service(sdk).openStrategyIntent({
+					sdk,
+					creditManager: strategy.creditManager,
+					empty: true
+				}), at);
+			}
 			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
 			if (!targetToken) return require_model_result.sdkErr(require_sdk_prepare_errors.noStrategyTargetCollateral(strategy.creditManager));
+			let creditAccount;
+			if (params.creditAccount) {
+				const reused = await slice(sdk, params.creditAccount);
+				if (!reused || !(0, viem.isAddressEqual)(reused.creditManager, strategy.creditManager)) return require_model_result.sdkErr(require_sdk_prepare_errors.creditAccountNotFound(params.creditAccount));
+				if (reused.totalDebt > 0n || reused.tokens.some((t) => t.quota > 0n)) return require_model_result.sdkErr(require_sdk_prepare_errors.creditAccountNotEmpty(params.creditAccount));
+				creditAccount = reused;
+			}
 			return opened(await service(sdk).openStrategyIntent({
 				sdk,
 				creditManager: strategy.creditManager,
@@ -192,7 +208,8 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 				leverage: params.leverage,
 				leftoverBalances: params.leftoverBalances,
 				slippage: params.slippage,
-				quotaReserve: params.quotaReserve
+				quotaReserve: params.quotaReserve,
+				creditAccount
 			}), at);
 		} catch (e) {
 			return require_model_result.sdkErr(require_sdk_prepare_errors.unexpectedFailure(e));

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

@@ -63,6 +63,16 @@ function noStrategyTargetCollateral(creditManager) {
 	};
 }
 /**
+* {@inheritDoc CreditAccountNotEmptyError}
+**/
+function creditAccountNotEmpty(creditAccount) {
+	return {
+		code: "creditAccountNotEmpty",
+		message: `Credit account ${creditAccount} carries debt or quotas.`,
+		creditAccount
+	};
+}
+/**
 * {@inheritDoc CreditAccountNotFoundError}
 **/
 function creditAccountNotFound(creditAccount) {
@@ -73,6 +83,15 @@ function creditAccountNotFound(creditAccount) {
 	};
 }
 /**
+* {@inheritDoc EmptyOpenTakesNothingError}
+**/
+function emptyOpenTakesNothing() {
+	return {
+		code: "emptyOpenTakesNothing",
+		message: "An empty opening takes no collateral, no account to reuse and no leverage."
+	};
+}
+/**
 * {@inheritDoc UnexpectedFailureError}
 *
 * Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
@@ -87,7 +106,9 @@ function unexpectedFailure(thrown) {
 	};
 }
 //#endregion
+exports.creditAccountNotEmpty = creditAccountNotEmpty;
 exports.creditAccountNotFound = creditAccountNotFound;
+exports.emptyOpenTakesNothing = emptyOpenTakesNothing;
 exports.noStrategyTargetCollateral = noStrategyTargetCollateral;
 exports.toRefusalError = toRefusalError;
 exports.unexpectedFailure = unexpectedFailure;

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

@@ -5,7 +5,9 @@ const require_sdk_prepare_PrepareApi = require("./PrepareApi.js");
 require("./types.js");
 exports.IntentPreviewError = require_onchain_validation_refusal.IntentPreviewError;
 exports.PrepareApi = require_sdk_prepare_PrepareApi.PrepareApi;
+exports.creditAccountNotEmpty = require_sdk_prepare_errors.creditAccountNotEmpty;
 exports.creditAccountNotFound = require_sdk_prepare_errors.creditAccountNotFound;
+exports.emptyOpenTakesNothing = require_sdk_prepare_errors.emptyOpenTakesNothing;
 exports.noStrategyTargetCollateral = require_sdk_prepare_errors.noStrategyTargetCollateral;
 exports.raise = require_onchain_validation_refusal.raise;
 exports.refuse = require_onchain_validation_refusal.refuse;

package/dist/esm/onchain/accounts/CreditAccountsServiceV310.js

@@ -204,7 +204,7 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		else if (typeof withdrawToken === "string") tokenToWithdraw = withdrawToken;
 		const { creditFacade } = cmSuite;
 		let calls = [
-			creditFacade.prepareIncreaseDebt(debt),
+			...debt > 0n ? [creditFacade.prepareIncreaseDebt(debt)] : [],
 			...creditFacade.prepareAddCollateral(collateral, permits),
 			...openPathCalls,
 			...tokenToWithdraw ? [creditFacade.prepareWithdrawCollateral(tokenToWithdraw, MAX_UINT256, to)] : [],
@@ -216,7 +216,7 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		];
 		calls = await this.#prependMidasReceiveGreenlist(cm.address, calls);
 		calls = await this.prependPriceUpdates(cm.address, calls);
-		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
+		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls, rwaOptions) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
 		tx.value = ethAmount.toString(10);
 		return tx;
 	}

package/dist/esm/onchain/accounts/intents/open-strategy.js

@@ -6,7 +6,10 @@ import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import "./utils/index.js";
 //#region src/onchain/accounts/intents/open-strategy.ts
-/** Stand-in account address: nothing exists on chain until the tx lands. */
+/**
+* Stand-in account address, used when the opening creates its own account:
+* nothing exists on chain until the tx lands.
+*/
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
@@ -21,7 +24,8 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * `sdk.accounts.openCA`.
 */
 async function buildOpenStrategyState(props) {
-	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (props.empty) return emptyOpenState(props);
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [], creditAccount: existing } = props;
 	assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
@@ -31,7 +35,7 @@ async function buildOpenStrategyState(props) {
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
 	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
-	const account = {
+	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
 		creditManager: creditManager.toLowerCase(),
 		creditFacade: suite.creditFacade.address.toLowerCase(),
@@ -100,7 +104,37 @@ async function buildOpenStrategyState(props) {
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls]
+		calls: [...leg.calls],
+		creditAccount: existing?.creditAccount
+	};
+}
+/**
+* The opening that holds an account and nothing else.
+*
+* Taken before the walk rather than threaded through it: the router has no
+* guard for an empty basket and would still make its `eth_call`, and every
+* assertion below reads amounts that are not there.
+*/
+async function emptyOpenState(props) {
+	const { sdk, creditManager } = props;
+	assertMarketOperable(sdk.marketRegister.findCreditManager(creditManager));
+	const snapshot = {
+		creditManager,
+		assets: [],
+		quotas: [],
+		totalDebt: 0n,
+		totalValue: 0n
+	};
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: 0n });
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact: void 0,
+		averageAssets: [],
+		minAssets: [],
+		averageQuota: [],
+		minQuota: [],
+		calls: []
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */

package/dist/esm/sdk/execute/ExecuteApi.js

@@ -59,6 +59,7 @@ async function openTx(sdk, request) {
 		calls: state.calls,
 		averageQuota: state.averageQuota,
 		minQuota: state.minQuota,
+		reopenCreditAccount: state.creditAccount,
 		permits: {},
 		referralCode: 0n,
 		rwaOptions: await openRwaOptions(sdk, request)

package/dist/esm/sdk/index.js

@@ -14,7 +14,7 @@ import { LiquidationsNamespace } from "./liquidations/LiquidationsNamespace.js";
 import "./liquidations/index.js";
 import { ExecuteApi } from "./execute/ExecuteApi.js";
 import "./execute/index.js";
-import { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./prepare/errors.js";
+import { creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./prepare/errors.js";
 import { PrepareApi } from "./prepare/PrepareApi.js";
 import "./prepare/index.js";
 import { filterResponse } from "./utils/filterResponse.js";
@@ -28,4 +28,4 @@ import { PreviewNamespace } from "./preview/PreviewNamespace.js";
 import "./preview/index.js";
 import { DEFAULT_MAX_STATE_AGE, GearboxSDK } from "./GearboxSDK.js";
 import "./types.js";
-export { AbstractNamespace, AllSourcesFailedError, AnalyticsNamespace, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, ExecuteApi, GearboxSDK, IntentPreviewError, LiquidationsNamespace, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, PrepareApi, PreviewNamespace, SourceChainMismatchError, SourceUnavailableError, assertSameChains, creditAccountNotFound, everyChainFailed, filterResponse, mergeChainList, mergeChainOne, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };
+export { AbstractNamespace, AllSourcesFailedError, AnalyticsNamespace, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, ExecuteApi, GearboxSDK, IntentPreviewError, LiquidationsNamespace, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, PrepareApi, PreviewNamespace, SourceChainMismatchError, SourceUnavailableError, assertSameChains, creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, everyChainFailed, filterResponse, mergeChainList, mergeChainOne, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };

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

@@ -6,8 +6,9 @@ import { toToken } from "../../onchain/validation/token.js";
 import { toCreditAccountSlice } from "../../onchain/accounts/intents/utils/credit-account-slice.js";
 import { CreditAccountOperationsService } from "../../onchain/accounts/intents/index.js";
 import "../../onchain/index.js";
-import { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
+import { creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
 import { withdrawableCollaterals } from "./withdrawable-collaterals.js";
+import { isAddressEqual } from "viem";
 //#region src/sdk/prepare/PrepareApi.ts
 /**
 * {@inheritDoc IOpportunitiesPrepare}
@@ -181,8 +182,23 @@ var PrepareApi = class extends MultichainConstruct {
 		try {
 			const sdk = await this.#chain(strategy.chainId);
 			const at = stateBlock(sdk);
+			if (params.empty) {
+				if (params.collateral.length > 0 || params.creditAccount || params.leverage !== 0n) return sdkErr(emptyOpenTakesNothing());
+				return opened(await service(sdk).openStrategyIntent({
+					sdk,
+					creditManager: strategy.creditManager,
+					empty: true
+				}), at);
+			}
 			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
 			if (!targetToken) return sdkErr(noStrategyTargetCollateral(strategy.creditManager));
+			let creditAccount;
+			if (params.creditAccount) {
+				const reused = await slice(sdk, params.creditAccount);
+				if (!reused || !isAddressEqual(reused.creditManager, strategy.creditManager)) return sdkErr(creditAccountNotFound(params.creditAccount));
+				if (reused.totalDebt > 0n || reused.tokens.some((t) => t.quota > 0n)) return sdkErr(creditAccountNotEmpty(params.creditAccount));
+				creditAccount = reused;
+			}
 			return opened(await service(sdk).openStrategyIntent({
 				sdk,
 				creditManager: strategy.creditManager,
@@ -191,7 +207,8 @@ var PrepareApi = class extends MultichainConstruct {
 				leverage: params.leverage,
 				leftoverBalances: params.leftoverBalances,
 				slippage: params.slippage,
-				quotaReserve: params.quotaReserve
+				quotaReserve: params.quotaReserve,
+				creditAccount
 			}), at);
 		} catch (e) {
 			return sdkErr(unexpectedFailure(e));

package/dist/esm/sdk/prepare/errors.js

@@ -62,6 +62,16 @@ function noStrategyTargetCollateral(creditManager) {
 	};
 }
 /**
+* {@inheritDoc CreditAccountNotEmptyError}
+**/
+function creditAccountNotEmpty(creditAccount) {
+	return {
+		code: "creditAccountNotEmpty",
+		message: `Credit account ${creditAccount} carries debt or quotas.`,
+		creditAccount
+	};
+}
+/**
 * {@inheritDoc CreditAccountNotFoundError}
 **/
 function creditAccountNotFound(creditAccount) {
@@ -72,6 +82,15 @@ function creditAccountNotFound(creditAccount) {
 	};
 }
 /**
+* {@inheritDoc EmptyOpenTakesNothingError}
+**/
+function emptyOpenTakesNothing() {
+	return {
+		code: "emptyOpenTakesNothing",
+		message: "An empty opening takes no collateral, no account to reuse and no leverage."
+	};
+}
+/**
 * {@inheritDoc UnexpectedFailureError}
 *
 * Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
@@ -86,4 +105,4 @@ function unexpectedFailure(thrown) {
 	};
 }
 //#endregion
-export { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };
+export { creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };

package/dist/esm/sdk/prepare/index.js

@@ -1,5 +1,5 @@
 import { IntentPreviewError, raise, refuse } from "../../onchain/validation/refusal.js";
-import { creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
+import { creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
 import { PrepareApi } from "./PrepareApi.js";
 import "./types.js";
-export { IntentPreviewError, PrepareApi, creditAccountNotFound, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };
+export { IntentPreviewError, PrepareApi, creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };

package/dist/types/onchain/accounts/intents/open-strategy.d.ts

@@ -4,11 +4,19 @@ import "../../../model/index.js";
 import { Asset } from "../../base/types.js";
 import { MultiCall } from "../../types/transactions.js";
 import { OnchainSDK } from "../../OnchainSDK.js";
-import { SimulationPrices } from "./types.js";
+import { CreditAccountSlice, SimulationPrices } from "./types.js";
 import "../../index.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/open-strategy.d.ts
-interface OpenStrategyProps {
+/**
+ * Opening an account and putting a position on it in one transaction.
+ *
+ * The union says which of the two openings this is: {@link OpenStrategyEmpty}
+ * takes only the market, because an account holding nothing has nothing to
+ * route, no leverage to reach and no target to reach it in.
+ */
+type OpenStrategyProps = OpenStrategyFunded | OpenStrategyEmpty;
+interface OpenStrategyFunded {
   sdk: OnchainSDK;
   /** Credit manager to open the account in. */
   creditManager: Address;
@@ -24,6 +32,20 @@ interface OpenStrategyProps {
   quotaReserve: number | undefined;
   /** Balances to leave unswapped; everything else is routed into the target. */
   leftoverBalances?: Asset[];
+  /**
+   * Existing credit account to put the position on, instead of opening one.
+   *
+   * Must carry no debt and no quotas. Growing a position that already exists
+   * is what the `DEPOSIT` intent is for.
+   **/
+  creditAccount?: CreditAccountSlice;
+  empty?: false;
+}
+/** Opening an account that holds nothing, for a position to land on later. */
+interface OpenStrategyEmpty {
+  sdk: OnchainSDK;
+  creditManager: Address;
+  empty: true;
 }
 /**
  * Projected result of opening a brand-new leveraged position.
@@ -49,6 +71,15 @@ interface OpenStrategyState extends Omit<AccountProjection, "assets" | "quotas">
   minQuota: Asset[];
   /** Router path; feeds `openCA.calls`. */
   calls: MultiCall[];
+  /**
+   * The account this opening was simulated against and must be executed on,
+   * when it reuses one; `undefined` for an opening that creates its own.
+   *
+   * Carried here rather than asked of the caller again at `buildTx`, so the
+   * transaction cannot be built against an account the numbers were not
+   * computed for.
+   **/
+  creditAccount?: Address;
 }
 /**
  * Builds the state opening a leveraged position out of wallet collateral would
@@ -64,4 +95,4 @@ interface OpenStrategyState extends Omit<AccountProjection, "assets" | "quotas">
  */
 declare function buildOpenStrategyState(props: OpenStrategyProps): Promise<OpenStrategyState>;
 //#endregion
-export { OpenStrategyProps, OpenStrategyState, buildOpenStrategyState };
+export { OpenStrategyEmpty, OpenStrategyFunded, OpenStrategyProps, OpenStrategyState, buildOpenStrategyState };

package/dist/types/onchain/accounts/intents/tests/open-strategy.fixtures.d.ts

@@ -1,6 +1,6 @@
 import { Asset } from "../../../base/types.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
-import { OpenStrategyProps } from "../open-strategy.js";
+import { OpenStrategyFunded } from "../open-strategy.js";
 import "../../../index.js";
 import { MarketSdkExtras } from "../testing/market.js";
 import { Address } from "viem";
@@ -51,6 +51,6 @@ declare const case_underlying_1x: OpenStrategyCase;
  */
 declare const case_mixed_with_leftover: OpenStrategyCase;
 declare function buildOpenStrategySdk(extras?: MarketSdkExtras): OnchainSDK;
-declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyProps;
+declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyFunded;
 //#endregion
 export { COLLATERAL_ANY, HALF_UND, KEEP_ANY, LEVERAGE_1X, LEVERAGE_2X, LEVERAGE_3X, LT, MARGIN_UND, OpenStrategyCase, buildOpenStrategyProps, buildOpenStrategySdk, case_mixed_with_leftover, case_underlying_1x, case_underlying_3x, quotaFor };

package/dist/types/onchain/accounts/types.d.ts

@@ -214,7 +214,8 @@ interface OpenCAProps extends PrepareUpdateQuotasProps {
    */
   creditManager: Address;
   /**
-   * Optional address of credit account to reopen
+   * Optional address of an existing credit account to run the opening on,
+   * instead of opening a new one.
    */
   reopenCreditAccount?: Address;
   /**

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

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

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

@@ -9,7 +9,7 @@ import { MultichainConstruct } from "../../onchain/base/MultichainConstruct.js";
 import { LeverageBand } from "../../onchain/accounts/intents/leverage-band.js";
 import { WithdrawCeilings } from "../../onchain/accounts/intents/types.js";
 import "../../onchain/index.js";
-import { AccountFlowError, DebtOutOfRangeError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
+import { AccountFlowError, CreditAccountNotEmptyError, CreditAccountNotFoundError, DebtOutOfRangeError, EmptyOpenTakesNothingError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
 import { AddCollateralParams, AdjustLeverageParams, DepositStrategyParams, FinalizeParams, FinalizeResult, IOpportunitiesPrepare, LpParams, LpRedeemParams, LpResult, OpenStrategyParams, OpenStrategyResult, PoolInput, PositionInput, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
 import { EnsureFreshChains } from "../types.js";
 import { Address } from "viem";
@@ -65,7 +65,7 @@ declare class PrepareApi extends MultichainConstruct implements IOpportunitiesPr
   /**
    * {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
    **/
-  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError>>;
+  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError | EmptyOpenTakesNothingError | CreditAccountNotFoundError | CreditAccountNotEmptyError>>;
   /**
    * {@inheritDoc IOpportunitiesPrepare.depositStrategy}
    **/

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

@@ -232,6 +232,22 @@ interface CreditAccountNotFoundError extends IGearboxError {
   code: "creditAccountNotFound";
   creditAccount: Address;
 }
+/**
+ * The account named to open a position on carries debt or quotas.
+ *
+ * Growing a position that already exists is `depositStrategy`.
+ **/
+interface CreditAccountNotEmptyError extends IGearboxError {
+  code: "creditAccountNotEmpty";
+  creditAccount: Address;
+}
+/**
+ * An empty opening was asked for with something to open it with: collateral to
+ * spend, an account to reuse, or a leverage to reach.
+ **/
+interface EmptyOpenTakesNothingError extends IGearboxError {
+  code: "emptyOpenTakesNothing";
+}
 /**
  * The SDK could not answer at all: a read that failed, a chain it is not
  * connected to, a market or token address it knows nothing about, a contract
@@ -304,10 +320,18 @@ declare function toRefusalError<I extends PreviewIssue>(issue: I): RefusalErrors
  * {@inheritDoc NoStrategyTargetCollateralError}
  **/
 declare function noStrategyTargetCollateral(creditManager: Address): NoStrategyTargetCollateralError;
+/**
+ * {@inheritDoc CreditAccountNotEmptyError}
+ **/
+declare function creditAccountNotEmpty(creditAccount: Address): CreditAccountNotEmptyError;
 /**
  * {@inheritDoc CreditAccountNotFoundError}
  **/
 declare function creditAccountNotFound(creditAccount: Address): CreditAccountNotFoundError;
+/**
+ * {@inheritDoc EmptyOpenTakesNothingError}
+ **/
+declare function emptyOpenTakesNothing(): EmptyOpenTakesNothingError;
 /**
  * {@inheritDoc UnexpectedFailureError}
  *
@@ -316,4 +340,4 @@ declare function creditAccountNotFound(creditAccount: Address): CreditAccountNot
  **/
 declare function unexpectedFailure(thrown: unknown): UnexpectedFailureError;
 //#endregion
-export { AccountFlowError, CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };
+export { AccountFlowError, CreditAccountNotEmptyError, CreditAccountNotFoundError, DebtOutOfRangeError, EmptyOpenTakesNothingError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };

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

@@ -1,7 +1,7 @@
 import { BorrowLimitBinding, IntentPreviewError, PreviewErrorDetails, PreviewErrorReason, PreviewIssue, PreviewRefusal, raise, refuse } from "../../onchain/validation/refusal.js";
 import { LeverageBand } from "../../onchain/accounts/intents/leverage-band.js";
 import { OperationState, PathLossRate, WithdrawCeilings } from "../../onchain/accounts/intents/types.js";
-import { AccountFlowError, CreditAccountNotFoundError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
+import { AccountFlowError, CreditAccountNotEmptyError, CreditAccountNotFoundError, DebtOutOfRangeError, EmptyOpenTakesNothingError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, LeverageOutOfRangeError, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError, creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure } from "./errors.js";
 import { AddCollateralParams, AdjustLeverageParams, DelayedStrategyResult, DepositStrategyParams, FinalizeParams, FinalizeResult, IOpportunitiesPrepare, LpParams, LpRedeemParams, LpResult, LpState, OpenStrategyParams, OpenStrategyResult, PoolInput, PositionInput, PrepareOptions, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, WithdrawCollateralParams, WithdrawStrategyParams } from "./types.js";
 import { ChainOf, PrepareApi } from "./PrepareApi.js";
-export { AccountFlowError, AddCollateralParams, AdjustLeverageParams, BorrowLimitBinding, ChainOf, CreditAccountNotFoundError, DebtOutOfRangeError, DelayedStrategyResult, DepositStrategyParams, FinalizeParams, FinalizeResult, ForbiddenTokenError, IOpportunitiesPrepare, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, IntentPreviewError, type LeverageBand, LeverageOutOfRangeError, LpParams, LpRedeemParams, LpResult, LpState, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, OpenStrategyParams, OpenStrategyResult, type OperationState, type PathLossRate, PoolInput, PoolSunsetError, PositionInput, PrepareApi, PrepareOptions, PreviewErrorDetails, PreviewErrorReason, PreviewIssue, PreviewRefusal, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, type WithdrawCeilings, WithdrawCollateralParams, WithdrawStrategyParams, WithdrawalInProgressError, creditAccountNotFound, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };
+export { AccountFlowError, AddCollateralParams, AdjustLeverageParams, BorrowLimitBinding, ChainOf, CreditAccountNotEmptyError, CreditAccountNotFoundError, DebtOutOfRangeError, DelayedStrategyResult, DepositStrategyParams, EmptyOpenTakesNothingError, FinalizeParams, FinalizeResult, ForbiddenTokenError, IOpportunitiesPrepare, InsufficientCollateralError, InsufficientPoolLiquidityError, InsufficientSourceBalanceError, IntentPreviewError, type LeverageBand, LeverageOutOfRangeError, LpParams, LpRedeemParams, LpResult, LpState, MalformedTransactionError, MarketExpiredError, MarketPausedError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, OpenStrategyParams, OpenStrategyResult, type OperationState, type PathLossRate, PoolInput, PoolSunsetError, PositionInput, PrepareApi, PrepareOptions, PreviewErrorDetails, PreviewErrorReason, PreviewIssue, PreviewRefusal, QuotaCountExceededError, QuotaLimitReachedError, RefusalErrors, RepayStrategyParams, StrategyInput, StrategyResult, StrategyRoutesResult, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, type WithdrawCeilings, WithdrawCollateralParams, WithdrawStrategyParams, WithdrawalInProgressError, creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, raise, refuse, toRefusalError, unexpectedFailure };

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

@@ -14,7 +14,7 @@ import { AccountCalculatorOperation } from "../../onchain/accounts/intents/opera
 import { ClaimRemainder, DelayedStart, OperationState, PathLossRate, ResumableIntent, RouteRefusals, WithdrawCeilings } from "../../onchain/accounts/intents/types.js";
 import { OpenStrategyState } from "../../onchain/accounts/intents/open-strategy.js";
 import "../../onchain/index.js";
-import { AccountFlowError, DebtOutOfRangeError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
+import { AccountFlowError, CreditAccountNotEmptyError, CreditAccountNotFoundError, DebtOutOfRangeError, EmptyOpenTakesNothingError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, OpenFlowError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithRouteRefusals, WithdrawalInProgressError } from "./errors.js";
 import { Address } from "viem";
 //#region src/sdk/prepare/types.d.ts
 /**
@@ -332,6 +332,29 @@ interface OpenStrategyParams extends PrepareOptions {
   targetToken?: Address;
   /** Collateral to leave unswapped; everything else is routed into the target. */
   leftoverBalances?: Asset[];
+  /**
+   * Existing credit account to open the position on, instead of creating one.
+   *
+   * Must belong to `strategy.creditManager` and carry no debt and no quotas —
+   * an account pre-opened by an {@link empty} opening.
+   * The projection is identical either way; only the transaction differs, and
+   * `execute.buildTx` reads which one to build off the result's own
+   * `state.creditAccount`.
+   **/
+  creditAccount?: Address;
+  /**
+   * Open the account holding nothing: no collateral, no debt, no quotas, and no
+   * route quoted. A wallet holds one so a position can be put on it later, by
+   * an opening that names it as {@link creditAccount}.
+   *
+   * {@link collateral} must be empty, {@link leverage} zero and
+   * {@link creditAccount} unset — the flag and the arguments have to agree.
+   * Neither leverage nor {@link targetToken} is read: with no collateral the
+   * debt is zero at any leverage, and there is nothing to route anywhere. Zero
+   * is the one leverage an ordinary opening refuses, so it cannot be mistaken
+   * for a request.
+   **/
+  empty?: boolean;
 }
 interface LpParams {
   /**
@@ -438,7 +461,7 @@ interface IOpportunitiesPrepare {
    * The one flow with no account yet, so the result carries no operation list —
    * it feeds `sdk.accounts.openCA` instead.
    **/
-  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError>>;
+  openNewStrategy(strategy: StrategyInput, params: OpenStrategyParams): Promise<SDKReturn<OpenStrategyResult, OpenFlowError | DebtOutOfRangeError | LeverageOutOfRangeError | UnsupportedTokenPairError | InsufficientPoolLiquidityError | NoStrategyTargetCollateralError | EmptyOpenTakesNothingError | CreditAccountNotFoundError | CreditAccountNotEmptyError>>;
   /**
    * Growing a position: collateral in, debt drawn on top, both converted into
    * the position token.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "16.0.0-next.57",
+  "version": "16.0.0-next.58",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {