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

package/dist/cjs/sdk/accounts/intents/utils/adjust-state-to-snapshot.js

@@ -1,14 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/sdk/accounts/intents/utils/adjust-state-to-snapshot.ts
 /**
-* Maps an intents {@link AdjustState} onto the {@link AccountSnapshot} that
+* Maps an intents {@link OperationState} onto the {@link AccountSnapshot} that
 * position-metric functions take. `accountDebt` is treated as total debt
 * (principal plus accrued interest and fees).
 **/
 function adjustStateToSnapshot(creditManager, state) {
 	return {
 		creditManager,
-		assets: state.assets,
+		assets: state.assets.map((a) => ({
+			token: a.token.address,
+			balance: a.value
+		})),
 		quotas: Object.values(state.quotas),
 		totalDebt: state.accountDebt,
 		totalValue: state.totalValue

package/dist/cjs/sdk/accounts/intents/utils/credit-account-slice.js

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees = require("./borrowed-amount-plus-interest-and-fees.js");
+//#region src/sdk/accounts/intents/utils/credit-account-slice.ts
+/**
+* Narrows full account data down to the slice the intent engine operates on.
+*
+* `accountDebt` is the total repayable debt (principal + accrued interest +
+* accrued fees) rather than the principal, because every debt-touching intent
+* settles the full outstanding amount.
+*
+* Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
+* behave consistently everywhere downstream.
+*/
+function toCreditAccountSlice(ca) {
+	return {
+		creditAccount: ca.creditAccount.toLowerCase(),
+		creditManager: ca.creditManager.toLowerCase(),
+		creditFacade: ca.creditFacade.toLowerCase(),
+		underlying: ca.underlying.toLowerCase(),
+		enabledTokensMask: ca.enabledTokensMask,
+		totalDebtUSD: ca.totalDebtUSD,
+		accountDebt: require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees.calcBorrowedAmountPlusInterestAndFees(ca),
+		tokens: ca.tokens.map((t) => ({
+			...t,
+			token: t.token.toLowerCase()
+		}))
+	};
+}
+/**
+* Reads an account by address and narrows it to {@link CreditAccountSlice}.
+*
+* The shared read model's `StrategyPosition` carries neither `tokens` nor
+* `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so simulating against
+* an existing position costs one account read.
+*
+* @throws When the account is not found in the connected markets.
+*/
+async function fetchCreditAccountSlice(sdk, creditAccount) {
+	const data = await sdk.accounts.getCreditAccountData(creditAccount);
+	if (!data) throw new Error(`credit account not found: ${creditAccount}`);
+	return toCreditAccountSlice(data);
+}
+//#endregion
+exports.fetchCreditAccountSlice = fetchCreditAccountSlice;
+exports.toCreditAccountSlice = toCreditAccountSlice;

package/dist/cjs/sdk/accounts/intents/utils/index.js

@@ -1,21 +1,30 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_common = require("./common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+const require_sdk_accounts_intents_utils_pick_token = require("./pick-token.js");
 const require_sdk_accounts_intents_utils_adjust_state_to_snapshot = require("./adjust-state-to-snapshot.js");
 const require_sdk_accounts_intents_utils_assemble_operation_calls = require("./assemble-operation-calls.js");
 const require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees = require("./borrowed-amount-plus-interest-and-fees.js");
-const require_sdk_accounts_intents_utils_common = require("./common.js");
-const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+const require_sdk_accounts_intents_utils_credit_account_slice = require("./credit-account-slice.js");
+const require_sdk_accounts_intents_utils_ledger = require("./ledger.js");
 const require_sdk_accounts_intents_utils_quotas_for_update = require("./quotas-for-update.js");
-const require_sdk_accounts_intents_utils_simulate_assets = require("./simulate-assets.js");
-const require_sdk_accounts_intents_utils_simulate_adjust_state = require("./simulate-adjust-state.js");
-const require_sdk_accounts_intents_utils_with_quota_update = require("./with-quota-update.js");
+const require_sdk_accounts_intents_utils_router_path = require("./router-path.js");
+exports.OperationLedger = require_sdk_accounts_intents_utils_ledger.OperationLedger;
 exports.adjustStateToSnapshot = require_sdk_accounts_intents_utils_adjust_state_to_snapshot.adjustStateToSnapshot;
 exports.assembleOperationCalls = require_sdk_accounts_intents_utils_assemble_operation_calls.assembleOperationCalls;
 exports.calcBorrowedAmountPlusInterestAndFees = require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees.calcBorrowedAmountPlusInterestAndFees;
+exports.clearedQuotas = require_sdk_accounts_intents_utils_quotas_for_update.clearedQuotas;
 exports.convertAmount = require_sdk_accounts_intents_utils_convert_amount.convertAmount;
+exports.createOraclePaths = require_sdk_accounts_intents_utils_router_path.createOraclePaths;
+exports.createRouterPaths = require_sdk_accounts_intents_utils_router_path.createRouterPaths;
 exports.eq = require_sdk_accounts_intents_utils_common.eq;
-exports.getOperationsWithQuotaUpdate = require_sdk_accounts_intents_utils_with_quota_update.getOperationsWithQuotaUpdate;
+exports.fetchCreditAccountSlice = require_sdk_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;
 exports.getQuotasForUpdate = require_sdk_accounts_intents_utils_quotas_for_update.getQuotasForUpdate;
-exports.simulateOperationAssets = require_sdk_accounts_intents_utils_simulate_assets.simulateOperationAssets;
-exports.simulateState = require_sdk_accounts_intents_utils_simulate_adjust_state.simulateState;
+exports.isPhantomToken = require_sdk_accounts_intents_utils_pick_token.isPhantomToken;
+exports.isRedemptionPhantomToken = require_sdk_accounts_intents_utils_pick_token.isRedemptionPhantomToken;
+exports.pickFattestNonPhantomToken = require_sdk_accounts_intents_utils_pick_token.pickFattestNonPhantomToken;
+exports.quotasAfterUpdate = require_sdk_accounts_intents_utils_quotas_for_update.quotasAfterUpdate;
+exports.rankAccountTokens = require_sdk_accounts_intents_utils_pick_token.rankAccountTokens;
+exports.toCreditAccountSlice = require_sdk_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;
 exports.toRouterCaSlice = require_sdk_accounts_intents_utils_common.toRouterCaSlice;
 exports.toTargetDecimals = require_sdk_accounts_intents_utils_common.toTargetDecimals;

package/dist/cjs/sdk/accounts/intents/utils/ledger.js

@@ -0,0 +1,94 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_bigint_math = require("../../../utils/bigint-math.js");
+//#region src/sdk/accounts/intents/utils/ledger.ts
+/**
+* Running account state, advanced one operation at a time.
+*
+* Exists because the amounts an operation is built from depend on the balances
+* the previous ones left behind: a swap has to know how much of its input token
+* is genuinely swap input, so the router does not sweep collateral that must
+* stay put. Applying each op as it is built keeps that a single forward pass —
+* a builder that re-simulated the chain from the start for every leg would be
+* quadratic in the number of legs and easy to desynchronise.
+*/
+var OperationLedger = class {
+	#balances = /* @__PURE__ */ new Map();
+	#underlying;
+	#convert;
+	#debt;
+	constructor(args) {
+		this.#underlying = args.underlying;
+		this.#convert = args.convert;
+		this.#debt = args.debt;
+		for (const asset of args.initialAssets) {
+			const token = asset.token.toLowerCase();
+			this.#balances.set(token, (this.#balances.get(token) ?? 0n) + asset.balance);
+		}
+	}
+	get debt() {
+		return this.#debt;
+	}
+	balanceOf(token) {
+		return this.#balances.get(token.toLowerCase()) ?? 0n;
+	}
+	applyAll(operations) {
+		for (const op of operations) this.apply(op);
+		return this;
+	}
+	snapshot() {
+		const assets = [...this.#balances.entries()].map(([token, balance]) => ({
+			token,
+			balance
+		}));
+		return {
+			assets,
+			totalValue: assets.reduce((acc, a) => acc + this.#convert(a.token, this.#underlying, a.balance), 0n),
+			debt: this.#debt
+		};
+	}
+	/** Advances the state by one operation; quota changes move no balance. */
+	apply(op) {
+		switch (op.type) {
+			case "changeQuota": break;
+			case "increaseDebt":
+				this.#debt += op.amount;
+				this.#add(this.#underlying, op.amount);
+				break;
+			case "decreaseDebt":
+				this.#debt = require_sdk_utils_bigint_math.BigIntMath.max(0n, this.#debt - op.amount);
+				this.#add(this.#underlying, -op.amount);
+				break;
+			case "addCollateral":
+				this.#add(op.token, op.amount);
+				break;
+			case "withdrawCollateral":
+				this.#add(op.token, -op.amount);
+				break;
+			case "swap":
+				for (const input of op.from) this.#add(input.token, -input.balance);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "wrapRwaCollateral":
+			case "unwrapRwaCollateral":
+				this.#add(op.tokenIn, -op.amount);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "startDelayedWithdrawal":
+				this.#add(op.token, -op.amountIn);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+				break;
+			case "claimDelayedWithdrawal":
+				this.#add(op.withdrawalPhantomToken, -op.withdrawalTokenSpent);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+		}
+		return this;
+	}
+	#add(token, delta) {
+		const key = token.toLowerCase();
+		const balance = (this.#balances.get(key) ?? 0n) + delta;
+		if (balance <= 0n) this.#balances.delete(key);
+		else this.#balances.set(key, balance);
+	}
+};
+//#endregion
+exports.OperationLedger = OperationLedger;

package/dist/cjs/sdk/accounts/intents/utils/pick-token.js

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_base_token_types = require("../../../base/token-types.js");
+const require_sdk_accounts_intents_utils_common = require("./common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+//#region src/sdk/accounts/intents/utils/pick-token.ts
+/** Prefix marking every phantom-token contract type in the registry. */
+const PHANTOM_TOKEN_PREFIX = "PHANTOM_TOKEN::";
+/**
+* Whether `token` is a phantom (a non-transferable position marker such as a
+* pending delayed withdrawal).
+*
+* Reads `contractType` directly instead of going through
+* `TokensMeta.isPhantomToken`, which throws when extended token data has not
+* been loaded. Here an unknown token is simply treated as non-phantom.
+*/
+function isPhantomToken(sdk, token) {
+	return !!sdk.tokensMeta.get(token)?.contractType?.startsWith(PHANTOM_TOKEN_PREFIX);
+}
+const REDEMPTION_PHANTOM_TOKEN_TYPES = new Set(require_sdk_base_token_types.NON_STRATEGY_PHANTOM_TOKEN_TYPES);
+/**
+* Whether `token` is the phantom of a redemption in flight, rather than one of
+* the phantoms a position is simply held in (Convex, Infrared, staking
+* rewards), which the router sells like any other balance.
+*
+* Only the former stands between an account and being emptied: it cannot be
+* sold and it cannot leave until its claim has landed.
+*/
+function isRedemptionPhantomToken(sdk, token) {
+	const contractType = sdk.tokensMeta.get(token)?.contractType;
+	return !!contractType && REDEMPTION_PHANTOM_TOKEN_TYPES.has(contractType);
+}
+/**
+* Account balances that can actually back an operation, richest first.
+*
+* Phantoms are dropped because a pending delayed withdrawal cannot be spent:
+* it has to be claimed first, in a transaction of its own.
+*/
+function rankAccountTokens(args) {
+	const { creditAccount, sdk, exclude = [] } = args;
+	const convert = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
+	const candidates = [];
+	for (const t of creditAccount.tokens) {
+		if (t.balance <= 0n) continue;
+		if (exclude.some((e) => require_sdk_accounts_intents_utils_common.eq(e, t.token))) continue;
+		if (isPhantomToken(sdk, t.token)) continue;
+		candidates.push({
+			token: t.token,
+			balance: t.balance,
+			valueInUnderlying: convert(t.token, creditAccount.underlying, t.balance)
+		});
+	}
+	candidates.sort((a, b) => {
+		if (a.valueInUnderlying !== b.valueInUnderlying) return a.valueInUnderlying > b.valueInUnderlying ? -1 : 1;
+		return a.token < b.token ? -1 : a.token > b.token ? 1 : 0;
+	});
+	return candidates;
+}
+/**
+* Default working token for flows that do not get one from the caller: the
+* most valuable non-phantom balance on the account.
+*
+* Used for the source of a partial withdraw and the position leg of a leverage
+* adjustment, both of which the caller may override explicitly.
+*/
+function pickFattestNonPhantomToken(args) {
+	return rankAccountTokens(args)[0];
+}
+//#endregion
+exports.isPhantomToken = isPhantomToken;
+exports.isRedemptionPhantomToken = isRedemptionPhantomToken;
+exports.pickFattestNonPhantomToken = pickFattestNonPhantomToken;
+exports.rankAccountTokens = rankAccountTokens;

package/dist/cjs/sdk/accounts/intents/utils/quotas-for-update.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_constants_math = require("../../../constants/math.js");
 const require_sdk_utils_mappers = require("../../../utils/mappers.js");
 const require_common_utils_utils_creditAccount_quota_utils = require("../../../../common-utils/utils/creditAccount/quota-utils.js");
 //#region src/sdk/accounts/intents/utils/quotas-for-update.ts
@@ -52,6 +53,53 @@ function getQuotasForUpdate({ assetsBefore, assetsAfter, initialQuotas, quotaRes
 	});
 	return filterQuotaUpdates(quotaResult.desiredQuota, quotaResult.quotaIncrease, quotaResult.quotaDecrease, [...new Set([...spend, ...obtain].map((q) => q.token)).values()]);
 }
+/**
+* The update that leaves the account holding no quota at all.
+*
+* Sits beside {@link getQuotasForUpdate} rather than inside it because the two
+* answer different questions: that one sizes quotas to the balances an
+* operation leaves behind, this one is asked for by a plan that ends the loan,
+* where the right size is none whatever the balances are.
+*
+* `MIN_INT96` is the protocol's "reset" sentinel, which is how a decrease says
+* "all of it" instead of naming an amount that interest may have moved.
+*/
+function clearedQuotas(initialQuotas) {
+	const quoted = initialQuotas.filter((q) => q.quota > 0n).map((q) => q.token.toLowerCase());
+	return {
+		desiredQuota: require_sdk_utils_mappers.TypedObjectUtils.fromEntries(quoted.map((token) => [token, {
+			token,
+			balance: 0n
+		}])),
+		quotaIncrease: [],
+		quotaDecrease: quoted.map((token) => ({
+			token,
+			balance: require_sdk_constants_math.MIN_INT96
+		}))
+	};
+}
+/**
+* The quotas the account stands at once an update lands: the ones it came with,
+* with the ones the update names written over them.
+*
+* An update only names the tokens its operation touched — see
+* {@link filterQuotaUpdates} — and the quotas of everything else keep standing,
+* so the update alone is not the account's quota set. Quotas that end at zero
+* are dropped: a token with no quota is a token the account is not quoted for.
+*/
+function quotasAfterUpdate(initialQuotas, desiredQuota) {
+	const after = {};
+	for (const q of initialQuotas) {
+		const token = q.token.toLowerCase();
+		if (q.quota > 0n) after[token] = {
+			token,
+			balance: q.quota
+		};
+	}
+	for (const [token, quota] of require_sdk_utils_mappers.TypedObjectUtils.entries(desiredQuota)) if (quota.balance > 0n) after[token] = quota;
+	else delete after[token];
+	return after;
+}
 function collectQuotaChange(assetsBefore, assetsAfter) {
 	const before = new Map(assetsBefore.map((a) => [a.token, a.balance]));
 	const after = new Map(assetsAfter.map((a) => [a.token, a.balance]));
@@ -119,4 +167,6 @@ function constructAssetRecord(a) {
 	}, {});
 }
 //#endregion
+exports.clearedQuotas = clearedQuotas;
 exports.getQuotasForUpdate = getQuotasForUpdate;
+exports.quotasAfterUpdate = quotasAfterUpdate;

package/dist/cjs/sdk/accounts/intents/utils/router-path.js

@@ -0,0 +1,118 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_common = require("./common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+//#region src/sdk/accounts/intents/utils/router-path.ts
+/**
+* The engine's only door to the pathfinder.
+*
+* Deliberately not a quoter abstraction with an oracle-priced twin: paths are
+* always resolved on-chain, because a preview whose swap amounts came from
+* oracle prices could not produce the calldata that realises them.
+*/
+function createRouterPaths(args) {
+	const { sdk, creditAccount, slippage } = args;
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const cmSlice = {
+		address: suite.creditManager.address.toLowerCase(),
+		creditFacade: suite.creditFacade.address.toLowerCase(),
+		collateralTokens: suite.creditManager.collateralTokens.map((t) => t.toLowerCase())
+	};
+	const router = sdk.routerFor({ creditFacade: suite.creditFacade.address });
+	return {
+		async swap({ tokenIn, tokenOut, amount, keep = 0n }) {
+			if (amount <= 0n) return {
+				amount: 0n,
+				minAmount: 0n,
+				calls: []
+			};
+			if (keep < 0n) throw new Error(`swap: spending ${amount} of ${tokenIn} exceeds its balance`);
+			if (keep > 0n) {
+				const expectedBalances = [{
+					token: tokenIn,
+					balance: amount + keep
+				}];
+				return router.findManyToOnePath({
+					creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, expectedBalances),
+					creditManager: cmSlice,
+					expectedBalances,
+					leftoverBalances: [{
+						token: tokenIn,
+						balance: keep
+					}],
+					target: tokenOut,
+					slippage
+				});
+			}
+			return router.findOneTokenPath({
+				creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, [{
+					token: tokenIn,
+					balance: amount
+				}]),
+				creditManager: cmSlice,
+				tokenIn,
+				tokenOut,
+				amount,
+				slippage
+			});
+		},
+		async closeAll({ balances }) {
+			const { amount, minAmount, calls } = await router.findBestClosePath({
+				creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, balances),
+				creditManager: cmSlice,
+				balances: {
+					expectedBalances: balances,
+					leftoverBalances: [],
+					tokensToClaim: []
+				},
+				slippage
+			});
+			return {
+				amount,
+				minAmount,
+				calls: [...calls]
+			};
+		},
+		async openStrategy({ expectedBalances, leftoverBalances, target }) {
+			return router.findOpenStrategyPath({
+				creditManager: cmSlice,
+				expectedBalances,
+				leftoverBalances,
+				target,
+				slippage
+			});
+		}
+	};
+}
+/**
+* The same door, priced by the oracle and opening onto no calldata.
+*
+* For a leg that cannot be quoted yet: the tail of a redemption trades funds
+* that do not exist, along a route the pathfinder will only be able to build
+* once they do. Asking it now would price a swap of nothing, so the amounts
+* come from the oracle instead — an estimate with no slippage floor, which is
+* all a projection days out can honestly be — and the walk yields a state
+* rather than a transaction.
+*/
+function createOraclePaths(args) {
+	const { sdk, creditAccount } = args;
+	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
+	const estimate = (amount) => ({
+		amount,
+		minAmount: amount,
+		calls: []
+	});
+	return {
+		async swap({ tokenIn, tokenOut, amount }) {
+			return estimate(amount > 0n ? price(tokenIn, tokenOut, amount) : 0n);
+		},
+		async closeAll({ balances }) {
+			return estimate(balances.reduce((sum, b) => sum + price(b.token, creditAccount.underlying, b.balance), 0n));
+		},
+		async openStrategy() {
+			throw new Error("oracle paths: opening a position is never projected");
+		}
+	};
+}
+//#endregion
+exports.createOraclePaths = createOraclePaths;
+exports.createRouterPaths = createRouterPaths;

