@1delta/margin-fetcher 5.0.74 → 5.0.76

package/dist/index.js

@@ -21531,6 +21531,14 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
       // Midnight is fixed-rate: expose the fixed borrow APR on stableBorrowRate
       // too, so fixed-rate consumers pick it up like a term product.
       stableBorrowRate: borrowAprPct,
+      // The rate card is a BORROW-side fact, so it lives on the row that has a
+      // borrow side — natively, not by a consumer matching `loanAddress`
+      // against each row's asset. That match is what broke when the loan token
+      // was also a collateral leg: the leg row carries the same token, so it
+      // matched too and was served a "Fixed from X %" it cannot offer.
+      // `params.market.terms` still carries the same card for readers of the
+      // market-level shape; the collateral legs below never carry one.
+      terms,
       intrinsicYield: 0,
       rewards: void 0,
       decimals: config.loanDecimals,
@@ -48271,6 +48279,109 @@ var scrvusdFetcher = {
     };
   }
 };
+var SUSDAT = "0xd166337499e176bbc38a1fbd113ab144e5bd2df7";
+var DEFILLAMA_POOL = "47e72726-3b2b-4fe6-b4a9-a26e1fcd9a50";
+var YEAR_SECONDS11 = 31536e3;
+var STRC_UNIT = 1e6;
+var SUSDAT_KEY = "Saturn sUSDat::SUSDAT";
+var SUSDAT_BRIDGED_KEY = "Staked Saturn USD::sUSDat";
+var VAULT_ABI = [
+  {
+    name: "vestingAmount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "vestingPeriod",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "totalAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getStrcOracle",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+var STRC_ORACLE_ABI = [
+  {
+    name: "getPrice",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "price", type: "uint256" },
+      { name: "decimals", type: "uint8" }
+    ]
+  }
+];
+var decodeStrcPrice = (cell) => {
+  if (Array.isArray(cell) && cell.length >= 2) {
+    return { price: BigInt(cell[0]), priceDecimals: Number(cell[1]) };
+  }
+  if (cell && typeof cell === "object") {
+    const o = cell;
+    if (o.price !== void 0 && o.decimals !== void 0) {
+      return {
+        price: BigInt(o.price),
+        priceDecimals: Number(o.decimals)
+      };
+    }
+  }
+  throw new Error("sUSDat: unrecognised STRC oracle response shape");
+};
+var computeIncomeApr = async () => {
+  const [vestingAmount, vestingPeriod, totalAssets, oracle] = await multicallRetryUniversal({
+    chain: Chain.ETHEREUM_MAINNET,
+    abi: VAULT_ABI,
+    calls: [
+      { address: SUSDAT, name: "vestingAmount", params: [] },
+      { address: SUSDAT, name: "vestingPeriod", params: [] },
+      { address: SUSDAT, name: "totalAssets", params: [] },
+      { address: SUSDAT, name: "getStrcOracle", params: [] }
+    ],
+    allowFailure: false
+  });
+  if (vestingPeriod <= 0n || totalAssets <= 0n) {
+    throw new Error("sUSDat: empty vault or zero vesting period");
+  }
+  const [oracleCell] = await multicallRetryUniversal({
+    chain: Chain.ETHEREUM_MAINNET,
+    abi: STRC_ORACLE_ABI,
+    calls: [{ address: oracle, name: "getPrice", params: [] }],
+    allowFailure: false
+  });
+  const { price: price2, priceDecimals } = decodeStrcPrice(oracleCell);
+  if (price2 <= 0n) throw new Error("sUSDat: STRC oracle returned no price");
+  const strcPriceUsd = Number(price2) / 10 ** Number(priceDecimals);
+  const rewardUsd = Number(vestingAmount) / STRC_UNIT * strcPriceUsd;
+  const cyclesPerYear = YEAR_SECONDS11 / Number(vestingPeriod);
+  const tvlUsd = Number(totalAssets) / 1e6;
+  const apr = rewardUsd * cyclesPerYear / tvlUsd * 100;
+  if (!Number.isFinite(apr) || apr < 0) {
+    throw new Error("sUSDat: implausible income APR");
+  }
+  return apr;
+};
+var saturnFetcher = {
+  label: "SATURN_SUSDAT",
+  fetch: async () => {
+    const apr = await computeIncomeApr().catch(() => fetchDefiLlamaApy(DEFILLAMA_POOL)).catch(() => 0);
+    return { [SUSDAT_KEY]: apr, [SUSDAT_BRIDGED_KEY]: apr };
+  }
+};
 var thBill = "Theo Short Duration US Treasury Fund::THBILL";
 var thBillBare = "thBILL::thBILL";
 var THBILL_DEFILLAMA_POOL = "e17dab50-85b1-45e8-b4a5-b8ae7898c4a3";
@@ -48352,7 +48463,7 @@ var sthusdFetcher = {
   }
 };
 var RAY9 = 10n ** 27n;
