@gearbox-protocol/sdk 14.12.0-next.66 → 14.12.0-next.68

package/dist/esm/sdk/market/MarketSuite.js

@@ -1,14 +1,21 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { isRWAToken, isSunsetPool } from "../chain/chains.js";
+import "../utils/index.js";
 import { SDKConstruct } from "../base/SDKConstruct.js";
 import "../base/index.js";
+import { rayToBps } from "./math.js";
 import { CreditSuite } from "./credit/CreditSuite.js";
 import "./credit/index.js";
 import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
+import { matchesOpportunityFilter } from "../../model/opportunities.js";
+import "../../model/index.js";
 import { createLossPolicy } from "./loss-policy/createLossPolicy.js";
 import "./loss-policy/index.js";
 import { createPriceOracle } from "./oracle/createPriceOracle.js";
 import "./oracle/index.js";
 import { PoolSuite } from "./pool/PoolSuite.js";
 import "./pool/index.js";
+import { isAddressEqual } from "viem";
 //#region src/sdk/market/MarketSuite.ts
 /**
 * Aggregates all SDK wrappers that make up one Gearbox market.
@@ -100,6 +107,158 @@ var MarketSuite = class extends SDKConstruct {
 		return this.pool.rwaFactory;
 	}
 	/**
+	* {@inheritDoc IPoolContract.unwrappedUnderlying}
+	*/
+	get unwrappedUnderlying() {
+		return this.pool.unwrappedUnderlying;
+	}
+	/**
+	* The market's underlying as the shared read model describes it.
+	*
+	* For an RWA market this is the token the underlying wraps rather than the
+	* wrapper itself, because only that token means anything to a reader. The
+	* wrapper converts one-for-one, so amounts denominated in it stay exact.
+	*/
+	get underlyingToken() {
+		return this.tokensMeta.mustGetToken(this.unwrappedUnderlying);
+	}
+	/**
+	* {@inheritDoc MarketConfiguratorContract.curator}
+	*/
+	get curator() {
+		return this.configurator.curator;
+	}
+	/**
+	* Every `(credit suite, collateral)` pair of this market that qualifies as a
+	* leveraged position.
+	*/
+	get strategies() {
+		return this.creditManagers.flatMap((suite) => suite.strategyCollaterals.map((collateral) => ({
+			suite,
+			collateral
+		})));
+	}
+	/**
+	* Tokens a position can actually be built on in this market, deduplicated
+	* across its credit suites.
+	*/
+	get collateralTokens() {
+		const seen = new AddressMap(void 0, "collateralTokens");
+		for (const { collateral } of this.strategies) seen.upsert(collateral, this.tokensMeta.mustGetToken(collateral));
+		return seen.values();
+	}
+	/**
+	* Whether at least one of {@link collateralTokens} is a real-world-asset
+	* token. Read from a hardcoded per-chain list rather than from the chain.
+	*/
+	get rwa() {
+		return this.strategies.some(({ collateral }) => isRWAToken(collateral, this.sdk.networkType));
+	}
+	/**
+	* Whether this market's pool is being wound down and should no longer be
+	* entered. Read from a hardcoded per-chain list.
+	*/
+	get sunset() {
+		return isSunsetPool(this.pool.pool.address, this.sdk.networkType);
+	}
+	/**
+	* Quota configuration of every token the market quotes: how much of it the
+	* market accepts in total, and what holding it costs.
+	*/
+	quotaAssets() {
+		const oracle = this.priceOracle;
+		const { underlying } = this;
+		return this.pool.pqk.quotas.entries().map(([token, quota]) => ({
+			token: this.tokensMeta.mustGetToken(token),
+			quotaRate: quota.rate,
+			limit: oracle.toAmount(underlying, quota.limit),
+			used: oracle.toAmount(underlying, quota.totalQuoted)
+		}));
+	}
+	/**
+	* Prices and feeds of a collateral token and the market's underlying.
+	*
+	* Pricing goes through the wrapper for an RWA market, since that is what the
+	* market's oracle knows.
+	*
+	* @param collateral - Collateral token to price.
+	*/
+	priceFeedSummary(collateral) {
+		return this.priceOracle.priceFeedSummary(this.underlying, collateral);
+	}
+	/**
+	* Every opportunity this market offers: its pool, plus one row per
+	* `(credit manager, target collateral)` pair.
+	*
+	* @param filter - Optional narrowing. A filter naming a kind skips building
+	* the other kind entirely; every built row is then checked in full by
+	* {@link matchesOpportunityFilter}, so there is one definition of what each
+	* criterion means.
+	*/
+	opportunities(filter) {
+		const rows = [];
+		if (filter?.kind !== "strategy") rows.push(this.poolOpportunity());
+		if (filter?.kind !== "pool") for (const { suite, collateral } of this.strategies) rows.push(suite.strategyOpportunity(collateral));
+		return rows.filter((row) => matchesOpportunityFilter(row, filter));
+	}
+	/**
+	* Passive lending into this market's pool, as the shared read model
+	* describes it.
+	*/
+	poolOpportunity() {
+		const { pool } = this.pool;
+		const oracle = this.priceOracle;
+		return {
+			kind: "pool",
+			chainId: this.chainId,
+			pool: pool.address,
+			name: `${this.underlyingToken.symbol} Pool`,
+			curator: this.curator,
+			underlyingToken: this.underlyingToken,
+			totalSupply: oracle.toAmount(pool.underlying, pool.totalAssets),
+			totalBorrow: oracle.toAmount(pool.underlying, pool.totalBorrowed),
+			utilization: pool.utilization,
+			supplyApy: { organicApy: rayToBps(pool.supplyRate) },
+			collateralTokens: this.collateralTokens,
+			paused: pool.isPaused,
+			rwa: this.rwa,
+			sunset: this.sunset
+		};
+	}
+	/**
+	* {@link poolOpportunity} plus the data only its detail screen needs.
+	*/
+	poolOpportunityDetail() {
+		return {
+			...this.poolOpportunity(),
+			rateCurve: this.pool.rateCurve,
+			quotaAssets: this.quotaAssets()
+		};
+	}
+	/**
+	* Resolves a strategy of this market by its two halves.
+	*
+	* @param creditManager - Credit manager the position is opened in.
+	* @param collateral - Target collateral of the position.
+	* @throws If this market has no such credit manager, or if that manager does
+	* not accept the collateral as a strategy.
+	*/
+	mustFindStrategy(creditManager, collateral) {
+		const strategy = this.strategies.find((s) => isAddressEqual(s.suite.creditManager.address, creditManager) && isAddressEqual(s.collateral, collateral));
+		if (!strategy) throw new Error(`${this.labelAddress(collateral)} is not a strategy collateral of credit manager ${this.labelAddress(creditManager)}`);
+		return strategy;
+	}
+	/**
+	* Detailed view of one leveraged position of this market.
+	*
+	* @param creditManager - Credit manager the position is opened in.
+	* @param collateral - Target collateral of the position.
+	* @throws If this market has no such strategy, see {@link mustFindStrategy}.
+	*/
+	strategyOpportunityDetail(creditManager, collateral) {
+		return this.mustFindStrategy(creditManager, collateral).suite.strategyOpportunityDetail(collateral);
+	}
+	/**
 	* Whether any child contract wrapper has observed events that require a
 	* market resync.
 	*/

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

