@gearbox-protocol/sdk 16.0.0-next.3 → 16.0.0-next.31

package/dist/cjs/onchain/market/math.js

@@ -0,0 +1,311 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_constants_math = require("../constants/math.js");
+//#region src/onchain/market/math.ts
+/**
+* Conversions between the units the protocol stores and the basis points the
+* read model exposes.
+*
+* These live here rather than inside the service so that the on-chain adapter,
+* the merger and any future consumer of the read model share one definition of
+* every derived value.
+**/
+const FULL = Number(require_onchain_constants_math.PERCENTAGE_FACTOR);
+/**
+* Converts a ray-scaled rate (`10 ** 27` = 100%) to basis points, truncating
+* towards zero.
+*
+* @example
+* ```ts
+* // ray: 5% (0.05 × 10²⁷)
+* rayToBps(50_000_000_000_000_000_000_000_000n) // 500 bps = 5%
+* ```
+**/
+function rayToBps(ray) {
+	return Number(ray * require_onchain_constants_math.PERCENTAGE_FACTOR / require_onchain_constants_math.RAY);
+}
+/**
+* Inverse of {@link rayToBps}, exact: a rate in basis points is a whole number
+* of the `10 ** 23` steps a ray is made of.
+*
+* @example
+* ```ts
+* bpsToRay(500) // 5% = 0.05 × 10²⁷
+* ```
+**/
+function bpsToRay(bps) {
+	return BigInt(bps) * require_onchain_constants_math.RAY / require_onchain_constants_math.PERCENTAGE_FACTOR;
+}
+/**
+* Raw 8-decimal USD values below this are compressor leftover dust (typically
+* 1-wei balances on empty accounts) and report as `0`.
+**/
+const USD_DUST_THRESHOLD = 1000n;
+/**
+* Converts a USD value in the oracle's 8-decimal fixed point to a float.
+*
+* Values whose magnitude is below {@link USD_DUST_THRESHOLD} report as `0`.
+* The threshold is weighed on the magnitude because the deltas the model
+* carries — a debt repaid, a balance sold — are negative, and dust is dust in
+* either direction.
+*
+* @example
+* ```ts
+* // usd: $1500.50 in 8-decimal fixed point
+* usdToNumber(150_050_000_000n) // 1500.5
+* usdToNumber(-150_050_000_000n) // -1500.5
+* ```
+**/
+function usdToNumber(usd) {
+	return (usd < 0n ? -usd : usd) < USD_DUST_THRESHOLD ? 0 : Number(usd) / Number(require_onchain_constants_math.PRICE_DECIMALS);
+}
+/**
+* Share of capital currently borrowed, in basis points. Returns `0` when there
+* is nothing to borrow from, and never exceeds 100%.
+*
+* @example
+* ```ts
+* // borrowed: 750, total: 1000
+* calcUtilizationRaw(750n, 1000n) // 750 / 1000 = 7500 bps = 75%
+* ```
+**/
+function calcUtilizationRaw(borrowed, total) {
+	if (total <= 0n || borrowed <= 0n) return 0;
+	const utilization = Number(borrowed * require_onchain_constants_math.PERCENTAGE_FACTOR / total);
+	return Math.min(utilization, FULL);
+}
+/**
+* Pool utilization: {@link PoolOpportunity.totalBorrowedWithInterest} as a
+* share of {@link PoolOpportunity.totalSupply}, in basis points.
+**/
+function calcUtilization(poolOpportunity) {
+	return calcUtilizationRaw(poolOpportunity.totalBorrowedWithInterest.value, poolOpportunity.totalSupply.value);
+}
+/**
+* Annual cost of debt for a credit manager, in basis points:
+* `baseInterestRate × (1 + feeInterest)` — the pool's base rate plus the
+* protocol's cut of the accrued interest.
+*
+* @param baseInterestRate - Pool base rate in ray.
+* @param feeInterest - Credit manager interest fee in basis points.
+*
+* @example
+* ```ts
+* // baseInterestRate: 5% in ray, feeInterest: 5000 bps = 50%
+* calcBorrowApy(50_000_000_000_000_000_000_000_000n, 5000) // 5% × 1.5 = 750 bps = 7.5%
+* ```
+**/
+function calcBorrowApy(baseInterestRate, feeInterest) {
+	return rayToBps(baseInterestRate * (require_onchain_constants_math.PERCENTAGE_FACTOR + BigInt(feeInterest)) / require_onchain_constants_math.PERCENTAGE_FACTOR);
+}
+/**
+* Annual quota cost of a collateral, in basis points:
+* `quotaRate × (1 + feeInterest)` — the quoted rate plus the protocol's cut of
+* the accrued quota interest, matching {@link calcBorrowApy}.
+*
+* @param quotaRate - Pool quota keeper rate in basis points, without the fee.
+* @param feeInterest - Credit manager interest fee in basis points.
+*
+* @example
+* ```ts
+* // quotaRate: 200 bps = 2%, feeInterest: 2500 bps = 25%
+* calcQuotaRate(200, 2500) // 2% × 1.25 = 250 bps = 2.5%
+* ```
+**/
+function calcQuotaRate(quotaRate, feeInterest) {
+	return Math.round(quotaRate * (FULL + feeInterest) / FULL);
+}
+/**
+* Extra quota, as a fraction of equity, that an aggressive position quotes
+* above the debt it actually owes. Matches {@link MAX_LEVERAGE_BUFFER_BPS}.
+**/
+const DEFAULT_QUOTA_BUFFER_BPS = 500;
+/**
+* Quoted amount per unit of equity at the given leverage and quota mode.
+* Dimensionless: `1` means the quota equals the user's equity.
+**/
+function calcQuotaMultiplier(leverage, lt, quotaMode = "safe") {
+	switch (quotaMode) {
+		case "min": return leverage - 1;
+		case "safe": return leverage * lt / FULL;
+		case "aggressive": return (1 + 500 / FULL) * (leverage - 1);
+	}
+}
+/**
+* Annual cost of credit on the user's equity, in basis points, at a given
+* leverage and quota mode: base interest on the borrowed part plus quota
+* interest on the quoted amount. Both rates already include the protocol's
+* interest fee.
+*
+* @param opportunity - Borrow APY, quota rate, and liquidation threshold.
+* @param leverage - Total-value leverage, same scale as {@link Leverage}.
+* @param mode - How much quota the position quotes, see {@link QuotaMode}.
+**/
+function calcEffectiveBorrowApy(opportunity, leverage, mode = "safe") {
+	const { borrowApy, quotaRate, liquidationThreshold } = opportunity;
+	return Math.round(borrowApy * (leverage - 1) + quotaRate * calcQuotaMultiplier(leverage, liquidationThreshold, mode));
+}
+/**
+* Net yield of a strategy on the user's equity, in basis points, at a given
+* leverage and quota mode:
+* `leverage × totalCollateralApy − effectiveBorrowApy`. Collateral yield is
+* on the whole position; borrow and quota interest are those of
+* {@link calcEffectiveBorrowApy}.
+*
+* @param opportunity - Borrow APY, quota rate, and liquidation threshold.
+* @param totalCollateralApy - Collateral yield the caller chose, typically
+* `totalApy` of {@link StrategyOpportunity.collateralApy} or
+* {@link StrategyOpportunity.collateralApyAvg7D}.
+* @param leverage - Total-value leverage, same scale as {@link Leverage}.
+* @param mode - How much quota the position quotes, see {@link QuotaMode}.
+**/
+function calcNetStrategyApy(opportunity, totalCollateralApy, leverage, mode = "safe") {
+	return Math.round(leverage * totalCollateralApy - calcEffectiveBorrowApy(opportunity, leverage, mode));
+}
+/**
+* 5% safety margin subtracted from 100% in {@link calcMaxLeverage}, so a
+* maxed position opens with HF slightly above 1.
+**/
+const MAX_LEVERAGE_BUFFER_BPS = 500;
+/**
+* Highest total-value leverage a liquidation threshold allows, floored.
+*
+* At HF = 1, debt is `liquidationThreshold × totalValue`, leaving
+* `1 − liquidationThreshold` of equity per unit of exposure; a maxed position
+* has to stay some way off that boundary. Given a `targetHF`, that distance is
+* solved for — `HF = liquidationThreshold × L / (L − 1)` inverts to
+* `L = targetHF / (targetHF − liquidationThreshold)`.
+*
+* Without one it falls back on a flat {@link MAX_LEVERAGE_BUFFER_BPS}, which
+* under-buffers as the threshold rises — at 95% it allows 19x, or HF ≈ 1.0028.
+* That branch is scaffolding, kept so this parameter moves no number before
+* the callers name a target, and goes away with the constant.
+*
+* @param targetHF - Health factor the maxed position should leave, in basis
+* points. Omitted keeps the legacy buffer.
+*
+* @example
+* ```ts
+* // liquidationThreshold: 9000 bps = 90%
+* calcMaxLeverage(9000)        // floor((1 − 0.05) / (1 − 0.9)) = 9x
+* calcMaxLeverage(9000, 10100) // floor(1.01 / (1.01 − 0.9))    = 9x
+* ```
+* @throws If `liquidationThreshold` is 100% or more, or reaches a named
+* `targetHF` — either way no leverage clears the bar.
+**/
+function calcMaxLeverage(liquidationThreshold, targetHF) {
+	if (liquidationThreshold >= FULL) throw new Error("cannot compute max leverage: liquidation threshold is 100% or more");
+	if (targetHF === void 0) return Math.max(Math.floor((FULL - 500) / (FULL - liquidationThreshold)), 1);
+	if (liquidationThreshold >= targetHF) throw new Error("cannot compute max leverage: liquidation threshold reaches the target health factor");
+	return Math.max(Math.floor(targetHF / (targetHF - liquidationThreshold)), 1);
+}
+/**
+* Converts a credit account's health factor from the 18-decimal fixed point the
+* contracts store to basis points.
+*
+* Accounts with no debt store `MAX_UINT256` on-chain; for those this
+* returns `0`.
+*
+* @example
+* ```ts
+* // healthFactor: 1.25 in 18-decimal fixed point
+* healthFactorBps(1_250_000_000_000_000_000n) // 12500 bps = 1.25
+* ```
+**/
+function healthFactorBps(healthFactor) {
+	if (healthFactor === 115792089237316195423570985008687907853269984665640564039457584007913129639935n) return 0;
+	return Number(healthFactor * require_onchain_constants_math.PERCENTAGE_FACTOR / require_onchain_constants_math.WAD);
+}
+/**
+* Total-value leverage of an open position:
+* `totalValue / (totalValue − totalDebt)`. `1` when unleveraged, `0` when
+* underwater.
+*
+* @param totalValue - Total value of the position.
+* @param totalDebt - Debt principal plus accrued interest and fees, same token.
+*
+* @example
+* ```ts
+* // totalValue: 100k, totalDebt: 80k → equity: 100k − 80k = 20k
+* calcPositionLeverage(100_000n, 80_000n) // 100k / 20k = 5x
+* ```
+**/
+function calcPositionLeverage(totalValue, totalDebt) {
+	const equity = totalValue - totalDebt;
+	if (totalValue <= 0n || equity <= 0n) return 0;
+	if (totalDebt <= 0n) return 1;
+	return Number(totalValue) / Number(equity);
+}
+/**
+* {@link PERCENTAGE_FACTOR} less a 0.1% safety buffer.
+*
+* Partial liquidation amounts are computed off prices that can drift between
+* quoting and execution, so both the seized and the repaid amount are pulled
+* this far away from the boundary the contracts would revert on.
+**/
+const PARTIAL_LIQUIDATION_BUFFER_BPS = 9990n;
+/**
+* Minimum collateral a partial liquidation must seize for a given repayment,
+* derived from the liquidation discount and buffered by
+* {@link PARTIAL_LIQUIDATION_BUFFER_BPS}.
+*
+* @param tokenAmount - Repaid amount converted from underlying into the seized
+* token by the oracle.
+* @param liquidationDiscount - Discount in effect for this account, in basis
+* points (the expired variant once the credit manager has expired).
+**/
+function minSeizedAmount(tokenAmount, liquidationDiscount) {
+	return tokenAmount * PARTIAL_LIQUIDATION_BUFFER_BPS / BigInt(liquidationDiscount);
+}
+/**
+* Amount of underlying whose repayment brings the account's health factor close
+* to `optimalHF`, capped so the account keeps at least `minDebt` of debt.
+*
+* Ported from solidity:
+* https://github.com/Gearbox-protocol/router-v3/blob/56e2d515ec6d9bb1e324e71c3708e59710779b24/contracts/liquidation/AbstractLiquidator.sol#L292
+*
+* @returns The repaid amount, or `0n` when the account is already healthy
+* enough or carries less than the minimum debt.
+* @throws If the discounted target health factor does not exceed the seized
+* token's liquidation threshold, in which case no repayment improves the
+* account.
+**/
+function optimalRepaidAmount({ totalDebt, twvUnderlying, minDebt, optimalHF, discount, ltTokenOut }) {
+	const denominator = discount * optimalHF / require_onchain_constants_math.PERCENTAGE_FACTOR - ltTokenOut;
+	if (denominator <= 0n) throw new Error("cannot compute optimal repaid amount: invalid liquidation parameters (discount * hfOptimal <= ltTokenOut)");
+	const numerator = totalDebt * optimalHF - twvUnderlying * require_onchain_constants_math.PERCENTAGE_FACTOR;
+	if (numerator <= 0n) return 0n;
+	const repaidAmount = numerator / denominator * discount / require_onchain_constants_math.PERCENTAGE_FACTOR;
+	if (totalDebt < minDebt) return 0n;
+	const surplusDebt = totalDebt - minDebt;
+	if (repaidAmount > surplusDebt) return surplusDebt * PARTIAL_LIQUIDATION_BUFFER_BPS / require_onchain_constants_math.PERCENTAGE_FACTOR;
+	return repaidAmount;
+}
+/**
+* Health factor a partial liquidation should target, in basis points: just
+* above 1, by enough to cover up to 1% of borrow cost so the account does not
+* fall back under water immediately.
+*
+* @param borrowRate - Blended borrow rate of the account, in basis points.
+**/
+function optimalHFForPartialLiquidation(borrowRate) {
+	return require_onchain_constants_math.PERCENTAGE_FACTOR + (borrowRate < 100n ? borrowRate : 100n);
+}
+//#endregion
+exports.DEFAULT_QUOTA_BUFFER_BPS = DEFAULT_QUOTA_BUFFER_BPS;
+exports.MAX_LEVERAGE_BUFFER_BPS = MAX_LEVERAGE_BUFFER_BPS;
+exports.PARTIAL_LIQUIDATION_BUFFER_BPS = PARTIAL_LIQUIDATION_BUFFER_BPS;
+exports.bpsToRay = bpsToRay;
+exports.calcBorrowApy = calcBorrowApy;
+exports.calcEffectiveBorrowApy = calcEffectiveBorrowApy;
+exports.calcMaxLeverage = calcMaxLeverage;
+exports.calcNetStrategyApy = calcNetStrategyApy;
+exports.calcPositionLeverage = calcPositionLeverage;
+exports.calcQuotaRate = calcQuotaRate;
+exports.calcUtilization = calcUtilization;
+exports.calcUtilizationRaw = calcUtilizationRaw;
+exports.healthFactorBps = healthFactorBps;
+exports.minSeizedAmount = minSeizedAmount;
+exports.optimalHFForPartialLiquidation = optimalHFForPartialLiquidation;
+exports.optimalRepaidAmount = optimalRepaidAmount;
+exports.rayToBps = rayToBps;
+exports.usdToNumber = usdToNumber;

