@1delta/margin-fetcher 5.0.8 → 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;
@@ -2299,11 +2351,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 +2398,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>;
@@ -3252,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;
 }
 
 /**
@@ -3504,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): {