@@ -1,7 +1,7 @@
-import { iPausableAbi } from "../../../abi/iPausable.js";
 import { iCreditFacadeMulticallV310Abi, iCreditFacadeV310Abi } from "../../../abi/310/generated.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
+import { iPausableAbi } from "../../../abi/iPausable.js";
 //#region src/sdk/market/credit/CreditFacadeV310BaseContract.ts
 const abi = [
 	...iCreditFacadeV310Abi,

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

@@ -1,11 +1,15 @@
 import { iCreditManagerV310Abi } from "../../../abi/310/generated.js";
 import { AddressMap } from "../../utils/AddressMap.js";
+import { PERCENTAGE_FACTOR } from "../../constants/math.js";
+import "../../constants/index.js";
 import { fmtBinaryMask, percentFmt } from "../../utils/formatter.js";
 import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
 import { createAdapter } from "../adapters/createAdapter.js";
 import "../adapters/index.js";
+import { maxLeverage } from "../math.js";
+import { isAddressEqual } from "viem";
 //#region src/sdk/market/credit/CreditManagerV310Contract.ts
 const abi = iCreditManagerV310Abi;
 var CreditManagerV310Contract = class extends BaseContract {
@@ -59,6 +63,28 @@ var CreditManagerV310Contract = class extends BaseContract {
 	get collateralTokens() {
 		return this.liquidationThresholds.keys();
 	}
+	/**
+	* {@inheritDoc ICreditManagerContract.leverageableCollaterals}
+	*/
+	get leverageableCollaterals() {
+		return this.collateralTokens.filter((token) => {
+			if (isAddressEqual(token, this.underlying)) return false;
+			const lt = this.liquidationThresholds.get(token);
+			return !!lt && lt > 0 && lt < Number(10000n);
+		});
+	}
+	/**
+	* {@inheritDoc ICreditManagerContract.maxLeverage}
+	*/
+	maxLeverage(collateral) {
+		return maxLeverage(this.liquidationThresholds.mustGet(collateral));
+	}
+	/**
+	* {@inheritDoc ICreditManagerContract.liquidationPremium}
+	*/
+	get liquidationPremium() {
+		return Number(PERCENTAGE_FACTOR) - this.liquidationDiscount;
+	}
 	processLog(log) {
 		switch (log.eventName) {
 			case "SetCreditConfigurator": this.dirty = true;

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

@@ -1,5 +1,10 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import { isSunsetStrategy } from "../../chain/chains.js";
+import "../../constants/math.js";
+import "../../constants/index.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import "../../base/index.js";
+import { additionalBorrowApyBps, borrowApyBps } from "../math.js";
 import createCreditConfigurator from "./createCreditConfigurator.js";
 import createCreditFacade from "./createCreditFacade.js";
 import createCreditManager from "./createCreditManager.js";
@@ -98,6 +103,93 @@ var CreditSuite = class extends SDKConstruct {
 		return this.creditFacade.expirable && this.creditFacade.expirationDate > 0 && this.creditFacade.expirationDate < this.sdk.timestamp;
 	}
 	/**
+	* Moment the facade expires, after which positions can no longer be opened
+	* and open ones become liquidatable, or `null` when it is not expirable.
+	*
+	* @remarks
+	* The facade stores `0` for a non-expirable suite, which as a timestamp
+	* would read as 1970 rather than as "never".
+	*/
+	get expirationDate() {
+		const { expirationDate } = this.creditFacade;
+		return expirationDate > 0 ? expirationDate : null;
+	}
+	/**
+	* Whether this suite can be used right now. A paused pool blocks borrowing,
+	* so the suite is unusable even when its own facade is live.
+	*/
+	get isPaused() {
+		return this.creditFacade.isPaused || this.market.pool.isPaused;
+	}
+	/**
+	* Collateral tokens a leveraged position can be built around in this suite:
+	* the ones the credit manager can lever up, narrowed to those the market
+	* still accepts quota for.
+	*/
+	get strategyCollaterals() {
+		const { pqk } = this.market.pool;
+		return this.creditManager.leverageableCollaterals.filter((token) => pqk.hasActiveQuota(token));
+	}
+	/**
+	* Largest debt a single new position can take on right now: the tightest of
+	* this manager's remaining debt limit, the pool's free liquidity and the
+	* facade's per-account maximum.
+	*/
+	get maxBorrowAmount() {
+		const { pool } = this.market.pool;
+		const debtParams = pool.creditManagerDebtParams.get(this.creditManager.address);
+		return BigIntMath.min(debtParams?.available ?? 115792089237316195423570985008687907853269984665640564039457584007913129639935n, pool.availableLiquidity, this.creditFacade.maxDebt);
+	}
+	/**
+	* Describes a leveraged position built on one collateral token as the shared
+	* read model does.
+	*
+	* @param collateral - Target collateral of the position.
+	* @throws If the credit manager does not value the collateral.
+	*/
+	strategyOpportunity(collateral) {
+		const { market, creditManager: cm } = this;
+		const { pool } = market.pool;
+		const oracle = market.priceOracle;
+		const liquidationThreshold = cm.liquidationThresholds.mustGet(collateral);
+		const maxLeverage = cm.maxLeverage(collateral);
+		const borrowed = pool.creditManagerDebtParams.get(cm.address)?.borrowed ?? 0n;
+		return {
+			kind: "strategy",
+			chainId: this.chainId,
+			creditManager: cm.address,
+			targetCollateral: this.tokensMeta.mustGetToken(collateral),
+			name: `${this.tokensMeta.symbol(collateral)} / ${market.underlyingToken.symbol}`,
+			curator: market.curator,
+			underlyingToken: market.underlyingToken,
+			totalBorrow: oracle.toAmount(pool.underlying, borrowed),
+			collateralTokens: market.collateralTokens,
+			paused: this.isPaused,
+			rwa: market.rwa,
+			sunset: isSunsetStrategy(cm.address, collateral, this.sdk.networkType),
+			liquidationThreshold,
+			liquidationPremium: cm.liquidationPremium,
+			liquidationFee: cm.feeLiquidation,
+			expirationDate: this.expirationDate,
+			borrowApy: borrowApyBps(pool.baseInterestRate, cm.feeInterest),
+			additionalBorrowApy: additionalBorrowApyBps(market.pool.pqk.quotaRate(collateral), maxLeverage),
+			maxBorrowAmount: oracle.toAmount(pool.underlying, this.maxBorrowAmount),
+			maxLeverage
+		};
+	}
+	/**
+	* {@link strategyOpportunity} plus the data only its detail screen needs.
+	*
+	* @param collateral - Target collateral of the position.
+	*/
+	strategyOpportunityDetail(collateral) {
+		return {
+			...this.strategyOpportunity(collateral),
+			rateCurve: this.market.pool.rateCurve,
+			priceFeeds: this.market.priceFeedSummary(collateral)
+		};
+	}
+	/**
 	* Whether the facade, manager, or configurator has observed logs that require
 	* a credit-suite resync.
 	*/

package/dist/esm/sdk/market/math.js

@@ -0,0 +1,98 @@
+import { PERCENTAGE_FACTOR, PRICE_DECIMALS, RAY } from "../constants/math.js";
+//#region src/sdk/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(PERCENTAGE_FACTOR);
+/**
+* Converts a ray-scaled rate (`10 ** 27` = 100%) to basis points, truncating
+* towards zero.
+*
+* @example
+* ```ts
+* rayToBps(50_000_000_000_000_000_000_000_000n) // 500, i.e. 5%
+* ```
+**/
+function rayToBps(ray) {
+	return Number(ray * PERCENTAGE_FACTOR / RAY);
+}
+/**
+* Converts a USD value in the oracle's 8-decimal fixed point to a float.
+*
+* @example
+* ```ts
+* usdToNumber(150_050_000_000n) // 1500.5
+* ```
+**/
+function usdToNumber(usd) {
+	return Number(usd) / Number(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
+* utilizationBps(750n, 1000n) // 7500, i.e. 75%
+* ```
+**/
+function utilizationBps(borrowed, total) {
+	if (total <= 0n || borrowed <= 0n) return 0;
+	const utilization = Number(borrowed * PERCENTAGE_FACTOR / total);
+	return Math.min(utilization, FULL);
+}
+/**
+* Annual cost of debt for a credit manager, in basis points: 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
+* // 5% base rate, 50% interest fee
+* borrowApyBps(50_000_000_000_000_000_000_000_000n, 5000) // 750, i.e. 7.5%
+* ```
+**/
+function borrowApyBps(baseInterestRate, feeInterest) {
+	return rayToBps(baseInterestRate * (PERCENTAGE_FACTOR + BigInt(feeInterest)) / PERCENTAGE_FACTOR);
+}
+/**
+* Highest leverage a liquidation threshold allows: `1 / (1 - lt)`.
+*
+* A threshold of 100% or more would allow unbounded leverage; such tokens are
+* not strategies and are filtered out before this is called, so the guard here
+* only exists to keep the function total.
+*
+* @example
+* ```ts
+* maxLeverage(9000) // 10
+* maxLeverage(8000) // 5
+* ```
+**/
+function maxLeverage(liquidationThreshold) {
+	const equity = FULL - liquidationThreshold;
+	return equity > 0 ? FULL / equity : Number.POSITIVE_INFINITY;
+}
+/**
+* Annual quota cost scaled to the debt a maximally leveraged position carries,
+* in basis points. Every unit of own capital carries `maxLeverage - 1` units of
+* debt, and the quota is paid on the whole quoted position.
+*
+* @example
+* ```ts
+* // 2.5% quota rate at 5x leverage
+* additionalBorrowApyBps(250, 5) // 1000, i.e. 10%
+* ```
+**/
+function additionalBorrowApyBps(quotaRate, leverage) {
+	if (!Number.isFinite(leverage)) return 0;
+	return Math.round(quotaRate * Math.max(leverage - 1, 0));
+}
+//#endregion
+export { additionalBorrowApyBps, borrowApyBps, maxLeverage, rayToBps, usdToNumber, utilizationBps };

package/dist/esm/sdk/market/oracle/PriceOracleBaseContract.js

@@ -6,6 +6,7 @@ import { formatBN } from "../../utils/formatter.js";
 import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
+import { usdToNumber } from "../math.js";
 import { PriceFeedRef } from "../pricefeeds/PriceFeedRef.js";
 import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
 import "../pricefeeds/index.js";
@@ -103,6 +104,57 @@ var PriceOracleBaseContract = class extends BaseContract {
 		return amount * 10n ** BigInt(this.tokensMeta.decimals(to)) / price;
 	}
 	/**
+	* {@inheritDoc IPriceOracleContract.safeUsdValue}
+	**/
+	safeUsdValue(token, amount) {
+		try {
+			return usdToNumber(this.convertToUSD(token, amount));
+		} catch (e) {
+			this.logger?.debug(`cannot price ${this.labelAddress(token)}: ${e}`);
+			return null;
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.toAmount}
+	**/
+	toAmount = (token, value) => {
+		return {
+			value,
+			valueUsd: this.safeUsdValue(token, value)
+		};
+	};
+	/**
+	* {@inheritDoc IPriceOracleContract.toTokenAmount}
+	**/
+	toTokenAmount = (token, value) => {
+		return {
+			token: this.tokensMeta.mustGetToken(token),
+			...this.toAmount(token, value)
+		};
+	};
+	/**
+	* {@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: usdToNumber(this.mainPrice(underlying)),
+			collateralPriceInUsd: 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() {

package/dist/esm/sdk/market/pool/LinearInterestRateModelContract.js

@@ -3,6 +3,7 @@ import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
 import { iLinearInterestRateModelV310Abi } from "../../../abi/310/iLinearInterestRateModelV310.js";
+import { borrowRateAtUtilization, rateCurveUtilizations, supplyRateAtUtilization } from "./math.js";
 import { decodeAbiParameters } from "viem";
 //#region src/sdk/market/pool/LinearInterestRateModelContract.ts
 const abi = iLinearInterestRateModelV310Abi;
@@ -58,6 +59,35 @@ var LinearInterestRateModelContract = class extends BaseContract {
 		this.Rslope3 = Rslope3;
 		this.isBorrowingMoreU2Forbidden = isBorrowingMoreU2Forbidden;
 	}
+	/**
+	* The model's own parameters, gathered for the rate math.
+	*/
+	get params() {
+		return {
+			U1: this.U1,
+			U2: this.U2,
+			Rbase: this.Rbase,
+			Rslope1: this.Rslope1,
+			Rslope2: this.Rslope2,
+			Rslope3: this.Rslope3,
+			isBorrowingMoreU2Forbidden: this.isBorrowingMoreU2Forbidden
+		};
+	}
+	/**
+	* The model evaluated into chart-ready points, so that no consumer has to
+	* reimplement it.
+	*/
+	rateCurve() {
+		const { params } = this;
+		return {
+			points: rateCurveUtilizations(params).map((utilization) => ({
+				utilization,
+				supplyApy: supplyRateAtUtilization(utilization, params),
+				borrowApy: borrowRateAtUtilization(utilization, params)
+			})),
+			borrowingLimitUtilization: params.isBorrowingMoreU2Forbidden ? params.U2 : null
+		};
+	}
 	stateHuman(raw) {
 		return {
 			...super.stateHuman(raw),

package/dist/esm/sdk/market/pool/PoolQuotaKeeperV310Contract.js

@@ -20,6 +20,32 @@ var PoolQuotaKeeperV310Contract = class extends BaseContract {
 			return [q.token, q];
 		}), "quotas");
 	}
+	/**
+	* Whether the market still accepts quota for a token: a token whose quota is
+	* inactive or whose limit is exhausted can no longer back a new position.
+	*
+	* @param token - Token address.
+	*/
+	hasActiveQuota(token) {
+		const quota = this.quotas.get(token);
+		return !!quota?.isActive && quota.limit > 0n;
+	}
+	/**
+	* Every token the market still accepts quota for, see
+	* {@link hasActiveQuota}.
+	*/
+	get activeQuotaTokens() {
+		return this.quotas.keys().filter((token) => this.hasActiveQuota(token));
+	}
+	/**
+	* Annual quota rate paid on a quoted token, in basis points, or `0` when the
+	* market does not quote it.
+	*
+	* @param token - Quoted token address.
+	*/
+	quotaRate(token) {
+		return this.quotas.get(token)?.rate ?? 0;
+	}
 	stateHuman(raw = true) {
 		return {
 			...super.stateHuman(raw),

package/dist/esm/sdk/market/pool/PoolSuite.js

@@ -99,6 +99,34 @@ var PoolSuite = class extends SDKConstruct {
 		return this.pool.underlying;
 	}
 	/**
+	* {@inheritDoc IPoolContract.unwrappedUnderlying}
+	*/
+	get unwrappedUnderlying() {
+		return this.pool.unwrappedUnderlying;
+	}
+	/**
+	* {@inheritDoc IPoolContract.utilization}
+	*/
+	get utilization() {
+		return this.pool.utilization;
+	}
+	/**
+	* Whether the pool is paused, which blocks borrowing across every connected
+	* credit suite.
+	*/
+	get isPaused() {
+		return this.pool.isPaused;
+	}
+	/**
+	* Interest rate curve of the pool's rate model.
+	*
+	* @throws If the market uses an interest-rate model that is not linear, and
+	* therefore has no curve the SDK can evaluate.
+	*/
+	get rateCurve() {
+		return this.linearModel.rateCurve();
+	}
+	/**
 	* RWA factory associated with the pool's underlying, undefined for non-RWA markets.
 	*/
 	get rwaFactory() {

package/dist/esm/sdk/market/pool/PoolV310Contract.js

@@ -1,10 +1,13 @@
-import { iPausableAbi } from "../../../abi/iPausable.js";
 import { iPoolV310Abi } from "../../../abi/310/generated.js";
 import { AddressMap } from "../../utils/AddressMap.js";
+import { RAY } from "../../constants/math.js";
+import "../../constants/index.js";
 import { formatBN, formatBNvalue, percentFmt } from "../../utils/formatter.js";
 import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
+import { iPausableAbi } from "../../../abi/iPausable.js";
+import { utilizationBps } from "../math.js";
 //#region src/sdk/market/pool/PoolV310Contract.ts
 const abi = [...iPoolV310Abi, ...iPausableAbi];
 var PoolV310Contract = class extends BaseContract {
@@ -31,6 +34,30 @@ var PoolV310Contract = class extends BaseContract {
 		const meta = this.#sdk.tokensMeta.mustGet(this.underlying);
 		if (this.#sdk.tokensMeta.isRWAUnderlying(meta)) return this.#sdk.mustGetContract(meta.rwaFactory);
 	}
+	/**
+	* {@inheritDoc IPoolContract.borrowed}
+	*/
+	get borrowed() {
+		return this.expectedLiquidity > this.availableLiquidity ? this.expectedLiquidity - this.availableLiquidity : 0n;
+	}
+	/**
+	* {@inheritDoc IPoolContract.totalAssets}
+	*/
+	get totalAssets() {
+		return this.totalSupply * this.dieselRate / RAY;
+	}
+	/**
+	* {@inheritDoc IPoolContract.utilization}
+	*/
+	get utilization() {
+		return utilizationBps(this.borrowed, this.expectedLiquidity);
+	}
+	/**
+	* {@inheritDoc IPoolContract.unwrappedUnderlying}
+	*/
+	get unwrappedUnderlying() {
+		return this.tokensMeta.unwrapRWA(this.underlying);
+	}
 	stateHuman(raw = true) {
 		return {
 			...super.stateHuman(raw),