package/dist/cjs/sdk/accounts/intents/view.js

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_common = require("./utils/common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
+const require_sdk_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
+//#region src/sdk/accounts/intents/view.ts
+/**
+* The account as the planners see it: a handful of numbers in underlying units
+* plus balance / price lookups. Read once per preview.
+*
+* TVL uses the RWA-aware conversion so an `rwa.asset` balance without a direct
+* pool price still counts at its wrapped value instead of throwing.
+*/
+function accountView(creditAccount, sdk) {
+	const { underlying, creditManager } = creditAccount;
+	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
+	const { creditFacade } = sdk.marketRegister.findCreditManager(creditManager);
+	let totalValue = 0n;
+	for (const t of creditAccount.tokens) totalValue += price(t.token, underlying, t.balance);
+	return {
+		underlying,
+		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
+		debt: creditAccount.accountDebt,
+		collateral: totalValue - creditAccount.accountDebt,
+		band: {
+			minDebt: creditFacade.minDebt,
+			maxDebt: creditFacade.maxDebt
+		},
+		balanceOf: (token) => creditAccount.tokens.find((t) => require_sdk_accounts_intents_utils_common.eq(t.token, token))?.balance ?? 0n,
+		price,
+		fattest: (exclude) => require_sdk_accounts_intents_utils_pick_token.pickFattestNonPhantomToken({
+			creditAccount,
+			sdk,
+			exclude
+		})?.token
+	};
+}
+//#endregion
+exports.accountView = accountView;

package/dist/cjs/sdk/accounts/liquidations/LiquidationsService.js

@@ -10,7 +10,7 @@ require("../../utils/index.js");
 const require_sdk_base_SDKConstruct = require("../../base/SDKConstruct.js");
 require("../../base/index.js");
 const require_sdk_market_math = require("../../market/math.js");
-const require_sdk_market_credit_dominantCollateral = require("../../market/credit/dominantCollateral.js");
+const require_sdk_market_credit_collateralUtils = require("../../market/credit/collateralUtils.js");
 const require_model_liquidations = require("../../../model/liquidations.js");
 require("../../../model/index.js");
 const require_sdk_market_rwa_midas_constants = require("../../market/rwa/midas/constants.js");
@@ -285,7 +285,7 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		};
 	}
 	#mainAsset(ca, market, fallback) {
