@gearbox-protocol/sdk 15.1.0-next.8 → 16.0.0-next.1

package/dist/esm/sdk/accounts/intents/testing/expect.js

@@ -1,162 +0,0 @@
-import { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL } from "./sdk-mock.js";
-import { expect } from "vitest";
-//#region src/sdk/accounts/intents/testing/expect.ts
-function expectedCalls(expected) {
-	return expected.calls ?? [];
-}
-/**
-* Fills sentinel `calls` for onchain resume expectations. Shared fixtures keep
-* `calls: []` for offchain; onchain tests map through this helper.
-*/
-function withOnchainOpCalls(ops) {
-	return ops.map((op) => {
-		switch (op.type) {
-			case "claimDelayedWithdrawal": return {
-				...op,
-				calls: [MOCK_CLAIM_CALL]
-			};
-			case "changeQuota": return {
-				...op,
-				calls: [CA_OP_CALLS.changeQuota]
-			};
-			case "decreaseDebt": return {
-				...op,
-				calls: [CA_OP_CALLS.decreaseDebt]
-			};
-			case "withdrawCollateral": return {
-				...op,
-				calls: [CA_OP_CALLS.withdrawCollateral]
-			};
-			case "swap": return {
-				...op,
-				calls: op.calls?.length ? op.calls : [MOCK_ROUTER_CALL]
-			};
-			case "wrapRwaCollateral": return {
-				...op,
-				calls: op.calls?.length ? op.calls : [MOCK_RWA_WRAP_CALL]
-			};
-			case "unwrapRwaCollateral": return {
-				...op,
-				calls: op.calls?.length ? op.calls : [MOCK_RWA_UNWRAP_CALL]
-			};
-			case "closeCreditAccount": return {
-				...op,
-				calls: op.calls?.length ? op.calls : [MOCK_CLOSE_CALL]
-			};
-			default: return op;
-		}
-	});
-}
-function matchOp(actual, expected, index) {
-	expect(actual.type, `op[${index}].type`).toBe(expected.type);
-	switch (expected.type) {
-		case "claimDelayedWithdrawal":
-			if (actual.type !== "claimDelayedWithdrawal") return;
-			expect(actual.token, `op[${index}].token`).toBe(expected.token);
-			expect(actual.withdrawalPhantomToken, `op[${index}].withdrawalPhantomToken`).toBe(expected.withdrawalPhantomToken);
-			expect(actual.withdrawalTokenSpent, `op[${index}].withdrawalTokenSpent`).toBe(expected.withdrawalTokenSpent);
-			expect(actual.outputs, `op[${index}].outputs`).toEqual(expected.outputs);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "changeQuota":
-			if (actual.type !== "changeQuota") return;
-			expect(actual.quotaIncrease, `op[${index}].quotaIncrease`).toEqual(expected.quotaIncrease);
-			expect(actual.quotaDecrease, `op[${index}].quotaDecrease`).toEqual(expected.quotaDecrease);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "closeCreditAccount":
-			if (actual.type !== "closeCreditAccount") return;
-			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
-			expect(actual.minAmount, `op[${index}].minAmount`).toBe(expected.minAmount);
-			expect(actual.underlyingBalance, `op[${index}].underlyingBalance`).toBe(expected.underlyingBalance);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "swap":
-			if (actual.type !== "swap") return;
-			expect(actual.from, `op[${index}].from`).toEqual(expected.from);
-			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
-			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "decreaseDebt":
-			if (actual.type !== "decreaseDebt") return;
-			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "withdrawCollateral":
-			if (actual.type !== "withdrawCollateral") return;
-			expect(actual.token, `op[${index}].token`).toBe(expected.token);
-			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
-			expect(actual.to, `op[${index}].to`).toBe(expected.to);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "unwrapRwaCollateral":
-			if (actual.type !== "unwrapRwaCollateral") return;
-			expect(actual.tokenIn, `op[${index}].tokenIn`).toBe(expected.tokenIn);
-			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
-			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
-			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-			break;
-		case "wrapRwaCollateral":
-			if (actual.type !== "wrapRwaCollateral") return;
-			expect(actual.tokenIn, `op[${index}].tokenIn`).toBe(expected.tokenIn);
-			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
-			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
-			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
-			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
-	}
-}
-/** Asserts exact operations on a raw op array (type + tokens + amounts). */
-function expectOpsArrayExact(ops, expected) {
-	expect(ops.length, "operations.length").toBe(expected.length);
-	for (let i = 0; i < expected.length; i++) {
-		const actual = ops[i];
-		const exp = expected[i];
-		if (actual === void 0 || exp === void 0) {
-			expect.fail(`missing op at index ${i}`);
-			return;
-		}
-		matchOp(actual, exp, i);
-	}
-}
-/** Asserts exact calls on a raw MultiCall array (target + callData). */
-function expectCallsArrayExact(calls, expected, label = "calls") {
-	expect(calls.length, `${label}.length`).toBe(expected.length);
-	for (let i = 0; i < expected.length; i++) {
-		const actual = calls[i];
-		const exp = expected[i];
-		if (actual === void 0 || exp === void 0) {
-			expect.fail(`missing call at index ${i}`);
-			return;
-		}
-		expect(actual.target, `${label}[${i}].target`).toBe(exp.target);
-		expect(actual.callData, `${label}[${i}].callData`).toBe(exp.callData);
-	}
-}
-/**
-* Asserts a successful adjust-style resume preview: ok, instant branch present,
-* exact calls (empty unless `expectedCalls` is provided), metrics from the
-* post-claim CA, and exact operations (incl. changeQuota).
-* Returns the adjust preview state for further asset/quota assertions.
-*/
-function expectAdjustResumePreview(result, args) {
-	expect(result.ok).toBe(true);
-	if (!result.ok) throw new Error("expected ok resume preview");
-	expect(result.instant, "instant branch").toBeDefined();
-	if (!result.instant) throw new Error("expected instant branch");
-	if (args.expectedCalls) expectCallsArrayExact(result.instant.calls, args.expectedCalls);
-	else expect(result.instant.calls).toEqual([]);
-	const state = result.instant.preview.min;
-	expect(state.kind).toBe("adjust");
-	if (state.kind !== "adjust") throw new Error("expected adjust preview state");
-	expect(state.totalValue).toBe(args.totalValue);
-	expect(state.accountDebt).toBe(args.accountDebt);
-	expectOpsArrayExact(result.instant.operations, args.expectedOps);
-	return state;
-}
-function assetBalance(assets, token) {
-	return assets.find((a) => a.token === token)?.balance ?? 0n;
-}
-//#endregion
-export { assetBalance, expectAdjustResumePreview, expectCallsArrayExact, expectOpsArrayExact, withOnchainOpCalls };

