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

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

@@ -1,293 +0,0 @@
-import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { MIN_HF_LIMITED } from "../../../common-utils/utils/validation/validate-hf.js";
-import { IntentPreviewError } from "./types.js";
-import { assertMarketOperable } from "./guards.js";
-import { maxProportionalWithdrawal } from "./math.js";
-import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
-import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
-import { previewOpenStrategy } from "./open-strategy.js";
-import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
-import { realize } from "./realize.js";
-import { accountView } from "./view.js";
-import { planTail, projectTail } from "./tail.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 {
-	/**
-	* 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`);
-			}
-		}));
-	}
-	/**
-	* 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
-	*/
-	maxWithdraw(props) {
-		const view = accountView(props.creditAccount, props.sdk);
-		return maxProportionalWithdrawal(view, view.band);
-	}
-	/**
-	* 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;
-	}
-	/**
-	* Largest `WITHDRAW_ASSET` amount of one token the account can take out
-	* while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
-	* point — the ceiling a withdraw-collateral form should offer. Thresholds,
-	* prices and quota activity come from the account's market, valued the way
-	* the facade values a call that pays out; zero debt frees the whole balance.
-	*
-	* @param props - Account slice, the SDK holding its market, and the
-	* collateral to withdraw
-	* @returns Amount in the token's units; `0n` when nothing can leave
-	*/
-	maxWithdrawCollateral(props) {
-		return maxWithdrawCollateral({
-			...props,
-			targetHF: MIN_HF_LIMITED + 2n
-		});
-	}
-	/**
-	* 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.
-	*
-	* `preview` is where the intent ends — the account once the redemption has
-	* matured, been claimed and the tail has run — because that is what the
-	* caller asked for; the half-way state the request itself lands in is
-	* `delayed.afterRequest`. Both are validated, so a request whose tail could
-	* not be completed is refused instead of started.
-	*
-	* @param props - Intent plus account slice, quota reserve and slippage
-	* @returns The request transaction, the state it ends in and what it recorded
-	* for the tail, or `{ ok: false, reason }` — `noDelayedRoute` when this route
-	* does not exist for the account at all
-	*/
-	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`);
-			}
-		});
-		if (!result.ok) return result;
-		const { delayed } = result;
-		if (!delayed) throw new Error("startDelayedIntent: plan started no withdrawal");
-		if (delayed.settlement === "instant") return {
-			...result,
-			delayed
-		};
-		const request = result.operations.find((op) => op.type === "startDelayedWithdrawal");
-		if (!request) throw new Error("startDelayedIntent: no request among the operations");
-		try {
-			const tail = await projectTail({
-				request,
-				delayed,
-				creditAccount: props.creditAccount,
-				sdk: props.sdk,
-				quotaReserve: props.quotaReserve
-			});
-			return {
-				...result,
-				preview: tail.state,
-				delayed
-			};
-		} catch (e) {
-			return asFailure(e);
-		}
-	}
-	/**
-	* 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 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: instantRoute,
-			delayed: delayedRoute,
-			refused
-		};
-		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: false,
-			reason,
-			refused
-		};
-	}
-	/**
-	* Previews the tail of a delayed intent, once the withdrawal it started has
-	* matured: the claim, then whatever the intent still owes.
-	*
-	* Serves the three operations that can genuinely be interrupted by a delay —
-	* a withdrawal, a deleveraging and an exit. 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 finishIntent(props) {
-		return plain(await this.#preview(props, () => planTail({
-			intent: props.intent,
-			claimable: props.claimable,
-			view: accountView(props.creditAccount, props.sdk)
-		})));
-	}
-	/**
-	* 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);
-		}
-	}
-	/** 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: 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
-	};
-	if (isUnroutable(e)) return {
-		ok: false,
-		reason: "unsupportedTokenPair"
-	};
-	throw e;
-}
-/**
-* How the pathfinder says there is no route: it reverts instead of answering
-* with an empty path, so viem raises a contract error where the rest of the
-* engine raises an {@link IntentPreviewError}. Nothing is wrong — the trade
-* asked for cannot be made, which is a refusal the caller can act on, and one
-* `intentRoutes` in particular must keep as a value so the other route can
-* still be offered.
-*/
-function isUnroutable(e) {
-	for (let cause = e; cause instanceof Error; cause = cause.cause) if (cause.message.includes("no optimal edge found")) return true;
-	return false;
-}
-//#endregion
-export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, toCreditAccountSlice };

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

@@ -1,51 +0,0 @@
-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 };

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

@@ -1,88 +0,0 @@
-import { BigIntMath } from "../../utils/bigint-math.js";
-import { PERCENTAGE_FACTOR } from "../../constants/math.js";
-import "../../utils/index.js";
-import { eq } from "./utils/common.js";
-//#region src/sdk/accounts/intents/maxWithdrawCollateral.ts
-/**
-* Largest amount of one collateral the account can withdraw while its health
-* factor stays at or above `targetHF`.
-*
-* This is the collateral check solved for one balance, and it counts what that
-* check counts: a holding backed by a quota contributes the lesser of the
-* quota and its threshold-weighted value, an unquoted one — the underlying —
-* its weighted value alone, and dust or a disabled balance nothing at all.
-* Collateral is valued at the lower of its two feeds, the way the facade
-* values a call that hands funds over; the debt is valued at the main feed,
-* as the check does. Zero debt frees the whole balance.
-*
-* Rounding always favours the account, so the answer clears the check rather
-* than landing a wei short of it.
-*
-* @returns Amount in the token's units; `0n` when nothing can leave —
-* including when the account is already below `targetHF`, or the target or the
-* underlying has no price
-**/
-function maxWithdrawCollateral(props) {
-	const { creditAccount, sdk, token, targetHF } = props;
-	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
-	const { priceOracle } = market;
-	const { pqk } = market.pool;
-	const underlying = market.pool.underlying;
-	const target = creditAccount.tokens.find((t) => eq(t.token, token));
-	if (!target || target.balance <= 10n) return 0n;
-	if (creditAccount.accountDebt === 0n) return target.balance;
-	const masked = creditAccount.enabledTokensMask !== 0n;
-	const counts = (t) => t.balance > 10n && (!masked || (t.mask & creditAccount.enabledTokensMask) !== 0n);
-	/** What a holding backs, in the check's units: USD × PERCENTAGE_FACTOR. */
-	const weigh = (t) => {
-		const lt = BigInt(creditManager.liquidationThresholds.get(t.token) ?? 0);
-		const weighted = (safeUsd(priceOracle, t.token, t.balance) ?? 0n) * lt;
-		if (t.quota === 0n) return weighted;
-		return BigIntMath.min(quotaUsd(t) * PERCENTAGE_FACTOR, weighted);
-	};
-	/** A quota is underlying-denominated, and a closed market backs nothing. */
-	const quotaUsd = (t) => pqk.hasActiveQuota(t.token) ? usd(priceOracle, underlying, t.quota) ?? 0n : 0n;
-	let otherMoney = 0n;
-	for (const t of creditAccount.tokens) {
-		if (eq(t.token, token) || !counts(t)) continue;
-		otherMoney += weigh(t);
-	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.accountDebt);
-	if (borrowed === void 0 || borrowed <= 0n) return 0n;
-	const required = borrowed * targetHF;
-	if (required <= otherMoney) return target.balance;
-	const shortfall = required - otherMoney;
-	if (target.quota > 0n && quotaUsd(target) * 10000n < shortfall) return 0n;
-	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
-	const targetUsd = safeUsd(priceOracle, target.token, target.balance);
-	if (targetLt === 0n || !targetUsd) return 0n;
-	const keptUsd = ceilDiv(shortfall, targetLt);
-	const kept = ceilDiv(target.balance * keptUsd, targetUsd);
-	return kept >= target.balance ? 0n : target.balance - kept;
-}
-/** USD value at the main feed, or `undefined` when the token has no price. */
-function usd(oracle, token, amount) {
-	try {
-		return oracle.convertToUSD(token, amount);
-	} catch {
-		return;
-	}
-}
-/**
-* USD value at the lower of the token's two feeds — what a call handing funds
-* over is judged at. Falls back to the main feed where there is no second one.
-**/
-function safeUsd(oracle, token, amount) {
-	const main = usd(oracle, token, amount);
-	if (main === void 0) return;
-	try {
-		return BigIntMath.min(main, oracle.convertToUSD(token, amount, true));
-	} catch {
-		return main;
-	}
-}
-function ceilDiv(a, b) {
-	return (a + b - 1n) / b;
-}
-//#endregion
-export { maxWithdrawCollateral };

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

@@ -1,133 +0,0 @@
-import "../../constants/math.js";
-import { IntentPreviewError } from "./types.js";
-import { convertAmount } from "./utils/convert-amount.js";
-import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
-import { assertDebtInBand, debtForLeverage } from "./math.js";
-import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
-import { createRouterPaths } from "./utils/router-path.js";
-import "./utils/index.js";
-//#region src/sdk/accounts/intents/open-strategy.ts
-/** Stand-in account address: nothing exists on chain until the tx lands. */
-const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
-/**
-* Previews opening a leveraged position out of wallet collateral.
-*
-* Debt follows from the target leverage against the supplied margin
-* (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
-* borrowed underlying are then routed into the target token in one pathfinder call.
-*
-* There is no account yet, so this does not go through `startIntent` and produces
-* no operation list — the caller passes the numbers and calls straight to
-* `sdk.accounts.openCA`.
-*/
-async function previewOpenStrategy(props) {
-	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
-	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `openStrategy: leverage ${leverage} is below 1x`);
-	const suite = sdk.marketRegister.findCreditManager(creditManager);
-	const market = sdk.marketRegister.findByCreditManager(creditManager);
-	assertMarketOperable(suite);
-	const underlying = market.pool.underlying.toLowerCase();
-	const convert = convertAmount(sdk, creditManager);
-	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "openStrategy: collateral is worth nothing in underlying");
-	const debt = debtForLeverage(margin, leverage);
-	const account = {
-		creditAccount: NO_ACCOUNT,
-		creditManager: creditManager.toLowerCase(),
-		creditFacade: suite.creditFacade.address.toLowerCase(),
-		underlying,
-		enabledTokensMask: 0n,
-		totalDebtUSD: 0n,
-		accountDebt: 0n,
-		tokens: []
-	};
-	assertDebtInBand(debt, suite.creditFacade);
-	assertCanBorrow(suite, debt);
-	const leg = await createRouterPaths({
-		sdk,
-		creditAccount: account,
-		slippage
-	}).openStrategy({
-		expectedBalances: mergeExpectedBalances(collateral, underlying, debt),
-		leftoverBalances,
-		target: targetToken
-	});
-	const priced = ({ token, balance }) => market.priceOracle.toTokenAmount(token, balance);
-	const averageAssets = toAssets(leg.balances);
-	const minAssets = toAssets(leg.minBalances);
-	const quotasFor = (assets) => getQuotasForUpdate({
-		assetsBefore: [],
-		assetsAfter: assets,
-		initialQuotas: [],
-		quotaReserve,
-		underlyingToken: underlying,
-		liquidationThresholds: suite.creditManager.liquidationThresholds,
-		quotas: market.pool.pqk.quotas,
-		maxDebt: suite.creditFacade.maxDebt,
-		convert
-	}).quotaIncrease;
-	const averageQuota = quotasFor(averageAssets);
-	const minQuota = quotasFor(minAssets);
-	assertGrowthAllowed({
-		sdk,
-		suite,
-		market,
-		before: [],
-		after: averageAssets
-	});
-	assertQuotaHeadroom(market, averageQuota);
-	const snapshot = {
-		creditManager,
-		assets: averageAssets,
-		quotas: averageQuota,
-		totalDebt: debt,
-		totalValue: margin + debt
-	};
-	const projectedPool = { availableLiquidityChange: -debt };
-	const metrics = {
-		healthFactor: sdk.positions.healthFactor(snapshot),
-		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
-		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
-		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
-	};
-	assertCollateralised(metrics.healthFactor);
-	return {
-		debt,
-		collateral: margin,
-		totalValue: margin + debt,
-		averageAssets: averageAssets.map(priced),
-		minAssets: minAssets.map(priced),
-		averageQuota,
-		minQuota,
-		calls: [...leg.calls],
-		...metrics
-	};
-}
-/** Collateral plus the borrowed underlying, folded into one balance per token. */
-function mergeExpectedBalances(collateral, underlying, debt) {
-	const merged = /* @__PURE__ */ new Map();
-	for (const a of collateral) {
-		const token = a.token.toLowerCase();
-		merged.set(token, (merged.get(token) ?? 0n) + a.balance);
-	}
-	if (debt > 0n) merged.set(underlying, (merged.get(underlying) ?? 0n) + debt);
-	return [...merged.entries()].map(([token, balance]) => ({
-		token,
-		balance
-	}));
-}
-/** Router balance records carry mixed-case keys; normalise and drop empties. */
-function toAssets(balances) {
-	const merged = /* @__PURE__ */ new Map();
-	for (const [token, balance] of Object.entries(balances)) {
-		if (balance <= 0n) continue;
-		const key = token.toLowerCase();
-		merged.set(key, (merged.get(key) ?? 0n) + balance);
-	}
-	return [...merged.entries()].map(([token, balance]) => ({
-		token,
-		balance
-	}));
-}
-//#endregion
-export { previewOpenStrategy };