@1delta/margin-fetcher 5.0.108 → 5.0.110

package/dist/index.js

@@ -49133,6 +49133,33 @@ var sthusdFetcher = {
     };
   }
 };
+
+// src/yields/intrinsic/fetchers/usual.ts
+var USDZEROPLUS_URL = "https://app.usual.money/api/rewards/rates/USD0++";
+var ETHZERO_URL = "https://app.usual.money/api/rewards/rates/ETH0";
+var BUSD0_KEY = "Staked USD0::USD0++";
+var usdZeroPlus = BUSD0_KEY;
+var ethZero = "ETH0::ETH0";
+var usdZeroPlusFetcher = {
+  label: "USDZEROPLUS",
+  fetch: async () => {
+    const res = await fetch(USDZEROPLUS_URL, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    }).then((r) => r.json());
+    return { [usdZeroPlus]: Number(res?.rewards[0]?.apr ?? 0) * 100 };
+  }
+};
+var ethZeroFetcher = {
+  label: "ETHZERO",
+  fetch: async () => {
+    const res = await fetch(ETHZERO_URL, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    }).then((r) => r.json());
+    return { [ethZero]: Number(res?.rewards[0]?.apr ?? 0) * 100 };
+  }
+};
 var CHAIN_ID14 = Chain.ETHEREUM_MAINNET;
 var HUMA_PST_FEED = "0x4be50be32db1510240d542f77c5b36ca0d0965e6";
 var HUMA_PST_KEY = "HUMA::PST";
@@ -52479,6 +52506,50 @@ var SINGLE_CHAIN_ENTRIES = {
       yieldFetcher: saturnFetcher,
       yieldKey: SUSDAT_KEY
     },
+    // ---- Usual (usual.money) — bUSD0, Bond USD0 (ex-USD0++) ------------
+    //
+    // A fixed-maturity BOND over USD0, not a staked stablecoin: one bUSD0 is
+    // one USD0 at `getEndTime()` = 1844335800 (2028-06-11 11:30 UTC; the bond
+    // started 2024-06-11 and runs `totalBondTimes()` = 4 years). Not ERC-4626
+    // in any part, hence the `usual-bond` reader. Fully backed 1:1 — the
+    // contract held exactly its supply in USD0 (518,288,230.80 each) on
+    // 2026-10-07 — but the backing is admin-sweepable (`emergencyWithdraw`),
+    // so `solvency` stays unasserted and the reader clamps the rate to it.
+    //
+    // The rate is par and NEVER drifts: the yield is a USUAL reward stream
+    // (Usual's `rewards/rates/USD0++` API, 5.69 % at integration). The
+    // interesting numbers are the early exits — `unlockUsd0ppFloorPrice` at
+    // `getFloorPrice()` (0.92 → `withdrawFeeBps` 800), `unlockUSD0ppWithUsual`
+    // at par for `calculateRequiredUsual` (2.147 USUAL per bUSD0 ≈ 2.6 % at
+    // $0.0122), and `reconstruct` at par for an equal rt-bUSD0 burn, which only
+    // V3 mints receive (~337.9k rt against ~518M bUSD0). The market sat at
+    // ~0.971, so the floor is NOT the cheapest exit — the market and the USUAL
+    // unlock both beat it. Every user path is `whenNotPaused`, and transfers
+    // revert for USD0-blacklisted addresses.
+    {
+      reader: "usual-bond",
+      address: "0x35d8949372d46b7a3d5a56006ae77b215fc69bc0",
+      underlying: "0x73a15fed60bf67631dc6cd7bc5b6e8da8190acf5",
+      // USD0
+      symbol: "bUSD0",
+      brand: "Usual",
+      description: "Usual's four-year bond on its USD0 stablecoin: each bUSD0 is backed by one USD0 held in the contract and redeems for it at par on 11 June 2028. The yield is paid separately in USUAL tokens, not added to the bond. Leaving before maturity costs something \u2014 the guaranteed floor price (currently 0.92), a fee paid in USUAL for par, or a sale on the market below par \u2014 unless you still hold the redemption token from minting.",
+      decimals: 18,
+      isRebasing: false,
+      isMintable: true,
+      withdrawalMode: "fee-or-maturity",
+      expiry: 1844335800,
+      // getEndTime() — 2028-06-11 11:30 UTC
+      usualBond: {
+        redemptionToken: "0x82dca22b48b14de38ccf83b03330120c4b8acfe9",
+        // rt-bUSD0
+        parUnlockToken: "0xc4441c2be5d8fa8126822b9929ca0b81ea0de38e",
+        // USUAL
+        parUnlockTokenSymbol: "USUAL"
+      },
+      yieldFetcher: usdZeroPlusFetcher,
+      yieldKey: BUSD0_KEY
+    },
     // ---- Strata (docs.strata.markets) — senior/junior risk tranches ----
     //
     // Six CDO markets, twelve ERC-4626 tranche tokens, all Ethereum.