package/dist/esm/sdk/accounts/intents/testing/resume.js

@@ -1,157 +0,0 @@
-import { toBN } from "../../../utils/formatter.js";
-import "../../../index.js";
-import { MOCK_CLAIM_CALL, buildMockSdk } from "./sdk-mock.js";
-//#region src/sdk/accounts/intents/testing/resume.ts
-/**
-* Shared kit for claim-only resume fixtures (add collateral, increase
-* leverage, deposit, deposit+increase).
-*
-* Unlike the legacy props (which echoed `creditAccount.totalValue`), the
-* service computes totalValue from CA token balances via the price oracle.
-* Each case's base balance is therefore `postClaimTotalValue − claimed value
-* in UND`, so the derived totalValue matches the legacy expectation exactly.
-*/
-const UND_DECIMALS = 8;
-const TOK_DECIMALS = 18;
-const UND = "0x3333333333333333333333333333333333333333";
-const ANY = "0x1111111111111111111111111111111111111111";
-const ANY2 = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
-const RWA_ASSET = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-const RESUME_FIXTURE_PHANTOM = "0xcccccccccccccccccccccccccccccccccccccccc";
-const CREDIT_MANAGER = "0xdddddddddddddddddddddddddddddddddddddddd";
-const CREDIT_FACADE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-const CREDIT_ACCOUNT = "0xacacacacacacacacacacacacacacacacacacacac";
-const PRICES = {
-	[UND]: toBN("2", 8),
-	[ANY]: toBN("1", 8),
-	[ANY2]: toBN("1", 8),
-	[RWA_ASSET]: toBN("2", 8)
-};
-const DECIMALS = {
-	[UND]: 8,
-	[ANY]: 18,
-	[ANY2]: 18,
-	[RWA_ASSET]: 8
-};
-const QUOTAS = {
-	[ANY]: {
-		token: ANY,
-		rate: 500n,
-		limit: toBN("999999999999999", 18),
-		isActive: true
-	},
-	[ANY2]: {
-		token: ANY2,
-		rate: 500n,
-		limit: toBN("999999999999999", 18),
-		isActive: true
-	},
-	[RWA_ASSET]: {
-		token: RWA_ASSET,
-		rate: 500n,
-		limit: toBN("999999999999999", 8),
-		isActive: true
-	}
-};
-const LIQUIDATION_THRESHOLDS = {
-	[UND]: 9800,
-	[ANY]: 9200,
-	[ANY2]: 9200,
-	[RWA_ASSET]: 9200
-};
-const MAX_DEBT = toBN("200000", 8);
-/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
-function claimedValueInUnd(amount, token) {
-	return amount * PRICES[token] * 10n ** BigInt(8) / (PRICES[UND] * 10n ** BigInt(DECIMALS[token]));
-}
-/**
-* Mock sdk for a resume case. The fixture phantom token gets the claimed
-* token's decimals so the offchain `toTargetDecimals` rescale stays identity
-* (its `10n * decimals` factor is only correct for equal decimals).
-* `closePath` configures the router `findBestClosePath` result (close resume).
-*/
-function buildResumeSdk(c, extras) {
-	const phantom = extras?.phantom ?? "0xcccccccccccccccccccccccccccccccccccccccc";
-	return buildMockSdk({
-		prices: {
-			...PRICES,
-			...extras?.extraPrices
-		},
-		decimals: {
-			...DECIMALS,
-			...extras?.extraDecimals,
-			[phantom]: extras?.extraDecimals?.[c.claimedToken] ?? DECIMALS[c.claimedToken]
-		},
-		quotas: QUOTAS,
-		liquidationThresholds: LIQUIDATION_THRESHOLDS,
-		maxDebt: MAX_DEBT,
-		creditManager: CREDIT_MANAGER,
-		creditFacade: CREDIT_FACADE,
-		underlying: UND,
-		closePath: extras?.closePath,
-		rwaAssets: extras?.rwaAssets
-	});
-}
-function buildOffchainOptions(c) {
-	return {
-		kind: "offchain",
-		phantomSpent: c.claimedAmount,
-		withdrawalConfig: {
-			creditManager: CREDIT_MANAGER,
-			token: c.claimedToken,
-			withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
-			underlying: c.claimedToken,
-			withdrawalLength: 0n
-		}
-	};
-}
-function buildOnchainOptions(c) {
-	return {
-		kind: "onchain",
-		claimableWithdrawal: {
-			token: c.claimedToken,
-			withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
-			withdrawalTokenSpent: c.claimedAmount,
-			outputs: [{
-				token: c.claimedToken,
-				amount: c.claimedAmount,
-				isDelayed: false
-			}],
-			claimCalls: [MOCK_CLAIM_CALL]
-		}
-	};
-}
-function buildClaimResumeProps(args) {
-	const { intent, case: c, sdk, options } = args;
-	return {
-		intent,
-		creditAccount: {
-			creditAccount: CREDIT_ACCOUNT,
-			creditManager: CREDIT_MANAGER,
-			creditFacade: CREDIT_FACADE,
-			underlying: UND,
-			enabledTokensMask: 0n,
-			totalDebtUSD: 0n,
-			accountDebt: c.postClaimDebt,
-			tokens: [{
-				token: RESUME_FIXTURE_PHANTOM,
-				balance: c.claimedAmount,
-				quota: 0n,
-				mask: 0n,
-				success: true
-			}, ...c.baseAssets ?? [{
-				token: "0x3333333333333333333333333333333333333333",
-				balance: c.postClaimTotalValue - claimedValueInUnd(c.claimedAmount, c.claimedToken),
-				quota: 0n,
-				mask: 0n,
-				success: true
-			}]]
-		},
-		sdk,
-		quotaReserve: void 0,
-		options,
-		slippage: void 0
-	};
-}
-//#endregion
-export { ANY, ANY2, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, RESUME_FIXTURE_PHANTOM, RWA_ASSET, TOK_DECIMALS, UND, UND_DECIMALS, buildClaimResumeProps, buildOffchainOptions, buildOnchainOptions, buildResumeSdk, claimedValueInUnd };

