@1delta/margin-fetcher 5.0.8 → 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>;

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) => {