-		const asset = require_sdk_market_credit_dominantCollateral.dominantCollateral(ca, market);
+		const asset = require_sdk_market_credit_collateralUtils.dominantCollateral(ca, market);
 		if (!asset) return fallback;
 		return this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(asset) ?? asset;
 	}

package/dist/cjs/sdk/accounts/utils/midasUtils.js

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_AddressMap = require("../../utils/AddressMap.js");
+let viem = require("viem");
+//#region src/sdk/accounts/utils/midasUtils.ts
+const ADAPTER_MIDAS_GATEWAY = "ADAPTER::MIDAS_GATEWAY";
+const ADAPTER_MIDAS_ISSUANCE_VAULT = "ADAPTER::MIDAS_ISSUANCE_VAULT";
+/**
+* Permissionless gateways have no greenlist and reject `receiveGreenlist`,
+* see MidasMode in integrations-v3
+*/
+const MIDAS_MODE_PERMISSIONLESS = 0;
+const iMidasGatewayAdapterExtAbi = (0, viem.parseAbi)(["function receiveGreenlist() external returns (bool)"]);
+const iMidasGatewayModeAbi = (0, viem.parseAbi)(["function mode() external view returns (uint8)"]);
+const receiveGreenlistCallData = (0, viem.encodeFunctionData)({
+	abi: iMidasGatewayAdapterExtAbi,
+	functionName: "receiveGreenlist"
+});
+/**
+* Prepends `MidasGatewayAdapter.receiveGreenlist()` to a credit facade
+* multicall that mints an mToken through a Midas issuance vault.
+*
+* Permissioned and restricted-interface mTokens can only be held by greenlisted
+* accounts, and a freshly opened credit account is never greenlisted, so the
+* mint reverts with `WMAC: hasnt role` unless the account asks the gateway for
+* the greenlist first. Greenlisting the borrower is not enough — the role is
+* checked on the token holder, which is the credit account.
+*
+* Returns `calls` unchanged when nothing has to be greenlisted: no issuance
+* vault is called, its mToken has no gateway adapter on this credit manager,
+* the gateway is permissionless, or the call is already there.
+*/
+async function prependMidasReceiveGreenlist(props) {
+	const { cm, client, calls, logger } = props;
+	const adapters = Array.from(cm.creditManager.adapters.values());
+	const gatewayByMToken = require_sdk_utils_AddressMap.AddressMap.fromMappedArray(adapters.filter((a) => a.contractType === ADAPTER_MIDAS_GATEWAY), (a) => a.mToken);
+	const calledVaults = adapters.filter((a) => a.contractType === ADAPTER_MIDAS_ISSUANCE_VAULT).filter((vault) => calls.some((call) => (0, viem.isAddressEqual)(call.target, vault.address)));
+	if (gatewayByMToken.size === 0 || calledVaults.length === 0) return calls;
+	const gateways = new require_sdk_utils_AddressMap.AddressMap();
+	for (const vault of calledVaults) {
+		const gateway = gatewayByMToken.get(vault.mToken);
+		if (!gateway) logger?.debug(`midas: no gateway adapter for mToken ${vault.mToken} minted by ${vault.address} on ${cm.name}, cannot greenlist the credit account`);
+		else if (calls.some((call) => (0, viem.isAddressEqual)(call.target, gateway.address) && call.callData === receiveGreenlistCallData)) logger?.debug(`midas: gateway adapter ${gateway.address} already receives the greenlist`);
+		else gateways.upsert(gateway.address, gateway);
+	}
+	if (gateways.size === 0) return calls;
+	const uniqueGateways = gateways.values();
+	const modes = await client.multicall({
+		allowFailure: false,
+		contracts: uniqueGateways.map(({ targetContract }) => ({
+			address: targetContract,
+			abi: iMidasGatewayModeAbi,
+			functionName: "mode"
+		}))
+	});
+	const prepended = [];
+	for (const [i, gateway] of uniqueGateways.entries()) {
+		if (modes[i] === MIDAS_MODE_PERMISSIONLESS) {
+			logger?.debug(`midas: gateway ${gateway.targetContract} is permissionless, nothing to greenlist`);
+			continue;
+		}
+		logger?.debug(`midas: greenlisting the credit account via gateway adapter ${gateway.address}`);
+		prepended.push({
+			target: gateway.address,
+			callData: receiveGreenlistCallData
+		});
+	}
+	return prepended.length > 0 ? [...prepended, ...calls] : calls;
+}
+//#endregion
+exports.prependMidasReceiveGreenlist = prependMidasReceiveGreenlist;

