@defisaver/positions-sdk 2.1.144-dev → 2.1.145

package/esm/contracts.js

@@ -94,6 +94,7 @@ export const getYearnV3VaultContractViem = (client, address) => {
     });
 };
 export const MorphoBlueViewContractViem = createViemContractFromConfigFunc('MorphoBlueView');
+export const MorphoMidnightViewContractViem = createViemContractFromConfigFunc('MidnightView');
 export const AaveLoanInfoV2ContractViem = createViemContractFromConfigFunc('AaveLoanInfoV2');
 export const AaveV3ViewContractViem = createViemContractFromConfigFunc('AaveV3View');
 export const AaveIncentiveDataProviderV3ContractViem = createViemContractFromConfigFunc('AaveUiIncentiveDataProviderV3');

package/esm/fluid/index.js

@@ -1256,8 +1256,12 @@ export const _getAllUserEarnPositionsWithFTokens = (provider, network, user) =>
 export const getAllUserEarnPositionsWithFTokens = (provider, network, user) => __awaiter(void 0, void 0, void 0, function* () { return _getAllUserEarnPositionsWithFTokens(getViemProvider(provider, network), network, user); });
 export const _getUserPositions = (provider, network, user) => __awaiter(void 0, void 0, void 0, function* () {
     const view = FluidViewContractViem(provider, network);
-    const data = yield view.read.getUserPositions([user]);
-    const parsedMarketData = (yield Promise.all(data[1].map((vaultData) => __awaiter(void 0, void 0, void 0, function* () { return parseMarketData(provider, vaultData, network); }))));
+    const [data, merklCampaigns] = yield Promise.all([
+        view.read.getUserPositions([user]),
+        getFluidMerklCampaigns(network),
+    ]);
+    const parsedMarketData = (yield Promise.all(data[1].map((vaultData) => __awaiter(void 0, void 0, void 0, function* () { return parseMarketData(provider, vaultData, network); }))))
+        .map(marketData => (marketData ? attachFluidMerklIncentives(marketData, merklCampaigns) : marketData));
     const userData = data[0].map((position, i) => (parsedMarketData[i] && Object.assign({}, parseUserData(position, parsedMarketData[i]))));
     return parsedMarketData.map((market, i) => ({
         marketData: market,

package/esm/helpers/fluidHelpers/index.js

@@ -2,7 +2,7 @@ import Dec from 'decimal.js';
 import { assetAmountInEth } from '@defisaver/tokens';
 import { FluidVaultType, IncentiveSource, } from '../../types';
 import { calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos, } from '../../moneymarket';
-import { calculateInterestEarned, calculateNetApy, EligibilityMapping } from '../../staking';
+import { calculateInterestEarned, calculateNetApy, getIncentiveEligibility } from '../../staking';
 import { IncentiveSide, LeverageType } from '../../types/common';
 import { getEthAmountForDecimals } from '../../services/utils';
 export const getUniqueFluidMerklIncentives = (assetsData, side) => {
@@ -16,10 +16,11 @@ export const getUniqueFluidMerklIncentives = (assetsData, side) => {
         ])).values()];
 };
 const getMerklIncentiveInterest = (incentives, principal, usedAssets) => incentives.reduce((total, { apy, eligibilityId }) => {
-    const eligibilityCheck = eligibilityId ? EligibilityMapping[eligibilityId] : null;
-    const { isEligible, eligibleUSDAmount } = eligibilityCheck
-        ? eligibilityCheck(usedAssets, undefined)
-        : { isEligible: true, eligibleUSDAmount: principal };
+    const { isEligible, eligibleUSDAmount } = getIncentiveEligibility({
+        incentive: { eligibilityId },
+        usedAssets,
+        defaultEligibleUSDAmount: principal,
+    });
     const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : 0;
     return new Dec(total).add(incentiveInterest).toString();
 }, '0');

package/esm/helpers/index.d.ts

@@ -4,6 +4,7 @@ export * as sparkHelpers from './sparkHelpers';
 export * as curveUsdHelpers from './curveUsdHelpers';
 export * as makerHelpers from './makerHelpers';
 export * as morphoBlueHelpers from './morphoBlueHelpers';
+export * as morphoMidnightHelpers from './morphoMidnightHelpers';
 export * as llamaLendHelpers from './llamaLendHelpers';
 export * as liquityV2Helpers from './liquityV2Helpers';
 export * as fluidHelpers from './fluidHelpers';

package/esm/helpers/index.js

@@ -4,6 +4,7 @@ export * as sparkHelpers from './sparkHelpers';
 export * as curveUsdHelpers from './curveUsdHelpers';
 export * as makerHelpers from './makerHelpers';
 export * as morphoBlueHelpers from './morphoBlueHelpers';
+export * as morphoMidnightHelpers from './morphoMidnightHelpers';
 export * as llamaLendHelpers from './llamaLendHelpers';
 export * as liquityV2Helpers from './liquityV2Helpers';
 export * as fluidHelpers from './fluidHelpers';

package/esm/helpers/morphoMidnightHelpers/headroom.d.ts

@@ -0,0 +1,48 @@
+import Dec from 'decimal.js';
+/**
+ * Safety margin every Midnight position is held at. On Midnight the lltv is *both* the borrow cap and the
+ * liquidation threshold (`liquidationLimitUsd === borrowLimitUsd` in the aggregate), so a position borrowed
+ * to its full limit opens at a health ratio of exactly 1 — immediately liquidatable. This is what holds it
+ * off that line, and what absorbs swap price impact on a boost.
+ */
+export declare const MIDNIGHT_MIN_HEALTH_RATIO = 1.025;
+export interface MidnightBorrowHeadroomParams {
+    borrowLimitUsd: Dec.Value;
+    borrowedUsd: Dec.Value;
+    /** Principal a unit of borrow power is worth (loan-per-unit price, ≤ 1), off a book rate. */
+    principalPerUnit?: Dec.Value;
+    /** Depth the book can fill, in loan tokens, from the same quote. Omitted leaves the answer uncapped. */
+    availableAssets?: Dec.Value;
+    loanTokenPrice?: Dec.Value;
+    /** Loan token decimals. Omitted skips the quantisation, which only a caller ignoring `leftToBorrow` wants. */
+    loanTokenDecimals?: number;
+    isMatured?: boolean;
+    minHealthRatio?: Dec.Value;
+}
+export interface MidnightBorrowHeadroom {
+    /** Face-value headroom, before the order-book discount. What a *boost* solve scales itself. */
+    headroomUsd: string;
+    /** The borrowable amount in loan tokens — the Borrow action's Max, quantised exactly as it is typed in. */
+    leftToBorrow: string;
+    /** `leftToBorrow · price`. Derived FROM the token amount, never computed alongside it — see below. */
+    leftToBorrowUsd: string;
+    borrowPowerUsed: string;
+}
+/**
+ * The one answer to "how much more can this position borrow". Every surface that sizes a Midnight borrow
+ * derives from here — the max-borrow getter, the position overview's headroom rows, and the max-boost
+ * solve, which scales `headroomUsd` by its own leverage factors — so a max and the figure shown next to it
+ * cannot drift into two different formulas. They did: the overview used to price
+ * the whole headroom off the top-of-book offer (often dust) with no rate pad and no depth cap, while the
+ * max walked the book for its real size, which is what put the two 1–2% apart.
+ *
+ * Three corrections separate this from a plain `limit − debt`, and dropping any one overstates the answer:
+ * `minHealthRatio` reserves the margin, `principalPerUnit` turns face-value headroom into the principal a
+ * borrow actually receives (a correction that grows with the term, past 7% on a one-year market), and
+ * `availableAssets` caps it at what the book can currently fill.
+ *
+ * `leftToBorrowUsd` is deliberately `leftToBorrow · price` rather than the USD figure the token amount was
+ * derived from: the two differ by the round-down to token decimals, and a UI showing one next to an input
+ * holding the other would be reporting a difference the user cannot spend. Everything quantises once, here.
+ */
+export declare const getMorphoMidnightBorrowHeadroom: ({ borrowLimitUsd, borrowedUsd, principalPerUnit, availableAssets, loanTokenPrice, loanTokenDecimals, isMatured, minHealthRatio, }: MidnightBorrowHeadroomParams) => MidnightBorrowHeadroom;

package/esm/helpers/morphoMidnightHelpers/headroom.js

@@ -0,0 +1,45 @@
+import Dec from 'decimal.js';
+/**
+ * Safety margin every Midnight position is held at. On Midnight the lltv is *both* the borrow cap and the
+ * liquidation threshold (`liquidationLimitUsd === borrowLimitUsd` in the aggregate), so a position borrowed
+ * to its full limit opens at a health ratio of exactly 1 — immediately liquidatable. This is what holds it
+ * off that line, and what absorbs swap price impact on a boost.
+ */
+export const MIDNIGHT_MIN_HEALTH_RATIO = 1.025;
+/**
+ * The one answer to "how much more can this position borrow". Every surface that sizes a Midnight borrow
+ * derives from here — the max-borrow getter, the position overview's headroom rows, and the max-boost
+ * solve, which scales `headroomUsd` by its own leverage factors — so a max and the figure shown next to it
+ * cannot drift into two different formulas. They did: the overview used to price
+ * the whole headroom off the top-of-book offer (often dust) with no rate pad and no depth cap, while the
+ * max walked the book for its real size, which is what put the two 1–2% apart.
+ *
+ * Three corrections separate this from a plain `limit − debt`, and dropping any one overstates the answer:
+ * `minHealthRatio` reserves the margin, `principalPerUnit` turns face-value headroom into the principal a
+ * borrow actually receives (a correction that grows with the term, past 7% on a one-year market), and
+ * `availableAssets` caps it at what the book can currently fill.
+ *
+ * `leftToBorrowUsd` is deliberately `leftToBorrow · price` rather than the USD figure the token amount was
+ * derived from: the two differ by the round-down to token decimals, and a UI showing one next to an input
+ * holding the other would be reporting a difference the user cannot spend. Everything quantises once, here.
+ */
+export const getMorphoMidnightBorrowHeadroom = ({ borrowLimitUsd, borrowedUsd, principalPerUnit = 1, availableAssets, loanTokenPrice = 0, loanTokenDecimals, isMatured = false, minHealthRatio = MIDNIGHT_MIN_HEALTH_RATIO, }) => {
+    const usableLimitUsd = new Dec(borrowLimitUsd).div(minHealthRatio);
+    const headroomUsd = isMatured ? new Dec(0) : Dec.max(0, usableLimitUsd.sub(borrowedUsd));
+    const price = new Dec(loanTokenPrice);
+    // Capped in loan tokens rather than in USD: `availableAssets` is quoted in tokens, and converting it to
+    // USD only to divide the result back out again would re-round the one number that has to land exactly.
+    const payout = price.lte(0) ? new Dec(0) : headroomUsd.mul(principalPerUnit).div(price);
+    const capped = availableAssets === undefined ? payout : Dec.min(payout, availableAssets);
+    // Round down: rounding the last decimal up would eat into the margin we just reserved.
+    const leftToBorrow = loanTokenDecimals === undefined ? capped : capped.toDP(loanTokenDecimals, Dec.ROUND_DOWN);
+    return {
+        headroomUsd: headroomUsd.toString(),
+        leftToBorrow: leftToBorrow.toString(),
+        leftToBorrowUsd: leftToBorrow.mul(price).toString(),
+        // Measured against the margined limit rather than the raw one, so it reads 100% at max borrow instead
+        // of 97.56%, and can exceed 100% inside the reserved band. Deliberately left uncapped by book depth:
+        // how much a position has borrowed is a property of the position, not of what the book can fill today.
+        borrowPowerUsed: usableLimitUsd.lte(0) ? '0' : new Dec(borrowedUsd).div(usableLimitUsd).mul(100).toString(),
+    };
+};

package/esm/helpers/morphoMidnightHelpers/index.d.ts

@@ -0,0 +1,113 @@
+import Dec from 'decimal.js';
+import { MMUsedAssets, NetworkNumber } from '../../types/common';
+import { MorphoMidnightAggregatedPositionData, MorphoMidnightAssetsData, MorphoMidnightBookSide, MorphoMidnightMarketData, MorphoMidnightMarketInfo, MorphoMidnightParsedBook } from '../../types';
+export { buildMidnightParsedBook, midnightApyFromPrice, midnightBookBestFirst, midnightBoundPrice, midnightPriceFromApy, midnightTimeToMaturityDays, MIDNIGHT_DEFAULT_RATE_SLIPPAGE, } from './rate';
+export { getMorphoMidnightBorrowHeadroom, MIDNIGHT_MIN_HEALTH_RATIO, } from './headroom';
+export type { MidnightBorrowHeadroom, MidnightBorrowHeadroomParams } from './headroom';
+export { tenorBookKeyFor, tenorBookRateToApyPercent, tenorOfferFillToApiFill, tenorOfferToApiOffer, } from './tenor';
+/**
+ * Aggregate a Morpho Midnight position. Midnight markets are multi-collateral, so the borrow limit is
+ * the sum of each collateral's USD value times its own lltv (Aave-v4 style), rather than a single pair.
+ *
+ * Note on amounts: `borrowedUsd` is derived from the position's `debt`, which is the face value owed at
+ * maturity (principal + fixed interest). Health is therefore measured against the full maturity debt,
+ * matching how MidnightView computes `ratio`. Fixed-rate APY is not derived on-chain in MVP, so
+ * `netApy` reflects the `'0'` rates in `assetsData` (see the module getter).
+ */
+export declare const getMorphoMidnightAggregatedPositionData: ({ usedAssets, assetsData, marketInfo, }: {
+    usedAssets: MMUsedAssets;
+    assetsData: MorphoMidnightAssetsData;
+    marketInfo: MorphoMidnightMarketInfo;
+}) => MorphoMidnightAggregatedPositionData;
+export interface MorphoMidnightBorrowInfo {
+    borrowRate: string;
+    debtBase: string;
+    debtInterest: string;
+    debtTotal: string;
+}
+export interface MorphoMidnightBorrowQuote {
+    bestPrice: string;
+    worstPrice: string;
+    estBorrowRate: string;
+    maxRate: string;
+    newUnits: string;
+    maxUnits: string;
+    availableAssets: string;
+    availableUnits: string;
+    takeableOffers: any[];
+}
+export interface MorphoMidnightPaybackQuote {
+    bestPrice: string;
+    worstPrice: string;
+    estPaybackRate: string;
+    minRate: string;
+    newUnits: string;
+    minUnits: string;
+    availableAssets: string;
+    availableUnits: string;
+    takeableOffers: any[];
+}
+export interface MorphoMidnightPaybackUnitsQuote {
+    bestPrice: string;
+    worstPrice: string;
+    estPaybackRate: string;
+    minRate: string;
+    newAssets: string;
+    maxAssets: string;
+    availableAssets: string;
+    availableUnits: string;
+    takeableOffers: any[];
+}
+/**
+ * Coerce a slippage into what the quote endpoint accepts: 0.1–100 with at most one decimal place. The
+ * validation is lexical, so a computed value (`4.15066671050631467`) is rejected outright — without this
+ * the request 400s and the quote looks unavailable.
+ *
+ * Rounded **down**, since a wider slippage is a looser cap than the caller asked for.
+ */
+export declare const midnightSlippageParam: (slippagePercent: Dec.Value) => string;
+/**
+ * Current borrower rate + debt breakdown from the Midnight positions API. Reconstructing this from the raw
+ * `/transactions` fill history only sums `borrow` fills, so it overstates debt for any position with an
+ * early exit or partial liquidation (`exit_borrow_primary`, `partial_liquidation`, ... — the fill history
+ * has no exhaustive list of debt-reducing event types). `/positions` instead reports the already-netted
+ * `debt`, matching `MidnightView.getPositionInfo` exactly, plus `cost_basis` (outstanding principal,
+ * WAD-scaled raw base units) and `effective_rate_wad` (borrow APY, WAD-scaled) for the base/interest split.
+ * The caller swallows errors — a missing rate must never block position rendering.
+ */
+export declare const getMorphoMidnightUserBorrowInfo: (account: string, marketId: string, loanTokenSymbol: string) => Promise<MorphoMidnightBorrowInfo>;
+/**
+ * The inverse of the split above: where `getMorphoMidnightUserBorrowInfo` reads a position's principal and
+ * interest off the indexer, this carries that same split forward through a payback, from a debt of
+ * `borrowedBefore` down to one of `borrowedAfter`. Retiring units retires principal and interest pro rata,
+ * so both scale by the same fraction.
+ *
+ * Deriving the interest as `borrowedAfter − debtBase` instead reads it off two different sources —
+ * `borrowed` is the chain's debt, `debtBase` the indexer's principal — so the entire gap between them lands
+ * in the interest whenever they disagree, which they do until the indexer catches up with a fresh borrow or
+ * payback: behind a borrow it inflates the interest by the debt the indexer has not seen yet, behind a
+ * payback it goes negative on a position that still owes. Callers detect that window as
+ * `debtBase + debtInterest !== debt`.
+ *
+ * Pro rata is also what keeps the answer sane when a payback retires debt at a different rate than the one
+ * it was opened at. Mirroring a borrow instead — principal growing by the assets received, interest by the
+ * rest — hands back a negative interest as soon as the book sells units back cheaper than they were bought.
+ */
+export declare const scaleMorphoMidnightDebtSplit: ({ debtBase, debtInterest }: Pick<MorphoMidnightBorrowInfo, "debtBase" | "debtInterest">, borrowedBefore: Dec.Value, borrowedAfter: Dec.Value) => Pick<MorphoMidnightBorrowInfo, "debtBase" | "debtInterest">;
+/**
+ * One side of a market's resting order book, as rates rather than the API's WAD-scaled loan-per-unit
+ * prices. Annualizing each price against time-to-maturity gives the rate a taker filling that offer gets
+ * — verified against Morpho's fixed-market UI, where per-offer rates match to the cent.
+ *
+ * `bids` are the lend offers a borrower fills, so the best of them is the *lowest* rate; `asks` are the
+ * sell offers a repayer buys debt units from, where a lower price buys more units, so the best is the
+ * *highest* rate. Either way `offers` comes back best-first and `bestRate` is `offers[0].rate`.
+ *
+ * Returns `null` for an empty side: there is nothing to take, so a market listing should skip the market
+ * rather than advertise it at a 0% rate. Throws when the request fails — an error response is rarely
+ * JSON, so without the `res.ok` check it parses as an empty book and the market silently vanishes.
+ */
+export declare const getMorphoMidnightMarketBook: (market: MorphoMidnightMarketData, network: NetworkNumber, side?: MorphoMidnightBookSide) => Promise<MorphoMidnightParsedBook | null>;
+export declare const getMorphoMidnightBorrowQuote: (marketId: string, assetsRaw: string, slippagePercent: Dec.Value, maturity: number, maxBorrowRate?: Dec.Value, taker?: string, rateSlippagePercent?: Dec.Value) => Promise<MorphoMidnightBorrowQuote>;
+export declare const getMorphoMidnightPaybackQuote: (marketId: string, assetsRaw: string, slippagePercent: Dec.Value, maturity: number, minPaybackRate?: Dec.Value, taker?: string, rateSlippagePercent?: Dec.Value) => Promise<MorphoMidnightPaybackQuote>;
+export declare const getMorphoMidnightPaybackUnitsQuote: (marketId: string, unitsRaw: string, slippagePercent: Dec.Value, maturity: number, minPaybackRate?: Dec.Value, taker?: string, rateSlippagePercent?: Dec.Value) => Promise<MorphoMidnightPaybackUnitsQuote>;

package/esm/helpers/morphoMidnightHelpers/index.js

@@ -0,0 +1,271 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos, } from '../../moneymarket';
+import { calculateNetApy } from '../../staking';
+import { LeverageType, } from '../../types/common';
+import { WAD } from '../../constants';
+import { LONGER_TIMEOUT } from '../../services/utils';
+import { isTenorMidnightMarket } from '../../markets/morphoMidnight';
+import { buildMidnightParsedBook, midnightApyFromPrice, midnightBoundPrice, midnightTimeToMaturityDays, } from './rate';
+import { getTenorBorrowQuote, getTenorMarketBook, getTenorPaybackQuote, getTenorPaybackUnitsQuote, } from './tenor';
+export { buildMidnightParsedBook, midnightApyFromPrice, midnightBookBestFirst, midnightBoundPrice, midnightPriceFromApy, midnightTimeToMaturityDays, MIDNIGHT_DEFAULT_RATE_SLIPPAGE, } from './rate';
+export { getMorphoMidnightBorrowHeadroom, MIDNIGHT_MIN_HEALTH_RATIO, } from './headroom';
+export { tenorBookKeyFor, tenorBookRateToApyPercent, tenorOfferFillToApiFill, tenorOfferToApiOffer, } from './tenor';
+/**
+ * Aggregate a Morpho Midnight position. Midnight markets are multi-collateral, so the borrow limit is
+ * the sum of each collateral's USD value times its own lltv (Aave-v4 style), rather than a single pair.
+ *
+ * Note on amounts: `borrowedUsd` is derived from the position's `debt`, which is the face value owed at
+ * maturity (principal + fixed interest). Health is therefore measured against the full maturity debt,
+ * matching how MidnightView computes `ratio`. Fixed-rate APY is not derived on-chain in MVP, so
+ * `netApy` reflects the `'0'` rates in `assetsData` (see the module getter).
+ */
+export const getMorphoMidnightAggregatedPositionData = ({ usedAssets, assetsData, marketInfo, }) => {
+    var _a;
+    const payload = {};
+    payload.suppliedUsd = getAssetsTotal(usedAssets, ({ isSupplied }) => isSupplied, ({ suppliedUsd }) => suppliedUsd);
+    payload.suppliedCollateralUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ suppliedUsd }) => suppliedUsd);
+    payload.borrowedUsd = getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd);
+    // borrowLimit = Σ collateralUsd_i * lltv_i (per-collateral lltv carried on assetsData)
+    payload.borrowLimitUsd = getAssetsTotal(usedAssets, ({ isSupplied, collateral }) => isSupplied && collateral, ({ symbol, suppliedUsd }) => { var _a; return new Dec(suppliedUsd).mul(((_a = assetsData[symbol]) === null || _a === void 0 ? void 0 : _a.lltv) || 0); });
+    payload.liquidationLimitUsd = payload.borrowLimitUsd;
+    // Same subtraction every other money market uses, but it does NOT mean the same thing here. Elsewhere
+    // `borrowedUsd` is debt at present value, so the remainder is what a borrow would pay out. Midnight
+    // records debt at its face value at maturity, so this is face-value headroom: borrowing it would add
+    // more debt than the number says, by the market's discount. It also reserves no safety margin, and this
+    // aggregate is synchronous so it has no book rate to discount by.
+    //
+    // DO NOT SURFACE THIS AS "what you can borrow" — use `getMorphoMidnightBorrowHeadroom` instead, which
+    // applies both corrections (the margin, and the loan-per-unit price off a book rate) and caps on the
+    // depth the book can fill. The discount alone grows past 7% on a one-year market.
+    const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
+    payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
+    const loanTokenPrice = ((_a = assetsData[marketInfo.loanToken]) === null || _a === void 0 ? void 0 : _a.price) || '0';
+    payload.leftToBorrow = new Dec(loanTokenPrice).eq(0) ? '0' : new Dec(payload.leftToBorrowUsd).div(loanTokenPrice).toString();
+    const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({ usedAssets, assetsData: assetsData });
+    payload.netApy = netApy;
+    payload.incentiveUsd = incentiveUsd;
+    payload.totalInterestUsd = totalInterestUsd;
+    payload.ltv = new Dec(payload.suppliedCollateralUsd).eq(0) ? '0' : new Dec(payload.borrowedUsd).div(payload.suppliedCollateralUsd).toString();
+    payload.ratio = new Dec(payload.borrowedUsd).eq(0) ? '0' : new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString();
+    payload.healthRatio = new Dec(payload.borrowedUsd).eq(0) ? 'Infinity' : new Dec(payload.liquidationLimitUsd).div(payload.borrowedUsd).toDP(4).toString();
+    const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);
+    payload.leveragedType = leveragedType;
+    payload.liquidationPrice = '';
+    if (leveragedType !== '') {
+        payload.leveragedAsset = leveragedAsset;
+        let assetPrice = assetsData[leveragedAsset].price;
+        if (leveragedType === LeverageType.VolatilePair) {
+            const borrowedAsset = Object.values(usedAssets).find(({ borrowedUsd }) => +borrowedUsd > 0);
+            const borrowedAssetPrice = assetsData[borrowedAsset.symbol].price;
+            const leveragedAssetPrice = assetsData[leveragedAsset].price;
+            const isReverse = new Dec(leveragedAssetPrice).lt(borrowedAssetPrice);
+            if (isReverse) {
+                payload.leveragedType = LeverageType.VolatilePairReverse;
+                payload.currentVolatilePairRatio = new Dec(borrowedAssetPrice).div(leveragedAssetPrice).toDP(18).toString();
+                assetPrice = new Dec(borrowedAssetPrice).div(assetPrice).toString();
+            }
+            else {
+                assetPrice = new Dec(assetPrice).div(borrowedAssetPrice).toString();
+                payload.currentVolatilePairRatio = new Dec(leveragedAssetPrice).div(borrowedAssetPrice).toDP(18).toString();
+            }
+        }
+        payload.liquidationPrice = calcLeverageLiqPrice(payload.leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
+    }
+    payload.minCollRatio = new Dec(payload.borrowLimitUsd).eq(0) ? '0' : new Dec(payload.suppliedCollateralUsd).div(payload.borrowLimitUsd).mul(100).toString();
+    payload.collLiquidationRatio = new Dec(payload.liquidationLimitUsd).eq(0) ? '0' : new Dec(payload.suppliedCollateralUsd).div(payload.liquidationLimitUsd).mul(100).toString();
+    payload.exposure = getExposure(payload.borrowedUsd, payload.suppliedUsd);
+    return payload;
+};
+// ── Off-chain order-book rate helpers ──────────────────────────────────────────────────────────────
+// notion: https://app.notion.com/p/defisaver/Estimate-borrow-rate-and-slippage-before-execution-3a70be682adc80c783c8c11fdb761dd2
+// the borrow rate is not exposed on-chain (MidnightView only stores total debt at maturity in `units`).
+// derive the rate + interest from Morpho's public keyless Midnight API
+// Quote prices are WAD-scaled
+// loan-per-unit ratios (< 1 for a discounted fixed-term borrow); annualizing them yields the borrow APY.
+const MIDNIGHT_API_BASE = 'https://api.morpho.org/v0/midnight';
+// The book endpoint is markedly slower than the rest of the API — `LONGER_TIMEOUT` (5s) aborts it often
+// enough that markets drop out of the list for no reason.
+const MIDNIGHT_BOOK_TIMEOUT = 30000;
+// The quote endpoint's `slippage` query param is validated as a string: 0.1–100, at most one decimal
+// place (`0.50` is rejected even though `0.5` passes). See `midnightSlippageParam`.
+const MIDNIGHT_SLIPPAGE_MIN = 0.1;
+const MIDNIGHT_SLIPPAGE_MAX = 100;
+/**
+ * Coerce a slippage into what the quote endpoint accepts: 0.1–100 with at most one decimal place. The
+ * validation is lexical, so a computed value (`4.15066671050631467`) is rejected outright — without this
+ * the request 400s and the quote looks unavailable.
+ *
+ * Rounded **down**, since a wider slippage is a looser cap than the caller asked for.
+ */
+export const midnightSlippageParam = (slippagePercent) => Dec.min(Dec.max(new Dec(slippagePercent), MIDNIGHT_SLIPPAGE_MIN), MIDNIGHT_SLIPPAGE_MAX).toDP(1, Dec.ROUND_DOWN).toString();
+/**
+ * Current borrower rate + debt breakdown from the Midnight positions API. Reconstructing this from the raw
+ * `/transactions` fill history only sums `borrow` fills, so it overstates debt for any position with an
+ * early exit or partial liquidation (`exit_borrow_primary`, `partial_liquidation`, ... — the fill history
+ * has no exhaustive list of debt-reducing event types). `/positions` instead reports the already-netted
+ * `debt`, matching `MidnightView.getPositionInfo` exactly, plus `cost_basis` (outstanding principal,
+ * WAD-scaled raw base units) and `effective_rate_wad` (borrow APY, WAD-scaled) for the base/interest split.
+ * The caller swallows errors — a missing rate must never block position rendering.
+ */
+export const getMorphoMidnightUserBorrowInfo = (account, marketId, loanTokenSymbol) => __awaiter(void 0, void 0, void 0, function* () {
+    const res = yield fetch(`${MIDNIGHT_API_BASE}/users/${account}/positions`, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
+    const json = yield res.json();
+    const position = ((json === null || json === void 0 ? void 0 : json.data) || []).find((p) => { var _a; return p.type === 'borrow' && ((_a = p.market_id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === marketId.toLowerCase(); });
+    const debtTotal = assetAmountInEth((position === null || position === void 0 ? void 0 : position.debt) || '0', loanTokenSymbol);
+    const costBasisRaw = new Dec((position === null || position === void 0 ? void 0 : position.cost_basis) || 0).div(WAD); // WAD-scaled → raw base units
+    const debtBase = Dec.min(assetAmountInEth(costBasisRaw.toString(), loanTokenSymbol), debtTotal).toString();
+    const debtInterest = Dec.max(new Dec(debtTotal).sub(debtBase), 0).toString();
+    const borrowRate = new Dec((position === null || position === void 0 ? void 0 : position.effective_rate_wad) || 0).div(WAD).mul(100).toString();
+    return {
+        borrowRate, debtBase, debtInterest, debtTotal,
+    };
+});
+/**
+ * The inverse of the split above: where `getMorphoMidnightUserBorrowInfo` reads a position's principal and
+ * interest off the indexer, this carries that same split forward through a payback, from a debt of
+ * `borrowedBefore` down to one of `borrowedAfter`. Retiring units retires principal and interest pro rata,
+ * so both scale by the same fraction.
+ *
+ * Deriving the interest as `borrowedAfter − debtBase` instead reads it off two different sources —
+ * `borrowed` is the chain's debt, `debtBase` the indexer's principal — so the entire gap between them lands
+ * in the interest whenever they disagree, which they do until the indexer catches up with a fresh borrow or
+ * payback: behind a borrow it inflates the interest by the debt the indexer has not seen yet, behind a
+ * payback it goes negative on a position that still owes. Callers detect that window as
+ * `debtBase + debtInterest !== debt`.
+ *
+ * Pro rata is also what keeps the answer sane when a payback retires debt at a different rate than the one
+ * it was opened at. Mirroring a borrow instead — principal growing by the assets received, interest by the
+ * rest — hands back a negative interest as soon as the book sells units back cheaper than they were bought.
+ */
+export const scaleMorphoMidnightDebtSplit = ({ debtBase, debtInterest }, borrowedBefore, borrowedAfter) => {
+    const fractionRemaining = new Dec(borrowedBefore).lte(0)
+        ? new Dec(0)
+        : Dec.max(0, new Dec(borrowedAfter)).div(borrowedBefore);
+    return {
+        debtBase: new Dec(debtBase).mul(fractionRemaining).toString(),
+        debtInterest: new Dec(debtInterest).mul(fractionRemaining).toString(),
+    };
+};
+/**
+ * One side of a market's resting order book, as rates rather than the API's WAD-scaled loan-per-unit
+ * prices. Annualizing each price against time-to-maturity gives the rate a taker filling that offer gets
+ * — verified against Morpho's fixed-market UI, where per-offer rates match to the cent.
+ *
+ * `bids` are the lend offers a borrower fills, so the best of them is the *lowest* rate; `asks` are the
+ * sell offers a repayer buys debt units from, where a lower price buys more units, so the best is the
+ * *highest* rate. Either way `offers` comes back best-first and `bestRate` is `offers[0].rate`.
+ *
+ * Returns `null` for an empty side: there is nothing to take, so a market listing should skip the market
+ * rather than advertise it at a 0% rate. Throws when the request fails — an error response is rarely
+ * JSON, so without the `res.ok` check it parses as an empty book and the market silently vanishes.
+ */
+export const getMorphoMidnightMarketBook = (market_1, network_1, ...args_1) => __awaiter(void 0, [market_1, network_1, ...args_1], void 0, function* (market, network, side = 'bids') {
+    var _a;
+    if (isTenorMidnightMarket(market)) {
+        return getTenorMarketBook(market, network, side);
+    }
+    const loanSymbol = getAssetInfoByAddress(market.loanToken, network).symbol;
+    const res = yield fetch(`${MIDNIGHT_API_BASE}/books/${market.marketId}`, { signal: AbortSignal.timeout(MIDNIGHT_BOOK_TIMEOUT) });
+    if (!res.ok)
+        throw new Error(`Midnight book request failed for ${market.value} (${res.status})`);
+    const json = yield res.json();
+    const ttmDays = midnightTimeToMaturityDays(market.maturity);
+    const offers = (((_a = json === null || json === void 0 ? void 0 : json.data) === null || _a === void 0 ? void 0 : _a[side]) || []).map((offer) => ({
+        rate: midnightApyFromPrice(new Dec(offer.price).div(WAD), ttmDays),
+        liquidity: assetAmountInEth(offer.assets, loanSymbol),
+    }));
+    return buildMidnightParsedBook(offers, side);
+});
+// The API says why a quote failed — NOT_FOUND (market matured or not open yet), INSUFFICIENT_LIQUIDITY
+// (book can't fill the size), VALIDATION_ERROR (bad param, with the offending field in `details`).
+// Callers surface this to the user, so keep the reason rather than collapsing everything into one string.
+const midnightQuoteError = (error) => {
+    const detail = ((error === null || error === void 0 ? void 0 : error.details) || []).map(({ issue }) => issue).filter(Boolean).join('; ');
+    const reason = detail || (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.code);
+    return reason ? `Morpho Midnight quote unavailable: ${reason}` : 'Morpho Midnight quote unavailable';
+};
+// The raw quote both sides share: prices descaled from WAD, everything else forwarded verbatim.
+const fetchMorphoMidnightQuote = (marketId, side, size, slippagePercent) => __awaiter(void 0, void 0, void 0, function* () {
+    const [sizeParam, sizeValue] = 'assets' in size ? ['assets', size.assets] : ['units', size.units];
+    const url = `${MIDNIGHT_API_BASE}/books/${marketId}/${side}/quote?${sizeParam}=${sizeValue}&slippage=${midnightSlippageParam(slippagePercent)}`;
+    const res = yield fetch(url, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
+    const json = yield res.json();
+    const d = json === null || json === void 0 ? void 0 : json.data;
+    if (!(d === null || d === void 0 ? void 0 : d.average_best_price))
+        throw new Error(midnightQuoteError(json === null || json === void 0 ? void 0 : json.error));
+    return {
+        bestPrice: new Dec(d.average_best_price).div(WAD).toString(),
+        worstPrice: new Dec(d.average_worst_price || 0).div(WAD).toString(),
+        availableAssets: d.available_assets || '0',
+        availableUnits: d.available_units || '0',
+        takeableOffers: d.takeable_offers || [],
+    };
+});
+export const getMorphoMidnightBorrowQuote = (marketId, assetsRaw, slippagePercent, maturity, maxBorrowRate, taker, rateSlippagePercent) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isTenorMidnightMarket(marketId)) {
+        return getTenorBorrowQuote(marketId, assetsRaw, slippagePercent, maturity, maxBorrowRate, taker, rateSlippagePercent);
+    }
+    const quote = yield fetchMorphoMidnightQuote(marketId, 'bids', { assets: assetsRaw }, slippagePercent);
+    const { bestPrice } = quote;
+    const ttmDays = midnightTimeToMaturityDays(maturity);
+    const estBorrowRate = midnightApyFromPrice(bestPrice, ttmDays);
+    // Price the cap sits at, and the rate that price represents — one derivation, so `maxRate` and
+    // `maxUnits` can never disagree about what the user is protected at.
+    const capPrice = midnightBoundPrice(estBorrowRate, ttmDays, 'ceiling', maxBorrowRate, rateSlippagePercent);
+    const maxRate = midnightApyFromPrice(capPrice, ttmDays);
+    const newUnits = new Dec(bestPrice).lte(0) ? '0' : new Dec(assetsRaw).div(bestPrice).toFixed(0);
+    const maxUnits = new Dec(capPrice).lte(0) ? '0' : new Dec(assetsRaw).div(capPrice).toFixed(0);
+    return Object.assign(Object.assign({}, quote), { estBorrowRate,
+        maxRate,
+        newUnits,
+        maxUnits });
+});
+export const getMorphoMidnightPaybackQuote = (marketId, assetsRaw, slippagePercent, maturity, minPaybackRate, taker, rateSlippagePercent) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isTenorMidnightMarket(marketId)) {
+        return getTenorPaybackQuote(marketId, assetsRaw, slippagePercent, maturity, minPaybackRate, taker, rateSlippagePercent);
+    }
+    const quote = yield fetchMorphoMidnightQuote(marketId, 'asks', { assets: assetsRaw }, slippagePercent);
+    const { bestPrice } = quote;
+    const ttmDays = midnightTimeToMaturityDays(maturity);
+    const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
+    const capPrice = midnightBoundPrice(estPaybackRate, ttmDays, 'floor', minPaybackRate, rateSlippagePercent);
+    const minRate = midnightApyFromPrice(capPrice, ttmDays);
+    // Rounded down on both counts: `newUnits` must not overstate the debt the user sees retired, and a
+    // `minUnits` rounded up would be a stricter floor than asked for and revert a payback that was fine.
+    const newUnits = new Dec(bestPrice).lte(0) ? '0' : new Dec(assetsRaw).div(bestPrice).toFixed(0, Dec.ROUND_DOWN);
+    const minUnits = new Dec(capPrice).lte(0) ? '0' : new Dec(assetsRaw).div(capPrice).toFixed(0, Dec.ROUND_DOWN);
+    return Object.assign(Object.assign({}, quote), { estPaybackRate,
+        minRate,
+        newUnits,
+        minUnits });
+});
+export const getMorphoMidnightPaybackUnitsQuote = (marketId, unitsRaw, slippagePercent, maturity, minPaybackRate, taker, rateSlippagePercent) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isTenorMidnightMarket(marketId)) {
+        return getTenorPaybackUnitsQuote(marketId, unitsRaw, slippagePercent, maturity, minPaybackRate, taker, rateSlippagePercent);
+    }
+    const quote = yield fetchMorphoMidnightQuote(marketId, 'asks', { units: unitsRaw }, slippagePercent);
+    const { bestPrice } = quote;
+    const ttmDays = midnightTimeToMaturityDays(maturity);
+    const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
+    const capPrice = midnightBoundPrice(estPaybackRate, ttmDays, 'floor', minPaybackRate, rateSlippagePercent);
+    const minRate = midnightApyFromPrice(capPrice, ttmDays);
+    // Rounded UP on both counts — the mirror of the assets-target quote's ROUND_DOWN. Here the figures are
+    // what the taker SPENDS, so a value rounded down understates the cost by a base unit and would leave the
+    // buy short of the units it was asked for.
+    const newAssets = new Dec(unitsRaw).mul(bestPrice).toFixed(0, Dec.ROUND_UP);
+    const maxAssets = new Dec(unitsRaw).mul(capPrice).toFixed(0, Dec.ROUND_UP);
+    return Object.assign(Object.assign({}, quote), { estPaybackRate,
+        minRate,
+        newAssets,
+        maxAssets });
+});