-var YEAR_SECONDS11 = 31536e3;
+var YEAR_SECONDS12 = 31536e3;
 var DSR_ABI = [
   {
     name: "dsr",
@@ -48380,7 +48491,7 @@ var SUSDD_GROUP_KEY = "Savings Usdd::sUSDD";
 var aprFromDsr = (dsr) => {
   if (dsr <= RAY9) return 0;
   const perSecond = Number(dsr - RAY9) / 1e27;
-  return perSecond * YEAR_SECONDS11 * 100;
+  return perSecond * YEAR_SECONDS12 * 100;
 };
 var fetchChainDsr = async (chainId, pot) => {
   const [dsr] = await multicallRetryUniversal({
@@ -50557,6 +50668,102 @@ var VESPER_ENTRIES = {
     }
   ]
 };
+var VENUS_CORE_COMPTROLLER = "0xfd36e2c2a6789db23113685031d7f16329158384";
+var VENUS_RESILIENT_ORACLE = "0x6592b5de802159f3e74b2486b091d11a8256ab8a";
+var XVS = "0xcf6bb5389c92bdda8a3747ddb454cb7a64626c63";
+var hubBase = {
+  reader: "venus-hub",
+  brand: "Venus",
+  // Share decimals are 24 — `decimalsOffset(6)` on an 18-decimal underlying.
+  // Getting this wrong is silent: the exchange rate reads 1e-6 of par.
+  decimals: 24,
+  underlyingDecimals: 18,
+  isRebasing: false,
+  isMintable: true,
+  withdrawalMode: "instant-capped",
+  // Asserted, not assumed — every leg is collateral-backed with an on-chain
+  // liquidation threshold, incl. the FRV one whose docs read like unsecured
+  // credit. See the note above for the live ratios and the two qualifications
+  // that live in the descriptions instead.
+  solvency: "overcollateralized"
+  // No `yieldFetcher`: the rate is the groups' TVL-weighted `spotAPYBps()`,
+  // which the reader computes from the same block's `totalAssets()` reads.
+  // There is nothing off-chain to fall back to — the Hub publishes no APY
+  // view by design, `api.venus.io` has no Hub route, and DefiLlama carries
+  // only `venus-core-pool` / `venus-flux` pools.
+};
+var EXIT_PROSE = "Exits are same-transaction and free, but capped at the liquid legs: anything sitting in a Fixed-Rate Vault is locked until it matures, typically a 30-day term.";
+var BACKING_PROSE = "Every leg is overcollateralised, though not all of it is Venus: Flux lends through third-party Fluid, and a Fixed-Rate Vault is one institutional borrower posting custodial or real-world-asset collateral rather than a pool.";
+var VENUS_HUB_ENTRIES = {
+  [Chain.BNB_SMART_CHAIN_MAINNET]: [
+    {
+      ...hubBase,
+      address: "0x18afdacf30f8671021dec4b78297e39d2fe87226",
+      underlying: "0x55d398326f99059ff775485246999027b3197955",
+      symbol: "vhUSDT",
+      description: `Venus's USDT Liquidity Hub cascades one deposit across Venus Core lending, Fluid and Venus Fixed-Rate Vaults; the share price is the blend. ${EXIT_PROSE} ${BACKING_PROSE}`,
+      venusHub: {
+        yieldGroups: [
+          "0xc9e6ced9589363f8dc5695be2c79ab4ddaecc94b",
+          "0xe3df38e12e37ed80e1b3ccf2bdf84f9e1527ce14",
+          "0x621ef38ce0c4e7060ff0bf3d609e3d46ec144be7"
+        ],
+        core: {
+          yieldGroup: "0xc9e6ced9589363f8dc5695be2c79ab4ddaecc94b",
+          vToken: "0xfd5840cd36d94d7229439859c0112a4185bc0255",
+          comptroller: VENUS_CORE_COMPTROLLER,
+          oracle: VENUS_RESILIENT_ORACLE,
+          rewardToken: XVS
+        }
+      }
+    },
+    {
+      ...hubBase,
+      address: "0x9d2d9592cf8dfbf59107faab703d08494be14617",
+      underlying: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
+      symbol: "vhUSDC",
+      description: `Venus's USDC Liquidity Hub cascades one deposit across Venus Core lending, Fluid and Venus Fixed-Rate Vaults; the share price is the blend. ${EXIT_PROSE} ${BACKING_PROSE}`,
+      venusHub: {
+        yieldGroups: [
+          "0x299d9be7cefff91c68f13f267d525cfc18e965ef",
+          "0xa65bb4b20542268b64cf08871a98d75342afe927",
+          "0x438388847ee16850ab4f5b82dc7954c0d043b716"
+        ],
+        core: {
+          yieldGroup: "0x299d9be7cefff91c68f13f267d525cfc18e965ef",
+          vToken: "0xeca88125a5adbe82614ffc12d0db554e2e2867c8",
+          comptroller: VENUS_CORE_COMPTROLLER,
+          oracle: VENUS_RESILIENT_ORACLE,
+          rewardToken: XVS
+        }
+      }
+    },
+    {
+      ...hubBase,
+      address: "0x0e5aa174d4f31b757a237eb1999de151596788b0",
+      underlying: "0xce24439f2d9c6a2289f741120fe202248b666666",
+      symbol: "vhU",
+      description: `Venus's Liquidity Hub for U (United Stables) cascades one deposit across Venus Core lending, Fluid and Venus Fixed-Rate Vaults; the share price is the blend. ${EXIT_PROSE} ${BACKING_PROSE}`,
+      venusHub: {
+        yieldGroups: [
+          "0x8a680f77a5367fa7cd33a02f51896cb1d55159c3",
+          "0xe31b8851c3fa9b3dd39a04a2ed9493869a410616",
+          "0x30908eddb9e94add7ac9944a0adda66d80b89143"
+        ],
+        core: {
+          yieldGroup: "0x8a680f77a5367fa7cd33a02f51896cb1d55159c3",
+          vToken: "0x3d5e269787d562b74acc55f18bd26c5d09fa245e",
+          comptroller: VENUS_CORE_COMPTROLLER,
+          oracle: VENUS_RESILIENT_ORACLE,
+          rewardToken: XVS
+        }
+      }
+    }
+  ]
+};
+({
+  [Chain.BNB_SMART_CHAIN_MAINNET]: "0x6d93fd479f2d37445cfbe132412e316a0364acc2"
+});
 
 // src/vaults/savings/registry.ts
 var stUsdGroup = {
@@ -51247,6 +51454,68 @@ var SINGLE_CHAIN_ENTRIES = {
       yieldFetcher: apyxFetcher,
       yieldKey: APYUSD_KEY
     },
+    // ---- Saturn (saturn.credit) — USDat / sUSDat ----------------------
+    //
+    // `USDat` is an M^0 extension token (a wrapped `$M` claim on tokenized
+    // Treasuries) and `sUSDat` is the vault that stakes it into **Strategy's
+    // STRC**, the variable-rate perpetual preferred stock, passing the
+    // dividend through. Ethereum only: the same addresses on BNB (56) and
+    // Monad (143) are bare LayerZero OFT mirrors whose entire 4626 surface
+    // reverts, so staking round-trips to mainnet (the Cap / Apyx / Brix
+    // precedent) — Monad nevertheless holds $31.1M of USDat.
+    //
+    // Registered `volatile`, and the reason is the whole assessment.
+    // `totalAssets = usdatBalance + (strcBalance − unvested) × STRC price`,
+    // and 96.5 % of NAV is STRC held outright — 723,435.68 STRC against just
+    // $2.55M of actual USDat, with the implied $97.8893 matching Chainlink
+    // STRC/USD to 0.01 %. So the solvency invariant is genuinely on-chain and
+    // checkable (better than Spark V2 / Maple / Native, none of which can be),
+    // and the share price nonetheless moves with a preferred stock. The income
+    // leg is real and clockwork — 50 `transferInRewards` distributions over
+    // 152.3 days at a 3.11-day cadence, 12.19 % APR, which is what DefiLlama's
+    // 15.58 % and Saturn's "11 %+" both measure — while the vault's whole life
+    // returned **+3.73 % with a −22.82 % max drawdown**. The rate published
+    // here is the REALIZED one; see `saturnFetcher` for why there is no
+    // DefiLlama fallback.
+    //
+    // NOT `secondaryMarketOnly`, and the fork test is why. USDat's own mint is
+    // whitelist-gated (`isWhitelistEnabled()` true, `isAllowedToWrap(<random
+    // EOA>)` false) — but that is a fact about the UNDERLYING, one level below
+    // this row. STAKING is permissionless: `maxDeposit` is `uint256.max`,
+    // `_deposit` consults no allowlist, and a fork deposit from an
+    // unwhitelisted account mints at par. Marking the vault
+    // `secondaryMarketOnly` made `/v1/actions/vaults/deposit` refuse a mint
+    // that works, which is the Brix trap inverted — there a `maxDeposit` of
+    // `uint.max` hid a gate, here a gate on a neighbouring contract hid an
+    // open door. Acquiring the USDat is an ordinary swap (the Curve pool
+    // round-trips 100k at −3 bps with USDat at $0.9997), i.e. a routing
+    // question, not a property of this vault.
+    //
+    // Exit is `request-based` and there is exactly one protocol route:
+    // `requestRedeem(shares, minUsdat)` escrows the shares and mints an
+    // ERC-721 receipt, a `PROCESSOR_ROLE` batch sells STRC, then `claim`.
+    // Measured latency ~24-25 h (Saturn documents 3-7 days) — pinned at 24 h
+    // here and NOT read on-chain, because nothing on the queue publishes it:
+    // it is an operator cadence, not a dial. Verified on-chain 2026-09-10.
+    {
+      reader: "saturn-vault",
+      address: "0xd166337499e176bbc38a1fbd113ab144e5bd2df7",
+      underlying: "0x23238f20b894f29041f48d88ee91131c395aaa71",
+      // USDat
+      symbol: "sUSDat",
+      brand: "Saturn",
+      solvency: "overcollateralized",
+      description: "Saturn's staking vault: deposited USDat (a dollar backed by tokenized Treasuries) buys Strategy's STRC preferred stock, whose dividend is paid in every three days. Almost all the backing is that one stock, marked to market \u2014 so the share price falls when STRC does, and it has: a ~12% dividend over the first five months still returned only 3.7% annualised, after a 22.8% drawdown. Leaving is a request a Saturn operator settles in about a day by selling STRC, paying what that sale realises rather than the share price on the day you asked.",
+      decimals: 18,
+      underlyingDecimals: 6,
+      isRebasing: false,
+      isMintable: true,
+      withdrawalMode: "request-based",
+      withdrawalCooldownSeconds: 86400,
+      withdrawQueue: "0x4bc9fec04f0f95e9b42a3ef18f3c96fb57923d2e",
+      yieldFetcher: saturnFetcher,
+      yieldKey: SUSDAT_KEY
+    },
     // ---- Strata (docs.strata.markets) — senior/junior risk tranches ----
     //
     // Six CDO markets, twelve ERC-4626 tranche tokens, all Ethereum.
@@ -51255,7 +51524,8 @@ var SINGLE_CHAIN_ENTRIES = {
     // the senior earns a benchmark-floored rate (its `maxDeposit` is
     // coverage-cap-gated), the junior takes the residual — levered
     // upside AND first-loss capital (jrUSDat marked down to ~0.36
-    // absorbing the 2026-07 USDat depeg; junior redemptions pause when
+    // absorbing the 2026-06/07 sUSDat drawdown — the SATURN VAULT fell
+    // 22.8 %, USDat itself never lost its peg; junior redemptions pause when
     // senior coverage drops below the market's minimum). Exits are
     // two-legged and both escrow through the market's cooldown
     // contracts, claimed via `finalize`: redeeming into the collateral
@@ -51419,7 +51689,7 @@ var SINGLE_CHAIN_ENTRIES = {
       symbol: "srUSDat",
       solvency: "tranched-senior",
       brand: "Strata",
-      description: "Strata's senior tranche over Saturn USDat (a Strategy-preferred-stock-backed dollar): fixed yield at 65% of the STRC dividend rate, junior-protected \u2014 the senior held its rate straight through the 2026-07 USDat depeg that the junior absorbed. Exits claim through cooldown contracts (the sUSDat leg effectively instant) minus a 0\u20135 bps fee.",
+      description: "Strata's senior tranche over Saturn USDat (a Strategy-preferred-stock-backed dollar): fixed yield at 65% of the STRC dividend rate, junior-protected \u2014 the senior held its rate straight through the 2026-06/07 sUSDat drawdown that the junior absorbed. Exits claim through cooldown contracts (the sUSDat leg effectively instant) minus a 0\u20135 bps fee.",
       decimals: 18,
       underlyingDecimals: 6,
       isRebasing: false,
@@ -51436,7 +51706,7 @@ var SINGLE_CHAIN_ENTRIES = {
       symbol: "jrUSDat",
       solvency: "tranched-junior",
       brand: "Strata",
-      description: "Strata's junior tranche over Saturn USDat \u2014 first-loss capital that proved it: the 2026-07 USDat collateral depeg marked jrUSDat down to ~0.36 while the senior stayed whole, and its trailing APR is depeg-recovery-inflated. Exits claim through cooldown contracts and pause while senior coverage is below the market minimum.",
+      description: "Strata's junior tranche over Saturn USDat \u2014 first-loss capital that proved it: the 2026-06/07 drawdown in the collateral \u2014 Saturn's sUSDat vault, which is marked to Strategy's STRC preferred stock and fell 22.8%; USDat itself held its peg \u2014 marked jrUSDat down to ~0.36 while the senior stayed whole, and its trailing APR is recovery-inflated. Exits claim through cooldown contracts and pause while senior coverage is below the market minimum.",
       decimals: 18,
       underlyingDecimals: 6,
       isRebasing: false,
@@ -52433,6 +52703,10 @@ var SAVINGS_REGISTRY = (() => {
     if (!out[chainId]) out[chainId] = [];
     out[chainId].push(...entries);
   }
+  for (const [chainId, entries] of Object.entries(VENUS_HUB_ENTRIES)) {
+    if (!out[chainId]) out[chainId] = [];
+    out[chainId].push(...entries);
+  }
   return out;
 })();
 var savingsBalanceKind = (chainId, address) => {
@@ -64066,9 +64340,24 @@ var queuedRoute = (i) => ({
   kind: "queued",
   label: asyncLabel(i.withdrawalCooldownSeconds),
   settlement: "async",
-  waitSeconds: i.withdrawalCooldownSeconds
+  waitSeconds: i.withdrawalCooldownSeconds,
+  ...i.exitMinAmount !== void 0 ? {
+    minAmount: i.exitMinAmount,
+    minAmountFormatted: i.exitMinAmountFormatted
+  } : {}
+});
+var marketRoute = () => ({
+  id: "market",
+  kind: "market",
+  label: "Sell on the market",
+  settlement: "market",
+  description: "The protocol's own mint and redeem are permissioned, so for a holder without that permission this is the route: sell the share token at whatever the book bids, with price impact that grows with size. It fills at the MARKET price, which is not the row's `exchangeRate` \u2014 that stays the NAV \u2014 so the leg must be built with a slippage bound."
 });
 var deriveExitRoutes = (i) => {
+  const routes2 = deriveProtocolExitRoutes(i);
+  return i.secondaryMarketOnly ? [...routes2, marketRoute()] : routes2;
+};
+var deriveProtocolExitRoutes = (i) => {
   switch (i.withdrawalMode) {
     // The instant leg pays the fee; the queue pays at par. That is the
     // convention `SavingsVault.withdrawFeeBps` already documents — and
@@ -68473,6 +68762,166 @@ var YieldBasisAmmReadAbi = [
   }
 ];
 
+// src/vaults/savings/abis/venusHub.ts
+var VenusHubReadAbi = [
+  {
+    name: "maxDeposit",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "hubPaused",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "maxWithdrawalSize",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "redeemFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint16" }]
+  },
+  {
+    name: "registeredYieldGroups",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address[]" }]
+  }
+];
+var VenusYieldGroupReadAbi = [
+  {
+    name: "maxWithdraw",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "totalAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "spotAPYBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint64" }]
+  },
+  {
+    name: "blocksPerYear",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "resources",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address[]" }]
+  }
+];
+var VenusComptrollerRewardsAbi = [
+  {
+    name: "venusSupplySpeeds",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "oracle",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  }
+];
+var VenusResilientOracleAbi = [
+  {
+    name: "getPrice",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "getUnderlyingPrice",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var VTokenSizeReadAbi = [
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "exchangeRateStored",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "comptroller",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  }
+];
+
+// src/vaults/savings/abis/saturn.ts
+var SaturnMinWithdrawalAbi = [
+  {
+    name: "MIN_WITHDRAWAL",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var SaturnDepositFeeAbi = [
+  {
+    name: "depositFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var SaturnPreviewDepositAbi = [
+  {
+    name: "previewDeposit",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "assets", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+
 // src/vaults/savings/readers/erc4626Idle.ts
 var readerErc4626Idle = (entry) => {
   const shareUnit = 10n ** BigInt(entry.decimals);
@@ -68905,6 +69354,208 @@ var readerNativeWnlp = (entry) => {
   };
 };
 
+// src/vaults/savings/readers/saturn.ts
+var readerSaturnVault = (entry) => {
+  const shareUnit = 10n ** BigInt(entry.decimals);
+  const underlyingUnit = 10n ** BigInt(entry.underlyingDecimals ?? entry.decimals);
+  return {
+    calls: [
+      { address: entry.address, name: "totalAssets", params: [] },
+      { address: entry.address, name: "totalSupply", params: [] },
+      { address: entry.address, name: "convertToAssets", params: [shareUnit] },
+      {
+        address: entry.address,
+        name: "previewDeposit",
+        params: [underlyingUnit]
+      },
+      { address: entry.address, name: "depositFeeBps", params: [] },
+      { address: entry.address, name: "MIN_WITHDRAWAL", params: [] }
+    ],
+    abis: [
+      Erc4626ReadAbi2,
+      TotalSupplyAbi2,
+      Erc4626ReadAbi2,
+      SaturnPreviewDepositAbi,
+      SaturnDepositFeeAbi,
+      SaturnMinWithdrawalAbi
+    ],
+    parse: ([assets, supply, rate, previewShares, feeBps, minWithdrawal]) => {
+      const totalAssets = toBigInt15(assets);
+      const totalSupply = toBigInt15(supply);
+      const convertToAssetsRaw = toBigInt15(rate);
+      if (totalAssets === void 0 || totalSupply === void 0 || convertToAssetsRaw === void 0) {
+        return void 0;
+      }
+      const entryShares = toBigInt15(previewShares);
+      const depositFeeBps = toBigInt15(feeBps);
+      const exitMinAmount = toBigInt15(minWithdrawal);
+      return {
+        totalAssets,
+        totalSupply,
+        exchangeRate: convertToAssetsRaw * ONE_E1814 / underlyingUnit,
+        // Shares minted for ONE underlying unit, net of the fee. Equals the
+        // derived `1/exchangeRate` while the dial is 0, and diverges the
+        // moment it is not.
+        convertToShares: entryShares,
+        depositFeeBps: depositFeeBps !== void 0 ? Number(depositFeeBps) : void 0,
+        exitMinAmount
+      };
+    }
+  };
+};
+
+// src/vaults/savings/readers/venusHub.ts
+var NEUTRAL_PROBE2 = "0x000000000000000000000000000000000000dead";
+var BPS_TO_PCT = 100;
+var readerVenusHub = (entry) => {
+  const shareUnit = 10n ** BigInt(entry.decimals);
+  const underlyingUnit = 10n ** BigInt(entry.underlyingDecimals ?? entry.decimals);
+  const cfg = entry.venusHub;
+  const groups = cfg?.yieldGroups ?? [];
+  const coreGroup = cfg?.core?.yieldGroup;
+  const calls = [
+    { address: entry.address, name: "totalAssets", params: [] },
+    { address: entry.address, name: "totalSupply", params: [] },
+    { address: entry.address, name: "convertToAssets", params: [shareUnit] },
+    { address: entry.address, name: "maxDeposit", params: [NEUTRAL_PROBE2] },
+    { address: entry.address, name: "hubPaused", params: [] },
+    { address: entry.address, name: "maxWithdrawalSize", params: [] },
+    { address: entry.address, name: "redeemFeeBps", params: [] },
+    { address: entry.underlying, name: "balanceOf", params: [entry.address] }
+  ];
+  const abis = [
+    Erc4626ReadAbi2,
+    TotalSupplyAbi2,
+    Erc4626ReadAbi2,
+    VenusHubReadAbi,
+    VenusHubReadAbi,
+    VenusHubReadAbi,
+    VenusHubReadAbi,
+    BalanceOfAbi
+  ];
+  for (const group of groups) {
+    calls.push({ address: group, name: "maxWithdraw", params: [] });
+    calls.push({ address: group, name: "totalAssets", params: [] });
+    calls.push({ address: group, name: "spotAPYBps", params: [] });
+    abis.push(
+      VenusYieldGroupReadAbi,
+      VenusYieldGroupReadAbi,
+      VenusYieldGroupReadAbi
+    );
+  }
+  const emissionCallCount = cfg?.core ? 6 : 0;
+  if (cfg?.core) {
+    const { yieldGroup, vToken, comptroller, oracle, rewardToken } = cfg.core;
+    calls.push({ address: yieldGroup, name: "blocksPerYear", params: [] });
+    calls.push({
+      address: comptroller,
+      name: "venusSupplySpeeds",
+      params: [vToken]
+    });
+    calls.push({ address: oracle, name: "getPrice", params: [rewardToken] });
+    calls.push({
+      address: oracle,
+      name: "getUnderlyingPrice",
+      params: [vToken]
+    });
+    calls.push({ address: vToken, name: "totalSupply", params: [] });
+    calls.push({ address: vToken, name: "exchangeRateStored", params: [] });
+    abis.push(
+      VenusYieldGroupReadAbi,
+      VenusComptrollerRewardsAbi,
+      VenusResilientOracleAbi,
+      VenusResilientOracleAbi,
+      VTokenSizeReadAbi,
+      VTokenSizeReadAbi
+    );
+  }
+  return {
+    calls,
+    abis,
+    parse: (slice2) => {
+      const totalAssets = toBigInt15(slice2[0]);
+      const totalSupply = toBigInt15(slice2[1]);
+      const convertToAssetsRaw = toBigInt15(slice2[2]);
+      if (totalAssets === void 0 || totalSupply === void 0 || convertToAssetsRaw === void 0) {
+        return void 0;
+      }
+      const paused = slice2[4] === true;
+      const maxWithdrawalSize = toBigInt15(slice2[5]);
+      const redeemFeeBps = toBigInt15(slice2[6]);
+      const idle = toBigInt15(slice2[7]);
+      const depositCapacity = toBigInt15(slice2[3]);
+      let groupLiquid = 0n;
+      let weightedBps = 0n;
+      let rateWeight = 0n;
+      let coreGroupAssets = 0n;
+      let groupsOk = groups.length > 0;
+      for (let i = 0; i < groups.length; i++) {
+        const base = 8 + i * 3;
+        const liquid = toBigInt15(slice2[base]);
+        const assets = toBigInt15(slice2[base + 1]);
+        const apyBps = toBigInt15(slice2[base + 2]);
+        if (liquid === void 0 || assets === void 0 || apyBps === void 0) {
+          groupsOk = false;
+          continue;
+        }
+        if (groups[i] === coreGroup) coreGroupAssets = assets;
+        groupLiquid += liquid;
+        weightedBps += apyBps * assets;
+        rateWeight += assets;
+      }
+      let instantRedeemCapacity;
+      if (groupsOk && idle !== void 0) {
+        const aggregate = groupLiquid + idle;
+        instantRedeemCapacity = maxWithdrawalSize !== void 0 && maxWithdrawalSize < aggregate ? maxWithdrawalSize : aggregate;
+      }
+      const supplyRate = rateWeight > 0n ? Number(weightedBps * 1000000n / rateWeight) / 1e6 / BPS_TO_PCT : void 0;
+      return {
+        totalAssets,
+        totalSupply,
+        exchangeRate: convertToAssetsRaw * ONE_E1814 / underlyingUnit,
+        ...supplyRate !== void 0 ? { supplyRate } : {},
+        ...instantRedeemCapacity !== void 0 ? {
+          instantRedeemCapacity: paused ? 0n : instantRedeemCapacity,
+          instantRedeemEnabled: !paused,
+          // Retained in the vault rather than paid out, and 0 on every
+          // live Hub — but it IS deducted from a redeemer's payout, so
+          // it belongs on the same field every other two-legged row uses.
+          withdrawFeeBps: redeemFeeBps !== void 0 ? Number(redeemFeeBps) : 0
+        } : {},
+        ...depositCapacity !== void 0 ? { depositCapacity } : {},
+        ...cfg?.core ? {
+          strandedRewardsRate: parseStrandedRewards(
+            slice2,
+            calls.length - emissionCallCount,
+            coreGroupAssets,
+            totalAssets
+          )
+        } : {}
+      };
+    }
+  };
+};
+var parseStrandedRewards = (slice2, base, coreGroupAssets, hubTotalAssets) => {
+  const blocksPerYear = toBigInt15(slice2[base]);
+  const supplySpeed = toBigInt15(slice2[base + 1]);
+  const rewardPrice = toBigInt15(slice2[base + 2]);
+  const underlyingPrice = toBigInt15(slice2[base + 3]);
+  const vTokenSupply = toBigInt15(slice2[base + 4]);
+  const exchangeRateStored = toBigInt15(slice2[base + 5]);
+  if (blocksPerYear === void 0 || supplySpeed === void 0 || rewardPrice === void 0 || underlyingPrice === void 0 || vTokenSupply === void 0 || exchangeRateStored === void 0) {
+    return void 0;
+  }
+  if (supplySpeed === 0n) return 0;
+  const rewardsPerYearUsd = supplySpeed * blocksPerYear * rewardPrice;
+  const suppliedRaw = vTokenSupply * exchangeRateStored / ONE_E1814;
+  const suppliedUsd = suppliedRaw * underlyingPrice;
+  if (suppliedUsd === 0n || hubTotalAssets === 0n) return void 0;
+  const marketAprPct = Number(rewardsPerYearUsd * 1000000000n / suppliedUsd) / 1e9;
+  const hubShare = Number(coreGroupAssets * 1000000000n / hubTotalAssets) / 1e9;
+  const scale3 = hubShare > 1 ? 1 : hubShare;
+  return marketAprPct * scale3 * 100;
+};
+
 // src/vaults/savings/readers/vesperPool.ts
 var readerVesperPool = (entry) => {
   const underlyingUnit = 10n ** BigInt(entry.underlyingDecimals ?? entry.decimals);
@@ -69038,6 +69689,10 @@ var buildReader2 = (entry) => {
       return readerWrenNav(entry);
     case "vesper-pool":
       return readerVesperPool(entry);
+    case "venus-hub":
+      return readerVenusHub(entry);
+    case "saturn-vault":
+      return readerSaturnVault(entry);
     case "erc4626-cooldown":
       return readerErc4626Cooldown(entry);
     case "erc4626-idle":
@@ -69090,7 +69745,7 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
     const underlyingLc = entry.underlying.toLowerCase();
     const asset = tokenList[underlyingLc];
     const priceUsd = prices[underlyingLc];
-    const supplyRate = aprByAddress[addressLc] ?? 0;
+    const supplyRate = state.supplyRate ?? aprByAddress[addressLc] ?? 0;
     const rewardsRate = 0;
     const depositRate = supplyRate + rewardsRate;
     const shareDec = entry.decimals;
@@ -69112,7 +69767,7 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       Number(liquidityAmount * 1000000n / state.totalAssets) / 1e6
     ) : 1;
     const convertToAssets = state.exchangeRate * underlyingUnit / ONE_E1815;
-    const convertToShares = state.exchangeRate > 0n ? ONE_E1815 * shareUnit / state.exchangeRate : 0n;
+    const convertToShares = state.convertToShares ?? (state.exchangeRate > 0n ? ONE_E1815 * shareUnit / state.exchangeRate : 0n);
     const depositCapacity = state.depositCapacity?.toString();
     const depositCapacityFormatted = state.depositCapacity !== void 0 ? Number(state.depositCapacity) / 10 ** underlyingDec : void 0;
     const depositCapacityUsd = depositCapacityFormatted !== void 0 && priceUsd !== void 0 ? depositCapacityFormatted * priceUsd : void 0;
@@ -69148,6 +69803,9 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       supplyRate,
       rewardsRate,
       depositRate,
+      // NOT part of `depositRate` — it is the incentive the vault's position
+      // earns and the depositor does not. See the field's docstring.
+      strandedRewardsRate: state.strandedRewardsRate,
       // Opt-IN, not opt-out: a new bespoke reader exists precisely
       // because its token is not a conforming vault, so the default for
       // an unlisted reader must be `false`. `erc4626-idle`,
@@ -69156,7 +69814,11 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       // limit view / the exit lock), so they count; Native's wNLP and Re's
       // NAV-oracle tokens revert on
       // `asset()`/`totalAssets()`/`convertToAssets()` and do not.
-      isErc4626: entry.reader === void 0 || entry.reader === "erc4626" || entry.reader === "erc4626-cooldown" || entry.reader === "erc4626-idle" || entry.reader === "erc4626-withdraw-limit" || // hbfUSD / pbfUSD ARE conforming 4626 — the bespoke reader exists for
+      isErc4626: entry.reader === void 0 || entry.reader === "erc4626" || entry.reader === "erc4626-cooldown" || entry.reader === "erc4626-idle" || entry.reader === "erc4626-withdraw-limit" || // Venus's Liquidity Hub IS a conforming 4626 on every leg
+      // (`deposit(assets, receiver)`, `redeem(shares, receiver, owner)`);
+      // the bespoke reader exists for the FRV lock, the rate blend and the
+      // emission read, not because the standard surface is missing.
+      entry.reader === "venus-hub" || // hbfUSD / pbfUSD ARE conforming 4626 — the bespoke reader exists for
       // the epoch ledger and the share-denominated supply cap, not because
       // the standard surface is missing. bfBTC (`bitfi-bfbtc`) is the
       // opposite and correctly falls through to `false`.
@@ -69172,6 +69834,7 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       // queue window is per-asset and governance-mutable.
       withdrawalCooldownSeconds: state.withdrawalCooldownSeconds ?? entry.withdrawalCooldownSeconds,
       withdrawFeeBps: state.withdrawFeeBps,
+      depositFeeBps: state.depositFeeBps,
       // Term-sheet inputs that no reader can derive — see the registry's
       // docstrings. Passed through verbatim so the sheet can stop hardcoding
       // "compounds per second" and "needs an approval" for every vault.
@@ -69196,7 +69859,13 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
           withdrawalCooldownSeconds: state.withdrawalCooldownSeconds ?? entry.withdrawalCooldownSeconds,
           liquidity: liquidityRaw,
           liquidityFormatted,
-          liquidityUsd
+          liquidityUsd,
+          // The floor that decides whether a single-route exit is reachable.
+          exitMinAmount: state.exitMinAmount?.toString(),
+          exitMinAmountFormatted: state.exitMinAmount !== void 0 ? Number(state.exitMinAmount) / 10 ** underlyingDec : void 0,
+          // Adds the `market` leg — the only route a holder without the
+          // protocol's mint/redeem permission actually has.
+          secondaryMarketOnly: entry.secondaryMarketOnly
         }),
         resolveSelfOnly(chainId, entry.address)
       ),
@@ -70251,8 +70920,20 @@ var VOLATILE_VAULT_OVERRIDES = /* @__PURE__ */ new Set([
   // yb-cbBTC
   "1-0x771f7290428d830ecd41e980745c327e507823ec",
   // yb-tBTC
-  "1-0x2b9c9f3bdceb5d8e36a4704f08a78fca53343cea"
+  "1-0x2b9c9f3bdceb5d8e36a4704f08a78fca53343cea",
   // yb-WETH
+  // Saturn sUSDat — a savings vault whose assets are 96.5 % Strategy's STRC
+  // preferred stock, held outright and MARKED to an oracle
+  // (`totalAssets = usdatBalance + (strcBalance − unvested) × price`). Unlike
+  // Yield Basis this one has a real, clockwork income leg — 50
+  // `transferInRewards` distributions on a 3.11-day cadence, 12.19 % APR
+  // measured over 152 days, which is what DefiLlama's 15.58 % reports — and it
+  // is still not a yield-bearing row, because the mark moves further than the
+  // coupon does. Over the vault's whole life: +3.73 % realized APR, −22.82 %
+  // max drawdown (1.00954 on 2026-05-15 → 0.77915 on 2026-06-28), 33 % of
+  // two-day samples negative. See SATURN.md.
+  "1-0xd166337499e176bbc38a1fbd113ab144e5bd2df7"
+  // sUSDat
 ]);
 var STABLECOIN_SYMBOLS = /* @__PURE__ */ new Set([
   // USD majors
@@ -70348,6 +71029,12 @@ var STABLECOIN_SYMBOLS = /* @__PURE__ */ new Set([
   "USG",
   "BOB"
 ]);
+var STABLECOIN_UNDERLYING_OVERRIDES = /* @__PURE__ */ new Set([
+  // United Stables (`U`) — a USD stablecoin on BNB Chain, a Venus Core market
+  // and the underlying of the vhU Liquidity Hub. Priced at $0.999 by Venus's
+  // own ResilientOracle.
+  "56-0xce24439f2d9c6a2289f741120fe202248b666666"
+]);
 var normalizeSymbol = (s) => (s ?? "").trim().toUpperCase();
 var isStablecoinSymbol = (symbol) => {
   const s = normalizeSymbol(symbol);
@@ -70358,7 +71045,8 @@ var isStablecoinSymbol = (symbol) => {
 var classifyVault = (input) => {
   const key3 = `${input.chainId}-${input.address.toLowerCase()}`;
   const yieldProfile2 = VOLATILE_VAULT_OVERRIDES.has(key3) || VOLATILE_PROVIDERS.has(input.provider) ? "volatile" : "yield-bearing";
-  const denomination2 = isStablecoinSymbol(input.underlyingSymbol) ? "stable" : "volatile";
+  const underlyingKey = input.underlyingAddress !== void 0 ? `${input.chainId}-${input.underlyingAddress.toLowerCase()}` : void 0;
+  const denomination2 = underlyingKey !== void 0 && STABLECOIN_UNDERLYING_OVERRIDES.has(underlyingKey) || isStablecoinSymbol(input.underlyingSymbol) ? "stable" : "volatile";
   return { yieldProfile: yieldProfile2, denomination: denomination2 };
 };
 var stampVaultClassification = (data, chainId, tokenList = {}) => {
@@ -70379,7 +71067,8 @@ var stampVaultClassification = (data, chainId, tokenList = {}) => {
         provider,
         chainId,
         address: v.address,
-        underlyingSymbol: v.asset?.symbol ?? v.symbol
+        underlyingSymbol: v.asset?.symbol ?? v.symbol,
+        underlyingAddress: v.underlying
       });
       v.yieldProfile = c.yieldProfile;
       v.denomination = c.denomination;
@@ -72110,7 +72799,7 @@ var readVaultSharePrices = async (chainId, addresses, multicallRetry) => {
 };
 
 // src/vaults/yield/annualize.ts
-var YEAR_SECONDS12 = 365 * 24 * 60 * 60;
+var YEAR_SECONDS13 = 365 * 24 * 60 * 60;
 var SCALE = 10n ** 18n;
 var appendSnapshot = (points, snap, options) => {
   const maxPoints = options?.maxPoints ?? 90;
@@ -72139,7 +72828,7 @@ var computeVaultApr = (points, options) => {
   if (pThen === 0n) return void 0;
   const ratioScaled = BigInt(now.p) * SCALE / pThen;
   const ratio = Number(ratioScaled) / 1e18;
-  const apr = (ratio - 1) * (YEAR_SECONDS12 / windowSeconds);
+  const apr = (ratio - 1) * (YEAR_SECONDS13 / windowSeconds);
   return {
     apr,
     sharePriceNow: now.p,