package/dist/esm/sdk/accounts/intents/utils/simulate-adjust-state.js

@@ -1,38 +0,0 @@
-import { getQuotasForUpdate } from "./quotas-for-update.js";
-import { simulateOperationAssets } from "./simulate-assets.js";
-//#region src/sdk/accounts/intents/utils/simulate-adjust-state.ts
-function simulateState(props) {
-	const market = props.sdk.marketRegister.findByCreditManager(props.creditAccount.creditManager);
-	const convert = (token, to, amount) => market.priceOracle.convert(token, to, amount);
-	const creditManager = props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager);
-	const { assets, totalValue, debt } = simulateOperationAssets({
-		initialAssets: props.creditAccount.tokens,
-		operations: props.operations,
-		underlyingToken: props.creditAccount.underlying,
-		debt: props.creditAccount.accountDebt,
-		convert
-	});
-	const quotaResult = getQuotasForUpdate({
-		assetsBefore: props.creditAccount.tokens,
-		assetsAfter: assets,
-		liquidationThresholds: creditManager.creditManager.liquidationThresholds,
-		quotas: market.pool.pqk.quotas,
-		initialQuotas: props.creditAccount.tokens,
-		quotaReserve: props.quotaReserve,
-		underlyingToken: props.creditAccount.underlying,
-		maxDebt: creditManager.creditFacade.maxDebt,
-		convert
-	});
-	return {
-		state: {
-			kind: "adjust",
-			totalValue,
-			accountDebt: debt,
-			assets,
-			quotas: quotaResult.desiredQuota
-		},
-		quotaResult
-	};
-}
-//#endregion
-export { simulateState };