package/esm/helpers/morphoMidnightHelpers/rate.d.ts

@@ -0,0 +1,15 @@
+import Dec from 'decimal.js';
+import { MorphoMidnightBookOffer, MorphoMidnightBookSide, MorphoMidnightParsedBook } from '../../types';
+export declare const midnightTimeToMaturityDays: (maturity: number, atSeconds?: number) => number;
+export declare const midnightApyFromPrice: (price: Dec.Value, ttmDays: Dec.Value) => string;
+/**
+ * Inverse of `midnightApyFromPrice`: the loan-per-unit price a borrow APY implies,
+ * price = (1 + rate)^(−ttmDays / 365).
+ */
+export declare const midnightPriceFromApy: (ratePercent: Dec.Value, ttmDays: Dec.Value) => string;
+export declare const MIDNIGHT_DEFAULT_RATE_SLIPPAGE = 0.1;
+/** Which side of the estimate a guard sits on: a ceiling for borrows, a floor for paybacks. */
+export type MidnightRateBoundKind = 'ceiling' | 'floor';
+export declare const midnightBoundPrice: (estRate: Dec.Value, ttmDays: Dec.Value, kind: MidnightRateBoundKind, boundRate?: Dec.Value, rateSlippagePercent?: Dec.Value) => string;
+export declare const midnightBookBestFirst: (side: MorphoMidnightBookSide) => 1 | -1;
+export declare const buildMidnightParsedBook: (offers: MorphoMidnightBookOffer[], side: MorphoMidnightBookSide) => MorphoMidnightParsedBook | null;