@@ -55558,32 +55629,6 @@ var csusdlFetcher = {
   }
 };
 
-// src/yields/intrinsic/fetchers/usual.ts
-var USDZEROPLUS_URL = "https://app.usual.money/api/rewards/rates/USD0++";
-var ETHZERO_URL = "https://app.usual.money/api/rewards/rates/ETH0";
-var usdZeroPlus = "Staked USD0::USD0++";
-var ethZero = "ETH0::ETH0";
-var usdZeroPlusFetcher = {
-  label: "USDZEROPLUS",
-  fetch: async () => {
-    const res = await fetch(USDZEROPLUS_URL, {
-      method: "GET",
-      headers: { Accept: "application/json" }
-    }).then((r) => r.json());
-    return { [usdZeroPlus]: Number(res?.rewards[0]?.apr ?? 0) * 100 };
-  }
-};
-var ethZeroFetcher = {
-  label: "ETHZERO",
-  fetch: async () => {
-    const res = await fetch(ETHZERO_URL, {
-      method: "GET",
-      headers: { Accept: "application/json" }
-    }).then((r) => r.json());
-    return { [ethZero]: Number(res?.rewards[0]?.apr ?? 0) * 100 };
-  }
-};
-
 // src/yields/intrinsic/fetchers/jito.ts
 var JITOSOL_URL = "https://www.jito.network/api/getJitoPoolStats/";
 var jitoSol = "Jito Staked SOL::JitoSOL";
@@ -55662,6 +55707,108 @@ var onycFetcher = {
   }
 };
 
+// src/yields/intrinsic/fetchers/sanctum.ts
+var KAMINO_STAKING_YIELDS = "https://api.kamino.finance/staking-yields/tokens";
+var INF_MINT = "5oVNBeEEQvYi1cX3ir8Dx5n1P7pdxydbGF2X4TxVusJm";
+var INF_LLAMA_POOL = "3075a746-bdd1-4aac-bcd5-b035abee2622";
+var INF_KEY = "Infinity::INF::solana";
+var INF_EPOCHS = 10;
+var MAX_PLAUSIBLE_APY = 0.3;
+function meanEpochApy(rows, n = INF_EPOCHS) {
+  if (!Array.isArray(rows)) return void 0;
+  const ok2 = rows.map((r) => ({ epoch: Number(r?.epoch), apy: Number(r?.apy) })).filter(
+    (r) => Number.isFinite(r.epoch) && Number.isFinite(r.apy) && r.apy > 0 && r.apy < MAX_PLAUSIBLE_APY
+  ).sort((a, b) => b.epoch - a.epoch).slice(0, n);
+  if (ok2.length === 0) return void 0;
+  return ok2.reduce((s, r) => s + r.apy, 0) / ok2.length;
+}
+async function kaminoInfApy() {
+  const end = /* @__PURE__ */ new Date();
+  const start = new Date(end.getTime() - 30 * 864e5);
+  const d = (x) => x.toISOString().slice(0, 10);
+  const res = await fetch(
+    `${KAMINO_STAKING_YIELDS}/${INF_MINT}/history?start=${d(start)}&end=${d(end)}`,
+    {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    }
+  );
+  if (!res.ok) throw new Error(`Kamino staking-yields HTTP ${res.status}`);
+  return meanEpochApy(await res.json());
+}
+var infFetcher = {
+  label: "SANCTUM_INF",
+  fetch: async () => {
+    const apy = await kaminoInfApy().catch((e) => {
+      console.warn(`[sanctum] Kamino INF history unavailable: ${e.message}`);
+      return void 0;
+    });
+    if (apy !== void 0) return { [INF_KEY]: apyToAprPercent(apy * 100) };
+    const llama = await fetchDefiLlamaApy(INF_LLAMA_POOL);
+    if (!(llama > 0) || llama >= MAX_PLAUSIBLE_APY * 100) return {};
+    return { [INF_KEY]: apyToAprPercent(llama) };
+  }
+};
+
+// src/yields/intrinsic/fetchers/exponentTranching.ts
+var EXPONENT_APP_API = "https://app.exponent.finance/api/tranching-markets";
+var EXPONENT_SENIOR_GROUPS = {
+  FvQP1fjox2GPSwkEhENuZisz8UeRURLWf7GYF9n2mURD: "Exponent Senior eHYUSD::srEHYUSD::solana",
+  F17tzaQaFf1x3tC5gQFVvXAF2hcgq1qX6Mc9595zo3FD: "Exponent Senior AUTO::srAUTO::solana",
+  "9J8VvigcjFTkN3jhZH2ieTi2hdGVBVpEXbcA1JDo7QpA": "Exponent Senior ONyc::srONyc::solana",
+  "4tnzVYkaXKwMt7p86wpDzeTyzHSZhj2BvdGwBem7peH5": "Exponent Senior nOPAL::srnOPAL::solana"
+};
+var EXPONENT_BASE_GROUPS = {
+  HnnGv3HrSqjRpgdFmx7vQGjntNEoex1SU4e9Lxcxuihz: "Earn Hylo USD::eHYUSD::solana"
+};
+var MAX_PLAUSIBLE_APY2 = 0.5;
+function seniorApy(stats) {
+  const s = stats;
+  for (const k of ["seniorApy30d", "seniorApy7d", "seniorApy1d"]) {
+    const v = Number(s?.[k] ?? NaN);
+    if (s?.[k] != null && Number.isFinite(v) && v > -MAX_PLAUSIBLE_APY2 && v < MAX_PLAUSIBLE_APY2)
+      return v;
+  }
+  return void 0;
+}
+var getJson3 = async (url) => {
+  const res = await fetch(url, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) throw new Error(`Exponent HTTP ${res.status} for ${url}`);
+  return res.json();
+};
+var exponentSeniorFetcher = {
+  label: "EXPONENT_SENIOR",
+  fetch: async () => {
+    const markets = await getJson3(EXPONENT_APP_API);
+    const wanted = (Array.isArray(markets) ? markets : []).filter(
+      (m) => m.address && m.mintLpSenior && EXPONENT_SENIOR_GROUPS[m.mintLpSenior]
+    );
+    const out = {};
+    for (const m of Array.isArray(markets) ? markets : []) {
+      const group = m.mintBase ? EXPONENT_BASE_GROUPS[m.mintBase] : void 0;
+      const apy = Number(m.underlyingApy7d);
+      if (group && m.underlyingApy7d != null && apy > 0 && apy < MAX_PLAUSIBLE_APY2)
+        out[group] = apyToAprPercent(apy * 100);
+    }
+    await Promise.all(
+      wanted.map(async (m) => {
+        const apy = await getJson3(`${EXPONENT_APP_API}/${m.address}/stats`).then(seniorApy).catch((e) => {
+          console.warn(`[exponent] ${m.address} stats: ${e.message}`);
+          return void 0;
+        });
+        if (apy !== void 0)
+          out[EXPONENT_SENIOR_GROUPS[m.mintLpSenior]] = apyToAprPercent(
+            apy * 100
+          );
+      })
+    );
+    return out;
+  }
+};
+
 // src/yields/intrinsic/fetchers/superreturn.ts
 var SSUPERUSD_URL = "https://www.superreturn.ai/api/trpc/cmc.getUSDCPrice,rewardBackend.getYield,rewardBackend.getTvlChange?batch=1&input=%7B%220%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%2C%221%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%2C%222%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%7D";
 var ssuperusd = "SuperReturn sSuperUSD::SSUPERUSD";