package/dist/cjs/sdk/base/BaseContract.js

@@ -171,7 +171,7 @@ var BaseContract = class extends require_sdk_base_Construct.Construct {
 			name: decoded.functionName,
 			args: decoded.args
 		});
-		if (!abiItem || abiItem.type !== "function") return `Unknown function: ${decoded.functionName}`;
+		if (abiItem?.type !== "function") return `Unknown function: ${decoded.functionName}`;
 		const params = this.stringifyFunctionParams(decoded).map((v, i) => `${abiItem.inputs[i].name}: ${v}`);
 		return `${this.name}.${decoded.functionName}({${params.join(", ")}})`;
 	}

package/dist/cjs/sdk/base/TokensMeta.js

@@ -41,10 +41,21 @@ var TokensMeta = class extends require_sdk_utils_AddressMap.AddressMap {
 			...existing,
 			...v
 		};
+		if (v) {
+			const pretty = this.#prettyName(address);
+			if (pretty) v = {
+				...v,
+				symbol: pretty
+			};
+		}
 		super.upsert(address, v);
 	}
 	/**
-	* Returns the symbol string for a token.
+	* Returns the display symbol for a token.
+	*
+	* This is not always the on-chain ERC-20 `symbol()`: curated pretty names
+	* and redemption phantom tokens (`"source -> target"`) replace it.
+	*
 	* @param token - Token address.
 	* @throws If the token is not in the registry.
 	*/
