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

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

@@ -1,3 +1,4 @@
+import { MIN_INT96 } from "../../../constants/math.js";
 import { TypedObjectUtils } from "../../../utils/mappers.js";
 import { calcQuotaUpdate } from "../../../../common-utils/utils/creditAccount/quota-utils.js";
 //#region src/sdk/accounts/intents/utils/quotas-for-update.ts
@@ -51,6 +52,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: TypedObjectUtils.fromEntries(quoted.map((token) => [token, {
+			token,
+			balance: 0n
+		}])),
+		quotaIncrease: [],
+		quotaDecrease: quoted.map((token) => ({
+			token,
+			balance: 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 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]));
@@ -118,4 +166,4 @@ function constructAssetRecord(a) {
 	}, {});
 }
 //#endregion
-export { getQuotasForUpdate };
+export { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate };

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

@@ -0,0 +1,85 @@
+import { toRouterCaSlice } from "./common.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: toRouterCaSlice(creditAccount, expectedBalances),
+					creditManager: cmSlice,
+					expectedBalances,
+					leftoverBalances: [{
+						token: tokenIn,
+						balance: keep
+					}],
+					target: tokenOut,
+					slippage
+				});
+			}
+			return router.findOneTokenPath({
+				creditAccount: toRouterCaSlice(creditAccount, [{
+					token: tokenIn,
+					balance: amount
+				}]),
+				creditManager: cmSlice,
+				tokenIn,
+				tokenOut,
+				amount,
+				slippage
+			});
+		},
+		async closeAll({ balances }) {
+			const { amount, minAmount, calls } = await router.findBestClosePath({
+				creditAccount: 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
+			});
+		}
+	};
+}
+//#endregion
+export { createRouterPaths };

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

@@ -0,0 +1,37 @@
+import { eq } from "./utils/common.js";
+import { convertAmount } from "./utils/convert-amount.js";
+import { pickFattestNonPhantomToken } from "./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 = 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) => eq(t.token, token))?.balance ?? 0n,
+		price,
+		fattest: (exclude) => pickFattestNonPhantomToken({
+			creditAccount,
+			sdk,
+			exclude
+		})?.token
+	};
+}
+//#endregion
+export { accountView };

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

@@ -9,7 +9,7 @@ import "../../utils/index.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import "../../base/index.js";
 import { usdToNumber } from "../../market/math.js";
-import { dominantCollateral } from "../../market/credit/dominantCollateral.js";
+import { dominantCollateral } from "../../market/credit/collateralUtils.js";
 import { matchesLiquidatableAccountFilter } from "../../../model/liquidations.js";
 import "../../../model/index.js";
 import { RWA_LIQUIDATOR_MIDAS } from "../../market/rwa/midas/constants.js";
@@ -32,7 +32,6 @@ var LiquidationsService = class extends SDKConstruct {
 	* Accounts whose collateral computation failed are excluded.
 	**/
 	async getLiquidatableAccounts(props) {
-		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets(void 0, props?.blockNumber);
 		const unhealthy = await this.sdk.accounts.getCreditAccounts({
 			maxHealthFactor: WAD - 1n,
 			includeZeroDebt: false
@@ -59,7 +58,6 @@ var LiquidationsService = class extends SDKConstruct {
 		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
 		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		const { priceOracle } = suite.market;
-		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets(void 0, blockNumber);
 		const account = this.#buildAccount(ca, suite);
 		const data = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices, blockNumber);
 		return {
@@ -96,7 +94,6 @@ var LiquidationsService = class extends SDKConstruct {
 	async getLiquidationPositions(props) {
 		const compressor = this.sdk.withdrawalCompressor;
 		if (!compressor) return [];
-		await compressor.loadWithdrawableAssets(void 0, props.blockNumber);
 		const phantomTokens = new AddressSet(compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken));
 		const { claimable, pending } = await compressor.getExternalAccountCurrentWithdrawals({
 			account: props.liquidator,

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

@@ -0,0 +1,69 @@
+import { AddressMap } from "../../utils/AddressMap.js";
+import { encodeFunctionData, isAddressEqual, parseAbi } from "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 = parseAbi(["function receiveGreenlist() external returns (bool)"]);
+const iMidasGatewayModeAbi = parseAbi(["function mode() external view returns (uint8)"]);
+const receiveGreenlistCallData = 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 = 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) => isAddressEqual(call.target, vault.address)));
+	if (gatewayByMToken.size === 0 || calledVaults.length === 0) return calls;
+	const gateways = new 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) => 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
+export { prependMidasReceiveGreenlist };

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

@@ -170,7 +170,7 @@ var BaseContract = class extends 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/esm/sdk/base/index.js

@@ -4,8 +4,7 @@ import { Construct } from "./Construct.js";
 import { BaseContract, ContractParseError } from "./BaseContract.js";
 import { MissingSerializedParamsError } from "./errors.js";
 import { MultichainConstruct } from "./MultichainConstruct.js";
-import { PlaceholderContract } from "./PlaceholderContract.js";
 import { SDKConstruct } from "./SDKConstruct.js";
 import { PHANTOM_TOKEN_CONTRACT_TYPES, RWA_ON_DEMAND_LP_MONOPOLIZED, RWA_UNDERLYING_DEFAULT, RWA_UNDERLYING_ON_DEMAND } from "./token-types.js";
 import { VotingContractStatus } from "./types.js";
-export { BaseContract, ChainContractsRegister, Construct, ContractParseError, MissingSerializedParamsError, MultichainConstruct, PHANTOM_TOKEN_CONTRACT_TYPES, PlaceholderContract, RWA_ON_DEMAND_LP_MONOPOLIZED, RWA_UNDERLYING_DEFAULT, RWA_UNDERLYING_ON_DEMAND, SDKConstruct, TokensMeta, VotingContractStatus };
+export { BaseContract, ChainContractsRegister, Construct, ContractParseError, MissingSerializedParamsError, MultichainConstruct, PHANTOM_TOKEN_CONTRACT_TYPES, RWA_ON_DEMAND_LP_MONOPOLIZED, RWA_UNDERLYING_DEFAULT, RWA_UNDERLYING_ON_DEMAND, SDKConstruct, TokensMeta, VotingContractStatus };