@defisaver/positions-sdk 2.1.127-midnight-dev → 2.1.127-midnight-2-dev

package/esm/config/contracts.d.ts

@@ -99340,3 +99340,25 @@ export declare const AaveV4View: {
         };
     };
 };
+export declare const UniswapTokenDistributor: {
+    readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "index";
+            readonly type: "uint256";
+        }];
+        readonly name: "isClaimed";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    readonly networks: {
+        readonly "1": {
+            readonly address: "0x090D4613473dEE047c3f2706764f49E0821D256e";
+        };
+    };
+};

package/esm/config/contracts.js

@@ -1358,3 +1358,11 @@ export const AaveV4View = {
         }
     }
 };
+export const UniswapTokenDistributor = {
+    "abi": [{ "inputs": [{ "internalType": "uint256", "name": "index", "type": "uint256" }], "name": "isClaimed", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }],
+    "networks": {
+        "1": {
+            "address": "0x090D4613473dEE047c3f2706764f49E0821D256e",
+        }
+    }
+};

package/esm/contracts.d.ts

@@ -619752,3 +619752,38 @@ export declare const AaveV4ViewContractViem: (client: Client, network: NetworkNu
         readonly type: "function";
     }];
 };
+export declare const UniswapTokenDistributorViem: (client: Client, network: NetworkNumber, block?: Blockish) => {
+    read: {
+        isClaimed: (args: readonly [bigint], options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<readonly [{
+            readonly inputs: readonly [{
+                readonly internalType: "uint256";
+                readonly name: "index";
+                readonly type: "uint256";
+            }];
+            readonly name: "isClaimed";
+            readonly outputs: readonly [{
+                readonly internalType: "bool";
+                readonly name: "";
+                readonly type: "bool";
+            }];
+            readonly stateMutability: "view";
+            readonly type: "function";
+        }], "isClaimed", readonly [bigint]>, "address" | "args" | "abi" | "functionName">> | undefined) => Promise<boolean>;
+    };
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "index";
+            readonly type: "uint256";
+        }];
+        readonly name: "isClaimed";
+        readonly outputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "";
+            readonly type: "bool";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+};

package/esm/contracts.js

