@defisaver/positions-sdk 2.1.127-midnight-14-dev → 2.1.127-midnight-15-dev

package/esm/fluid/merkl.js

@@ -0,0 +1,95 @@
+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 memoize from 'memoizee';
+import { aprToApy } from '../moneymarket';
+import { fetchAllMerklOpportunities } from '../services/merkl';
+import { IncentiveKind, IncentiveSource, OpportunityStatus, } from '../types';
+/**
+ * Merkl tags Fluid vault-scoped reward campaigns via the opportunity `type` field:
+ *   - FLUIDVAULT_COLLATERAL → reward for supplying collateral to the vault
+ *   - FLUIDVAULT_BORROW     → reward for borrowing from the vault
+ * (ERC20LOGPROCESSOR campaigns target fToken earn positions rather than vaults, so they don't
+ * belong on vault market data.)
+ *
+ * A campaign identifies its vault via `identifier` — the vault address. Conditional campaigns
+ * append a marker to it (e.g. `0x5668…eeaBORROW_BL`, excluding holders who borrow the reward
+ * asset elsewhere); those are still attached, with the full identifier passed through as
+ * `eligibilityId` so a curated check in EligibilityMapping can gate them in net APY — unknown
+ * ids apply unconditionally, mirroring Aave V3. Whitelist-gated campaigns only accrue to
+ * whitelisted addresses, so they are skipped rather than advertised to every user.
+ */
+export var FluidMerklOpportunityType;
+(function (FluidMerklOpportunityType) {
+    FluidMerklOpportunityType["Collateral"] = "FLUIDVAULT_COLLATERAL";
+    FluidMerklOpportunityType["Borrow"] = "FLUIDVAULT_BORROW";
+})(FluidMerklOpportunityType || (FluidMerklOpportunityType = {}));
+// '0x' + 20-byte vault address; conditional campaigns append a marker after it
+const VAULT_ADDRESS_LENGTH = 42;
+const buildMerklIncentive = (opportunity) => {
+    var _a, _b, _c, _d, _e, _f;
+    const token = ((_d = (_c = (_b = (_a = opportunity.rewardsRecord) === null || _a === void 0 ? void 0 : _a.breakdowns) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.token) === null || _d === void 0 ? void 0 : _d.symbol) || ((_f = (_e = opportunity.tokens) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.symbol) || '';
+    return {
+        apy: aprToApy(opportunity.apr),
+        token,
+        incentiveKind: IncentiveKind.Reward,
+        source: IncentiveSource.Merkl,
+        description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
+        eligibilityId: opportunity.identifier,
+    };
+};
+export const buildFluidMerklRewardMap = (opportunities, chainId) => {
+    const result = {};
+    opportunities
+        .filter((o) => o.chainId === chainId)
+        .filter((o) => o.status === OpportunityStatus.LIVE)
+        .filter((o) => Object.values(FluidMerklOpportunityType).includes(o.type))
+        .filter((o) => { var _a; return !((_a = o.identifier) === null || _a === void 0 ? void 0 : _a.includes('WHITELIST')); })
+        .forEach((o) => {
+        var _a;
+        const vaultAddress = (_a = o.identifier) === null || _a === void 0 ? void 0 : _a.slice(0, VAULT_ADDRESS_LENGTH).toLowerCase();
+        if (!vaultAddress || vaultAddress.length !== VAULT_ADDRESS_LENGTH)
+            return;
+        if (!result[vaultAddress])
+            result[vaultAddress] = { supply: [], borrow: [] };
+        result[vaultAddress][o.type === FluidMerklOpportunityType.Borrow ? 'borrow' : 'supply'].push(buildMerklIncentive(o));
+    });
+    return result;
+};
+/**
+ * Fetches live vault-scoped Fluid campaigns for the chain, keyed by vault address. Never throws —
+ * on any failure it returns an empty map, so Merkl being down can't break market data.
+ */
+export const getFluidMerklCampaigns = memoize((chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const opportunities = yield fetchAllMerklOpportunities({
+            mainProtocolId: 'fluid',
+            type: Object.values(FluidMerklOpportunityType).join(','),
+            status: OpportunityStatus.LIVE,
+        });
+        return buildFluidMerklRewardMap(opportunities, chainId);
+    }
+    catch (e) {
+        console.error('Failed to fetch Fluid Merkl campaigns', e);
+        return {};
+    }
+}), { promise: true, maxAge: 60 * 1000 });
+/**
+ * Appends the vault's Merkl campaigns to its assets' incentive arrays — supply rewards on every
+ * suppliable asset and borrow rewards on every borrowable one. Smart collateral/debt vaults hold
+ * the position across both pair tokens, so the pro-rata reward APY applies to each side's value.
+ */
+export const attachFluidMerklIncentives = (marketData, campaigns) => {
+    var _a;
+    const vaultCampaigns = campaigns[(_a = marketData.marketData.marketAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()];
+    if (!vaultCampaigns || (!vaultCampaigns.supply.length && !vaultCampaigns.borrow.length))
+        return marketData;
+    const assetsData = Object.fromEntries(Object.entries(marketData.assetsData).map(([symbol, asset]) => [symbol, Object.assign(Object.assign({}, asset), { supplyIncentives: asset.canBeSupplied ? [...asset.supplyIncentives, ...vaultCampaigns.supply] : asset.supplyIncentives, borrowIncentives: asset.canBeBorrowed ? [...asset.borrowIncentives, ...vaultCampaigns.borrow] : asset.borrowIncentives })]));
+    return Object.assign(Object.assign({}, marketData), { assetsData });
+};

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

@@ -1,4 +1,6 @@
-import { FluidAggregatedVaultData, FluidAssetData, FluidAssetsData, FluidDexBorrowDataStructOutput, FluidDexSupplyDataStructOutput, FluidUsedAsset, FluidUsedAssets, InnerFluidMarketData } from '../../types';
+import { FluidAggregatedVaultData, FluidAssetData, FluidAssetsData, FluidDexBorrowDataStructOutput, FluidDexSupplyDataStructOutput, FluidUsedAsset, FluidUsedAssets, IncentiveData, InnerFluidMarketData } from '../../types';
+import { IncentiveSide } from '../../types/common';
+export declare const getUniqueFluidMerklIncentives: (assetsData: FluidAssetsData, side: IncentiveSide) => IncentiveData[];
 export declare const getFluidAggregatedData: ({ usedAssets, assetsData, marketData, }: {
     usedAssets: FluidUsedAssets;
     marketData: InnerFluidMarketData;

package/esm/helpers/fluidHelpers/index.js

@@ -1,17 +1,41 @@
 import Dec from 'decimal.js';
 import { assetAmountInEth } from '@defisaver/tokens';
-import { FluidVaultType, } from '../../types';
+import { FluidVaultType, IncentiveSource, } from '../../types';
 import { calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos, } from '../../moneymarket';
-import { calculateNetApy } from '../../staking';
-import { LeverageType } from '../../types/common';
+import { calculateInterestEarned, calculateNetApy, EligibilityMapping } from '../../staking';
+import { IncentiveSide, LeverageType } from '../../types/common';
 import { getEthAmountForDecimals } from '../../services/utils';
-const calculateNetApyDex = ({ marketData, suppliedUsd, borrowedUsd }) => {
+export const getUniqueFluidMerklIncentives = (assetsData, side) => {
+    const field = side === IncentiveSide.Supply ? 'supplyIncentives' : 'borrowIncentives';
+    const incentives = Object.values(assetsData)
+        .flatMap(asset => asset[field])
+        .filter(incentive => incentive.source === IncentiveSource.Merkl);
+    return [...new Map(incentives.map(incentive => [
+            [incentive.eligibilityId, incentive.token, incentive.apy, incentive.description].join('|'),
+            incentive,
+        ])).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 incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : 0;
+    return new Dec(total).add(incentiveInterest).toString();
+}, '0');
+const calculateNetApyDex = ({ marketData, assetsData, usedAssets, suppliedUsd, borrowedUsd, }) => {
     const { borrowRate, supplyRate, incentiveBorrowRate, incentiveSupplyRate, tradingBorrowRate, tradingSupplyRate, } = marketData;
     const totalBorrowRate = new Dec(borrowRate).minus(tradingBorrowRate || '0').toString();
     const totalSupplyRate = new Dec(supplyRate).add(tradingSupplyRate || '0').toString();
     const borrowIncentive = new Dec(incentiveBorrowRate || '0').mul(borrowedUsd).div(100).toString();
     const supplyIncentive = new Dec(incentiveSupplyRate || '0').mul(suppliedUsd).div(100).toString();
-    const incentiveUsd = new Dec(supplyIncentive).minus(borrowIncentive).toString();
+    const merklSupplyIncentive = getMerklIncentiveInterest(getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Supply), suppliedUsd, usedAssets);
+    const merklBorrowIncentive = getMerklIncentiveInterest(getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Borrow), borrowedUsd, usedAssets);
+    const incentiveUsd = new Dec(supplyIncentive)
+        .minus(borrowIncentive)
+        .add(merklSupplyIncentive)
+        .add(merklBorrowIncentive)
+        .toString();
     const borrowInterest = new Dec(totalBorrowRate).mul(borrowedUsd).div(100).toString();
     const supplyInterest = new Dec(totalSupplyRate).mul(suppliedUsd).div(100).toString();
     const totalInterestUsd = new Dec(supplyInterest).add(incentiveUsd).minus(borrowInterest).toString();
@@ -32,7 +56,15 @@ export const getFluidAggregatedData = ({ usedAssets, assetsData, marketData, },
         ? getAssetsTotal(usedAssets, ({ isBorrowed }) => isBorrowed, ({ borrowedUsd }) => borrowedUsd)
         : new Dec(marketData.debtSharePrice).mul(borrowShares).toString();
     const isDex = [FluidVaultType.T2, FluidVaultType.T3, FluidVaultType.T4].includes(marketData.vaultType);
-    const { netApy, incentiveUsd, totalInterestUsd } = isDex ? calculateNetApyDex({ marketData, suppliedUsd: payload.suppliedUsd, borrowedUsd: payload.borrowedUsd }) : calculateNetApy({ usedAssets, assetsData: assetsData });
+    payload.merklSupplyIncentives = getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Supply);
+    payload.merklBorrowIncentives = getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Borrow);
+    const { netApy, incentiveUsd, totalInterestUsd } = isDex ? calculateNetApyDex({
+        marketData,
+        assetsData,
+        usedAssets,
+        suppliedUsd: payload.suppliedUsd,
+        borrowedUsd: payload.borrowedUsd,
+    }) : calculateNetApy({ usedAssets, assetsData: assetsData });
     payload.netApy = netApy;
     payload.incentiveUsd = incentiveUsd;
     payload.totalInterestUsd = totalInterestUsd;

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

@@ -4,9 +4,10 @@ export declare const calculateNetApyLiquityV2: (usedAssets: LiquityV2UsedAssets,
     totalInterestUsd: string;
     incentiveUsd: string;
 };
-export declare const getLiquityV2AggregatedPositionData: ({ usedAssets, assetsData, minCollRatio, interestRate, }: {
+export declare const getLiquityV2AggregatedPositionData: ({ usedAssets, assetsData, minCollRatio, interestRate, liqRatio, }: {
     usedAssets: LiquityV2UsedAssets;
     assetsData: LiquityV2AssetsData;
     minCollRatio: string;
     interestRate: string;
+    liqRatio?: string;
 }) => LiquityV2AggregatedTroveData;

package/esm/helpers/liquityV2Helpers/index.js

@@ -31,11 +31,12 @@ export const calculateNetApyLiquityV2 = (usedAssets, assetsData, interestRate) =
     const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
     return { netApy, totalInterestUsd, incentiveUsd };
 };
-export const getLiquityV2AggregatedPositionData = ({ usedAssets, assetsData, minCollRatio, interestRate, }) => {
+export const getLiquityV2AggregatedPositionData = ({ usedAssets, assetsData, minCollRatio, interestRate, liqRatio, }) => {
     const payload = {};
     payload.suppliedUsd = getAssetsTotal(usedAssets, (usedAsset) => usedAsset, ({ suppliedUsd }) => suppliedUsd);
     payload.borrowedUsd = getAssetsTotal(usedAssets, (usedAsset) => usedAsset, ({ borrowedUsd }) => borrowedUsd);
     payload.borrowLimitUsd = new Dec(payload.suppliedUsd).div(minCollRatio).mul(100).toString();
+    payload.liquidationLimitUsd = new Dec(payload.suppliedUsd).div(liqRatio !== null && liqRatio !== void 0 ? liqRatio : minCollRatio).mul(100).toString();
     const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
     payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
     payload.ratio = (+payload.suppliedUsd && +payload.borrowedUsd) ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
@@ -50,7 +51,7 @@ export const getLiquityV2AggregatedPositionData = ({ usedAssets, assetsData, min
     payload.liquidationPrice = '';
     if (leveragedType !== '') {
         const assetPrice = assetsData[leveragedAsset].price;
-        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.borrowLimitUsd);
+        payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
     }
     payload.exposure = getExposure(payload.borrowedUsd, payload.suppliedUsd);
     return payload;

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

@@ -2,6 +2,8 @@ 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

package/esm/helpers/morphoMidnightHelpers/index.js

@@ -18,6 +18,7 @@ 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
@@ -40,9 +41,12 @@ export const getMorphoMidnightAggregatedPositionData = ({ usedAssets, assetsData
     // 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. Anything surfacing this as "what you can
-    // borrow" has to scale it by the loan-per-unit price first (`midnightPriceFromApy` off a book rate) —
-    // a correction that grows with the term, past 7% on a one-year market.
+    // 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';

package/esm/liquityV2/index.js

@@ -309,15 +309,14 @@ export const _getLiquityV2TroveData = (provider_1, network_1, _a, ...args_1) =>
     const interestBatchManager = data.interestBatchManager;
     const lastInterestRateAdjTime = data.lastInterestRateAdjTime.toString();
     const hasInterestBatchManager = !compareAddresses(interestBatchManager, ZERO_ADDRESS);
-    const liqRatio = hasInterestBatchManager ? new Dec(minCollRatio).add(batchCollRatio).toString() : minCollRatio;
+    const borrowLimitRatio = hasInterestBatchManager ? new Dec(minCollRatio).add(batchCollRatio).toString() : minCollRatio;
     const payload = Object.assign(Object.assign({ usedAssets,
         troveId,
         interestRate,
         interestBatchManager,
         debtInFront,
-        lastInterestRateAdjTime,
-        liqRatio, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)] }, getLiquityV2AggregatedPositionData({
-        usedAssets, assetsData, minCollRatio: liqRatio, interestRate,
+        lastInterestRateAdjTime, liqRatio: minCollRatio, borrowLimitRatio, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)] }, getLiquityV2AggregatedPositionData({
+        usedAssets, assetsData, minCollRatio: borrowLimitRatio, interestRate, liqRatio: minCollRatio,
     })), { collRatio });
     return payload;
 });

package/esm/moneymarket/moneymarketCommonService.js

@@ -23,6 +23,8 @@ export const STABLE_ASSETS = [
     'USDtb', 'eUSDe', 'PT USDe July', 'PT eUSDe Aug', 'PT sUSDe Sep', 'PT USDe Sep', 'PT sUSDe Nov', 'PT USDe Nov', 'PT sUSDe Jan', 'PT USDe Jan',
     'PT sUSDe Feb', 'PT USDe Feb', 'PT sUSDe Apr', 'PT USDe Apr', 'PT sUSDe May', 'PT USDe May', 'PT srUSDe Apr', 'frxUSD', 'PT sUSDe June',
     'PT USDe June', 'PT srUSDe Jun', 'PT srUSDe Oct', 'PT USDG May', 'PT sUSDS Nov', 'PT sUSDe Oct', 'PT USDG Sep',
+    'USDG', 'mUSD', 'PYUSD', 'USDbC', 'MAI', 'sGHO', 'USD3', 'stUSDS', 'PRIME',
+    'crvUSD', 'syrupUSDC', 'syrupUSDT', 'syrupUSDG', 'PT syrupUSDC Aug',
 ];
 export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
     let borrowUnstable = 0;

package/esm/morphoBlue/index.d.ts

@@ -1,6 +1,7 @@
 import { Client } from 'viem';
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
 import { MorphoBlueEarnData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBlueMarketRewards, MorphoBluePositionData } from '../types';
+export { MorphoBlueMerklOpportunityType, addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities, addMorphoBlueMerklRewardsToMarketInfo, } from './merkl';
 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>;

package/esm/morphoBlue/index.js

@@ -17,6 +17,8 @@ import { isMainnetNetwork, wethToEth } from '../services/utils';
 import { getBorrowRate, getMorphoBlueAggregatedPositionData, getRewardsForMarket, getSupplyRate, } from '../helpers/morphoBlueHelpers';
 import { getChainlinkAssetAddress } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities } from './merkl';
+export { MorphoBlueMerklOpportunityType, addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities, addMorphoBlueMerklRewardsToMarketInfo, } from './merkl';
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
 const getMorphoRewardIncentives = (apy) => [{
         token: 'MORPHO',
@@ -119,15 +121,15 @@ function getMorphoBlueMarketDataInternal(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' });
-        }
+        const [marketInfo, rewards, merklOpportunities] = yield Promise.all([
+            getMorphoBlueMarketDataInternal(provider, network, selectedMarket),
+            getRewardsForMarket(selectedMarket.marketId, network).catch((error) => {
+                console.error(error);
+                return { supplyApy: '0', borrowApy: '0' };
+            }),
+            getMorphoBlueMerklOpportunities(),
+        ]);
+        return addMorphoBlueMerklOpportunitiesToMarketInfo(addMorphoBlueRewardsToMarketInfo(marketInfo, rewards), selectedMarket, network, merklOpportunities);
     });
 }
 export function _getMorphoBluePortfolioMarketData(provider, network, selectedMarket) {

package/esm/morphoBlue/merkl.d.ts

@@ -0,0 +1,35 @@
+import { MerklOpportunity, MorphoBlueMarketData, MorphoBlueMarketInfo, NetworkNumber } from '../types';
+/**
+ * Merkl tags Morpho Blue market-level reward campaigns via the opportunity `type` field:
+ *   - MORPHOSUPPLY     → reward for supplying the market's loan asset
+ *   - MORPHOCOLLATERAL → reward for depositing the market's collateral asset
+ *   - MORPHOBORROW     → reward for borrowing the market's loan asset
+ * (MORPHOVAULT/ERC20LOGPROCESSOR are MetaMorpho vault campaigns and MORPHOSUPPLY_SINGLETOKEN is
+ * token-wide rather than market-scoped, so none of them belong on per-market data.)
+ *
+ * A campaign identifies its market via `identifier` — the first 20 bytes of the 32-byte Morpho
+ * market id, formatted as a checksummed address. Whitelist-gated campaigns append a marker to that
+ * identifier (e.g. `0x54cf…c46WHITELIST_CAMPAIGN`); their rewards only accrue to whitelisted
+ * addresses, so they are skipped rather than advertised to every user.
+ */
+export declare enum MorphoBlueMerklOpportunityType {
+    Supply = "MORPHOSUPPLY",
+    Collateral = "MORPHOCOLLATERAL",
+    Borrow = "MORPHOBORROW"
+}
+/**
+ * Appends the given live Merkl campaigns for the market to its `assetsData` incentive arrays
+ * (collateral supply / loan supply / loan borrow). Existing Merkl incentives are replaced rather
+ * than duplicated, so re-applying on refreshed data is safe.
+ */
+export declare const addMorphoBlueMerklOpportunitiesToMarketInfo: (marketInfo: MorphoBlueMarketInfo, selectedMarket: MorphoBlueMarketData, chainId: NetworkNumber, opportunities: MerklOpportunity[]) => MorphoBlueMarketInfo;
+/**
+ * Fetches live market-scoped Morpho Blue campaigns for all chains. Never throws — on any failure
+ * it returns an empty list, so Merkl being down can't break market data.
+ */
+export declare const getMorphoBlueMerklOpportunities: () => Promise<MerklOpportunity[]>;
+/**
+ * Fetches live Merkl campaigns and appends the ones for the market to its `assetsData` incentive
+ * arrays. Never throws — on any failure the market info is returned unchanged.
+ */
+export declare const addMorphoBlueMerklRewardsToMarketInfo: (marketInfo: MorphoBlueMarketInfo, selectedMarket: MorphoBlueMarketData, network: NetworkNumber) => Promise<MorphoBlueMarketInfo>;

package/esm/morphoBlue/merkl.js

@@ -0,0 +1,96 @@
+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 { aprToApy } from '../moneymarket';
+import { fetchAllMerklOpportunities } from '../services/merkl';
+import { IncentiveKind, OpportunityStatus, } from '../types';
+/**
+ * Merkl tags Morpho Blue market-level reward campaigns via the opportunity `type` field:
+ *   - MORPHOSUPPLY     → reward for supplying the market's loan asset
+ *   - MORPHOCOLLATERAL → reward for depositing the market's collateral asset
+ *   - MORPHOBORROW     → reward for borrowing the market's loan asset
+ * (MORPHOVAULT/ERC20LOGPROCESSOR are MetaMorpho vault campaigns and MORPHOSUPPLY_SINGLETOKEN is
+ * token-wide rather than market-scoped, so none of them belong on per-market data.)
+ *
+ * A campaign identifies its market via `identifier` — the first 20 bytes of the 32-byte Morpho
+ * market id, formatted as a checksummed address. Whitelist-gated campaigns append a marker to that
+ * identifier (e.g. `0x54cf…c46WHITELIST_CAMPAIGN`); their rewards only accrue to whitelisted
+ * addresses, so they are skipped rather than advertised to every user.
+ */
+export var MorphoBlueMerklOpportunityType;
+(function (MorphoBlueMerklOpportunityType) {
+    MorphoBlueMerklOpportunityType["Supply"] = "MORPHOSUPPLY";
+    MorphoBlueMerklOpportunityType["Collateral"] = "MORPHOCOLLATERAL";
+    MorphoBlueMerklOpportunityType["Borrow"] = "MORPHOBORROW";
+})(MorphoBlueMerklOpportunityType || (MorphoBlueMerklOpportunityType = {}));
+const MERKL_DESCRIPTION_MARKER = 'through Merkl';
+// '0x' + first 20 bytes of the market id
+const MARKET_ID_PREFIX_LENGTH = 42;
+const buildMerklIncentive = (opportunity) => {
+    var _a, _b, _c, _d, _e, _f;
+    const token = ((_d = (_c = (_b = (_a = opportunity.rewardsRecord) === null || _a === void 0 ? void 0 : _a.breakdowns) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.token) === null || _d === void 0 ? void 0 : _d.symbol) || ((_f = (_e = opportunity.tokens) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.symbol) || '';
+    return {
+        apy: aprToApy(opportunity.apr),
+        token,
+        incentiveKind: IncentiveKind.Reward,
+        description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
+    };
+};
+const withoutMerklIncentives = (incentives = []) => incentives
+    .filter(({ description }) => !(description === null || description === void 0 ? void 0 : description.includes(MERKL_DESCRIPTION_MARKER)));
+/**
+ * Appends the given live Merkl campaigns for the market to its `assetsData` incentive arrays
+ * (collateral supply / loan supply / loan borrow). Existing Merkl incentives are replaced rather
+ * than duplicated, so re-applying on refreshed data is safe.
+ */
+export const addMorphoBlueMerklOpportunitiesToMarketInfo = (marketInfo, selectedMarket, chainId, opportunities) => {
+    const marketIdPrefix = (selectedMarket.marketId || '').slice(0, MARKET_ID_PREFIX_LENGTH).toLowerCase();
+    const collateralAsset = marketInfo.assetsData[marketInfo.collateralToken];
+    const loanAsset = marketInfo.assetsData[marketInfo.loanToken];
+    if (marketIdPrefix.length !== MARKET_ID_PREFIX_LENGTH || !collateralAsset || !loanAsset)
+        return marketInfo;
+    const relevant = opportunities.filter((o) => {
+        var _a;
+        return o.chainId === chainId
+            && o.status === OpportunityStatus.LIVE
+            && Object.values(MorphoBlueMerklOpportunityType).includes(o.type)
+            // a suffixed identifier marks a whitelist-gated campaign — skip those
+            && ((_a = o.identifier) === null || _a === void 0 ? void 0 : _a.length) === MARKET_ID_PREFIX_LENGTH
+            && o.identifier.toLowerCase() === marketIdPrefix;
+    });
+    if (!relevant.length)
+        return marketInfo;
+    const incentivesByType = (type) => relevant.filter((o) => o.type === type).map(buildMerklIncentive);
+    const collateralSupply = incentivesByType(MorphoBlueMerklOpportunityType.Collateral);
+    const loanSupply = incentivesByType(MorphoBlueMerklOpportunityType.Supply);
+    const loanBorrow = incentivesByType(MorphoBlueMerklOpportunityType.Borrow);
+    return Object.assign(Object.assign({}, marketInfo), { assetsData: Object.assign(Object.assign({}, marketInfo.assetsData), { [marketInfo.collateralToken]: Object.assign(Object.assign({}, collateralAsset), { supplyIncentives: [...withoutMerklIncentives(collateralAsset.supplyIncentives), ...collateralSupply] }), [marketInfo.loanToken]: Object.assign(Object.assign({}, loanAsset), { supplyIncentives: [...withoutMerklIncentives(loanAsset.supplyIncentives), ...loanSupply], borrowIncentives: [...withoutMerklIncentives(loanAsset.borrowIncentives), ...loanBorrow] }) }) });
+};
+/**
+ * Fetches live market-scoped Morpho Blue campaigns for all chains. Never throws — on any failure
+ * it returns an empty list, so Merkl being down can't break market data.
+ */
+export const getMorphoBlueMerklOpportunities = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield fetchAllMerklOpportunities({
+            mainProtocolId: 'morpho',
+            type: Object.values(MorphoBlueMerklOpportunityType).join(','),
+            status: OpportunityStatus.LIVE,
+        });
+    }
+    catch (e) {
+        console.error('Failed to fetch Morpho Blue Merkl campaigns', e);
+        return [];
+    }
+});
+/**
+ * Fetches live Merkl campaigns and appends the ones for the market to its `assetsData` incentive
+ * arrays. Never throws — on any failure the market info is returned unchanged.
+ */
+export const addMorphoBlueMerklRewardsToMarketInfo = (marketInfo, selectedMarket, network) => __awaiter(void 0, void 0, void 0, function* () { return addMorphoBlueMerklOpportunitiesToMarketInfo(marketInfo, selectedMarket, network, yield getMorphoBlueMerklOpportunities()); });

package/esm/portfolio/index.js

@@ -27,7 +27,7 @@ import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
 import { _getLiquityV2MarketData, getLiquitySAndYBold, getLiquityV2Staking } from '../liquityV2';
 import { _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
 import { getUmbrellaData } from '../umbrella';
-import { getMeritUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
+import { getMerklUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
 import { getCompoundV3Rewards } from '../claiming/compV3';
 import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
 import { getKingRewards } from '../claiming/king';
@@ -120,7 +120,7 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
                 },
             };
             rewardsData[address.toLowerCase()] = {
-                aaveV3merit: {},
+                merkl: {},
                 aaveV3: {},
                 compV3: {},
                 spark: {},
@@ -345,12 +345,12 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
             }))).flat(),
             ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const aaveMeritData = yield getMeritUnclaimedRewards(address, network);
-                    rewardsData[address.toLowerCase()].aaveV3merit = { error: '', data: aaveMeritData };
+                    const merklData = yield getMerklUnclaimedRewards(address, network);
+                    rewardsData[address.toLowerCase()].merkl = { error: '', data: merklData };
                 }
                 catch (error) {
-                    console.error(`Error fetching Aave V3 Merit rewards data for address ${address}:`, error);
-                    rewardsData[address.toLowerCase()].aaveV3merit = { error: `Error fetching Aave V3 Merit rewards data for address ${address}`, data: null };
+                    console.error(`Error fetching Merkl rewards data for address ${address}:`, error);
+                    rewardsData[address.toLowerCase()].merkl = { error: `Error fetching Merkl rewards data for address ${address}`, data: null };
                 }
             })),
             ...aaveV3Markets.map(market => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {

package/esm/services/merkl.d.ts

@@ -0,0 +1,6 @@
+import { MerklOpportunity } from '../types';
+/**
+ * Fetches every page matching the query. Merkl returns 20 opportunities by default, so omitting
+ * `items` and advancing `page` avoids imposing a client-side maximum on the result set.
+ */
+export declare const fetchAllMerklOpportunities: (query: Record<string, string>) => Promise<MerklOpportunity[]>;