@1delta/margin-fetcher 5.0.7 → 5.0.9

package/dist/index.d.ts

@@ -2299,11 +2299,45 @@ interface LenderRewards {
         };
     };
 }
+/**
+ * Rewards keyed by the RESERVE TOKEN the campaign pays on — the aToken for a
+ * supply campaign, the variable debt token for a borrow one.
+ *
+ * Why this exists: a protocol's Merkl campaigns cover every deployment under
+ * one `mainProtocolId` ("aave" spans V3 mainnet, Horizon, Prime, Ether.fi and
+ * every V4 hub/spoke), and nothing in the opportunity payload names the
+ * deployment reliably — `depositUrl`'s `marketName` is wrong on at least one
+ * live campaign ("Borrow USDC on Aave" claims `proto_mainnet` while paying on
+ * `variableDebtHorRwaUSDC`, i.e. Horizon). Attributing by (lender, underlying)
+ * therefore collapsed every deployment's campaign onto the base lender key and
+ * SUMMED them: Aave V3 USDC read 5.75% borrow (1.75 + 2 + 2 across three
+ * deployments) and V3 USDG read 12% (two V4 hubs), while Horizon/Prime/V4
+ * markets read 0%.
+ *
+ * The reserve token is unambiguous — it exists in exactly one market of exactly
+ * one deployment. Consumers hold the other half of the join already: Aave-type
+ * market nodes carry `params.metadata.{aToken, vToken}`, so matching on those
+ * lands each campaign on exactly one marketUid, and cross-deployment summing
+ * becomes impossible by construction.
+ */
+interface RewardsByReserveToken {
+    /** chainId → lowercased reserve-token address → reward */
+    [chainId: string]: {
+        [reserveToken: string]: LenderAssetReward;
+    };
+}
 interface YieldDataWithTimestamp {
     intrinsicYields: {
         [asset: string]: number | undefined;
     };
     lenderRewards: LenderRewards;
+    /**
+     * Reserve-token-keyed rewards for protocols whose campaigns cannot be
+     * attributed to a deployment from the campaign payload alone (Aave).
+     * Those protocols are absent from `lenderRewards` — better no reward than
+     * one filed against the wrong market.
+     */
+    rewardsByReserveToken: RewardsByReserveToken;
 }
 interface LenderRewardsByMarketUid {
     [marketUid: string]: LenderAssetReward;
@@ -2312,7 +2346,25 @@ interface YieldDataByMarketUid {
     intrinsicYields: {
         [asset: string]: number | undefined;
     };
+    /**
+     * Flattened to marketUid via `createMarketUid(chain, lender, asset)`.
+     *
+     * CAVEAT: that construction assumes a market's uid ends in its underlying
+     * address, which is not universal — Aave V4 uids end in a numeric RESERVE ID
+     * (`AAVE_V4_94E7A5DC…:1:3` is WBTC), so a reward flattened this way can never
+     * match one. Prefer `rewardsByLenderAsset` when the consumer has the market
+     * nodes to hand; this stays for callers that only have uids.
+     */
     lenderRewards: LenderRewardsByMarketUid;
+    /**
+     * The same lender-keyed rewards UNflattened — (chain → lender → underlying).
+     * Consumers holding market nodes should join on this: it needs no assumption
+     * about how a lender composes its marketUid.
+     */
+    rewardsByLenderAsset: LenderRewards;
+    /** See {@link RewardsByReserveToken} — joined by the consumer against each
+     *  market node's `params.metadata.{aToken, vToken}`. */
+    rewardsByReserveToken: RewardsByReserveToken;
 }
 
 declare const fetchGeneralYields: () => Promise<YieldDataWithTimestamp>;
@@ -8808,8 +8860,17 @@ interface LiquidationTerms {
     ltv?: number;
     /** Threshold at which liquidation becomes possible. */
     liquidationLtv?: number;
-    /** Fraction of repaid debt paid to the liquidator on top of par. */
-    penalty: number;
+    /**
+     * Fraction of repaid debt paid to the liquidator on top of par.
+     *
+     * OPTIONAL, and the distinction is load-bearing: `0` means "the liquidator
+     * gets no bonus", `undefined` means "we do not know it". The first cut
+     * defaulted the unknown case to `0` and every market on `/lending/latest`
+     * rendered a confident "Liquidator takes debt repaid + 0%" — the origin's
+     * `market_config` had no penalty column at all, so NOTHING was known. A row
+     * we cannot fill must be absent, not zero.
+     */
+    penalty?: number;
     closeFactor: number;
     targetHealthFactor?: number;
     /**

package/dist/index.js

@@ -23028,7 +23028,11 @@ async function fetchChainExtras(chainId, markets) {
       abi: LLAMALEND_READ_ABI,
       allowFailure: true
     });
-  } catch {
+  } catch (e) {
+    console.error(
+      `[llamalend] chain-extras multicall failed on chain ${chainId} for ${markets.length} market(s) \u2014 LTV/price/band state unavailable this cycle:`,
+      e?.message ?? e
+    );
     return {};
   }
   const out = {};
@@ -24019,7 +24023,7 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
     const utilization = reserves > 0 ? totalDebt / reserves : 0;
     const borrowRatePct = (m.borrowApr ?? 0) * 100;
     const depositRatePct = (m.lendApr ?? 0) * 100;
-    const ltv = m.collateralFactor ?? 0;
+    const ltv = m.collateralFactor ?? null;
     const liqPenalty = Number(market.liquidationDiscount) / 1e18 || 0;
     const closeFactor = 1;
     const depositsEnabled = (m.maxDeposit ?? 0) > 0;
@@ -24128,7 +24132,10 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
         collateralDecimals: collDecimals,
         // The Controller doubles as the market id.
         id: market.controller.toLowerCase(),
-        lltv: String(ltv),
+        // Mirrors the Morpho shape. Empty string, not "0": a consumer parsing
+        // this as a number gets NaN and can branch, where "0" would silently
+        // become a zero LTV. The real curve is in `llamalend.bandLtv`.
+        lltv: ltv !== null ? String(ltv) : "",
         oracle: market.priceOracle ?? market.amm,
         irm: market.monetaryPolicy ?? zeroAddress,
         collateralAddress: collAddr,
@@ -45942,6 +45949,12 @@ function emptyReward() {
     additionalBorrowData: []
   };
 }
+function ensureReserveTokenReward(result, chainId, reserveToken) {
+  if (!result[chainId]) result[chainId] = {};
+  const key2 = reserveToken.toLowerCase();
+  if (!result[chainId][key2]) result[chainId][key2] = emptyReward();
+  return result[chainId][key2];
+}
 function ensureReward(result, chainId, lender, asset) {
   if (!result[chainId]) result[chainId] = {};
   if (!result[chainId][lender]) result[chainId][lender] = {};
@@ -45989,6 +46002,7 @@ function createMerklRewardFetcher(config) {
     label: `MERKL_${config.merklProtocolId.toUpperCase()}`,
     fetch: async () => {
       const result = {};
+      const byReserveToken = {};
       const chainResults = config.chainIds ? await Promise.all(
         config.chainIds.map(async (chainId) => {
           try {
@@ -46012,8 +46026,17 @@ function createMerklRewardFetcher(config) {
           for (const resolved2 of resolutions) {
             const bucket = resolved2.bucket ?? (opp.action === "LEND" ? "deposit" : opp.action === "BORROW" ? "borrow" : void 0);
             if (!bucket) continue;
-            const lender = resolved2.lender ?? config.lenderKey;
-            const reward = ensureReward(result, chainId, lender, resolved2.asset);
+            const keyBy = resolved2.keyBy ?? (config.keyByReserveToken ? "reserveToken" : "lender");
+            const reward = keyBy === "reserveToken" ? ensureReserveTokenReward(
+              byReserveToken,
+              chainId,
+              resolved2.asset
+            ) : ensureReward(
+              result,
+              chainId,
+              resolved2.lender ?? config.lenderKey,
+              resolved2.asset
+            );
             const breakdowns = extractRewardBreakdowns(opp);
             reward.link = getMerkleUrl(opp);
             if (bucket === "deposit") {
@@ -46026,13 +46049,41 @@ function createMerklRewardFetcher(config) {
           }
         }
       }
-      return result;
+      return { byLender: result, byReserveToken };
     }
   };
 }
 var aaveMerklRewardFetcher = createMerklRewardFetcher({
   merklProtocolId: "aave",
-  lenderKey: "AAVE_V3"
+  lenderKey: "AAVE_V3",
+  // Aave campaigns are keyed by the reserve token they pay on, NOT by lender:
+  // Merkl's `aave` protocol id covers V3 mainnet, Horizon, Prime, Ether.fi and
+  // every V4 hub/spoke, and nothing in the payload identifies the deployment
+  // reliably — "Borrow USDC on Aave" advertises `marketName=proto_mainnet` in
+  // its depositUrl while paying on `variableDebtHorRwaUSDC`, i.e. Horizon.
+  // Filing them all under AAVE_V3 summed unrelated deployments into one number
+  // (V3 USDC borrow read 5.75% = 1.75 + 2 + 2; V3 USDG read 12% = two V4 hubs)
+  // and left the deployments actually running the campaigns at 0%.
+  keyByReserveToken: true,
+  resolveAsset: (opp) => {
+    const explorer = opp.explorerAddress?.toLowerCase();
+    if (opp.type?.startsWith("AAVE_V4")) {
+      const underlying2 = resolveUnderlyingFromOpportunity(opp);
+      if (!explorer || !underlying2) return void 0;
+      return {
+        asset: underlying2,
+        lender: `AAVE_V4_${explorer.slice(2).toUpperCase()}`,
+        keyBy: "lender"
+      };
+    }
+    if (explorer) return { asset: explorer };
+    const underlying = resolveUnderlyingFromOpportunity(opp);
+    const candidates = (opp.tokens ?? []).filter(
+      (t) => t.address.toLowerCase() !== underlying
+    );
+    if (candidates.length !== 1) return void 0;
+    return { asset: candidates[0].address.toLowerCase() };
+  }
 });
 function parseEulerVaultFromUrl(depositUrl) {
   if (!depositUrl) return void 0;
@@ -46349,6 +46400,8 @@ async function fetchForPool(chainId, lender, pool, nowSeconds) {
 }
 var dtrinityRebateRewardFetcher = {
   label: "DTRINITY_REBATE",
+  // On-chain source: the pool (and therefore the lender key) is known up front,
+  // so this stays lender-keyed — no deployment ambiguity to resolve.
   fetch: async () => {
     const nowSeconds = Math.floor(Date.now() / 1e3);
     const results = await Promise.all(
@@ -46371,7 +46424,7 @@ var dtrinityRebateRewardFetcher = {
         }
       }
     }
-    return merged;
+    return { byLender: merged };
   }
 };
 
@@ -46391,30 +46444,51 @@ var rewardFetchers = [
   morphoCollateralMerklRewardFetcher,
   dtrinityRebateRewardFetcher
 ];
+function mergeReserveTokenRewards(target, source) {
+  for (const [chainId, byToken] of Object.entries(source)) {
+    if (!target[chainId]) target[chainId] = {};
+    Object.assign(target[chainId], byToken);
+  }
+}
 async function fetchLenderRewards() {
   const results = await Promise.all(
     rewardFetchers.map((f) => safeFetch(f.label, f.fetch))
   );
-  const lenderRewards = {};
+  const byLender = {};
+  const byReserveToken = {};
   for (const rr of results) {
-    if (rr) mergeRewardResults(lenderRewards, rr);
+    if (!rr) continue;
+    if (rr.byLender) mergeRewardResults(byLender, rr.byLender);
+    if (rr.byReserveToken)
+      mergeReserveTokenRewards(byReserveToken, rr.byReserveToken);
   }
-  return lenderRewards;
+  return { byLender, byReserveToken };
 }
 
 // src/yields/fetchGeneralYields.ts
 var fetchGeneralYields = async () => {
-  const [intrinsicYields, lenderRewards] = await Promise.all([
+  const [intrinsicYields, rewards] = await Promise.all([
     fetchIntrinsicYields(),
     fetchLenderRewards()
   ]);
-  return { intrinsicYields, lenderRewards };
+  return {
+    intrinsicYields,
+    lenderRewards: rewards.byLender,
+    rewardsByReserveToken: rewards.byReserveToken
+  };
 };
 var fetchGeneralYieldsByMarketUid = async () => {
-  const { intrinsicYields, lenderRewards } = await fetchGeneralYields();
+  const { intrinsicYields, lenderRewards, rewardsByReserveToken } = await fetchGeneralYields();
   return {
     intrinsicYields,
-    lenderRewards: flattenLenderRewards(lenderRewards)
+    lenderRewards: flattenLenderRewards(lenderRewards),
+    // Same rewards, un-flattened: the flatten above assumes a uid ends in the
+    // underlying address, which Aave V4 (reserve-id uids) breaks. Consumers
+    // with market nodes join (lender, underlying) off this instead.
+    rewardsByLenderAsset: lenderRewards,
+    // Left un-flattened for the same reason: turning a reserve token into a
+    // marketUid needs the market's own metadata, which only the consumer has.
+    rewardsByReserveToken
   };
 };
 var flattenLenderRewards = (input) => {
@@ -62540,8 +62614,9 @@ function borrowDescription(b) {
       "Liquidation here is triggered by TIME, not price \u2014 being late is the trigger, and being over-collateralised does not protect you."
     );
   } else if (b.liquidation.liquidationLtv != null) {
+    const pen = b.liquidation.penalty;
     parts.push(
-      `Liquidation starts at ${pct(b.liquidation.liquidationLtv * 100)} LTV, with a ${pct(b.liquidation.penalty * 100)} penalty.`
+      `Liquidation starts at ${pct(b.liquidation.liquidationLtv * 100)} LTV` + (pen != null ? `, with a ${pct(pen * 100)} penalty` : "") + "."
     );
   }
   return parts.join(" ");
@@ -63167,7 +63242,20 @@ function buildConstraints(input, siblings, acceptedCollateral) {
     }
   };
 }
-function liquidationFrom(cfg, input) {
+function marketLltv(input) {
+  const raw = input.market?.lltv;
+  if (raw == null) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  return n / 1e18;
+}
+function liquidationFrom(cfg, input, acceptedCollateral) {
+  const lltv = marketLltv(input);
+  const soleCollateral = acceptedCollateral?.count === 1 ? acceptedCollateral.items[0] : void 0;
+  const isolated = lltv != null || !hasCrossMarginRisk(input.lender) && soleCollateral != null;
+  const ownLtv = cfg?.borrowCollateralFactor;
+  const ownLiqLtv = cfg?.collateralFactor;
+  const ownPenalty = cfg?.liquidationPenalty;
   return {
     // The ordinary model: a liquidator repays part of the debt and takes
     // collateral plus a bonus. Adapters override for the four lenders where
@@ -63175,9 +63263,11 @@ function liquidationFrom(cfg, input) {
     model: "repay-seize",
     absorber: "liquidator",
     trigger: "price",
-    ltv: cfg?.borrowCollateralFactor,
-    liquidationLtv: cfg?.collateralFactor,
-    penalty: cfg?.liquidationPenalty ?? 0,
+    ltv: ownLtv || (isolated ? soleCollateral?.ltv ?? lltv : void 0) || ownLtv,
+    liquidationLtv: ownLiqLtv || (isolated ? soleCollateral?.liquidationLtv ?? lltv : void 0) || ownLiqLtv,
+    // No `?? 0` — see `LiquidationTerms.penalty`. An unknown penalty is
+    // undefined so the row is omitted rather than rendered as "+0%".
+    penalty: ownPenalty || (isolated ? soleCollateral?.liquidationPenalty : void 0) || ownPenalty,
     closeFactor: cfg?.closeFactor ?? input.closeFactor ?? 1,
     targetHealthFactor: cfg?.targetHealthFactor ?? input.targetHealthFactor,
     seizure: "proportional",
@@ -63204,7 +63294,8 @@ function buildModes(input) {
       liquidation: {
         ltv: c.borrowCollateralFactor,
         liquidationLtv: c.collateralFactor,
-        penalty: c.liquidationPenalty ?? 0,
+        // Same rule as the top-level penalty: unknown stays unknown.
+        penalty: c.liquidationPenalty,
         closeFactor: c.closeFactor ?? input.closeFactor ?? 1,
         targetHealthFactor: c.targetHealthFactor ?? input.targetHealthFactor
       },
@@ -63299,6 +63390,7 @@ function buildBorrow(input, now, siblings) {
   const rate = buildRate(input, "borrow");
   const maturity = buildMaturity(input, now);
   const fees = buildFees(input, "borrow");
+  const acceptedCollateral = buildExposures2(input, siblings, "accepted");
   const borrow = {
     rate,
     maturity,
@@ -63313,8 +63405,8 @@ function buildBorrow(input, now, siblings) {
       minDebt: resolveMinDebt(input),
       fees: fees.filter((f) => f.when === "exit" || f.when === "late")
     },
-    liquidation: liquidationFrom(cfg, input),
-    acceptedCollateral: buildExposures2(input, siblings, "accepted"),
+    liquidation: liquidationFrom(cfg, input, acceptedCollateral),
+    acceptedCollateral,
     modes: buildModes(input),
     fees,
     counterparty: { kind: "pool", solvency: "overcollateralized" },
@@ -64939,7 +65031,7 @@ function validateTermSheet(sheet) {
           "full-collateral seizure must surface a tag or an implication"
         );
     }
-    if (l.penalty < 0 || l.penalty > 1)
+    if (l.penalty != null && (l.penalty < 0 || l.penalty > 1))
       fail("penalty-range", `liquidation.penalty ${l.penalty} outside 0..1`);
     if (l.closeFactor <= 0 || l.closeFactor > 1)
       fail(