@1delta/margin-fetcher 5.0.109 → 5.0.110

package/dist/index.d.ts

@@ -8316,7 +8316,9 @@ type SupplyExitMode = Open<'instant' | 'instant-capped' | 'instant-or-queued' |
 /** Sell the instrument on a book (Term, TermMax, Midnight). */
  | 'market-sale'
 /** No early exit at all. */
- | 'at-maturity' | 'off-chain' | 'dex-only'>;
+ | 'at-maturity'
+/** A dated bond: par at maturity, or earlier at a price (Usual bUSD0). */
+ | 'fee-or-maturity' | 'off-chain' | 'dex-only'>;
 /**
  * One concrete way out, as published by the vault row. Re-exported from the
  * vault layer so a term sheet and the `/v1/data/vaults` row cannot disagree
@@ -9108,7 +9110,14 @@ type DeepPartial<T> = {
  * kept separate so the two providers can evolve independently without
  * one provider's withdrawal taxonomy creep affecting the other.
  */
-type SavingsWithdrawalMode = 'instant' | 'instant-capped' | 'fixed-cooldown' | 'queued' | 'request-based' | 'fee-or-queued';
+type SavingsWithdrawalMode = 'instant' | 'instant-capped' | 'fixed-cooldown' | 'queued' | 'request-based' | 'fee-or-queued'
+/**
+ * A fixed-maturity BOND: redeemable at par on a date, or earlier for a
+ * price — Usual's bUSD0 (floor-price unlock, a par unlock paid in USUAL, or
+ * par with the redemption token). There is no request and no queue; the
+ * "wait" is the bond's own end, in `expiry`.
+ */
+ | 'fee-or-maturity';
 /**
  * Parsed savings-vault entry.
  *
@@ -9354,6 +9363,44 @@ interface SavingsVault extends VaultClassificationFields {
      * only per-share number there is.
      */
     redemptionDiscountBps?: number;
+    /**
+     * Unix seconds at which the position MATURES and redeems at par. The term
+     * sheet reads it as a `fixed-date` maturity (`termSheet.supply.maturity`),
+     * which also closes entry once it passes. Same field name and units as
+     * `PendlePt.expiry`.
+     */
+    expiry?: number;
+    /**
+     * 1e18-scaled underlying paid per share by the guaranteed EARLY exit
+     * (bUSD0's `getFloorPrice()`, 0.92 at integration). `withdrawFeeBps` carries
+     * the same fact as a haircut on that leg. Absent ⇒ not read; `'0'` ⇒ the
+     * floor exit is switched off.
+     */
+    floorPrice?: string;
+    /**
+     * Signed basis-point gap between the share's MARKET price and what it
+     * redeems for (`exchangeRate` × underlying price): negative ⇒ it trades
+     * below par. Only computed for `fee-or-maturity` rows, and only when the
+     * caller's price map carries the share token itself — bUSD0 traded at ~0.971
+     * against USD0 at integration, i.e. ≈ −290 bps, which is the yield a buyer
+     * locks in by holding to `expiry`.
+     */
+    marketDiscountBps?: number;
+    /** `true` when the protocol's user paths are paused. Absent ⇒ not read. */
+    isPaused?: boolean;
+    /** The rest of a bond's terms — see `SavingsOnChainState.bond`. */
+    bond?: {
+        /** Unix seconds the bond period began. */
+        startTime?: number;
+        /** Token a par exit before maturity burns one-for-one (rt-bUSD0). */
+        redemptionToken?: string;
+        /** Its supply, raw — the most that can EVER exit early at par. */
+        redemptionTokenSupply?: string;
+        /** Token the par early unlock is paid in (USUAL). */
+        parUnlockToken?: string;
+        /** Raw `parUnlockToken` pulled per ONE share by that unlock. */
+        parUnlockCostPerShare?: string;
+    };
     /**
      * Curated loss-waterfall / backing classification, straight from the
      * registry entry. Absent ⇒ not assessed (NOT "safe").

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";
@@ -67581,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;
@@ -67607,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 [
         {
@@ -72236,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);
@@ -72801,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;
@@ -73092,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":
@@ -73203,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,
@@ -73264,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.
@@ -73298,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)
       ),
@@ -74333,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";
@@ -76676,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"
 };
@@ -76715,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}`;
 }
@@ -79067,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"
 };
@@ -79080,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."
 };
@@ -79386,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;
@@ -79947,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) {
@@ -80007,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),
@@ -80089,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),
@@ -82893,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",
@@ -82953,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"