package/esm/helpers/morphoMidnightHelpers/rate.js

@@ -0,0 +1,50 @@
+import Dec from 'decimal.js';
+import { SECONDS_PER_DAY } from '../../constants';
+const nowInSeconds = () => Math.floor(Date.now() / 1000);
+// Days remaining until maturity, optionally measured at a past timestamp (for historical fills).
+export const midnightTimeToMaturityDays = (maturity, atSeconds = nowInSeconds()) => new Dec(maturity).sub(atSeconds).div(SECONDS_PER_DAY).toNumber();
+// Annualize a fixed-term discount price into an APY percent: (1 / price)^(365 / ttmDays) − 1.
+// `price` is loan-per-unit (assets received / units owed), so 1/price ≥ 1.
+export const midnightApyFromPrice = (price, ttmDays) => {
+    const p = new Dec(price);
+    const ttm = new Dec(ttmDays);
+    if (p.lte(0) || ttm.lte(0))
+        return '0';
+    return new Dec(1).div(p).pow(new Dec(365).div(ttm)).sub(1)
+        .mul(100)
+        .toString();
+};
+/**
+ * Inverse of `midnightApyFromPrice`: the loan-per-unit price a borrow APY implies,
+ * price = (1 + rate)^(−ttmDays / 365).
+ */
+export const midnightPriceFromApy = (ratePercent, ttmDays) => {
+    const rate = new Dec(ratePercent);
+    const ttm = new Dec(ttmDays);
+    if (rate.lte(0) || ttm.lte(0))
+        return '1';
+    return new Dec(1).div(new Dec(1).add(rate.div(100)).pow(ttm.div(365))).toString();
+};
+export const MIDNIGHT_DEFAULT_RATE_SLIPPAGE = 0.1;
+const MIDNIGHT_MIN_FLOOR_RATIO = 0.5;
+export const midnightBoundPrice = (estRate, ttmDays, kind, boundRate, rateSlippagePercent = MIDNIGHT_DEFAULT_RATE_SLIPPAGE) => {
+    if (boundRate !== undefined && new Dec(boundRate).gt(0))
+        return midnightPriceFromApy(boundRate, ttmDays);
+    const est = new Dec(estRate);
+    const slippage = new Dec(rateSlippagePercent);
+    const bound = kind === 'ceiling'
+        ? est.add(slippage)
+        : Dec.max(est.sub(slippage), est.mul(MIDNIGHT_MIN_FLOOR_RATIO));
+    return midnightPriceFromApy(bound, ttmDays);
+};
+export const midnightBookBestFirst = (side) => (side === 'asks' ? -1 : 1);
+export const buildMidnightParsedBook = (offers, side) => {
+    const bestFirst = [...offers].sort((a, b) => new Dec(a.rate).minus(b.rate).mul(midnightBookBestFirst(side)).toNumber());
+    if (bestFirst.length === 0)
+        return null;
+    return {
+        bestRate: bestFirst[0].rate,
+        totalLiquidity: bestFirst.reduce((sum, offer) => sum.add(offer.liquidity), new Dec(0)).toString(),
+        offers: bestFirst,
+    };
+};