package/dist/esm/sdk/accounts/intents/utils/simulate-assets.js

@@ -1,68 +0,0 @@
-import { BigIntMath } from "../../../utils/bigint-math.js";
-//#region src/sdk/accounts/intents/utils/simulate-assets.ts
-/** Apply an op chain to CA token balances. Address keys are lowercased. */
-function simulateOperationAssets({ initialAssets, operations, underlyingToken, debt, convert }) {
-	let debtAfter = debt;
-	const balances = /* @__PURE__ */ new Map();
-	for (const asset of initialAssets) {
-		const token = asset.token.toLowerCase();
-		balances.set(token, (balances.get(token) ?? 0n) + asset.balance);
-	}
-	const get = (token) => balances.get(token.toLowerCase()) ?? 0n;
-	const set = (token, balance) => {
-		const key = token.toLowerCase();
-		if (balance <= 0n) balances.delete(key);
-		else balances.set(key, balance);
-	};
-	for (const op of operations) switch (op.type) {
-		case "changeQuota":
-		case "closeCreditAccount":
-		case "repayCreditAccount": break;
-		case "increaseDebt":
-			debtAfter = debtAfter + op.amount;
-			set(underlyingToken, get(underlyingToken) + op.amount);
-			break;
-		case "decreaseDebt":
-			debtAfter = BigIntMath.max(0n, debtAfter - op.amount);
-			set(underlyingToken, get(underlyingToken) - op.amount);
-			break;
-		case "addCollateral":
-			set(op.token, get(op.token) + op.amount);
-			break;
-		case "withdrawCollateral":
-			set(op.token, get(op.token) - op.amount);
-			break;
-		case "swap":
-			for (const swapInput of op.from) set(swapInput.token, get(swapInput.token) - swapInput.balance);
-			set(op.tokenOut, get(op.tokenOut) + op.amountOut);
-			break;
-		case "wrapRwaCollateral":
-			set(op.tokenIn, get(op.tokenIn) - op.amount);
-			set(op.tokenOut, get(op.tokenOut) + op.amountOut);
-			break;
-		case "unwrapRwaCollateral":
-			set(op.tokenIn, get(op.tokenIn) - op.amount);
-			set(op.tokenOut, get(op.tokenOut) + op.amountOut);
-			break;
-		case "startDelayedWithdrawal":
-			set(op.token, get(op.token) - op.amountIn);
-			for (const out of op.outputs) set(out.token, get(out.token) + out.amount);
-			break;
-		case "claimDelayedWithdrawal":
-			set(op.withdrawalPhantomToken, get(op.withdrawalPhantomToken) - op.withdrawalTokenSpent);
-			for (const out of op.outputs) set(out.token, get(out.token) + out.amount);
-	}
-	const assets = [...balances.entries()].map(([token, balance]) => ({
-		token: token.toLowerCase(),
-		balance
-	}));
-	return {
-		assets,
-		totalValue: assets.reduce((acc, a) => {
-			return acc + convert(a.token, underlyingToken, a.balance);
-		}, 0n),
-		debt: debtAfter
-	};
-}
-//#endregion
-export { simulateOperationAssets };

