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

package/esm/portfolio/index.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import Dec from 'decimal.js';
 import { NetworkNumber } from '../types/common';
 import { AaveMarkets, AaveV4Spokes, CompoundMarkets, CrvUsdMarkets, EulerV2Markets, LiquityV2Markets, LlamaLendMarkets, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets, } from '../markets';
-import { _getMorphoBlueAccountData, _getMorphoBlueMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
 import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData, getMorphoMidnightEarn } from '../morphoMidnight';
 import { AaveVersions, CompoundVersions, } from '../types';
 import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
@@ -35,6 +35,7 @@ import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
 import { getKingRewards } from '../claiming/king';
 import { fetchEthenaAirdropRewards } from '../claiming/ethena';
 import { _getAaveV4AccountData, _getAaveV4SpokeData } from '../aaveV4';
+import { getUniswapRewards } from '../claiming/uniswap';
 export function getPortfolioData(provider_1, network_1, defaultProvider_1, addresses_1) {
     return __awaiter(this, arguments, void 0, function* (provider, network, defaultProvider, addresses, isSim = false) {
         const isMainnet = network === NetworkNumber.Eth;
@@ -52,7 +53,7 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
         const liquityV2Markets = [NetworkNumber.Eth].includes(network) ? Object.values(LiquityV2Markets(network)) : [];
         const liquityV2MarketsStaking = [NetworkNumber.Eth].includes(network) ? Object.values(LiquityV2Markets(network)).filter(market => !market.isLegacy) : [];
         const aaveV4Spokes = Object.values(AaveV4Spokes(network)).filter((market) => market.chainIds.includes(network));
-        const args = [network, { batch: { multicall: { batchSize: isSim ? 500000 : 2500000 } } }];
+        const args = [network, { batch: { multicall: { batchSize: isSim ? 2000 : 2500000 } } }];
         const client = getViemProvider(provider, ...args);
         const defaultClient = getViemProvider(defaultProvider, ...args);
         const morphoMarketsData = {};
@@ -137,7 +138,7 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
         yield Promise.allSettled([
             // === MARKET DATA (needs to be fetched first) ===
             ...morphoMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
-                const marketData = yield _getMorphoBlueMarketData(client, network, market);
+                const marketData = yield _getMorphoBluePortfolioMarketData(client, network, market);
                 morphoMarketsData[market.value] = marketData;
             })),
             ...morphoMidnightMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
@@ -299,6 +300,34 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
                     }
                 }
             }))(),