@@ -55777,7 +55924,7 @@ var getGmxApiHost = (chainId) => GMX_API_HOSTS[chainId];
 
 // src/vaults/gmx/api.ts
 var GMX_DEFAULT_APY_PERIOD = "1d";
-var getJson3 = async (url) => {
+var getJson4 = async (url) => {
   const res = await fetch(url, {
     method: "GET",
     headers: { Accept: "application/json" }
@@ -55789,12 +55936,12 @@ var fetchGmxRawData = async (chainId, period, apiUrlOverride) => {
   const host = apiUrlOverride ?? getGmxApiHost(chainId);
   if (!host) throw new Error(`GMX not supported on chain ${chainId}`);
   const [apy, marketsRes, glvsRes, tokensRes] = await Promise.all([
-    getJson3(`${host}/apy?period=${encodeURIComponent(period)}`),
-    getJson3(`${host}/markets`).catch(() => ({
+    getJson4(`${host}/apy?period=${encodeURIComponent(period)}`),
+    getJson4(`${host}/markets`).catch(() => ({
       markets: []
     })),
-    getJson3(`${host}/glvs`).catch(() => ({ glvs: [] })),
-    getJson3(`${host}/tokens`).catch(() => ({
+    getJson4(`${host}/glvs`).catch(() => ({ glvs: [] })),
+    getJson4(`${host}/tokens`).catch(() => ({
       tokens: []
     }))
   ]);
@@ -56416,6 +56563,13 @@ var LENDING_ONLY_FETCHERS = [
   // ONyc (OnRe reinsurance, Solana): NAV-accruing collateral on Loopscale /
   // Kamino / Jupiter Lend, no vault row.
   onycFetcher,
+  // INF (Sanctum Infinity, Solana): the SOL-value accrual of the multi-LST
+  // pool, collateral on Kamino / Jupiter Lend / Project 0 / Save. Its earn
+  // row lives in margin-fetcher-sol, so it is lending-only here.
+  infFetcher,
+  // Exponent senior tranches (srEHYUSD / srAUTO / srONyc / srnOPAL, Solana):
+  // Loopscale loop collateral, no earn row.
+  exponentSeniorFetcher,
   thbillFetcher,
   // sthusdFetcher / scrvusdFetcher are NOT here (and deliberately not
   // imported): both are vault-wired by their savings rows, so they reach
@@ -65071,7 +65225,7 @@ function rescaleExchangeRate(exchangeRate, shareDecimals) {
   const dec2 = Math.max(0, Math.round(Number(shareDecimals) || 0));
   return (r * 10n ** BigInt(dec2) / 10n ** 18n).toString();
 }
-async function getJson4(url) {
+async function getJson5(url) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS2);
   try {
@@ -65163,7 +65317,7 @@ async function mapWithConcurrency(items, limit, fn) {
   return out;
 }
 async function fetchEulerEarnVaultsFromApi(chainId, prices = {}, tokenList = {}, multicallRetry) {
-  const list = await getJson4(
+  const list = await getJson5(
     `${EULER_DATA_API_BASE2}/earn/vaults?chainId=${chainId}&limit=200&visibility=${VISIBILITY_ALL}`
   );
   if (!list) return void 0;
@@ -65180,7 +65334,7 @@ async function fetchEulerEarnVaultsFromApi(chainId, prices = {}, tokenList = {},
     mapWithConcurrency(
       rows,
       DETAIL_CONCURRENCY,
-      (row) => getJson4(
+      (row) => getJson5(
         `${EULER_DATA_API_BASE2}/earn/vaults/${chainId}/${row.address}?include=strategies`
       ).then((d) => d?.data)
     ),
@@ -67472,6 +67626,87 @@ var marketRoute = () => ({
   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 capped = (a, b) => {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return BigInt(a) < BigInt(b) ? a : b;
+};
+var bondExitRoutes = (i) => {
+  const routes2 = [];
+  const now = i.now ?? Math.floor(Date.now() / 1e3);
+  const matured = i.expiry !== void 0 && now >= i.expiry;
+  const capacity = {
+    capacity: i.liquidity,
+    capacityFormatted: i.liquidityFormatted,
+    capacityUsd: i.liquidityUsd
+  };
+  if (i.withdrawFeeBps != null)
+    routes2.push({
+      id: "floor",
+      kind: "instant",
+      label: "Early exit at the floor price",
+      settlement: "sync",
+      feeBps: i.withdrawFeeBps,
+      waitSeconds: 0,
+      ...capacity,
+      selfOnly: true,
+      description: "Burns the bond now for the protocol's floor price; the difference to par goes to the protocol's treasury, not to you. Pays the sender only."
+    });
+  if (i.parUnlockAvailable) {
+    const token = i.parUnlockTokenSymbol ?? "the protocol token";
+    routes2.push({
+      id: "usual-unlock",
+      kind: "instant",
+      label: `Early exit at par (pays ${token})`,
+      settlement: "sync",
+      feeBps: i.parUnlockFeeBps,
+      ...i.parUnlockFeeBps == null ? { feeUnknown: true } : {},
+      waitSeconds: 0,
+      ...capacity,
+      selfOnly: true,
+      description: `Pays par in the underlying, but you must also pay ${token} \u2014 a fixed amount per bond, so its cost in dollars moves with ${token}'s price. Pays the sender only.`
+    });
+  }
+  if (i.redemptionTokenCapacity !== void 0)
+    routes2.push({
+      id: "reconstruct",
+      kind: "instant",
+      label: "Par with the redemption token",
+      settlement: "sync",
+      feeBps: 0,
+      waitSeconds: 0,
+      capacity: capped(i.liquidity, i.redemptionTokenCapacity),
+      capacityFormatted: i.liquidityFormatted !== void 0 && i.redemptionTokenCapacityFormatted !== void 0 ? Math.min(i.liquidityFormatted, i.redemptionTokenCapacityFormatted) : i.redemptionTokenCapacityFormatted ?? i.liquidityFormatted,
+      description: "Free and at par any time, but it burns an equal amount of the redemption token, which only fresh mints receive \u2014 a holder who bought the bond, or minted it before the token existed, cannot take this route. Capacity is the token supply across everyone."
+    });
+  routes2.push(
+    matured ? {
+      id: "maturity",
+      kind: "instant",
+      label: "Par at maturity",
+      settlement: "sync",
+      feeBps: 0,
+      waitSeconds: 0,
+      description: "The bond has matured: redeem at par. Burns your WHOLE balance in one call."
+    } : {
+      id: "maturity",
+      kind: "queued",
+      label: i.expiry !== void 0 ? `Par at maturity (${new Date(i.expiry * 1e3).toISOString().slice(0, 10)})` : "Par at maturity",
+      settlement: "async",
+      feeBps: 0,
+      waitSeconds: i.expiry !== void 0 ? Math.max(0, i.expiry - now) : void 0,
+      description: "Hold to the maturity date and redeem at par \u2014 nothing to request in the meantime. The redemption burns your WHOLE balance in one call."
+    }
+  );
+  routes2.push({
+    id: "market",
+    kind: "market",
+    label: "Sell on the market",
+    settlement: "market",
+    description: "Sell the bond to somebody else. It fills at the market price \u2014 usually a discount to par that closes toward maturity \u2014 not at the row's `exchangeRate`, with price impact that grows with size, so the leg must be built with a slippage bound."
+  });
+  return routes2;
+};
 var deriveExitRoutes = (i) => {
   const routes2 = deriveProtocolExitRoutes(i);
   return i.secondaryMarketOnly ? [...routes2, marketRoute()] : routes2;
@@ -67498,6 +67733,8 @@ var deriveProtocolExitRoutes = (i) => {
     // inventory instead.
     case "instant-or-queued":
       return [instantRoute(i, i.withdrawFeeBps ?? 0), queuedRoute(i)];
+    case "fee-or-maturity":
+      return bondExitRoutes(i);
     case "instant":
       return [
         {
@@ -72127,6 +72364,30 @@ var NEST_FEE_INSTANT_REDEMPTION = 0;
 var NEST_FEE_DEPOSIT = 1;
 var NEST_FEE_REDEMPTION = 2;
 
+// src/vaults/savings/abis/usual.ts
+var view = (name, inputs = []) => ({
+  name,
+  type: "function",
+  stateMutability: "view",
+  inputs,
+  outputs: [{ name: "", type: "uint256" }]
+});
+var UsualBondFloorPriceAbi = [view("getFloorPrice")];
+var UsualBondStartTimeAbi = [view("getStartTime")];
+var UsualBondEndTimeAbi = [view("getEndTime")];
+var UsualBondRequiredUsualAbi = [
+  view("calculateRequiredUsual", [{ name: "usd0ppAmount", type: "uint256" }])
+];
+var UsualBondPausedAbi = [
+  {
+    name: "paused",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+
 // src/vaults/savings/readers/erc4626Idle.ts
 var readerErc4626Idle = (entry) => {
   const shareUnit = 10n ** BigInt(entry.decimals);
@@ -72692,6 +72953,88 @@ var readerSaturnVault = (entry) => {
   };
 };
 
+// src/vaults/savings/readers/usualBond.ts
+var readerUsualBond = (entry) => {
+  const cfg = entry.usualBond;
+  const shareUnit = 10n ** BigInt(entry.decimals);
+  return {
+    calls: [
+      { address: entry.address, name: "totalSupply", params: [] },
+      { address: entry.underlying, name: "balanceOf", params: [entry.address] },
+      { address: entry.address, name: "getFloorPrice", params: [] },
+      { address: entry.address, name: "getStartTime", params: [] },
+      { address: entry.address, name: "getEndTime", params: [] },
+      { address: entry.address, name: "paused", params: [] },
+      // No pinned rt token ⇒ read the bond's own supply in its place and
+      // discard it, keeping the slice width fixed.
+      {
+        address: cfg?.redemptionToken ?? entry.address,
+        name: "totalSupply",
+        params: []
+      },
+      {
+        address: entry.address,
+        name: "calculateRequiredUsual",
+        params: [shareUnit]
+      }
+    ],
+    abis: [
+      TotalSupplyAbi2,
+      BalanceOfAbi,
+      UsualBondFloorPriceAbi,
+      UsualBondStartTimeAbi,
+      UsualBondEndTimeAbi,
+      UsualBondPausedAbi,
+      TotalSupplyAbi2,
+      UsualBondRequiredUsualAbi
+    ],
+    parse: ([
+      supply,
+      backingRaw,
+      floor,
+      start,
+      end,
+      paused,
+      rtSupply,
+      usual
+    ]) => {
+      const totalSupply = toBigInt16(supply);
+      const backing = toBigInt16(backingRaw);
+      const endTime = toBigInt16(end);
+      if (totalSupply === void 0 || backing === void 0 || endTime === void 0 || endTime <= 0n)
+        return void 0;
+      const exchangeRate = totalSupply > 0n && backing < totalSupply ? backing * ONE_E1815 / totalSupply : ONE_E1815;
+      const floorPrice = toBigInt16(floor);
+      const startTime = toBigInt16(start);
+      const isPaused = typeof paused === "boolean" ? paused : void 0;
+      const parUnlockCostPerShare = toBigInt16(usual);
+      return {
+        totalAssets: backing,
+        totalSupply,
+        exchangeRate,
+        expiry: Number(endTime),
+        paused: isPaused,
+        // The floor exit's haircut, in the field every reader uses for "what
+        // the immediate exit costs". Rounded UP: 0.92 → 800 bps exactly, and a
+        // floor that is not a whole bps never reads cheaper than it is.
+        withdrawFeeBps: floorPrice !== void 0 && floorPrice > 0n && floorPrice <= ONE_E1815 ? Number((ONE_E1815 - floorPrice + 10n ** 14n - 1n) / 10n ** 14n) : void 0,
+        // Unread ⇒ assume open (the immediate exits are the norm); a READ pause
+        // closes every leg, maturity included.
+        instantRedeemEnabled: isPaused !== true,
+        // Every immediate exit pays out of the bond's own USD0 — at most the
+        // whole backing, never more.
+        instantRedeemCapacity: isPaused === true ? 0n : backing,
+        bond: {
+          floorPrice,
+          startTime: startTime !== void 0 ? Number(startTime) : void 0,
+          redemptionTokenSupply: cfg?.redemptionToken ? toBigInt16(rtSupply) : void 0,
+          parUnlockCostPerShare
+        }
+      };
+    }
+  };
+};
+
 // src/vaults/savings/readers/venusHub.ts
 var NEUTRAL_PROBE2 = "0x000000000000000000000000000000000000dead";
 var BPS_TO_PCT = 100;
@@ -72983,6 +73326,8 @@ var buildReader2 = (entry) => {
       return readerSaturnVault(entry);
     case "nest-vault":
       return readerNestVault(entry);
+    case "usual-bond":
+      return readerUsualBond(entry);
     case "erc4626-cooldown":
       return readerErc4626Cooldown(entry);
     case "erc4626-idle":
@@ -73094,6 +73439,18 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
     const redemptionDiscountBps = state.fundamentalExchangeRate !== void 0 && state.fundamentalExchangeRate > 0n ? Number(
       state.exchangeRate * 100000000n / state.fundamentalExchangeRate - 100000000n
     ) / 1e4 : void 0;
+    const bond = state.bond;
+    const isBond = entry.withdrawalMode === "fee-or-maturity";
+    const sharePriceUsd = prices[addressLc];
+    const redeemableUsd = priceUsd !== void 0 ? Number(state.exchangeRate) / 1e18 * priceUsd : 0;
+    const marketDiscountBps = isBond && sharePriceUsd !== void 0 && redeemableUsd > 0 ? Math.round((sharePriceUsd / redeemableUsd - 1) * 1e5) / 10 : void 0;
+    const parToken = entry.usualBond?.parUnlockToken.toLowerCase();
+    const parTokenPrice = parToken !== void 0 ? prices[parToken] : void 0;
+    const parTokenDec = parToken !== void 0 ? tokenList[parToken]?.decimals ?? 18 : 18;
+    const parUnlockFeeBps = bond?.parUnlockCostPerShare !== void 0 && parTokenPrice !== void 0 && redeemableUsd > 0 ? Math.round(
+      Number(bond.parUnlockCostPerShare) / 10 ** parTokenDec * parTokenPrice * 1e4 / redeemableUsd
+    ) : void 0;
+    const rtSupply = bond?.redemptionTokenSupply;
     const productName = entry.label ?? entry.symbol;
     const displayName = entry.label ? `${entry.brand} ${entry.label}` : composeVaultDisplayName(
       entry.brand,
@@ -73155,6 +73512,18 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       withdrawalCooldownSeconds: state.withdrawalCooldownSeconds ?? entry.withdrawalCooldownSeconds,
       withdrawFeeBps: state.withdrawFeeBps,
       depositFeeBps: state.depositFeeBps,
+      // Bond terms — absent on every perpetual vault. See the type.
+      expiry: state.expiry ?? entry.expiry,
+      isPaused: state.paused,
+      floorPrice: bond?.floorPrice?.toString(),
+      marketDiscountBps,
+      bond: bond ? {
+        startTime: bond.startTime,
+        redemptionToken: entry.usualBond?.redemptionToken.toLowerCase(),
+        redemptionTokenSupply: rtSupply?.toString(),
+        parUnlockToken: parToken,
+        parUnlockCostPerShare: bond.parUnlockCostPerShare?.toString()
+      } : void 0,
       // 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.
@@ -73189,7 +73558,14 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
           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
+          secondaryMarketOnly: entry.secondaryMarketOnly,
+          // Bond legs (`fee-or-maturity` only; ignored by every other mode).
+          expiry: state.expiry ?? entry.expiry,
+          redemptionTokenCapacity: rtSupply?.toString(),
+          redemptionTokenCapacityFormatted: rtSupply !== void 0 ? Number(rtSupply) / 10 ** underlyingDec : void 0,
+          parUnlockAvailable: bond?.parUnlockCostPerShare !== void 0 && bond.parUnlockCostPerShare > 0n,
+          parUnlockFeeBps,
+          parUnlockTokenSymbol: entry.usualBond?.parUnlockTokenSymbol
         }),
         resolveSelfOnly(chainId, entry.address)
       ),
@@ -74224,6 +74600,7 @@ var classifyRedemption = (provider, v) => {
   if (SYNC_REDEMPTION_PROVIDERS.has(provider)) return "sync";
   if (provider === "lst") return "async";
   if (provider === "savings") {
+    if (v.withdrawalMode === "fee-or-maturity") return void 0;
     return v.withdrawalMode === "instant" && !v.withdrawalCooldownSeconds ? "sync" : "async";
   }
   return "sync";
@@ -75610,7 +75987,7 @@ function clearPendleMarketsCache() {
   marketsCache = void 0;
   assetsCache = void 0;
 }
-async function getJson5(url, label) {
+async function getJson6(url, label) {
   const response = await fetch(url, { headers: { Accept: "application/json" } });
   if (!response.ok) {
     throw new Error(
@@ -75631,7 +76008,7 @@ function cache5(slot, build6, store) {
 function fetchPendleApiMarkets() {
   return cache5(
     marketsCache,
-    async () => (await getJson5(PENDLE_MARKETS_URL, "markets"))?.markets ?? [],
+    async () => (await getJson6(PENDLE_MARKETS_URL, "markets"))?.markets ?? [],
     (c) => {
       marketsCache = c;
     }
@@ -75642,7 +76019,7 @@ function fetchPendleApiAssets() {
   return cache5(
     assetsCache,
     async () => {
-      const json = await getJson5(PENDLE_ASSETS_URL, "assets");
+      const json = await getJson6(PENDLE_ASSETS_URL, "assets");
       const map = /* @__PURE__ */ new Map();
       for (const a of json?.assets ?? []) {
         if (a?.chainId == null || !a?.address) continue;
@@ -76567,6 +76944,7 @@ var exitPhrase = {
   "request-based": "withdrawals need a request",
   "market-sale": "exit by selling on the market",
   "at-maturity": "locked until maturity",
+  "fee-or-maturity": "exit early at a discount, or at par at maturity",
   "off-chain": "exit off-chain",
   "dex-only": "exit only via a DEX"
 };
@@ -76606,6 +76984,7 @@ function headlineExitFromRoutes(routes2, symbol) {
   const fastPart = fast.feeBps == null ? "instant exit" : fast.feeBps === 0 ? "free instant exit" : `instant exit for ${(fast.feeBps / 100).toFixed(2)} %`;
   const slowCost = slow.feeBps === 0 ? "free" : slow.feeBps != null ? `${(slow.feeBps / 100).toFixed(2)} %` : void 0;
   const floor = slow.minAmountFormatted != null && slow.minAmountFormatted > 0 ? ` above ${amount(slow.minAmountFormatted)}${symbol ? ` ${symbol}` : ""}` : "";
+  if (slow.id === "maturity") return `${fastPart}, or par at maturity`;
   const slowPart = slowCost ? `queue${floor} for ${slowCost}` : `queue${floor}`;
   return `${fastPart}, or ${slowPart}`;
 }
@@ -78958,6 +79337,7 @@ var EXIT_MODE_LABELS = {
   "request-based": "Request",
   "market-sale": "Market sale",
   "at-maturity": "At maturity",
+  "fee-or-maturity": "Fee or maturity",
   "off-chain": "Off-chain",
   "dex-only": "DEX only"
 };
@@ -78971,6 +79351,7 @@ var EXIT_MODE_DESCRIPTIONS = {
   "request-based": "Withdrawals need a request and a later claim.",
   "market-sale": "Exit by selling the position on a market.",
   "at-maturity": "Locked until maturity.",
+  "fee-or-maturity": "Exit early at a discount, or at par at maturity.",
   "off-chain": "Exit is settled off-chain.",
   "dex-only": "Exit only by selling on a DEX."
 };
@@ -79277,7 +79658,10 @@ var UNCAPPED_EXIT_MODES = /* @__PURE__ */ new Set([
   "instant-or-queued",
   "request-based",
   "off-chain",
-  "at-maturity"
+  "at-maturity",
+  // A bond's par leg is the maturity, uncapped like `at-maturity`; the early
+  // legs are bounded by the backing, which `liquidity` already reports.
+  "fee-or-maturity"
 ]);
 function meetsLiquidityFloor(input, minUsd) {
   if (input.canWithdraw === false) return false;
@@ -79838,7 +80222,10 @@ function savingsCuration(provider, chainId, address) {
     solvency: e.solvency,
     accrual: e.accrual,
     yieldWarmupSeconds: e.yieldWarmupSeconds,
-    needsDepositApproval: e.needsDepositApproval
+    needsDepositApproval: e.needsDepositApproval,
+    // A dated bond's maturity (Usual bUSD0) — static, and the one fact that
+    // keeps a proxied bond row from rendering as perpetual.
+    expiry: e.expiry
   };
 }
 function vaultTermInputFromEarnMarket(m) {
@@ -79898,7 +80285,7 @@ function vaultTermInputFromEarnMarket(m) {
     withdrawalsPaused: m.availability.canWithdraw ? void 0 : true,
     isClosed: bool2(meta.isClosed),
     whitelisted: bool2(meta.whitelisted),
-    expiry: m.maturity?.maturity,
+    expiry: m.maturity?.maturity ?? curated.expiry,
     timelock: num14(meta.timelock),
     allocators: strArray(meta.allocators),
     owner: str7(meta.owner),
@@ -79980,7 +80367,7 @@ function vaultTermInputFromSourceRow(row, chainId) {
     withdrawalsPaused: bool2(meta.isWithdrawalPaused),
     isClosed: bool2(meta.isClosed),
     whitelisted: bool2(meta.whitelisted),
-    expiry: num14(meta.expiry) ?? num14(meta.maturity),
+    expiry: num14(meta.expiry) ?? num14(meta.maturity) ?? curated.expiry,
     timelock: num14(meta.timelock),
     allocators: strArray(meta.allocators),
     owner: str7(meta.owner),
@@ -82784,6 +83171,11 @@ var isNum4 = (v) => typeof v === "number" && Number.isFinite(v);
 function build2(input) {
   const vault = jupiterLendVaultFromKey(input.lender);
   const address = input.asset?.address ?? input.underlying;
+  const smart = input.market?.fluid ?? {};
+  const isSmartCol = !!smart.isSmartCol;
+  const isSmartDebt = !!smart.isSmartDebt;
+  const isSmart = isSmartCol || isSmartDebt;
+  const pair = (p) => Array.isArray(p) ? p.join(" + ") : void 0;
   const pending = {
     "borrow.liquidation.liquidationMaxLimit": "the max liquidation limit (the LTV past which a position is liquidated ENTIRELY) is not served",
     "borrow.availability.cap": "the layer's EXPANDING borrow limit (current, hard max, expand percent and duration) is not served \u2014 it is not a cap, so the row carries none",
@@ -82844,12 +83236,22 @@ function build2(input) {
     constraints: {
       crossMargin: false,
       positionModel: "nft",
-      positionIdMeaning: "The vault position NFT id (per vault; one collateral / debt pair each). positionId 0 MINTS a new position \u2014 only an opening deposit may pass 0; any other action sent with 0 acts on a fresh empty position and reports success."
+      positionIdMeaning: "The vault position NFT id (per vault; one collateral / debt pair each). positionId 0 MINTS a new position \u2014 only an opening deposit may pass 0; any other action sent with 0 acts on a fresh empty position and reports success.",
+      ...isSmart ? {
+        // the fluid adapter's notes: a smart side is a DEX share, not a token
+        notes: [
+          isSmartCol ? `Collateral is a Jupiter Lend DEX position (shares) over ${pair(smart.collateralPair) ?? "two tokens"}; this row is one leg of it.` : void 0,
+          isSmartDebt ? `Debt is a Jupiter Lend DEX position (shares) over ${pair(smart.debtPair) ?? "two tokens"}; this row is one leg of it.` : void 0,
+          isSmartDebt ? "The borrow rate is NET of the trading yield the debt LP earns, so it can be negative." : void 0,
+          isSmartCol ? "The supply rate INCLUDES the DEX trading yield (trailing 7 days, after the protocol revenue cut) on top of the liquidity-layer rate." : void 0,
+          "Both legs of a side move together \u2014 a leg cannot be supplied, borrowed or withdrawn on its own; the pool rebalances the split."
+        ].filter(Boolean)
+      } : {}
     },
     ext: {
       jupiterLend: {
         ...vault ? { market: vault.market, vaultId: vault.vaultId } : {},
-        fluidVaultType: FLUID_VAULT_TYPE_T1,
+        fluidVaultType: isNum4(smart.vaultType) ? smart.vaultType : FLUID_VAULT_TYPE_T1,
         ...vault?.market === "main" ? { programs: JL_MAIN_PROGRAMS } : {},
         /** The marketUid ref is the leg's MINT. */
         marketUidRef: "mint"
@@ -84198,7 +84600,13 @@ var SVM_EARN_VAULT_BUILDERS = {
   "savings:Nest": { verbs: ["deposit", "request-withdraw"] },
   // PRIME / AUTO: the vault-stake pool's own stake / redeem, same
   // transaction; wYLDS in (or USDC, minted 1:1 first), wYLDS out
-  "savings:Hastra": { verbs: ["deposit", "withdraw"], payAsset: true }
+  "savings:Hastra": { verbs: ["deposit", "withdraw"], payAsset: true },
+  // INF: Sanctum Infinity's own add / remove liquidity against wSOL
+  "savings:Sanctum": {
+    verbs: ["deposit", "withdraw"],
+    nativeDeposit: true,
+    nativeWithdraw: true
+  }
 };
 var UNBUILT_REASONS = {
   exponent: "Exponent PTs are not tradable through this API yet",