package/dist/cjs/onchain/market/oracle/PriceFeedAnswerMap.js

@@ -0,0 +1,18 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_onchain_utils_AddressMap = require("../../utils/AddressMap.js");
+require("../../utils/index.js");
+//#region src/onchain/market/oracle/PriceFeedAnswerMap.ts
+var PriceFeedAnswerMap = class extends require_onchain_utils_AddressMap.AddressMap {
+	price(token) {
+		const answer = this.get(token);
+		if (!answer) throw new Error(`no answer found for token ${token}`);
+		const { success, price } = answer;
+		if (!success) throw new Error(`answer (${price}) is not successful for token ${token}`);
+		return price;
+	}
+};
+//#endregion
+exports.default = PriceFeedAnswerMap;

package/dist/cjs/onchain/market/oracle/PriceOracleBaseContract.js

@@ -0,0 +1,359 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../../utils/AddressMap.js");
+const require_onchain_utils_AddressSet = require("../../utils/AddressSet.js");
+const require_onchain_constants_address_provider = require("../../constants/address-provider.js");
+const require_onchain_constants_addresses = require("../../constants/addresses.js");
+require("../../constants/math.js");
+const require_onchain_constants_versions = require("../../constants/versions.js");
+require("../../constants/index.js");
+const require_onchain_utils_formatter = require("../../utils/formatter.js");
+require("../../utils/index.js");
+const require_onchain_base_BaseContract = require("../../base/BaseContract.js");
+require("../../base/index.js");
+const require_onchain_market_math = require("../math.js");
+const require_abi_compressors_priceFeedCompressor = require("../../../abi/compressors/priceFeedCompressor.js");
+const require_onchain_market_pricefeeds_PriceFeedRef = require("../pricefeeds/PriceFeedRef.js");
+const require_onchain_market_pricefeeds_getRawPriceUpdates = require("../pricefeeds/getRawPriceUpdates.js");
+require("../pricefeeds/index.js");
+const require_onchain_market_oracle_PriceFeedAnswerMap = require("./PriceFeedAnswerMap.js");
+let viem = require("viem");
+let date_fns = require("date-fns");
+//#region src/onchain/market/oracle/PriceOracleBaseContract.ts
+const ZERO_PRICE_FEED = (0, viem.stringToHex)("PRICE_FEED::ZERO", { size: 32 });
+/**
+* Base implementation of the Gearbox price oracle.
+*
+* Manages dual main/reserve price feed mappings and price answers for
+* every collateral token in a market. Provides token-to-USD and
+* token-to-token conversion using the latest known prices.
+*
+* @typeParam abi - The concrete oracle contract's ABI type.
+**/
+var PriceOracleBaseContract = class extends require_onchain_base_BaseContract.BaseContract {
+	sdk;
+	/**
+	* {@inheritDoc IPriceOracleContract.mainPriceFeeds}
+	**/
+	mainPriceFeeds = new require_onchain_utils_AddressMap.AddressMap(void 0, "mainPriceFeeds");
+	/**
+	* {@inheritDoc IPriceOracleContract.reservePriceFeeds}
+	**/
+	reservePriceFeeds = new require_onchain_utils_AddressMap.AddressMap(void 0, "reservePriceFeeds");
+	/**
+	* {@inheritDoc IPriceOracleContract.mainPrices}
+	**/
+	mainPrices = new require_onchain_market_oracle_PriceFeedAnswerMap.default(void 0, "mainPrices");
+	/**
+	* {@inheritDoc IPriceOracleContract.reservePrices}
+	**/
+	reservePrices = new require_onchain_market_oracle_PriceFeedAnswerMap.default(void 0, "reservePrices");
+	#priceFeedTree = new require_onchain_utils_AddressMap.AddressMap(void 0, "priceFeedTree");
+	constructor(sdk, args, data) {
+		super(sdk, args);
+		this.sdk = sdk;
+		const { priceFeedMap, priceFeedTree } = data;
+		this.#loadState(priceFeedMap, priceFeedTree);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceFeedsForTokens}
+	**/
+	priceFeedsForTokens(tokens, opts) {
+		const main = opts?.main ?? true;
+		const reserve = opts?.reserve ?? true;
+		return tokens.flatMap((t) => [main ? this.mainPriceFeeds.get(t)?.priceFeed : void 0, reserve ? this.reservePriceFeeds.get(t)?.priceFeed : void 0]).filter((f) => !!f);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceUpdateTxsForAccount}
+	**/
+	async priceUpdateTxsForAccount(account, opts) {
+		return this.#priceUpdateTxsForTokens(getAccountTokens(account, opts?.extraTokens), opts);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceUpdatesForAccount}
+	**/
+	async priceUpdatesForAccount(account, opts) {
+		return require_onchain_market_pricefeeds_getRawPriceUpdates.getRawPriceUpdates(await this.priceUpdateTxsForAccount(account, opts));
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceUpdatesForTokens}
+	**/
+	async priceUpdatesForTokens(tokens, opts) {
+		return require_onchain_market_pricefeeds_getRawPriceUpdates.getRawPriceUpdates(await this.#priceUpdateTxsForTokens(tokens, opts));
+	}
+	async #priceUpdateTxsForTokens(tokens, opts) {
+		const priceFeeds = this.priceFeedsForTokens(tokens, opts);
+		const tStr = tokens.map((t) => this.labelAddress(t)).join(", ");
+		const remark = opts?.reserve === false ? " main" : "";
+		this.logger?.debug(`generating price feed updates for ${tStr} from ${priceFeeds.length}${remark} price feeds`);
+		return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.mainPrice}
+	**/
+	mainPrice(token) {
+		return this.mainPrices.price(token);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.reservePrice}
+	**/
+	reservePrice(token) {
+		return this.reservePrices.price(token);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.usesPriceFeed}
+	**/
+	usesPriceFeed(priceFeed) {
+		return this.#priceFeedTree.has(priceFeed);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.convert}
+	**/
+	convert(from, to, amount, reserve = false) {
+		if ((0, viem.isAddressEqual)(from, to)) return amount;
+		const fromToken = this.#priceableToken(from);
+		const toToken = this.#priceableToken(to);
+		const fromPrice = reserve ? this.reservePrice(fromToken) : this.mainPrice(fromToken);
+		const fromScale = 10n ** BigInt(this.tokensMeta.decimals(fromToken));
+		const toPrice = reserve ? this.reservePrice(toToken) : this.mainPrice(toToken);
+		const toScale = 10n ** BigInt(this.tokensMeta.decimals(toToken));
+		return amount * fromPrice * toScale / (toPrice * fromScale);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.convertToUSD}
+	**/
+	convertToUSD(from, amount, reserve = false) {
+		if (amount === 0n) return 0n;
+		const token = this.#priceableToken(from);
+		const price = reserve ? this.reservePrice(token) : this.mainPrice(token);
+		const scale = 10n ** BigInt(this.tokensMeta.decimals(token));
+		return amount * price / scale;
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.convertFromUSD}
+	**/
+	convertFromUSD(to, amount, reserve = false) {
+		if (amount === 0n) return 0n;
+		const token = this.#priceableToken(to);
+		const price = reserve ? this.reservePrice(token) : this.mainPrice(token);
+		return amount * 10n ** BigInt(this.tokensMeta.decimals(token)) / price;
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvert}
+	**/
+	safeConvert(from, to, amount) {
+		try {
+			return this.convert(from, to, amount);
+		} catch (e) {
+			this.logger?.debug(`cannot convert ${this.labelAddress(from)} to ${this.labelAddress(to)}: ${e}`);
+			return null;
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvertToUSD}
+	**/
+	safeConvertToUSD(token, amount) {
+		try {
+			return this.convertToUSD(token, amount);
+		} catch (e) {
+			this.logger?.debug(`cannot price ${this.labelAddress(token)}: ${e}`);
+			return null;
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeUsdValue}
+	**/
+	safeUsdValue(token, amount) {
+		const usd = this.safeConvertToUSD(token, amount);
+		return usd === null ? null : require_onchain_market_math.usdToNumber(usd);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.toAmount}
+	**/
+	toAmount = (token, value) => {
+		return {
+			value,
+			valueUsd: this.safeUsdValue(token, value)
+		};
+	};
+	/**
+	* {@inheritDoc IPriceOracleContract.toTokenAmount}
+	**/
+	toTokenAmount = (token, value) => {
+		if ((0, viem.isAddressEqual)(token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")) {
+			const { symbol, name, decimals } = this.sdk.chain.nativeCurrency;
+			return {
+				token: {
+					chainId: this.sdk.chainId,
+					address: require_onchain_constants_addresses.NATIVE_ADDRESS,
+					symbol,
+					name,
+					decimals
+				},
+				...this.toAmount(token, value)
+			};
+		}
+		return {
+			token: this.tokensMeta.mustGetToken(token),
+			...this.toAmount(token, value)
+		};
+	};
+	/**
+	* The native pseudo-address has no feed of its own; it is priced through
+	* WETH. All other tokens price as themselves.
+	**/
+	#priceableToken(token) {
+		return (0, viem.isAddressEqual)(token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") ? this.sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_WETH_TOKEN, 0) : token;
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceFeedData}
+	**/
+	priceFeedData(token) {
+		const ref = this.mainPriceFeeds.get(token);
+		if (!ref) throw new Error(`no main price feed for ${this.labelAddress(token)} in oracle ${this.labelAddress(this.address)}`);
+		return ref.priceFeed.describe();
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceFeedSummary}
+	**/
+	priceFeedSummary(underlying, collateral) {
+		const collateralUnit = 10n ** BigInt(this.tokensMeta.decimals(collateral));
+		const underlyingUnit = 10n ** BigInt(this.tokensMeta.decimals(underlying));
+		return {
+			underlyingPriceInUsd: require_onchain_market_math.usdToNumber(this.mainPrice(underlying)),
+			collateralPriceInUsd: require_onchain_market_math.usdToNumber(this.mainPrice(collateral)),
+			collateralPriceInUnderlying: Number(this.convert(collateral, underlying, collateralUnit)) / Number(underlyingUnit),
+			underlyingFeed: this.priceFeedData(underlying),
+			collateralFeed: this.priceFeedData(collateral)
+		};
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.priceFeeds}
+	**/
+	get priceFeeds() {
+		return this.#priceFeedTree.values().map((node) => this.sdk.priceFeeds.mustGet(node.baseParams.addr));
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.syncStateMulticall}
+	**/
+	syncStateMulticall() {
+		const args = [this.address];
+		const [address] = this.sdk.addressProvider.mustGetLatest(require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR, require_onchain_constants_versions.VERSION_RANGE_310);
+		return {
+			call: {
+				abi: require_abi_compressors_priceFeedCompressor.priceFeedCompressorAbi,
+				address,
+				functionName: "getPriceOracleState",
+				args
+			},
+			onResult: (resp) => {
+				const { priceFeedMap, priceFeedTree } = resp;
+				this.#loadState(priceFeedMap, priceFeedTree);
+			}
+		};
+	}
+	#loadState(entries, tree) {
+		this.#priceFeedTree.clear();
+		this.mainPriceFeeds.clear();
+		this.reservePriceFeeds.clear();
+		this.mainPrices.clear();
+		this.reservePrices.clear();
+		for (const node of tree) {
+			this.#priceFeedTree.upsert(node.baseParams.addr, node);
+			this.sdk.priceFeeds.upsert(node);
+		}
+		for (const entry of entries) {
+			const { token, priceFeed, reserve, stalenessPeriod } = entry;
+			const ref = new require_onchain_market_pricefeeds_PriceFeedRef.PriceFeedRef(this.sdk, priceFeed, stalenessPeriod);
+			const node = this.#priceFeedTree.get(priceFeed);
+			const price = node?.answer?.price;
+			const priceFeedType = node?.baseParams.contractType;
+			if (reserve) {
+				this.reservePriceFeeds.upsert(token, ref);
+				this.reservePrices.upsert(token, node?.answer);
+				if (!price && priceFeedType !== ZERO_PRICE_FEED) this.#noAnswerWarn(priceFeed, node);
+			} else {
+				this.mainPriceFeeds.upsert(token, ref);
+				this.mainPrices.upsert(token, node?.answer);
+				if (!price && priceFeedType !== ZERO_PRICE_FEED) this.#noAnswerWarn(priceFeed, node);
+			}
+			this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+		}
+		this.dirty = false;
+	}
+	#labelPriceFeed(address, usage, token) {
+		this.sdk.setAddressLabel(address, (oldLabel) => {
+			let pricefeedTag = `${this.tokensMeta.symbol(token)}.${usage}`;
+			if (oldLabel) {
+				const oldLabelParts = new Set(oldLabel.split(", "));
+				oldLabelParts.add(pricefeedTag);
+				pricefeedTag = Array.from(oldLabelParts).join(", ");
+			}
+			return pricefeedTag;
+		});
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.watchAddresses}
+	**/
+	get watchAddresses() {
+		return /* @__PURE__ */ new Set([this.address]);
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.stateHuman}
+	**/
+	stateHuman(raw = true) {
+		return {
+			...super.stateHuman(raw),
+			mainPriceFeeds: Object.fromEntries(this.mainPriceFeeds.entries().map(([token, v]) => [this.labelAddress(token), v.stateHuman(raw)])),
+			reservePriceFeeds: Object.fromEntries(this.reservePriceFeeds.entries().map(([token, v]) => [this.labelAddress(token), v.stateHuman(raw)])),
+			mainPrices: Object.fromEntries(this.mainPrices.entries().map(([token, answer]) => [this.labelAddress(token), formatAnswer(answer, raw)])),
+			reservePrices: Object.fromEntries(this.reservePrices.entries().map(([token, answer]) => [this.labelAddress(token), formatAnswer(answer, raw)]))
+		};
+	}
+	#noAnswerWarn(priceFeed, node) {
+		let label = this.labelAddress(priceFeed);
+		if (!node) {
+			this.logger?.warn(`no node found for price feed ${label}`);
+			return;
+		}
+		const { answer, baseParams, description } = node;
+		const { success, updatedAt } = answer;
+		const { addr } = baseParams;
+		label = description ? `${description} at ${addr}` : label;
+		let upd = "";
+		if (updatedAt) {
+			const u = /* @__PURE__ */ new Date(Number(updatedAt) * 1e3);
+			upd = `${(0, date_fns.format)(u, "PPppp")} (${(0, date_fns.formatDistanceToNow)(u)})`;
+		}
+		if (success) {
+			upd = upd || "never";
+			this.logger?.warn(`zero answer for price feed ${label}, updated ${upd}`);
+		} else {
+			upd = upd ? `, updated ${upd}` : "";
+			this.logger?.warn(`failed to get answer for price feed ${label}${upd}`);
+		}
+	}
+};
+/**
+* Tokens of an account that have to be priced: its underlying, every enabled
+* token it holds a non-dust balance of, and any extra tokens the caller adds.
+**/
+function getAccountTokens(account, extraTokens) {
+	const tokens = new require_onchain_utils_AddressSet.AddressSet([account.underlying, ...extraTokens ?? []]);
+	for (const t of account.tokens) {
+		const isEnabled = (t.mask & account.enabledTokensMask) !== 0n;
+		if (t.balance > 10n && isEnabled) tokens.add(t.token);
+	}
+	return tokens.asArray();
+}
+function formatAnswer({ price, success, updatedAt }, raw = true) {
+	if (!success) return "failed";
+	let priceS = require_onchain_utils_formatter.formatBN(price, 8);
+	let updated = updatedAt ? (0, date_fns.format)(/* @__PURE__ */ new Date(Number(updatedAt) * 1e3), "dd MMM yyyy HH:mm") : "";
+	if (raw) {
+		priceS = `${priceS} (${price.toString(10)})`;
+		updated = [updated, `(${updatedAt.toString(10)})`].filter(Boolean).join(" ");
+	}
+	return `${priceS} at ${updated}`;
+}
+//#endregion
+exports.PriceOracleBaseContract = PriceOracleBaseContract;