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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.127-midnight-1-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

@@ -98,6 +98,11 @@ export const getMorphoMidnightAggregatedPositionData = ({
 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,
@@ -105,6 +110,20 @@ interface MidnightTransaction {
   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
@@ -116,9 +135,9 @@ 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, // estBorrowRate + slippage (display only, not sent on-chain)
+  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, // slippage-capped debt (on-chain cap), 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
@@ -138,6 +157,33 @@ export const midnightApyFromPrice = (price: Dec.Value, ttmDays: Dec.Value): stri
     .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
@@ -179,31 +225,58 @@ export const getMorphoMidnightUserBorrowInfo = async (
   };
 };
 
+// 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';
+};
+
 /**
- * Estimate the borrow rate + slippage cap for a prospective borrow by quoting the Midnight order book.
- * `assetsRaw` (and the returned `newUnits`/`maxUnits`) are raw loan-token base units — callers convert to/from
- * human amounts. `maxUnits` (from the slippage-adjusted worst price) is the cap sent on-chain to protect the
- * user if better offers get filled first. Throws if the book can't fill the amount (caller handles).
+ * 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=${slippagePercent}`;
+  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?: any } = await res.json();
+  const json: { data?: MidnightQuoteResponse, error?: MidnightApiError } = await res.json();
   const d = json?.data;
-  if (!d?.average_best_price) throw new Error('Morpho Midnight quote unavailable');
+  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).div(WAD).toString();
+  const worstPrice = new Dec(d.average_worst_price || 0).div(WAD).toString();
   const ttmDays = midnightTimeToMaturityDays(maturity);
   const estBorrowRate = midnightApyFromPrice(bestPrice, ttmDays);
-  const maxRate = new Dec(estBorrowRate).add(slippagePercent).toString();
+
+  // 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(worstPrice).lte(0) ? '0' : new Dec(assetsRaw).div(worstPrice).toFixed(0);
+  const maxUnits = new Dec(capPrice).lte(0) ? '0' : new Dec(assetsRaw).div(capPrice).toFixed(0);
 
   return {
     bestPrice,
@@ -212,8 +285,8 @@ export const getMorphoMidnightBorrowQuote = async (
     maxRate,
     newUnits,
     maxUnits,
-    availableAssets: d.available_assets,
-    availableUnits: d.available_units,
+    availableAssets: d.available_assets || '0',
+    availableUnits: d.available_units || '0',
     takeableOffers: d.takeable_offers || [],
   };
 };

package/src/llamaLend/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/markets/aaveV4/index.ts

@@ -193,6 +193,18 @@ export const AAVE_V4_USDG_PENDLE_SPOKE = (networkId: NetworkNumber): AaveV4Spoke
   ],
 });
 
+export const AAVE_V4_USDG_MAPLE_SPOKE = (networkId: NetworkNumber): AaveV4SpokeInfo => ({
+  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: NetworkNumber) => ({
   [AaveV4SpokesType.AaveV4BluechipSpoke]: AAVE_V4_BLUECHIP_SPOKE(networkId),
   [AaveV4SpokesType.AaveV4EthenaCorrelatedSpoke]: AAVE_V4_ETHENA_CORRELATED_SPOKE(networkId),
@@ -205,6 +217,7 @@ export const AaveV4Spokes = (networkId: NetworkNumber) => ({
   [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),
 }) as const;
 
 export const getAaveV4SpokeTypeInfo = (type: AaveV4SpokesType, network?: NetworkNumber) => ({ ...AaveV4Spokes(network ?? NetworkNumber.Eth) }[type]);

package/src/morphoBlue/index.ts

@@ -8,7 +8,7 @@ import {
   DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoBlueViewContractViem,
 } from '../contracts';
 import {
-  MorphoBlueAssetsData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBluePositionData,
+  MorphoBlueAssetsData, MorphoBlueEarnData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBlueMarketRewards, MorphoBluePositionData,
 } from '../types';
 import { USD_QUOTE, WAD } from '../constants';
 import { calculateNetApy, getStakingApy, STAKING_ASSETS } from '../staking';
@@ -21,7 +21,39 @@ import { getViemProvider, setViemBlockNumber } from '../services/viem';
 
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
 
-export async function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
+const getMorphoRewardIncentives = (apy: string) => [{
+  token: 'MORPHO',
+  apy,
+  incentiveKind: IncentiveKind.Reward,
+  description: 'Eligible for protocol-level MORPHO incentives.',
+}];
+
+export const addMorphoBlueRewardsToMarketInfo = (
+  marketInfo: MorphoBlueMarketInfo,
+  rewards: MorphoBlueMarketRewards,
+): MorphoBlueMarketInfo => ({
+  ...marketInfo,
+  assetsData: {
+    ...marketInfo.assetsData,
+    [marketInfo.loanToken]: {
+      ...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),
+      ],
+    },
+  },
+});
+
+async function getMorphoBlueMarketDataInternal(
+  provider: Client,
+  network: NetworkNumber,
+  selectedMarket: MorphoBlueMarketData,
+): Promise<MorphoBlueMarketInfo> {
   const {
     loanToken, collateralToken, oracle, irm, lltv, oracleType,
   } = selectedMarket;
@@ -59,16 +91,6 @@ export async function _getMorphoBlueMarketData(provider: Client, network: Networ
     loanTokenPrice = loanTokenPriceRound[1].toString();
   }
 
-  let morphoSupplyApy = '0';
-  let morphoBorrowApy = '0';
-  try {
-    const { supplyApy: _morphoSupplyApy, borrowApy: _morphoBorrowApy } = await 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();
@@ -90,18 +112,8 @@ export async function _getMorphoBlueMarketData(provider: Client, network: Networ
     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)] = {
@@ -138,10 +150,70 @@ export async function _getMorphoBlueMarketData(provider: Client, network: Networ
   };
 }
 
+export async function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
+  const marketInfo = await getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
+
+  try {
+    const rewards = await getRewardsForMarket(selectedMarket.marketId, network);
+    return addMorphoBlueRewardsToMarketInfo(marketInfo, rewards);
+  } catch (error) {
+    console.error(error);
+    return addMorphoBlueRewardsToMarketInfo(marketInfo, { supplyApy: '0', borrowApy: '0' });
+  }
+}
+
+export function _getMorphoBluePortfolioMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
+  return getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
+}
+
 export async function getMorphoBlueMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
   return _getMorphoBlueMarketData(getViemProvider(provider, network), network, selectedMarket);
 }
 
+export function getMorphoBluePortfolioMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
+  return _getMorphoBluePortfolioMarketData(getViemProvider(provider, network), network, selectedMarket);
+}
+
+export const getMorphoBluePositionDataWithMarketInfo = (
+  data: MorphoBluePositionData,
+  marketInfo: MorphoBlueMarketInfo,
+): MorphoBluePositionData => ({
+  ...data,
+  ...getMorphoBlueAggregatedPositionData({
+    usedAssets: data.usedAssets,
+    assetsData: marketInfo.assetsData,
+    marketInfo,
+  }),
+});
+
+export const getMorphoEarnDataWithMarketInfo = (data: MorphoBlueEarnData, marketInfo: MorphoBlueMarketInfo): MorphoBlueEarnData => {
+  const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
+  const usedAssets: MMUsedAssets = {
+    [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 {
+    ...data,
+    apy: calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData as unknown as MMAssetsData }).netApy,
+  };
+};
+
+export function getMorphoBlueMarketRewards(
+  network: NetworkNumber,
+  selectedMarket: MorphoBlueMarketData,
+): Promise<MorphoBlueMarketRewards> {
+  return getRewardsForMarket(selectedMarket.marketId, network);
+}
+
 export const _getMorphoBlueAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoBlueMarketData): Promise<PositionBalances> => {
   let balances: PositionBalances = {
     collateral: {},
@@ -238,7 +310,7 @@ export async function getMorphoBlueAccountData(provider: EthereumProvider, netwo
   return _getMorphoBlueAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
 }
 
-export async function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<{ apy: string, amount: string, amountUsd: string }> {
+export async function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBlueEarnData> {
   const {
     loanToken, collateralToken, oracle, irm, lltv,
   } = selectedMarket;
@@ -254,24 +326,9 @@ export async function getMorphoEarn(provider: Client, network: NetworkNumber, ac
   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: MMUsedAssets = {
-    [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 as unknown as MMAssetsData });
-
-  return {
-    apy: netApy,
+  return getMorphoEarnDataWithMarketInfo({
+    apy: '0',
     amount: loanTokenSupplied,
     amountUsd: loanTokenSuppliedUsd,
-  };
-}
+  }, marketInfo);
+}

package/src/portfolio/index.ts

@@ -12,7 +12,7 @@ import {
   MorphoMidnightMarkets,
   SparkMarkets,
 } from '../markets';
-import { _getMorphoBlueAccountData, _getMorphoBlueMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
 import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData, getMorphoMidnightEarn } from '../morphoMidnight';
 import {
   AaveV2MarketData,
@@ -54,6 +54,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 async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim = false): Promise<{
   positions: PortfolioPositionsData;
@@ -78,7 +79,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   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: [NetworkNumber, any?] = [network, { batch: { multicall: { batchSize: isSim ? 500_000 : 2_500_000 } } }];
+
+  const args: [NetworkNumber, any?] = [network, { batch: { multicall: { batchSize: isSim ? 2_000 : 2_500_000 } } }];
   const client = getViemProvider(provider, ...args);
   const defaultClient = getViemProvider(defaultProvider, ...args);
 
@@ -170,7 +172,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   await Promise.allSettled([
     // === MARKET DATA (needs to be fetched first) ===
     ...morphoMarkets.map(async (market) => {
-      const marketData = await _getMorphoBlueMarketData(client, network, market);
+      const marketData = await _getMorphoBluePortfolioMarketData(client, network, market);
       morphoMarketsData[market.value] = marketData;
     }),
     ...morphoMidnightMarkets.map(async (market) => {
@@ -322,6 +324,33 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       }
     })(),
+    // Batch UNI rewards
+    (async () => {
+      try {
+        if (!isMainnet) {
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].uniswap = { error: '', data: [] };
+          }
+          return;
+        }
+        const uniswapRewards = await getUniswapRewards(client, network, addresses);
+        for (const address of addresses) {
+          const lowerAddress = address.toLowerCase() as EthAddress;
+          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() as EthAddress].uniswap = {
+            error: 'Error fetching Uniswap rewards data in batch',
+            data: null,
+          };
+        }
+      }
+    })(),
     ...sparkMarkets.map((market) => addresses.map(async address => {
       try {
         if (!isMainnet) {