@@ -142,3 +142,4 @@ export const YearnViewContractViem = createViemContractFromConfigFunc('YearnView
 export const MakerDsrContractViem = createViemContractFromConfigFunc('MakerDsr');
 export const SkySavingsContractView = createViemContractFromConfigFunc('SkySavings');
 export const AaveV4ViewContractViem = createViemContractFromConfigFunc('AaveV4View');
+export const UniswapTokenDistributorViem = createViemContractFromConfigFunc('UniswapTokenDistributor');

package/esm/curveUsd/index.js

@@ -24,7 +24,7 @@ const getAndFormatBands = (provider, network, selectedMarket, _minBand, _maxBand
     // getBandsData uses a lot of gas to get all of the bands at once, so we use pagination and fetch 200 bands at a time
     let i = minBand;
     while (i < maxBand) {
-        i += 200;
+        i += 20;
         if (i > maxBand) {
             pivots.push(maxBand);
         }

package/esm/helpers/morphoBlueHelpers/index.js

@@ -348,6 +348,7 @@ export const getRewardsForMarket = (marketId_1, ...args_1) => __awaiter(void 0,
             query: REWARDS_QUERY,
             variables: { marketId, chainId: network },
         }),
+        signal: AbortSignal.timeout(LONGER_TIMEOUT),
     });
     const data = yield response.json();
     const marketData = (_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.marketById;

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

@@ -1,3 +1,4 @@
+import Dec from 'decimal.js';
 import { MMUsedAssets } from '../../types/common';
 import { MorphoMidnightAggregatedPositionData, MorphoMidnightAssetsData, MorphoMidnightMarketInfo } from '../../types';
 /**
@@ -14,3 +15,64 @@ export declare const getMorphoMidnightAggregatedPositionData: ({ usedAssets, ass
     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 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).
+ *
+ * This is what turns an absolute rate ceiling into an on-chain `maxUnits` cap (units = assets / price),
+ * and equally the principal a unit of borrow power is worth — Midnight debt is recorded at its maturity
+ * face value, so borrowing the full limit as principal would overshoot it by the interest.
+ */
+export declare const midnightPriceFromApy: (ratePercent: Dec.Value, ttmDays: Dec.Value) => string;
+/**
+ * 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 transactions API. On-chain we can only read the
+ * total debt at maturity (`units`); the base-vs-interest split and the effective borrow rate require the
+ * fill history. Per fill the rate is (units / seller_assets)^(365 / ttmAtFill) − 1, weighted by base amount.
+ * The caller swallows errors — a missing rate must never block position rendering.
+ */
+export declare const getMorphoMidnightUserBorrowInfo: (account: string, marketId: string, maturity: number, loanTokenSymbol: string) => Promise<MorphoMidnightBorrowInfo>;
+/**
+ * Quote a prospective borrow against the Midnight order book: the estimated rate, the debt units it adds,
+ * and the `maxUnits` cap sent on-chain to protect the user if better offers get filled first. `assetsRaw`
+ * (and the returned `newUnits`/`maxUnits`) are raw loan-token base units — callers convert to/from human
+ * amounts. Throws if the book can't fill the amount (caller handles).
+ *
+ * Two ways to set the cap:
+ *  - `maxBorrowRate` — an absolute APY ceiling, honoured **exactly**: the cap price is derived locally via
+ *    `midnightPriceFromApy`. Prefer this when a user pins a max rate.
+ *  - otherwise `slippagePercent`, the API's own knob. Note it is a **price**-level slippage, not APY points:
+ *    near maturity the annualisation factor (365 / ttmDays) multiplies it heavily, so on a 22-day market a
+ *    slippage of 0.5 permitted an APY ~9pp above the estimate, not 0.5pp. It also saturates at the book's
+ *    cheapest bid. `maxRate` therefore reports what the cap actually permits, derived from the cap price.
+ *
+ * A `maxBorrowRate` below `estBorrowRate` yields `maxUnits < newUnits` — the borrow would revert on-chain.
+ * Compare the two before submitting and tell the user their ceiling is under the market rate.
+ */
+export declare const getMorphoMidnightBorrowQuote: (marketId: string, assetsRaw: string, slippagePercent: Dec.Value, maturity: number, maxBorrowRate?: Dec.Value) => Promise<MorphoMidnightBorrowQuote>;

package/esm/helpers/morphoMidnightHelpers/index.js

@@ -1,7 +1,19 @@
+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 } from '@defisaver/tokens';
 import { calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos, } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
 import { LeverageType, } from '../../types/common';
