@1delta/margin-fetcher 5.0.9 → 5.0.10

package/dist/index.d.ts

@@ -33,6 +33,50 @@ interface RewardEntry$1 extends BaseYields$1 {
     asset: string;
 }
 type RewardsList$1 = RewardEntry$1[];
+/**
+ * The knob the BORROWER turns at open, when this config's numbers depend on one.
+ *
+ * Absent on every protocol whose factors are constants (Aave, Morpho, Compound…).
+ * Present where a per-loan choice moves them — LlamaLend's band count `N` moves
+ * the collateral factor; Liquity's chosen interest rate moves the cost.
+ *
+ * This describes the DOMAIN only. The value a given position actually chose is
+ * per-position and lives in the user-data `modes[posId]` slot — it cannot live
+ * here, because a lender with sub-accounts (Liquity troves, TermMax GTs) has
+ * several live values in one market at once.
+ *
+ * `kind` is what tells a consumer how to READ that number: without it a UI
+ * renders a band count of 15 as "e-mode 15", since `modes` historically only
+ * ever carried e-mode categories.
+ *
+ * See POSITION_PARAMETERS_PLAN.md.
+ */
+interface OpenParameter {
+    /** Discriminator — how to interpret the matching `modes[posId]` value. */
+    kind: 'llamalend-bands' | 'interest-rate';
+    /** Which of this config's numbers moves with the parameter. */
+    dimension: 'collateralFactor' | 'rate';
+    /** Allowed values: a continuous range, or a discrete set. */
+    domain: {
+        min: number;
+        max: number;
+    } | {
+        values: number[];
+    };
+    /**
+     * The value THIS config's numbers were computed at. A consumer that quotes a
+     * different value must recompute — it must not reuse `collateralFactor`.
+     */
+    default: number;
+    /**
+     * `true`  ⇒ fixed for the life of the loan; changing it means close & reopen
+     *            (LlamaLend — `_add_collateral_borrow` reuses the tick width).
+     * `false` ⇒ adjustable in place (Liquity), subject to the friction below.
+     */
+    immutableAfterOpen: boolean;
+    /** Adjustment cooldown, when mutable (Liquity `interestRateAdjCooldownSeconds`). */
+    adjustCooldownSeconds?: number;
+}
 interface ConfigEntry {
     category: number;
     borrowCollateralFactor: number;
@@ -63,6 +107,8 @@ interface ConfigEntry {
     targetHealthFactor?: number;
     collateralDisabled?: boolean;
     debtDisabled?: boolean;
+    /** Borrower-chosen open-time parameter this config's numbers depend on. */
+    openParameter?: OpenParameter;
 }
 interface PoolConfig {
     [category: string]: ConfigEntry;
@@ -630,6 +676,12 @@ interface LenderConfigData {
     targetHealthFactor?: number;
     collateralDisabled?: boolean;
     debtDisabled?: boolean;
+    /**
+     * Borrower-chosen open-time parameter this config's numbers depend on.
+     * Mirrors the API-side `ConfigEntry.openParameter`; see
+     * POSITION_PARAMETERS_PLAN.md.
+     */
+    openParameter?: OpenParameter;
 }
 interface ModeBase {
     category: number;
@@ -3304,11 +3356,41 @@ interface ResupplyPairRaw {
     collateralPrice: bigint | null;
     /** Cached `1e36 / collateralPrice` from the pair (stale between writes). */
     exchangeRate: bigint | null;
+    /** Convex pool id the collateral is staked into. 0 = not staked, no rewards. */
+    convexPid: bigint | null;
+    /** This pair's WEIGHT in the RSUP emission stream (not a token balance). */
+    rsupWeight: bigint | null;
+    /** Convex reward streams on the staked collateral: reward wei per second per
+     *  1e18 of staked SHARES, aggregated by token (a pool can list the same
+     *  token twice). */
+    collateralRewards: {
+        token: string;
+        ratePerSecPerShare: bigint;
+    }[];
+}
+/**
+ * Chain-level RSUP emission state — one read for the whole roster.
+ *
+ * `pairEmissions` stakes governance WEIGHT, not tokens: `totalWeight` is the
+ * sum over all pairs and each pair's slice is its `rsupWeight`. A pair's RSUP
+ * per second is `rewardRate x rsupWeight / totalWeight`.
+ */
+interface ResupplyRsupEmissions {
+    /** The RSUP token. */
+    govToken: string;
+    /** RSUP wei per second across ALL pairs. */
+    rewardRate: bigint;
+    /** Sum of every pair's weight. */
+    totalWeight: bigint;
+    /** Emissions stop here; past it the stream pays nothing. */
+    periodFinish: bigint;
 }
 interface ResupplyMarketsRaw {
     lender: string;
     config?: ResupplyConfigChain;
     pairs: ResupplyPairRaw[];
+    /** Absent when the stream has ended or could not be read. */
+    rsup?: ResupplyRsupEmissions;
 }
 
 /**
@@ -3556,28 +3638,6 @@ declare function llamaLendKeyParts(key: string): {
     lender: string;
     controller: string;
 } | undefined;
-/**
- * Map the LlamaLend batch into the shared `MorphoGeneralPublicResponse` shape,
- * keyed by `LLAMALEND_<CONTROLLER_ADDR>` — one key per market.
- *
- * Per market, two entries in the isolated-pair layout:
- *
- *  - COLLATERAL entry — deposit-only. `collateralFactor` is the LTV AT THE
- *    MARKET'S DEFAULT BAND COUNT, because LlamaLend has no market-constant
- *    LTV: it is a function of `N` and moves 0.886..0.991 on a single market.
- *    The whole curve rides along in `params.market.llamalend.bandLtv` so the
- *    UI can show the trade-off and the leverage sizer can use the real number
- *    for the `N` the user actually picks.
- *  - LOAN entry — the borrowed token. Supply side is the ERC-4626 vault, so
- *    unlike Inverse this one HAS `totalDeposits`.
- *
- * SOFT LIQUIDATION is the thing this shape cannot express natively, so it is
- * carried explicitly in the descriptor. `liquidationPenalty` here is the HARD
- * liquidation bonus only — it applies below the entire band range. Inside the
- * range a position is converted gradually through the market's own AMM with no
- * penalty at all, and a consumer that renders `liquidationPenalty` as "what
- * you lose when the price hits X" is describing the wrong event.
- */
 declare function convertLlamaLendMarketsToResponse(raw: LlamaLendMarketsRaw, chainId: string, prices?: {
     [asset: string]: number;
 }, additionalYields?: AdditionalYields, tokens?: GenericTokenList): {

package/dist/index.js

@@ -7,7 +7,7 @@ import { fetchTokenLists, fetchTokenList, aavePools, compoundV3Pools, initConfig
 import lodash from 'lodash';
 import { Chain } from '@1delta/chain-registry';
 import { multicallRetryUniversal, getEvmClient, getEvmChain, getEvmClientUniversal } from '@1delta/providers';
-import { LiquityTroveManagerAbi, LiquityActivePoolAbi, LiquityStabilityPoolAbi, LiquityPriceFeedAbi, LiquitySortedTrovesAbi, RiverTroveManagerAbi, RiverStabilityPoolAbi, TellerMarketRegistryAbi, TellerV2Abi, InverseMarketAbi, InverseOracleAbi, InverseDbrAbi, Erc20Abi, LlamaLendControllerAbi, LlamaLendControllerV1Abi, LlamaLendControllerV2Abi, LlamaLendVaultAbi, LlamaLendAmmAbi, MetaMorphoAbi, ExactlyPreviewerAbi, ExactlyAuditorAbi, LenderCommitmentGroupAbi, ResupplyRegistryAbi, ResupplyPairAbi, UsddVatAbi, UsddJugAbi, UsddSpotAbi, FrankencoinPositionAbi, FluidLendingResolverAbi, FluidVaultResolverAbi, FluidLiquidityResolverAbi, MoolahVaultAbi, ResupplyUtilitiesAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, MidnightAbi, TermRepoTokenAbi, TermRepoServicerAbi, TermRepoCollateralManagerAbi, LiquityTroveNFTAbi, LiquityCollSurplusPoolAbi, TellerCollateralManagerAbi, TermMaxViewerAbi, InverseEscrowAbi, CurvanceMarketManagerAbi, CurvanceCTokenAbi, GearboxCreditAccountCompressorV310Abi, UsddCdpManagerAbi, UsddProxyRegistryAbi, CurvanceProtocolReaderAbi, CurvanceCentralRegistryAbi, TermPriceConsumerAbi, CurvanceOracleManagerAbi, TermMaxOracleAggregatorV2Abi } from '@1delta/abis';
+import { LiquityTroveManagerAbi, LiquityActivePoolAbi, LiquityStabilityPoolAbi, LiquityPriceFeedAbi, LiquitySortedTrovesAbi, RiverTroveManagerAbi, RiverStabilityPoolAbi, TellerMarketRegistryAbi, TellerV2Abi, InverseMarketAbi, InverseOracleAbi, InverseDbrAbi, Erc20Abi, LlamaLendControllerAbi, LlamaLendControllerV1Abi, LlamaLendControllerV2Abi, LlamaLendVaultAbi, LlamaLendAmmAbi, MetaMorphoAbi, ExactlyPreviewerAbi, ExactlyAuditorAbi, LenderCommitmentGroupAbi, ResupplyRegistryAbi, ResupplyPairAbi, ResupplyUtilitiesAbi, ResupplyRewardHandlerAbi, ResupplyPairEmissionsAbi, ConvexPoolUtilAbi, UsddVatAbi, UsddJugAbi, UsddSpotAbi, FrankencoinPositionAbi, FluidLendingResolverAbi, FluidVaultResolverAbi, FluidLiquidityResolverAbi, MoolahVaultAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, MidnightAbi, TermRepoTokenAbi, TermRepoServicerAbi, TermRepoCollateralManagerAbi, LiquityTroveNFTAbi, LiquityCollSurplusPoolAbi, TellerCollateralManagerAbi, TermMaxViewerAbi, InverseEscrowAbi, CurvanceMarketManagerAbi, CurvanceCTokenAbi, GearboxCreditAccountCompressorV310Abi, UsddCdpManagerAbi, UsddProxyRegistryAbi, CurvanceProtocolReaderAbi, CurvanceCentralRegistryAbi, TermPriceConsumerAbi, CurvanceOracleManagerAbi, TermMaxOracleAggregatorV2Abi } from '@1delta/abis';
 export { MorphoLensAbi } from '@1delta/abis';
 import { prepareDebitDataMulticall, prepareLenderDebitMulticall, parseDebitDataResult, parseLenderDebitResult, getPermit2ContractAddress, getCompoundV3CometAddress as getCompoundV3CometAddress$1, getMorphoAddress, getAaveCollateralTokenAddress, getSiloHalfForUnderlying, InitMarginAddresses, getLstAcceptedInputs } from '@1delta/calldata-sdk';
 import { proxyNativeFetch } from '@1delta/proxy-fetch';
@@ -21401,6 +21401,19 @@ function convertLiquityMarketsToResponse(raw, chainId, prices = {}, _additionalY
       borrowLiquidity = Math.min(borrowLiquidity, Math.max(0, cap - entireDebt));
     }
     if (shutdown) borrowLiquidity = 0;
+    const rateParameter = {
+      kind: "interest-rate",
+      dimension: "rate",
+      domain: {
+        min: Number(cfg.minAnnualInterestRate ?? 0) / 1e18,
+        max: Number(cfg.maxAnnualInterestRate ?? 0) / 1e18
+      },
+      // No protocol default — the borrower must choose. The low end is the
+      // cheapest but the first to be redeemed against.
+      default: Number(cfg.minAnnualInterestRate ?? 0) / 1e18,
+      immutableAfterOpen: false,
+      adjustCooldownSeconds: cfg.interestRateAdjCooldownSeconds ? Number(cfg.interestRateAdjCooldownSeconds) : void 0
+    };
     const entry = { data: {} };
     const collUid = createMarketUid(chainId, lenderKey, collAddr);
     entry.data[collUid] = {
@@ -21435,7 +21448,18 @@ function convertLiquityMarketsToResponse(raw, chainId, prices = {}, _additionalY
           liquidationPenalty: liqPenalty,
           closeFactor: 1,
           collateralDisabled: false,
-          debtDisabled: true
+          debtDisabled: true,
+          /**
+           * Liquity's borrower picks their own interest rate at open, and it
+           * sets redemption priority as well as cost — so it is a real
+           * parameter, not a quoted rate.
+           *
+           * The MUTABLE case: adjustable in place, but rate-limited by
+           * `interestRateAdjCooldownSeconds` and fee-charged if adjusted
+           * early. The per-trove value lives in `modes[troveId]`, because one
+           * address can hold several troves at different rates at once.
+           */
+          openParameter: rateParameter
         }
       },
       closeFactor: 1,
@@ -23205,7 +23229,7 @@ var VAULT_PRICE_ABI = [
   }
 ];
 var IDENTITY_READS = 3;
-var STATE_READS = 12;
+var STATE_READS = 14;
 var ONE = 10n ** 18n;
 var identityCache = /* @__PURE__ */ new Map();
 var identityKey = (chainId, pair) => `${chainId}:${pair.toLowerCase()}`;
@@ -23312,6 +23336,11 @@ async function fetchResupplyMarkets(lender, chainId) {
   }
   const identities = discovered.map((p) => identityCache.get(identityKey(chainId, p))).filter((x) => !!x);
   if (identities.length === 0) return { lender, config, pairs: [] };
+  const { rsup, pairEmissions, convexPoolUtil } = await readRewardContext(
+    chainId,
+    config.registry,
+    config.utilities
+  );
   const utilities = config.utilities;
   const calls = [];
   const abis = [];
@@ -23328,7 +23357,16 @@ async function fetchResupplyMarkets(lender, chainId) {
       // The collateral vault's own share price — the exact input Resupply's
       // `BasicVaultOracle` uses. Read LIVE rather than inverting the pair's
       // cached `exchangeRate`, which only moves when someone writes.
-      { address: id.collateral, name: "convertToAssets", params: [ONE] }
+      { address: id.collateral, name: "convertToAssets", params: [ONE] },
+      // Rewards. `convexPid == 0` means the collateral is not staked, so there
+      // is nothing to report; the weight is this pair's slice of the RSUP
+      // stream. Both are governance-mutable, so neither is cached.
+      { address: id.pair, name: "convexPid", params: [] },
+      {
+        address: pairEmissions ?? id.pair,
+        name: pairEmissions ? "balanceOf" : "convexPid",
+        params: pairEmissions ? [id.pair] : []
+      }
     );
     abis.push(
       ResupplyPairAbi,
@@ -23339,7 +23377,9 @@ async function fetchResupplyMarkets(lender, chainId) {
       ResupplyPairAbi,
       ResupplyPairAbi,
       ResupplyPairAbi,
-      VAULT_PRICE_ABI
+      VAULT_PRICE_ABI,
+      ResupplyPairAbi,
+      pairEmissions ? ResupplyPairEmissionsAbi : ResupplyPairAbi
     );
     if (utilities) {
       calls.push(
@@ -23397,11 +23437,118 @@ async function fetchResupplyMarkets(lender, chainId) {
       ratePerSec: tuple(rateInfo, 1),
       exchangeRate: tuple(exchangeInfo, 2),
       collateralPrice: big(results[base + 8]),
-      liveRatePerSec: utilities ? big(results[base + 9]) : null,
-      underlyingSupplyRatePerSec: utilities ? big(results[base + 10]) : null
+      // Indices follow the PUSH ORDER above exactly: the two reward reads sit
+      // at +9/+10, BEFORE the lens block, so the lens reads are +11/+12.
+      // (Getting this wrong is silent — it produced a 3-billion-percent APR
+      // before the numbers were checked against a hand computation.)
+      convexPid: big(results[base + 9]),
+      rsupWeight: pairEmissions ? big(results[base + 10]) : null,
+      liveRatePerSec: utilities ? big(results[base + 11]) : null,
+      underlyingSupplyRatePerSec: utilities ? big(results[base + 12]) : null,
+      collateralRewards: []
     };
   });
-  return { lender, config, pairs };
+  await attachCollateralRewards(chainId, convexPoolUtil, pairs);
+  return { lender, config, pairs, rsup };
+}
+async function readRewardContext(chainId, registry, utilities) {
+  const addr2 = (v) => typeof v === "string" && v.startsWith("0x") && !/^0x0+$/.test(v) ? v : void 0;
+  try {
+    const first = await multicallRetryUniversal({
+      chain: chainId,
+      calls: [
+        { address: registry, name: "rewardHandler", params: [] },
+        { address: registry, name: "govToken", params: [] },
+        ...utilities ? [{ address: utilities, name: "convexPoolUtil", params: [] }] : []
+      ],
+      abi: [
+        ResupplyRegistryAbi,
+        ResupplyRegistryAbi,
+        ...utilities ? [ResupplyUtilitiesAbi] : []
+      ],
+      allowFailure: true
+    });
+    const rewardHandler = addr2(first[0]);
+    const govToken = addr2(first[1]);
+    const convexPoolUtil = utilities ? addr2(first[2]) : void 0;
+    if (!rewardHandler || !govToken) return { convexPoolUtil };
+    const [emissions] = await multicallRetryUniversal({
+      chain: chainId,
+      calls: [{ address: rewardHandler, name: "pairEmissions", params: [] }],
+      abi: ResupplyRewardHandlerAbi,
+      allowFailure: true
+    });
+    const pairEmissions = addr2(emissions);
+    if (!pairEmissions) return { convexPoolUtil };
+    const stream = await multicallRetryUniversal({
+      chain: chainId,
+      calls: [
+        { address: pairEmissions, name: "periodFinish", params: [] },
+        { address: pairEmissions, name: "rewardRate", params: [] },
+        { address: pairEmissions, name: "totalSupply", params: [] }
+      ],
+      abi: [
+        ResupplyPairEmissionsAbi,
+        ResupplyPairEmissionsAbi,
+        ResupplyPairEmissionsAbi
+      ],
+      allowFailure: true
+    });
+    const periodFinish = big(stream[0]);
+    const rewardRate = big(stream[1]);
+    const totalWeight = big(stream[2]);
+    if (periodFinish === null || rewardRate === null || totalWeight === null || totalWeight === 0n) {
+      return { pairEmissions, convexPoolUtil };
+    }
+    if (periodFinish <= BigInt(Math.floor(Date.now() / 1e3))) {
+      return { pairEmissions, convexPoolUtil };
+    }
+    return {
+      rsup: { govToken, rewardRate, totalWeight, periodFinish },
+      pairEmissions,
+      convexPoolUtil
+    };
+  } catch {
+    return {};
+  }
+}
+async function attachCollateralRewards(chainId, convexPoolUtil, pairs) {
+  if (!convexPoolUtil) return;
+  const staked = pairs.filter((p) => (p.convexPid ?? 0n) > 0n);
+  if (staked.length === 0) return;
+  let res = [];
+  try {
+    res = await multicallRetryUniversal({
+      chain: chainId,
+      calls: staked.map((p) => ({
+        address: convexPoolUtil,
+        name: "rewardRates",
+        params: [p.convexPid]
+      })),
+      abi: staked.map(() => ConvexPoolUtilAbi),
+      allowFailure: true
+    });
+  } catch {
+    return;
+  }
+  staked.forEach((p, i) => {
+    const entry = res[i];
+    if (!Array.isArray(entry)) return;
+    const [tokens, rates] = entry;
+    if (!Array.isArray(tokens) || !Array.isArray(rates)) return;
+    const byToken = /* @__PURE__ */ new Map();
+    tokens.forEach((t, j) => {
+      const rate = rates[j];
+      if (typeof t !== "string" || typeof rate !== "bigint" || rate === 0n) {
+        return;
+      }
+      const key2 = t.toLowerCase();
+      byToken.set(key2, (byToken.get(key2) ?? 0n) + rate);
+    });
+    p.collateralRewards = [...byToken.entries()].map(
+      ([token, ratePerSecPerShare]) => ({ token, ratePerSecPerShare })
+    );
+  });
 }
 
 // src/prices/oracle-prices/fetchers/curvanceRoster.ts
@@ -23991,6 +24138,8 @@ function currencyFor9(address, decimals, symbol, tokens) {
   const lower3 = address.toLowerCase();
   return tokens[lower3] ?? { address: lower3, symbol, name: symbol, decimals };
 }
+var LLAMALEND_MIN_BANDS = 4;
+var LLAMALEND_MAX_BANDS = 50;
 function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additionalYields = {
   intrinsicYields: {},
   lenderRewards: {},
@@ -24027,6 +24176,13 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
     const liqPenalty = Number(market.liquidationDiscount) / 1e18 || 0;
     const closeFactor = 1;
     const depositsEnabled = (m.maxDeposit ?? 0) > 0;
+    const bandParameter = {
+      kind: "llamalend-bands",
+      dimension: "collateralFactor",
+      domain: { min: LLAMALEND_MIN_BANDS, max: LLAMALEND_MAX_BANDS },
+      default: market.defaultBands ?? 10,
+      immutableAfterOpen: true
+    };
     const entry = { data: {} };
     const collUid = createMarketUid(chainId, lenderKey, collAddr);
     entry.data[collUid] = {
@@ -24064,7 +24220,8 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
           liquidationPenalty: liqPenalty,
           closeFactor,
           collateralDisabled: false,
-          debtDisabled: true
+          debtDisabled: true,
+          openParameter: bandParameter
         }
       },
       closeFactor,
@@ -24263,6 +24420,52 @@ function ratePerSecToApr(rate) {
   if (rate === null) return 0;
   return Number(rate) / 1e18 * SECONDS_PER_YEAR9 * 100;
 }
+function buildRewardEntries(p, rsup, chainId, prices, tokens, collateralUsd, debtUsd) {
+  const priceOf = (address) => {
+    const lower3 = address.toLowerCase();
+    const token = tokens[lower3];
+    const key2 = toOracleKey(token?.assetGroup) || toGenericPriceKey(lower3, chainId);
+    return prices[key2] ?? 0;
+  };
+  const collateral = [];
+  if (collateralUsd > 0) {
+    for (const r of p.collateralRewards ?? []) {
+      const price2 = priceOf(r.token);
+      if (price2 <= 0) continue;
+      const decimals = tokens[r.token.toLowerCase()]?.decimals ?? 18;
+      const perSecond = Number(r.ratePerSecPerShare) * Number(p.totalCollateral ?? 0n) / 1e18;
+      const usdPerYear = perSecond / 10 ** decimals * SECONDS_PER_YEAR9 * price2;
+      const apr = usdPerYear / collateralUsd * 100;
+      if (!Number.isFinite(apr) || apr <= 0) continue;
+      collateral.push({
+        asset: r.token,
+        depositRate: apr,
+        variableBorrowRate: 0,
+        stableBorrowRate: 0
+      });
+    }
+  }
+  const borrow = [];
+  if (rsup && debtUsd > 0 && (p.rsupWeight ?? 0n) > 0n) {
+    const price2 = priceOf(rsup.govToken);
+    if (price2 > 0) {
+      const decimals = tokens[rsup.govToken.toLowerCase()]?.decimals ?? 18;
+      const perSecond = Number(rsup.rewardRate) * Number(p.rsupWeight) / Number(rsup.totalWeight);
+      const usdPerYear = perSecond / 10 ** decimals * SECONDS_PER_YEAR9 * price2;
+      const apr = usdPerYear / debtUsd * 100;
+      if (Number.isFinite(apr) && apr > 0) {
+        borrow.push({
+          asset: rsup.govToken,
+          depositRate: 0,
+          // A REBATE on the borrow cost, not a charge.
+          variableBorrowRate: apr,
+          stableBorrowRate: 0
+        });
+      }
+    }
+  }
+  return { collateral, borrow };
+}
 function convertResupplyMarketsToResponse(raw, chainId, prices = {}, _additionalYields = {
   intrinsicYields: {},
   lenderRewards: {},
@@ -24298,6 +24501,15 @@ function convertResupplyMarketsToResponse(raw, chainId, prices = {}, _additional
     const borrowLiquidity = Math.max(borrowLimit - totalDebt, 0);
     const halted = (p.borrowLimit ?? 0n) === 0n;
     const wrappedMarket = resolveWrappedMarket(chainId, id.collateral, id.name);
+    const rewardEntries = buildRewardEntries(
+      p,
+      raw.rsup,
+      chainId,
+      prices,
+      tokens,
+      totalColl * collPrice,
+      totalDebt * debtPrice
+    );
     const maxLtv = p.maxLTV !== null ? Number(p.maxLTV) / LTV_PRECISION : 0;
     const liquidationPenalty = p.liquidationFee !== null ? Number(p.liquidationFee) / LTV_PRECISION : 0;
     const mintFeePct = p.mintFee !== null ? Number(p.mintFee) / LTV_PRECISION * 100 : 0;
@@ -24328,7 +24540,9 @@ function convertResupplyMarketsToResponse(raw, chainId, prices = {}, _additional
       // The wrapped Curve Lend / Fraxlend supply rate — this collateral is a
       // lending position and earns while it sits here.
       intrinsicYield: collateralIntrinsicApr,
-      rewards: void 0,
+      // CRV/CVX from the Convex position the pair stakes the collateral into.
+      // Empty (not undefined) when the pair does not stake — `convexPid == 0`.
+      rewards: rewardEntries.collateral,
       decimals: collDecimals,
       config: {
         0: {
@@ -24385,7 +24599,9 @@ function convertResupplyMarketsToResponse(raw, chainId, prices = {}, _additional
       // but it is governance-settable.
       originationFee: mintFeePct,
       intrinsicYield: 0,
-      rewards: void 0,
+      // RSUP emissions to BORROWERS — a rebate on `variableBorrowRate`, not a
+      // deposit yield. Empty when the emission stream has expired.
+      rewards: rewardEntries.borrow,
       decimals: debtDecimals,
       config: {
         0: {
@@ -31141,7 +31357,7 @@ var getLiquityUserDataConverter = (lender, chainId, account, meta) => {
               troveInfo
             }
           };
-          modes[t.troveId] = 0;
+          modes[t.troveId] = Number(troveInfo.annualInterestRate) / 1e18;
           hist[t.troveId] = {
             totalDeposits24h: collNum * collHist,
             totalDebt24h: debtNum * loanHist
@@ -31601,7 +31817,7 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
             }
           }
         };
-        const modes = { "0": 0 };
+        const modes = { "0": bandCount };
         const hist = {
           "0": {
             totalDeposits24h: collNum * collHist + bandBorrowedNum * loanHist,