+            // Batch UNI rewards
+            (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!isMainnet) {
+                        for (const address of addresses) {
+                            rewardsData[address.toLowerCase()].uniswap = { error: '', data: [] };
+                        }
+                        return;
+                    }
+                    const uniswapRewards = yield getUniswapRewards(client, network, addresses);
+                    for (const address of addresses) {
+                        const lowerAddress = address.toLowerCase();
+                        rewardsData[lowerAddress].uniswap = {
+                            error: '',
+                            data: uniswapRewards[lowerAddress] || [],
+                        };
+                    }
+                }
+                catch (error) {
+                    console.error('Error fetching Uniswap rewards data in batch:', error);
+                    for (const address of addresses) {
+                        rewardsData[address.toLowerCase()].uniswap = {
+                            error: 'Error fetching Uniswap rewards data in batch',
+                            data: null,
+                        };
+                    }
+                }
+            }))(),
             ...sparkMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!isMainnet) {

package/esm/savings/summerVaults/options.js

@@ -7,7 +7,7 @@ export const SUMMER_VAULT_USDC_MAINNET_LR = {
     asset: 'USDC',
     network: NetworkNumber.Eth,
     deploymentBlock: 21795049,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_USDC_MAINNET_HR = {
     type: SummerVaultType.SummerVaultUSDCMainnetHR,
@@ -16,7 +16,7 @@ export const SUMMER_VAULT_USDC_MAINNET_HR = {
     asset: 'USDC',
     network: NetworkNumber.Eth,
     deploymentBlock: 22488041,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_USDT_MAINNET_LR = {
     type: SummerVaultType.SummerVaultUSDTMainnetLR,
@@ -25,7 +25,7 @@ export const SUMMER_VAULT_USDT_MAINNET_LR = {
     asset: 'USDT',
     network: NetworkNumber.Eth,
     deploymentBlock: 21795276,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_ETH_MAINNET_LR = {
     type: SummerVaultType.SummerVaultETHMainnetLR,
@@ -34,7 +34,7 @@ export const SUMMER_VAULT_ETH_MAINNET_LR = {
     asset: 'WETH',
     network: NetworkNumber.Eth,
     deploymentBlock: 21795390,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_ETH_MAINNET_HR = {
     type: SummerVaultType.SummerVaultETHMainnetHR,
@@ -43,7 +43,7 @@ export const SUMMER_VAULT_ETH_MAINNET_HR = {
     asset: 'WETH',
     network: NetworkNumber.Eth,
     deploymentBlock: 22291252,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_USDC_ARBITRUM_LR = {
     type: SummerVaultType.SummerVaultUSDCArbitrumLR,
@@ -52,7 +52,7 @@ export const SUMMER_VAULT_USDC_ARBITRUM_LR = {
     asset: 'USDC',
     network: NetworkNumber.Arb,
     deploymentBlock: 404339289,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_USDT_ARBITRUM_LR = {
     type: SummerVaultType.SummerVaultUSDTArbitrumLR,
@@ -61,7 +61,7 @@ export const SUMMER_VAULT_USDT_ARBITRUM_LR = {
     asset: 'USDT',
     network: NetworkNumber.Arb,
     deploymentBlock: 303594065,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_USDC_BASE_LR = {
     type: SummerVaultType.SummerVaultUSDCBaseLR,
@@ -70,7 +70,7 @@ export const SUMMER_VAULT_USDC_BASE_LR = {
     asset: 'USDC',
     network: NetworkNumber.Base,
     deploymentBlock: 303594065,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_EURC_BASE_LR = {
     type: SummerVaultType.SummerVaultEURCBaseLR,
@@ -79,7 +79,7 @@ export const SUMMER_VAULT_EURC_BASE_LR = {
     asset: 'EURC',
     network: NetworkNumber.Base,
     deploymentBlock: 27544064,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULT_ETH_BASE_LR = {
     type: SummerVaultType.SummerVaultETHBaseLR,
@@ -88,7 +88,7 @@ export const SUMMER_VAULT_ETH_BASE_LR = {
     asset: 'WETH',
     network: NetworkNumber.Base,
     deploymentBlock: 29066887,
-    isLegacy: false,
+    isLegacy: true,
 };
 export const SUMMER_VAULTS = {
     [SummerVaultType.SummerVaultUSDCMainnetLR]: SUMMER_VAULT_USDC_MAINNET_LR,

package/esm/staking/staking.js

@@ -68,6 +68,7 @@ export const STAKING_ASSETS = [
     'PT sUSDe Nov', 'PT USDe Nov', 'PT USDe Jan', 'PT sUSDe Jan', 'wrsETH', 'wstETH', 'syrupUSDT', 'syrupUSDC', 'wstUSR',
     'PT sUSDe Feb', 'PT USDe Feb', 'PT sUSDe Apr', 'PT USDe Apr', 'PT sUSDe May', 'PT USDe May', 'PT srUSDe Apr', 'GHO',
     'PT sUSDe June', 'PT USDe June', 'PT srUSDe Jun', 'PT srUSDe Oct', 'PT USDG May', 'PT sUSDS Nov', 'PT sUSDe Oct', 'PT USDG Sep',
+    'syrupUSDG',
 ];
 export const getStakingApy = memoize((asset_1, ...args_1) => __awaiter(void 0, [asset_1, ...args_1], void 0, function* (asset, network = NetworkNumber.Eth) {
     try {
@@ -125,6 +126,8 @@ export const getStakingApy = memoize((asset_1, ...args_1) => __awaiter(void 0, [
             return yield getApyFromDfsApi('syrupUSDT');
         if (asset === 'syrupUSDC')
             return yield getApyFromDfsApi('syrupUSDC');
+        if (asset === 'syrupUSDG')
+            return yield getApyFromDfsApi('syrupUSDG');
         if (asset === 'wstUSR')
             return yield getApyFromDfsApi('wstUSR');
         if (asset === 'PT sUSDe Feb')

package/esm/types/aaveV4.d.ts

@@ -16,7 +16,8 @@ export declare enum AaveV4SpokesType {
     AaveV4LidoSpoke = "aave_v4_lido_spoke",
     AaveV4LombardBtcSpoke = "aave_v4_lombard_btc_spoke",
     AaveV4MainSpoke = "aave_v4_main_spoke",
-    AaveV4USDGPendleSpoke = "aave_v4_usdg_pendle_spoke"
+    AaveV4USDGPendleSpoke = "aave_v4_usdg_pendle_spoke",
+    AaveV4USDGMapleSpoke = "aave_v4_usdg_maple_spoke"
 }
 export interface AaveV4HubInfo {
     chainIds: NetworkNumber[];

package/esm/types/aaveV4.js

@@ -18,4 +18,5 @@ export var AaveV4SpokesType;
     AaveV4SpokesType["AaveV4LombardBtcSpoke"] = "aave_v4_lombard_btc_spoke";
     AaveV4SpokesType["AaveV4MainSpoke"] = "aave_v4_main_spoke";
     AaveV4SpokesType["AaveV4USDGPendleSpoke"] = "aave_v4_usdg_pendle_spoke";
+    AaveV4SpokesType["AaveV4USDGMapleSpoke"] = "aave_v4_usdg_maple_spoke";
 })(AaveV4SpokesType || (AaveV4SpokesType = {}));

package/esm/types/claiming.d.ts

@@ -14,6 +14,8 @@ export declare enum ClaimType {
     SPARK_AIRDROP = "SPARK_AIRDROP",
     /** Spark Airdrop */
     SPARK_WST_ETH_REWARDS = "SPARK_WST_ETH_REWARDS",// TODO: This will be removed once we fully refactor spark rewards
+    /** UNI Airdrop  */
+    UNI_REWARDS = "UNI_REWARDS",
     ETHENA_AIRDROP = "ETHENA_AIRDROP"
 }
 type _ClaimableTokenPartial = {
@@ -81,5 +83,13 @@ export type SparkWstEthRewardsClaimableToken = _ClaimableTokenPartial & {
 export type EthenaAirdropClaimableToken = _ClaimableTokenPartial & {
     claimType: ClaimType.ETHENA_AIRDROP;
 };
+export type UniswapAirdropClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.UNI_REWARDS;
+    additionalClaimFields: {
+        index: number;
+        isClaimed: boolean;
+        proof: string[];
+    };
+};
 export type ClaimableToken = AaveRewardsClaimableToken | AaveMeritRewardsClaimableToken | CompoundV3CompClaimableToken | SparkRewardsClaimableToken | KingRewardsClaimableToken | SparkAirdropClaimableToken | SparkWstEthRewardsClaimableToken | EthenaAirdropClaimableToken;
 export {};

package/esm/types/claiming.js

@@ -14,6 +14,8 @@ export var ClaimType;
     ClaimType["SPARK_AIRDROP"] = "SPARK_AIRDROP";
     /** Spark Airdrop */
     ClaimType["SPARK_WST_ETH_REWARDS"] = "SPARK_WST_ETH_REWARDS";
+    /** UNI Airdrop  */
+    ClaimType["UNI_REWARDS"] = "UNI_REWARDS";
     ClaimType["ETHENA_AIRDROP"] = "ETHENA_AIRDROP";
 })(ClaimType || (ClaimType = {}));
 export var SparkAirdropType;

package/esm/types/morphoBlue.d.ts

@@ -212,6 +212,15 @@ export interface MorphoBluePositionData {
     borrowShares: string;
     exposure: string;
 }
+export interface MorphoBlueEarnData {
+    apy: string;
+    amount: string;
+    amountUsd: string;
+}
+export interface MorphoBlueMarketRewards {
+    supplyApy: string;
+    borrowApy: string;
+}
 export interface MorphoBlueVault {
     address: string;
 }

package/esm/types/morphoMidnight.d.ts

@@ -86,6 +86,9 @@ export interface MorphoMidnightPositionData extends MorphoMidnightAggregatedPosi
     usedAssets: MMUsedAssets;
     credit: string;
     debt: string;
+    borrowRate: string;
+    debtBase: string;
+    debtInterest: string;
     maturity: number;
     isMatured: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.127-midnight-dev",
+  "version": "2.1.127-midnight-2-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -21,7 +21,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/tokens": "^1.7.41",
+    "@defisaver/tokens": "^1.7.44",
     "@types/lodash": "^4.17.15",
     "@types/memoizee": "^0.4.12",
     "decimal.js": "^10.6.0",

package/src/aaveV3/index.ts

@@ -84,9 +84,21 @@ export async function _getAaveV3MarketData(provider: Client, network: NetworkNum
   const aaveIncentivesContract = AaveIncentiveDataProviderV3ContractViem(provider, network);
   const marketAddress = market.providerAddress;
   const networksWithIncentives = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Opt, NetworkNumber.Linea, NetworkNumber.Plasma];
+  // Limit each view call to 10 tokens, run chunks concurrently, then combine their results into loanInfo.
+  const addressesPerRequest = 10;
+  const addressChunks: EthAddress[][] = _addresses.length > addressesPerRequest
+    ? Array.from(
+      { length: Math.ceil(_addresses.length / addressesPerRequest) },
+      (_, index) => _addresses.slice(index * addressesPerRequest, (index + 1) * addressesPerRequest) as EthAddress[],
+    )
+    : [_addresses as EthAddress[]];
+  const loanInfoPromise = Promise.all(addressChunks.map((addresses) => loanInfoContract.read.getFullTokensInfo(
+    [marketAddress, addresses],
+    setViemBlockNumber(blockNumber),
+  ))).then((loanInfoChunks) => loanInfoChunks.flat());
   // eslint-disable-next-line prefer-const
   let [loanInfo, eModesInfo, rewardInfo, merkleRewardsMap, meritRewardsMap] = await Promise.all([
-    loanInfoContract.read.getFullTokensInfo([marketAddress, _addresses as EthAddress[]], setViemBlockNumber(blockNumber)),
+    loanInfoPromise,
     loanInfoContract.read.getAllEmodes([marketAddress], setViemBlockNumber(blockNumber)),
     networksWithIncentives.includes(network) ? aaveIncentivesContract.read.getReservesIncentivesData([marketAddress], setViemBlockNumber(blockNumber)) : null,
     getMerkleCampaigns(network),

package/src/aaveV4/lend.ts

@@ -49,9 +49,9 @@ export const AAVE_V4_TOKENIZED_SPOKES: Record<string, EthAddress> = {
   USDC_PRIME: '0x486415fb1F8b062c89ED548f871cf64304AACb31',
   USDT_PRIME: '0x46c588DD8453aC259c1f6a54b4C9A93C2aC3762D',
 
-  USDC_PAXOS: '0x4131E0B2E7AFeCEAf3d3b4225aA61a3B2B7535b8',
-  USDT_PAXOS: '0x8Dabe53E8cB991c57f0307F6f419E6D469b0deAA',
-  PT_USDG_Sep_PAXOS: '0x27eF1140364948A0E30E248297FfDFE5a4091ec4',
+  USDC_PAXOS: '0xaed7c529bD2878170B61C758DfAa215AC7a4FD07',
+  USDT_PAXOS: '0xa0e97e45C2f89003730E467Bd484fA3eEcE5B4Cf',
+  PT_USDG_Sep_PAXOS: '0x7Df10B4A01350D2A1d95cFbE7c9207d7210A2663',
 };
 
 export const AAVE_V4_TOKENIZED_SPOKE_ADDRESSES: Partial<Record<NetworkNumber, EthAddress[]>> = {

package/src/claiming/index.ts

@@ -2,10 +2,12 @@ import * as aaveV3Claim from './aaveV3';
 import * as compV3Claim from './compV3';
 import * as kingV3Claim from './king';
 import * as sparkClaim from './spark';
+import * as uniswapClaim from './uniswap';
 
 export {
   aaveV3Claim,
   compV3Claim,
   kingV3Claim,
   sparkClaim,
+  uniswapClaim,
 };

package/src/claiming/uniswap.ts

@@ -0,0 +1,70 @@
+import Dec from 'decimal.js';
+import { Client } from 'viem';
+import { assetAmountInEth } from '@defisaver/tokens';
+import { EthAddress, NetworkNumber } from '../types';
+import { UniswapTokenDistributorViem } from '../contracts';
+import { ClaimType, UniswapAirdropClaimableToken } from '../types/claiming';
+
+const EMPTY_DATA = (walletAddress: EthAddress) => ({
+  address: walletAddress, index: 0, amount: '0x0', proof: [],
+});
+
+export const fetchUniswapRewardsData = async (walletAddress: EthAddress) => {
+  try {
+    const res = await fetch(`https://fe.defisaver.com/api/rewards/uniswap?user=${walletAddress}`,
+      { signal: AbortSignal.timeout(5000) });
+
+    if (!res.ok) throw new Error(await res.text());
+
+    const data = await res.json();
+    if (data.data.error) return EMPTY_DATA(walletAddress);
+
+    return data.data;
+  } catch (err) {
+    return EMPTY_DATA(walletAddress);
+  }
+};
+
+export const getUniswapRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]): Promise<Record<string, UniswapAirdropClaimableToken[]>> => {
+  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+  const apiDataPromises = walletAddresses.map(address => fetchUniswapRewardsData(address));
+  const apiDataArray = await Promise.all(apiDataPromises);
+
+  // Batch all contract calls using multicall
+  const contract = UniswapTokenDistributorViem(provider, network);
+  const cumulativePromises = apiDataArray.map(data => (data.index ? contract.read.isClaimed([data.index]) : Promise.resolve(false)),
+  );
+  const cumulativeResults = await Promise.all(cumulativePromises);
+
+  // Process results
+  const results: Record<string, UniswapAirdropClaimableToken[]> = {};
+
+  for (let i = 0; i < walletAddresses.length; i++) {
+    const walletAddress = walletAddresses[i];
+    const data = apiDataArray[i];
+    const cumulative = cumulativeResults[i];
+
+    const amountToClaim = new Dec(data.amount);
+
+    if (amountToClaim.lessThanOrEqualTo('0') || cumulative) {
+      results[walletAddress.toLowerCase() as EthAddress] = [];
+    } else {
+      results[walletAddress.toLowerCase() as EthAddress] = [{
+        symbol: 'UNI',
+        underlyingSymbol: 'UNI',
+        label: 'Uniswap Airdrop',
+        tokenAddress: '0x1f9840a85d5af5bf1d1762f925bdaddc4201f984',
+        amount: assetAmountInEth(amountToClaim.toString(), 'UNI'),
+        walletAddress,
+        claimType: ClaimType.UNI_REWARDS,
+        additionalClaimFields: {
+          index: data.index,
+          isClaimed: cumulative,
+          proof: data.proof,
+        },
+      }];
+    }
+  }
+
+  return results;
+};

package/src/config/contracts.ts

@@ -1360,3 +1360,12 @@ export const AaveV4View = {
     }
   }
 } as const;
+
+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",
+    }
+  }
+} as const;

package/src/contracts.ts

@@ -182,3 +182,5 @@ export const MakerDsrContractViem = createViemContractFromConfigFunc('MakerDsr')
 export const SkySavingsContractView = createViemContractFromConfigFunc('SkySavings');
 
 export const AaveV4ViewContractViem = createViemContractFromConfigFunc('AaveV4View');
+
+export const UniswapTokenDistributorViem = createViemContractFromConfigFunc('UniswapTokenDistributor');

package/src/curveUsd/index.ts

@@ -24,7 +24,7 @@ const getAndFormatBands = async (provider: Client, network: NetworkNumber, selec
   // 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);
     } else {

package/src/helpers/morphoBlueHelpers/index.ts

@@ -389,6 +389,7 @@ export const getRewardsForMarket = async (marketId: string, network: NetworkNumb
       query: REWARDS_QUERY,
       variables: { marketId, chainId: network },
     }),
+    signal: AbortSignal.timeout(LONGER_TIMEOUT),
   });
 
   const data = await response.json();

package/src/helpers/morphoMidnightHelpers/index.ts

@@ -1,4 +1,5 @@
 import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
 import {
   calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos,
 } from '../../moneymarket';
@@ -7,6 +8,8 @@ import {
   LeverageType, MMAssetsData, MMUsedAsset, MMUsedAssets,
 } from '../../types/common';
 import { MorphoMidnightAggregatedPositionData, MorphoMidnightAssetsData, MorphoMidnightMarketInfo } from '../../types';
+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
@@ -84,3 +87,206 @@ export const getMorphoMidnightAggregatedPositionData = ({
 
   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;
+
+interface MidnightTransaction {
+  event_type: string,
+  market_id: string,
+  created_at: number,
+  data: { seller_assets?: string, units?: string },
+}
+
+interface MidnightApiError {
+  code?: string,
+  message?: string,
+  details?: ({ field?: string, issue?: string })[] | null,
+}
+
+interface MidnightQuoteResponse {
+  average_best_price?: string,
+  average_worst_price?: string,
+  available_assets?: string,
+  available_units?: string,
+  takeable_offers?: unknown[],
+}
+
+export interface MorphoMidnightBorrowInfo {
+  borrowRate: string, // weighted-average borrow APY as a percent
+  debtBase: string, // base borrowed (Σ seller_assets), loan-token units
+  debtInterest: string, // debtTotal − debtBase (interest owed at maturity), loan-token units
+  debtTotal: string, // Σ units = on-chain debt at maturity, loan-token units
+}
+
+export interface MorphoMidnightBorrowQuote {
+  bestPrice: string, // average_best_price, loan-per-unit
+  worstPrice: string, // average_worst_price, slippage-adjusted
+  estBorrowRate: string, // estimated borrow APY as a percent
+  maxRate: string, // borrow APY the on-chain cap permits, i.e. `maxUnits` annualized (display only)
+  newUnits: string, // debt added at best price, raw loan-token base units
+  maxUnits: string, // capped debt (on-chain cap), raw loan-token base units
+  availableAssets: string,
+  availableUnits: string,
+  takeableOffers: any[], // opaque orderbook offers, forwarded verbatim to on-chain execution
+}
+
+// Days remaining until maturity, optionally measured at a past timestamp (for historical fills).
+export const midnightTimeToMaturityDays = (maturity: number, atSeconds: number = nowInSeconds()): number => 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: Dec.Value, ttmDays: Dec.Value): string => {
+  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: Dec.Value, ttmDays: Dec.Value): string => {
+  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.Value): string => 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 = async (
+  account: string,
+  marketId: string,
+  maturity: number,
+  loanTokenSymbol: string,
+): Promise<MorphoMidnightBorrowInfo> => {
+  const res = await fetch(`${MIDNIGHT_API_BASE}/users/${account}/transactions`, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
+  const json: { data?: MidnightTransaction[] } = await res.json();
+  const borrows = (json?.data || []).filter((t) => t.event_type === 'borrow' && t.market_id?.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) => {
+    const sellerAssets = new Dec(t.data?.seller_assets || 0);
+    const units = new Dec(t.data?.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?: MidnightApiError): string => {
+  const detail = (error?.details || []).map(({ issue }) => issue).filter(Boolean).join('; ');
+  const reason = detail || error?.message || 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 = async (
+  marketId: string,
+  assetsRaw: string,
+  slippagePercent: Dec.Value,
+  maturity: number,
+  maxBorrowRate?: Dec.Value,
+): Promise<MorphoMidnightBorrowQuote> => {
+  const url = `${MIDNIGHT_API_BASE}/books/${marketId}/bids/quote?assets=${assetsRaw}&slippage=${midnightSlippageParam(slippagePercent)}`;
+  const res = await fetch(url, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
+  const json: { data?: MidnightQuoteResponse, error?: MidnightApiError } = await res.json();
+  const d = json?.data;
+  if (!d?.average_best_price) throw new Error(midnightQuoteError(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 || [],
+  };
+};