+import { SECONDS_PER_DAY, WAD } from '../../constants';
+import { LONGER_TIMEOUT } from '../../services/utils';
 /**
  * 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.
@@ -59,3 +71,140 @@ export const getMorphoMidnightAggregatedPositionData = ({ usedAssets, assetsData
     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';
+const nowInSeconds = () => Math.floor(Date.now() / 1000);
+// 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;
+// 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).
+ *
+ * This is what turns an absolute rate ceiling into an on-chain `maxUnits` cap (units = assets / price),
+ * and equally the principal a unit of borrow power is worth — Midnight debt is recorded at its maturity
+ * face value, so borrowing the full limit as principal would overshoot it by the interest.
+ */
+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();
+};
+/**
+ * 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 transactions API. On-chain we can only read the
+ * total debt at maturity (`units`); the base-vs-interest split and the effective borrow rate require the
+ * fill history. Per fill the rate is (units / seller_assets)^(365 / ttmAtFill) − 1, weighted by base amount.
+ * The caller swallows errors — a missing rate must never block position rendering.
+ */
+export const getMorphoMidnightUserBorrowInfo = (account, marketId, maturity, loanTokenSymbol) => __awaiter(void 0, void 0, void 0, function* () {
+    const res = yield fetch(`${MIDNIGHT_API_BASE}/users/${account}/transactions`, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
+    const json = yield res.json();
+    const borrows = ((json === null || json === void 0 ? void 0 : json.data) || []).filter((t) => { var _a; return t.event_type === 'borrow' && ((_a = t.market_id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === marketId.toLowerCase(); });
+    let sumSeller = new Dec(0); // Σ seller_assets (base), raw
+    let sumUnits = new Dec(0); // Σ units (debt at maturity), raw
+    let weightedApy = new Dec(0); // Σ seller_assets × APYᵢ
+    borrows.forEach((t) => {
+        var _a, _b;
+        const sellerAssets = new Dec(((_a = t.data) === null || _a === void 0 ? void 0 : _a.seller_assets) || 0);
+        const units = new Dec(((_b = t.data) === null || _b === void 0 ? void 0 : _b.units) || 0);
+        if (sellerAssets.lte(0) || units.lte(0))
+            return;
+        const ttmDays = midnightTimeToMaturityDays(maturity, t.created_at);
+        const apy = midnightApyFromPrice(sellerAssets.div(units), ttmDays); // price = seller_assets / units
+        sumSeller = sumSeller.add(sellerAssets);
+        sumUnits = sumUnits.add(units);
+        weightedApy = weightedApy.add(sellerAssets.mul(apy));
+    });
+    const borrowRate = sumSeller.lte(0) ? '0' : weightedApy.div(sumSeller).toString();
+    const debtBase = assetAmountInEth(sumSeller.toFixed(0), loanTokenSymbol);
+    const debtTotal = assetAmountInEth(sumUnits.toFixed(0), loanTokenSymbol);
+    const debtInterest = Dec.max(new Dec(debtTotal).sub(debtBase), 0).toString();
+    return {
+        borrowRate, debtBase, debtInterest, debtTotal,
+    };
+});
+// 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';
+};
+/**
+ * Quote a prospective borrow against the Midnight order book: the estimated rate, the debt units it adds,
+ * and the `maxUnits` cap sent on-chain to protect the user if better offers get filled first. `assetsRaw`
+ * (and the returned `newUnits`/`maxUnits`) are raw loan-token base units — callers convert to/from human
+ * amounts. Throws if the book can't fill the amount (caller handles).
+ *
+ * Two ways to set the cap:
+ *  - `maxBorrowRate` — an absolute APY ceiling, honoured **exactly**: the cap price is derived locally via
+ *    `midnightPriceFromApy`. Prefer this when a user pins a max rate.
+ *  - otherwise `slippagePercent`, the API's own knob. Note it is a **price**-level slippage, not APY points:
+ *    near maturity the annualisation factor (365 / ttmDays) multiplies it heavily, so on a 22-day market a
+ *    slippage of 0.5 permitted an APY ~9pp above the estimate, not 0.5pp. It also saturates at the book's
+ *    cheapest bid. `maxRate` therefore reports what the cap actually permits, derived from the cap price.
+ *
+ * A `maxBorrowRate` below `estBorrowRate` yields `maxUnits < newUnits` — the borrow would revert on-chain.
+ * Compare the two before submitting and tell the user their ceiling is under the market rate.
+ */
+export const getMorphoMidnightBorrowQuote = (marketId, assetsRaw, slippagePercent, maturity, maxBorrowRate) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${MIDNIGHT_API_BASE}/books/${marketId}/bids/quote?assets=${assetsRaw}&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));
+    const bestPrice = new Dec(d.average_best_price).div(WAD).toString();
+    const worstPrice = new Dec(d.average_worst_price || 0).div(WAD).toString();
+    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 = maxBorrowRate !== undefined && new Dec(maxBorrowRate).gt(0)
+        ? midnightPriceFromApy(maxBorrowRate, ttmDays)
+        : worstPrice;
+    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 {
+        bestPrice,
+        worstPrice,
+        estBorrowRate,
+        maxRate,
+        newUnits,
+        maxUnits,
+        availableAssets: d.available_assets || '0',
+        availableUnits: d.available_units || '0',
+        takeableOffers: d.takeable_offers || [],
+    };
+});