@@ -139,11 +150,32 @@ var TokensMeta = class extends require_sdk_utils_AddressMap.AddressMap {
 		}
 		return meta.asset;
 	}
+	/**
+	* Rewrites display symbols of redemption phantom tokens to
+	* `"${source} -> ${target}"`.
+	*
+	* @param renames - Phantom / source / target address triples.
+	**/
+	renameRedemptionPhantoms(renames) {
+		for (const { phantom, source, target } of renames) {
+			const meta = this.get(phantom);
+			if (!meta || !this.has(source) || !this.has(target)) continue;
+			this.upsert(phantom, {
+				...meta,
+				symbol: `${this.symbol(source)} -> ${this.symbol(target)}`
+			});
+		}
+	}
 	get #networkType() {
 		const { chain } = this.#client;
 		if ("network" in chain) return chain.network;
 		throw new Error(`chain ${chain.id} is not a Gearbox SDK chain`);
 	}
+	#prettyName(token) {
+		const { chain } = this.#client;
+		if (!("network" in chain)) return;
+		return chain.tokenPrettyNames?.get(token);
+	}
 	formatBN(arg0, arg1, arg2) {
 		const token = typeof arg0 === "object" ? arg0.token : arg0;
 		const amount = typeof arg0 === "object" ? arg0.balance : arg1;

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

@@ -5,7 +5,6 @@ const require_sdk_base_Construct = require("./Construct.js");
 const require_sdk_base_BaseContract = require("./BaseContract.js");
 const require_sdk_base_errors = require("./errors.js");
 const require_sdk_base_MultichainConstruct = require("./MultichainConstruct.js");
-const require_sdk_base_PlaceholderContract = require("./PlaceholderContract.js");
 const require_sdk_base_SDKConstruct = require("./SDKConstruct.js");
 const require_sdk_base_token_types = require("./token-types.js");
 const require_sdk_base_types = require("./types.js");
@@ -15,8 +14,8 @@ exports.Construct = require_sdk_base_Construct.Construct;
 exports.ContractParseError = require_sdk_base_BaseContract.ContractParseError;
 exports.MissingSerializedParamsError = require_sdk_base_errors.MissingSerializedParamsError;
 exports.MultichainConstruct = require_sdk_base_MultichainConstruct.MultichainConstruct;
+exports.NON_STRATEGY_PHANTOM_TOKEN_TYPES = require_sdk_base_token_types.NON_STRATEGY_PHANTOM_TOKEN_TYPES;
 exports.PHANTOM_TOKEN_CONTRACT_TYPES = require_sdk_base_token_types.PHANTOM_TOKEN_CONTRACT_TYPES;
-exports.PlaceholderContract = require_sdk_base_PlaceholderContract.PlaceholderContract;
 exports.RWA_ON_DEMAND_LP_MONOPOLIZED = require_sdk_base_token_types.RWA_ON_DEMAND_LP_MONOPOLIZED;
 exports.RWA_UNDERLYING_DEFAULT = require_sdk_base_token_types.RWA_UNDERLYING_DEFAULT;
 exports.RWA_UNDERLYING_ON_DEMAND = require_sdk_base_token_types.RWA_UNDERLYING_ON_DEMAND;