package/dist/esm/sdk/accounts/intents/utils/with-quota-update.js

@@ -1,12 +0,0 @@
-import { buildQuotaUpdateOperation } from "../operations/quota-update/index.js";
-import "../operations/index.js";
-//#region src/sdk/accounts/intents/utils/with-quota-update.ts
-function getOperationsWithQuotaUpdate({ operations: coreOps, state, creditAccount, sdk, options }) {
-	return state.quotaResult.quotaIncrease.length + state.quotaResult.quotaDecrease.length === 0 ? coreOps : [...coreOps, buildQuotaUpdateOperation({
-		update: state.quotaResult,
-		creditAccount,
-		sdk
-	}, options)];
-}
-//#endregion
-export { getOperationsWithQuotaUpdate };

package/dist/esm/sdk/base/PlaceholderContract.js

@@ -1,16 +0,0 @@
-import { BaseContract } from "./BaseContract.js";
-//#region src/sdk/base/PlaceholderContract.ts
-const abi = [];
-/**
-* @internal
-*/
-var PlaceholderContract = class extends BaseContract {
-	constructor(options, args) {
-		super(options, {
-			...args,
-			abi
-		});
-	}
-};
-//#endregion
-export { PlaceholderContract };

package/dist/esm/sdk/market/adapters/PlaceholderAdapterContracts.js