package/esm/llamaLend/index.js

@@ -25,7 +25,7 @@ const getAndFormatBands = (provider, network, selectedMarket, _minBand, _maxBand
     // getBandsData uses a lot of gas to get all of the bands at once, so we use pagination and fetch 200 bands at a time
     let i = minBand;
     while (i < maxBand) {
-        i += 200;
+        i += 20;
         if (i > maxBand) {
             pivots.push(maxBand);
         }

package/esm/markets/aaveV4/index.d.ts

@@ -22,6 +22,7 @@ export declare const AAVE_V4_LIDO_SPOKE: (networkId: NetworkNumber) => AaveV4Spo
 export declare const AAVE_V4_LOMBARD_BTC_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
 export declare const AAVE_V4_MAIN_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
 export declare const AAVE_V4_USDG_PENDLE_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
+export declare const AAVE_V4_USDG_MAPLE_SPOKE: (networkId: NetworkNumber) => AaveV4SpokeInfo;
 export declare const AaveV4Spokes: (networkId: NetworkNumber) => {
     readonly aave_v4_bluechip_spoke: AaveV4SpokeInfo;
     readonly aave_v4_ethena_correlated_spoke: AaveV4SpokeInfo;
@@ -34,6 +35,7 @@ export declare const AaveV4Spokes: (networkId: NetworkNumber) => {
     readonly aave_v4_lombard_btc_spoke: AaveV4SpokeInfo;
     readonly aave_v4_main_spoke: AaveV4SpokeInfo;
     readonly aave_v4_usdg_pendle_spoke: AaveV4SpokeInfo;
+    readonly aave_v4_usdg_maple_spoke: AaveV4SpokeInfo;
 };
 export declare const getAaveV4SpokeTypeInfo: (type: AaveV4SpokesType, network?: NetworkNumber) => AaveV4SpokeInfo;
 export declare const findAaveV4SpokeByAddress: (networkId: NetworkNumber, address: string) => AaveV4SpokeInfo | undefined;

package/esm/markets/aaveV4/index.js

@@ -164,6 +164,17 @@ export const AAVE_V4_USDG_PENDLE_SPOKE = (networkId) => ({
         AAVE_V4_CORE_HUB(NetworkNumber.Eth).address,
     ],
 });
+export const AAVE_V4_USDG_MAPLE_SPOKE = (networkId) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'USDG Maple',
+    value: AaveV4SpokesType.AaveV4USDGMapleSpoke,
+    url: 'usdg-maple',
+    address: '0x774b9655413c34809c1f1b16b654465A89EBE989',
+    hubs: [
+        AAVE_V4_PAXOS_HUB(NetworkNumber.Eth).address,
+        AAVE_V4_CORE_HUB(NetworkNumber.Eth).address,
+    ],
+});
 export const AaveV4Spokes = (networkId) => ({
     [AaveV4SpokesType.AaveV4BluechipSpoke]: AAVE_V4_BLUECHIP_SPOKE(networkId),
     [AaveV4SpokesType.AaveV4EthenaCorrelatedSpoke]: AAVE_V4_ETHENA_CORRELATED_SPOKE(networkId),
@@ -176,6 +187,7 @@ export const AaveV4Spokes = (networkId) => ({
     [AaveV4SpokesType.AaveV4LombardBtcSpoke]: AAVE_V4_LOMBARD_BTC_SPOKE(networkId),
     [AaveV4SpokesType.AaveV4MainSpoke]: AAVE_V4_MAIN_SPOKE(networkId),
     [AaveV4SpokesType.AaveV4USDGPendleSpoke]: AAVE_V4_USDG_PENDLE_SPOKE(networkId),
+    [AaveV4SpokesType.AaveV4USDGMapleSpoke]: AAVE_V4_USDG_MAPLE_SPOKE(networkId),
 });
 export const getAaveV4SpokeTypeInfo = (type, network) => (Object.assign({}, AaveV4Spokes(network !== null && network !== void 0 ? network : NetworkNumber.Eth))[type]);
 export const findAaveV4SpokeByAddress = (networkId, address) => Object.values(AaveV4Spokes(networkId)).find(spoke => spoke.address.toLowerCase() === address.toLowerCase());

package/esm/morphoBlue/index.d.ts

@@ -1,14 +1,16 @@
 import { Client } from 'viem';
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
-import { MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBluePositionData } from '../types';
+import { MorphoBlueEarnData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBlueMarketRewards, MorphoBluePositionData } from '../types';
+export declare const addMorphoBlueRewardsToMarketInfo: (marketInfo: MorphoBlueMarketInfo, rewards: MorphoBlueMarketRewards) => MorphoBlueMarketInfo;
 export declare function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;
+export declare function _getMorphoBluePortfolioMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;
 export declare function getMorphoBlueMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;
+export declare function getMorphoBluePortfolioMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;
+export declare const getMorphoBluePositionDataWithMarketInfo: (data: MorphoBluePositionData, marketInfo: MorphoBlueMarketInfo) => MorphoBluePositionData;
+export declare const getMorphoEarnDataWithMarketInfo: (data: MorphoBlueEarnData, marketInfo: MorphoBlueMarketInfo) => MorphoBlueEarnData;
+export declare function getMorphoBlueMarketRewards(network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketRewards>;
 export declare const _getMorphoBlueAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoBlueMarketData) => Promise<PositionBalances>;
 export declare const getMorphoBlueAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoBlueMarketData) => Promise<PositionBalances>;
 export declare function _getMorphoBlueAccountData(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBluePositionData>;
 export declare function getMorphoBlueAccountData(provider: EthereumProvider, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBluePositionData>;
-export declare function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<{
-    apy: string;
-    amount: string;
-    amountUsd: string;
-}>;
+export declare function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBlueEarnData>;

package/esm/morphoBlue/index.js

@@ -18,7 +18,20 @@ import { getBorrowRate, getMorphoBlueAggregatedPositionData, getRewardsForMarket
 import { getChainlinkAssetAddress } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
-export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
+const getMorphoRewardIncentives = (apy) => [{
+        token: 'MORPHO',
+        apy,
+        incentiveKind: IncentiveKind.Reward,
+        description: 'Eligible for protocol-level MORPHO incentives.',
+    }];
+export const addMorphoBlueRewardsToMarketInfo = (marketInfo, rewards) => (Object.assign(Object.assign({}, marketInfo), { assetsData: Object.assign(Object.assign({}, marketInfo.assetsData), { [marketInfo.loanToken]: Object.assign(Object.assign({}, marketInfo.assetsData[marketInfo.loanToken]), { supplyIncentives: [
+                ...marketInfo.assetsData[marketInfo.loanToken].supplyIncentives.filter(({ token }) => token !== 'MORPHO'),
+                ...getMorphoRewardIncentives(rewards.supplyApy),
+            ], borrowIncentives: [
+                ...marketInfo.assetsData[marketInfo.loanToken].borrowIncentives.filter(({ token }) => token !== 'MORPHO'),
+                ...getMorphoRewardIncentives(rewards.borrowApy),
+            ] }) }) }));
+function getMorphoBlueMarketDataInternal(provider, network, selectedMarket) {
     return __awaiter(this, void 0, void 0, function* () {
         const { loanToken, collateralToken, oracle, irm, lltv, oracleType, } = selectedMarket;
         const lltvInWei = new Dec(lltv).mul(WAD).toString();
@@ -50,16 +63,6 @@ export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
             marketInfo = _marketInfo;
             loanTokenPrice = loanTokenPriceRound[1].toString();
         }
-        let morphoSupplyApy = '0';
-        let morphoBorrowApy = '0';
-        try {
-            const { supplyApy: _morphoSupplyApy, borrowApy: _morphoBorrowApy } = yield getRewardsForMarket(selectedMarket.marketId, network);
-            morphoSupplyApy = _morphoSupplyApy;
-            morphoBorrowApy = _morphoBorrowApy;
-        }
-        catch (e) {
-            console.error(e);
-        }
         const supplyRate = getSupplyRate(marketInfo.totalSupplyAssets.toString(), marketInfo.totalBorrowAssets.toString(), marketInfo.borrowRate.toString(), marketInfo.fee.toString());
         const compoundedBorrowRate = getBorrowRate(marketInfo.borrowRate.toString(), marketInfo.totalBorrowShares.toString());
         const utillization = new Dec(marketInfo.totalBorrowAssets.toString()).div(marketInfo.totalSupplyAssets.toString()).mul(100).toString();
@@ -78,18 +81,8 @@ export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
             totalBorrow: new Dec(marketInfo.totalBorrowAssets.toString()).div(scale).toString(),
             canBeSupplied: true,
             canBeBorrowed: true,
-            supplyIncentives: [{
-                    token: 'MORPHO',
-                    apy: morphoSupplyApy,
-                    incentiveKind: IncentiveKind.Reward,
-                    description: 'Eligible for protocol-level MORPHO incentives.',
-                }],
-            borrowIncentives: [{
-                    token: 'MORPHO',
-                    apy: morphoBorrowApy,
-                    incentiveKind: IncentiveKind.Reward,
-                    description: 'Eligible for protocol-level MORPHO incentives.',
-                }],
+            supplyIncentives: [],
+            borrowIncentives: [],
         };
         assetsData[wethToEth(collateralTokenInfo.symbol)] = {
             symbol: wethToEth(collateralTokenInfo.symbol),
@@ -124,11 +117,54 @@ export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
         };
     });
 }
+export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const marketInfo = yield getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
+        try {
+            const rewards = yield getRewardsForMarket(selectedMarket.marketId, network);
+            return addMorphoBlueRewardsToMarketInfo(marketInfo, rewards);
+        }
+        catch (error) {
+            console.error(error);
+            return addMorphoBlueRewardsToMarketInfo(marketInfo, { supplyApy: '0', borrowApy: '0' });
+        }
+    });
+}
+export function _getMorphoBluePortfolioMarketData(provider, network, selectedMarket) {
+    return getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
+}
 export function getMorphoBlueMarketData(provider, network, selectedMarket) {
     return __awaiter(this, void 0, void 0, function* () {
         return _getMorphoBlueMarketData(getViemProvider(provider, network), network, selectedMarket);
     });
 }
+export function getMorphoBluePortfolioMarketData(provider, network, selectedMarket) {
+    return _getMorphoBluePortfolioMarketData(getViemProvider(provider, network), network, selectedMarket);
+}
+export const getMorphoBluePositionDataWithMarketInfo = (data, marketInfo) => (Object.assign(Object.assign({}, data), getMorphoBlueAggregatedPositionData({
+    usedAssets: data.usedAssets,
+    assetsData: marketInfo.assetsData,
+    marketInfo,
+})));
+export const getMorphoEarnDataWithMarketInfo = (data, marketInfo) => {
+    const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
+    const usedAssets = {
+        [marketInfo.loanToken]: {
+            symbol: loanTokenInfo.symbol,
+            supplied: data.amount,
+            borrowed: '0',
+            isSupplied: new Dec(data.amount).gt(0),
+            isBorrowed: false,
+            collateral: false,
+            suppliedUsd: data.amountUsd,
+            borrowedUsd: '0',
+        },
+    };
+    return Object.assign(Object.assign({}, data), { apy: calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData }).netApy });
+};
+export function getMorphoBlueMarketRewards(network, selectedMarket) {
+    return getRewardsForMarket(selectedMarket.marketId, network);
+}
 export const _getMorphoBlueAccountBalances = (provider, network, block, addressMapping, address, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
     let balances = {
         collateral: {},
@@ -216,23 +252,10 @@ export function getMorphoEarn(provider, network, account, selectedMarket, market
         const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
         const loanTokenSupplied = assetAmountInEth(loanInfo.suppliedInAssets.toString(), marketInfo.loanToken);
         const loanTokenSuppliedUsd = new Dec(loanTokenSupplied).mul(loanTokenInfo.price).toString();
-        const usedAssets = {
-            [marketInfo.loanToken]: {
-                symbol: loanTokenInfo.symbol,
-                supplied: loanTokenSupplied,
-                borrowed: '0',
-                isSupplied: new Dec(loanInfo.suppliedInAssets.toString()).gt(0),
-                isBorrowed: false,
-                collateral: false,
-                suppliedUsd: loanTokenSuppliedUsd,
-                borrowedUsd: '0',
-            },
-        };
-        const { netApy } = calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData });
-        return {
-            apy: netApy,
+        return getMorphoEarnDataWithMarketInfo({
+            apy: '0',
             amount: loanTokenSupplied,
             amountUsd: loanTokenSuppliedUsd,
-        };
+        }, marketInfo);
     });
 }