@@ -1,30 +0,0 @@
-import { MissingSerializedParamsError } from "../../base/errors.js";
-import { PlaceholderContract } from "../../base/PlaceholderContract.js";
-import "../../base/index.js";
-import { decodeAbiParameters } from "viem";
-//#region src/sdk/market/adapters/PlaceholderAdapterContracts.ts
-/**
-* @internal
-*/
-var PlaceholderAdapterContract = class extends PlaceholderContract {
-	#targetContract;
-	#creditManager;
-	constructor(options, args) {
-		super(options, args.baseParams);
-		if (args.baseParams.serializedParams) {
-			const [cm, tc] = decodeAbiParameters([{ type: "address" }, { type: "address" }], args.baseParams.serializedParams);
-			this.#creditManager = cm;
-			this.#targetContract = tc;
-		}
-	}
-	get targetContract() {
-		if (!this.#targetContract) throw new MissingSerializedParamsError("targetContract");
-		return this.#targetContract;
-	}
-	get creditManager() {
-		if (!this.#creditManager) throw new MissingSerializedParamsError("creditManager");
-		return this.#creditManager;
-	}
-};
-//#endregion
-export { PlaceholderAdapterContract };

package/dist/esm/sdk/market/credit/dominantCollateral.js

@@ -1,45 +0,0 @@
-import "../../constants/math.js";
-import "../../constants/index.js";
-import { hexEq } from "../../utils/hex.js";
-import "../../utils/index.js";
-//#region src/sdk/market/credit/dominantCollateral.ts
-/**
-* The account's dominant collateral: the most valuable enabled non-underlying
-* token it holds above dust, by USD value.
-*
-* This is the single definition of "what this account is a position in".
-* Using onchain-only data we can only determine at the time of the call (without
-* unreasably difficult calls)
-*
-* @param account - Account to inspect.
-* @param market - Market of the account, whose oracle prices the candidates.
-* @returns The dominant collateral, or `undefined` when the account holds
-* nothing but its underlying, or nothing the oracle can price.
-**/
-function dominantCollateral(account, market) {
-	let bestValue = 0;
-	let dominant;
-	for (const t of account.tokens) {
-		if (hexEq(t.token, account.underlying) || (t.mask & account.enabledTokensMask) === 0n || t.balance <= 10n) continue;
-		const value = market.priceOracle.safeUsdValue(t.token, t.balance) ?? 0;
-		if (value > bestValue) {
-			bestValue = value;
-			dominant = t.token;
-		}
-	}
-	return dominant;
-}
-/**
-* {@link dominantCollateral}, for callers that cannot proceed without one, such
-* as picking the collateral a partial liquidation seizes.
-*
-* @throws If the account holds no enabled non-underlying collateral the oracle
-* can price.
-**/
-function mustGetDominantCollateral(account, market) {
-	const collateral = dominantCollateral(account, market);
-	if (!collateral) throw new Error(`cannot determine tokenOut for partial liquidation of ${market.sdk.labelAddress(account.creditAccount)}: no enabled non-underlying collateral with value`);
-	return collateral;
-}
-//#endregion
-export { dominantCollateral, mustGetDominantCollateral };

package/dist/esm/sdk/market/credit/isStrategyCollateral.js

@@ -1,48 +0,0 @@
-import "../../constants/math.js";
-import "../../constants/index.js";
-import { isAddressEqual } from "viem";
-//#region src/sdk/market/credit/isStrategyCollateral.ts
-/**
-* Withdrawal and redemption phantom tokens that can never be acquired as a
-* strategy target. Other `PHANTOM_TOKEN::*` types (Convex, Infrared, staking
-* rewards) can.
-*/
-const NON_STRATEGY_PHANTOM_TOKEN_TYPES = [
-	"PHANTOM_TOKEN::INFINIFI_UNWIND",
-	"PHANTOM_TOKEN::MELLOW_WITHDRAWAL",
-	"PHANTOM_TOKEN::MIDAS_REDEMPTION",
-	"PHANTOM_TOKEN::SECURITIZE_RD",
-	"PHANTOM_TOKEN::UPSHIFT_WITHDRAW"
-];
-const NON_STRATEGY_PHANTOM_TOKEN_TYPE_SET = new Set(NON_STRATEGY_PHANTOM_TOKEN_TYPES);
-const RWA_UNDERLYING_PREFIX = "RWA_UNDERLYING::";
-/**
-* Whether a collateral token can be the target of a leveraged strategy.
-*
-* A token qualifies when it
-*
-* - has a liquidation threshold above `0` and below `100%`, and is not the
-*   suite's underlying — borrowing an asset against itself is not a position,
-*   and an LT of `0` or at least `100%` would mean unbounded leverage;
-* - is not the token the market's underlying wraps, which for an RWA market
-*   is the same exposure as the underlying itself (also rejected when
-*   `contractType` starts with `"RWA_UNDERLYING::"`);
-* - is not a withdrawal or redemption phantom token listed in
-*   {@link NON_STRATEGY_PHANTOM_TOKEN_TYPES} — those only ever appear as the
-*   intermediate step of a withdrawal and cannot be acquired;
-* - is not an expired token, e.g. a matured Pendle PT;
-* - has a non-zero main price in the market's oracle — a zero or missing
-*   answer (e.g. a failed or zero price feed) means the position cannot be
-*   valued;
-* - the market still accepts quota for.
-*/
-function isStrategyCollateral({ token, underlying, unwrappedUnderlying, liquidationThreshold, contractType, isExpired, mainPrice, hasActiveQuota }) {
-	if (isAddressEqual(token, underlying) || isAddressEqual(token, unwrappedUnderlying)) return false;
-	if (liquidationThreshold <= 0 || liquidationThreshold >= Number(10000n)) return false;
-	if (contractType && (NON_STRATEGY_PHANTOM_TOKEN_TYPE_SET.has(contractType) || contractType.startsWith(RWA_UNDERLYING_PREFIX))) return false;
-	if (isExpired) return false;
-	if (!mainPrice) return false;
-	return hasActiveQuota;
-}
-//#endregion
-export { NON_STRATEGY_PHANTOM_TOKEN_TYPES, isStrategyCollateral };