package/esm/morphoMidnight/index.js

@@ -14,7 +14,7 @@ import { DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoMidnightVi
 import { USD_QUOTE } from '../constants';
 import { calculateNetApy } from '../staking';
 import { isMainnetNetwork, wethToEth } from '../services/utils';
-import { getMorphoMidnightAggregatedPositionData } from '../helpers/morphoMidnightHelpers';
+import { getMorphoMidnightAggregatedPositionData, getMorphoMidnightUserBorrowInfo } from '../helpers/morphoMidnightHelpers';
 import { getChainlinkAssetAddress } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
@@ -148,9 +148,33 @@ export function _getMorphoMidnightAccountData(provider, network, account, select
                 borrowedUsd: '0',
             };
         });
+        // Enrich borrower positions with the orderbook-derived rate + principal/interest split (off-chain).
+        // MidnightView only stores `debt` (= face value at maturity), so we default to full-debt-as-principal and
+        // override from the transactions API when available. Never throw here — the position must still render.
+        let borrowRate = '0';
+        let debtBase = debt; // fallback: treat the full on-chain debt as principal until fill history is known
+        let debtInterest = '0';
+        let assetsDataForApy = marketInfo.assetsData;
+        if (new Dec(positionInfo.debt.toString()).gt(0)) {
+            try {
+                const borrowInfo = yield getMorphoMidnightUserBorrowInfo(account, marketId, marketInfo.maturity, marketInfo.loanToken);
+                borrowRate = borrowInfo.borrowRate;
+                debtBase = borrowInfo.debtBase;
+                debtInterest = borrowInfo.debtInterest;
+                usedAssets[marketInfo.loanToken].borrowRate = borrowRate;
+                // Reflect the real borrow cost in netApy without mutating the shared marketInfo.assetsData.
+                assetsDataForApy = Object.assign(Object.assign({}, marketInfo.assetsData), { [marketInfo.loanToken]: Object.assign(Object.assign({}, loanTokenData), { borrowRate }) });
+            }
+            catch (err) {
+                // Orderbook API unavailable — keep the on-chain-only fallback above.
+            }
+        }
         return Object.assign({ usedAssets,
             credit,
-            debt, maturity: marketInfo.maturity, isMatured: marketInfo.isMatured }, getMorphoMidnightAggregatedPositionData({ usedAssets, assetsData: marketInfo.assetsData, marketInfo }));
+            debt,
+            borrowRate,
+            debtBase,
+            debtInterest, maturity: marketInfo.maturity, isMatured: marketInfo.isMatured }, getMorphoMidnightAggregatedPositionData({ usedAssets, assetsData: assetsDataForApy, marketInfo }));
     });
 }
 export function getMorphoMidnightAccountData(provider, network, account, selectedMarket, marketInfo) {