# Bondify Liquidity Layer Bondify introduces two dedicated liquidity layers that transform illiquid DeFi positions into tradeable, standardized instruments — one for leveraged looping positions themselves, and one for the yield rights they generate. *** ### Background: Funding Sources Every JR Token and YT is backed by a looping position that borrows from one of two funding sources. Understanding the difference matters because the source determines max leverage, points multiplier, and YT pricing. *** ### Liquidity Layer 1: JR Token — Standardized Leveraged Position Trading #### What is JR Token? JR Token is a standardized, fungible representation of a leveraged looping position. Each JR Token maintains a constant target LTV ratio through active management, enabling positions that are otherwise heterogeneous and non-transferable to become tradeable on secondary markets. **Token format:** `jr[Collateral][Leverage][LiquiditySource]` Examples: `jrUSDe4xSLF`, `jrwstETH5xMorpho` #### Why It Matters Traditional leveraged looping positions are trapped — they cannot be transferred, listed, or sold without fully unwinding the position. This creates significant friction for users who need to exit early or rebalance exposure. JR Token solves this by: * **Fungibility:** All positions with the same collateral, leverage target, and liquidity source are represented by the same token — enabling a real secondary market * **Active LTV Management:** The protocol actively rebalances positions to maintain the target LTV, ensuring JR Tokens remain consistent and comparable over time * **Standardized Leverage Exposure:** Buyers of JR Tokens gain instant, managed leveraged exposure without building a position from scratch * **One-Click Exit:** Holders can exit leveraged positions at any time by selling JR Tokens on the secondary market, bypassing lengthy unwinding periods (e.g., a 5x leveraged position on a T+35 fund could otherwise take 350 days to fully unwind) #### Minting JR Tokens When a user contributes a looping position into the JR pool, the protocol calculates how many JR tokens to issue based on the current per-share value (PSV) of the pool. **First position (pool creation):** The PSV is initialized from the incoming position's NAV and total collateral value: ``` PSV = NAV / totalCollateralValue = (C × P_deposit - D × P_borrow) / (C × P_deposit) = 1 - LTV (when P_borrow = 1.0, e.g. USDC debt) tokens_to_mint = NAV_in_baseToken / PSV ``` Example (sUSDe pool, P\_deposit = $1.21, LTV = 75%): ``` C = 500 sUSDe, D = 400 USDC totalCollateralValue = 500 × 1.21 = $605 NAV = $605 − $400 = $205 PSV = 205 / 605 = 0.3388 tokens_to_mint = 205 / 0.3388 = 605 JR ``` **Subsequent positions:** New entrants use the existing PSV. Tokens issued are proportional to the NAV contribution, so existing holders are not diluted. **LTV adjustment at entry:** If the incoming position's LTV differs from the pool's target LTV, the protocol adjusts it automatically before accepting the position: * Incoming LTV **above** pool target → user must repay the excess debt first * Incoming LTV **below** pool target → protocol withdraws excess collateral back to the user's wallet This ensures the pool always operates at a consistent LTV, and the user retains any collateral or debt difference returned to them. #### Redeeming JR Tokens When a holder redeems JR tokens, they receive a proportional share of the pool's underlying position: ``` exit_collateral = pool_collateral × (redeem_amount / total_supply) exit_debt = pool_debt × (redeem_amount / total_supply) ``` * **Full redemption** (all JR tokens burned, pool empties): the holder receives the pool's entire holding position directly — no split required * **Partial redemption**: the protocol splits the holding position proportionally; the user receives a new independent looping position with the corresponding collateral and debt **PSV is not affected by entry or exit.** Mints and redeems transfer proportional value in and out; they do not change the per-share value. Only yield accrual or liquidation loss moves PSV over time. #### Understanding PSV vs. USDC/JR Two metrics are used to track JR Token value. They measure different things and should not be conflated: **PSV (Per-Share Value) — denominated in sUSDe/JR** PSV reflects how much of the underlying collateral each JR token represents. It changes when: * sUSDe price appreciates (PSV rises even if borrow costs equal yield) * The pool incurs a liquidation loss (PSV falls) PSV is a reference/oracle metric used for internal pool accounting and Staple pricing. It is **not** a direct measure of user P\&L. **USDC/JR — the correct user-facing P\&L indicator** USDC/JR measures the dollar value of what each JR token can be redeemed for. It reflects the net result of yield earned minus borrow cost accumulated over time. | Scenario | Debt Growth | NAV (USD) | PSV (sUSDe/JR) | USDC/JR | | ------------- | ----------- | --------- | -------------- | -------- | | Initial state | — | $710 | 1.0000 | $1.21 | | Yield > Debt | +$10 | $790 | 1.0356 ↑ | $1.346 ↑ | | Yield = Debt | +$90 | $710 | 0.9308 ↓ | $1.21 → | | Yield < Debt | +$20 | $680 | 0.8914 ↓ | $1.159 ↓ | Note: In Case 2, PSV falls (because sUSDe price appreciation is captured in PSV denominator) while USDC/JR stays flat — this is the expected outcome when yield exactly offsets debt. PSV moving down does **not** mean the user lost money. Always use USDC/JR to evaluate position performance. #### Active LTV Management: Asymmetric Range Model The protocol uses an asymmetric rebalancing mechanism to maintain the target LTV: | Condition | Tolerance | Rationale | | ----------------------------- | ---------------- | ---------------------------------------------------- | | LTV too low (under-leveraged) | Tight (3% gap) | Low LTV = idle capital; users expect leveraged yield | | LTV too high (over-leveraged) | Wider (10% gap) | Still safe; frequent rebalancing increases gas costs | | LTV ≥ max\_borrow | Immediate action | Liquidation risk; protocol de-leverages instantly | #### Value Dynamics The USDC/JR price reflects the P\&L of the underlying leveraged position: * **Yield > Debt growth** → JR Token appreciates * **Yield = Debt growth** → JR Token holds value * **Yield < Debt growth** → JR Token depreciates This makes JR Token a clean, price-transparent instrument for leveraged yield exposure. *** ### Liquidity Layer 2: YT — Liquidity Layer for the Yield Tranche #### What is YT? YT (Yield Token) represents the yield rights generated by the collateral underlying a leveraged looping position. When a Looper sells their yield rights, the buyer receives all organic yield (and/or points) generated by the collateral from the time of purchase until maturity. YT can be issued in two forms: * **YT-O (Organic Yield):** Represents the organic staking yield of the underlying collateral (e.g., sUSDe yield) * **YT-P (Points):** Represents the points accrued by the underlying collateral (e.g., Ethena sat-days), tradeable independently of organic yield YT-O and YT-P can be sold together as a **bundle** or **split and listed independently** in separate FIFO queues. #### Why It Matters For Loopers, YT provides a mechanism to hedge yield uncertainty by locking in fixed income upfront. For buyers, YT offers leveraged yield exposure with a capped downside and uncapped upside — at a lower structural cost than comparable Pendle YT positions, because the seller (a Looper) is already more profitable and has more room to offer competitive pricing. #### Supply Sources YT supply comes from multiple sources, all clearing through the same FIFO queue on a time-priority basis. Orders from different sources compete equally — whoever lists first fills first — with one exception: **SLF always acts as the last-resort provider**, only deploying capital when no other seller exists in the queue. Sources that can supply YT: * **Looper-minted YT** — Loopers issuing YT directly from their active looping position * **YT → YT conversion** — holders of previously purchased YT who convert and relist * **YT resale** — secondary YT holders relisting before maturity * **SLF (last resort only)** — protocol deploys its own capital exclusively when the queue is empty; ensures YT is always available to buyers regardless of organic supply #### Unified Pricing Formula All YT supply sources use a unified time-decay pricing model: ``` YT_cost = YT_amount × SLF_daily_rate × remaining_seconds ``` This ensures fair, real-time pricing across all listings regardless of source, and allows prices to decay naturally as maturity approaches. **Worked example:** ``` Collateral: 6,876.88 sUSDe Daily rate: 0.0002 Remaining days: 72 Step 1 — YT value denominated in collateral: 6,876.88 × 0.0002 × 72 ≈ 99 sUSDe Step 2 — Convert to USDC (sUSDe oracle price = $1.20): 99 × 1.20 = ~120 USDC ``` #### Listing Requirements Before a Looper can list YT, two conditions must both be satisfied: * Position LTV must be **≤ max\_LTV** at the time of listing * Must list **100% of collateral** — partial listings are not permitted Once listed, the collateral is **100% locked**. The Looper can still repay debt to lower LTV, but cannot withdraw or unstake collateral until the listing is cancelled, bought back, or settled at maturity. #### Key Protocol Rule: Tokenization Happens at First Purchase YT is **not** officially minted at the time of listing. It becomes tokenized only when the first buyer executes against the listing. This means: * A listed YT that never gets purchased is treated as if it was never issued * The Looper retains 100% of organic yield generated during the listing period if no buyer ever fills the order * There is no penalty for listing and not selling #### YT Lifecycle Summary | State | Description | Outcome for Looper | | ---------------------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Listed, unsold at maturity | No buyer found before expiry | Full yield retained, no penalty | | Voluntarily cancelled | Listing cancelled before fill | Full yield retained, instant unlock, zero fees | | Partially filled, held to maturity | Some YT sold, remainder unsold | Fixed yield received for filled portion; unfilled yield retained | | Partially filled, then cancelled | Remaining listing cancelled post-partial fill | Yield for filled period deducted; position unlocked | | Secondary resale by YT holder | Holder relists before maturity | New buyer acquires remaining yield rights; original holder keeps yield accumulated during their hold | | Underlying position liquidated | LTV breaches the Liquidation Price threshold; position transferred to Liquidator | Fixed yield already received by the Looper is unaffected. The underlying looping position is dissolved. YT holders generally cease to receive subsequent organic yield (Liquidator may voluntarily share profits). The GYT token itself **remains valid until its maturity date** even after liquidation. | #### Position Split and Merge on Partial Fill Every partial fill automatically splits the underlying looping position to enable precise yield accounting: ``` Initial: 500 YT listed (single position, 500 sUSDe collateral) Fill 1 (Day 5): 300 YT purchased → Splits into: FILLED (Position A): 300 sUSDe — locked, yield rights transferred to buyer UNFILLED (Position B): 200 sUSDe — remains in FIFO queue Fill 2 (Day 10): 100 more YT purchased → Position B splits; new filled portion merges into Position A: FILLED (Position A): 400 sUSDe — merged UNFILLED (Position B): 100 sUSDe — still in queue ``` From the user's perspective, the interface always shows a clean two-position view: **FILLED** (locked, yield transferred) and **UNFILLED** (in queue, manageable). Subsequent fills automatically consolidate into the FILLED segment. #### Buy Back — How Loopers Exit Early A Looper who has sold YT can exit their commitment before maturity by buying back equivalent YT from the market and returning it to unlock their position. * Must buy back the **full issued amount** — partial buyback is not supported * YT returned to position → status reverts from YT-Issued → Active → Looper can Release **Buyback pricing uses the current market rate, not the original listing rate:** ``` Cost = GYT_amount × current_compound_price Example: Buy back 500 YT at Day 40 (50 days remaining) interestRate = (1.0002155)^51 - 1 = 0.01105 price per YT = 0.01105 / 1.01105 = 0.01093 Total cost ≈ 500 × 0.01093 ≈ 5,465 USDC ``` For Split Sale positions, the buyback routing is: 1. System cancels any unfilled listings in queue (recovering those tokens) 2. Remaining required YT-O and YT-P are purchased from their respective markets 3. Components are recombined into YT and returned to unlock the position #### YT-O and YT-P — Yield Decomposition (Upcoming Updats) Different YT supply sources carry different points multipliers — a YT from SLF sUSDe (20× points) is economically different from one migrated from AAVE (5× points). Bundling them into one token creates pricing inefficiency for buyers who only want one component. YT-O/YT-P decomposition solves this by allowing YT to be split into two independently tradeable yield components: * **YT-O (Organic Yield Token):** Rights to the staking APY of the underlying collateral. Cross-source fungible — organic yield depends only on the asset, not where the position was funded * **YT-P (Points Token):** Rights to protocol incentive points (e.g., Ethena sat-days). Cross-source fungible — all GYT-P represent the same unit of points regardless of origin This lets buyers target exactly what they want: pure organic yield, pure points exposure, or both. It also enables more accurate price discovery since the two components respond to different market signals. **Listing modes:** * **Bundle Sale:** YT listed as a unified bundle — buyers receive both organic yield and points together * **Split Sale:** YT is automatically decomposed on listing; YT-O and YT-P enter separate queues, allowing buyers to purchase each component independently Split and merge between YT and its components are reversible at any time with no value loss. This feature is planned for a future release. #### Retroactive Rewards If a protocol issues retroactive rewards after YT has already been split into YT-O and YT-P, those rewards are distributed proportionally to YT holders based on original YT ownership — not decomposed further into O/P components. Since their nature (organic or points) is unknown at listing time, they are treated as belonging to the YT layer. #### Structural Advantage vs. Pendle Pendle performs a "horizontal" split — separating principal from yield at the asset level. Both PT and YT holders remain exposed to the same underlying asset risk. Bondify performs a "vertical" split — creating a hierarchical capital structure where the Junior Tranche acts as a protective buffer. This means: * YT holders have a structurally lower-risk yield product * Loopers (the YT sellers) have greater room to price competitively because their leveraged returns are higher to begin with * The result is deeper, more sustainable yield market liquidity *** ### Summary | | JR Token | YT | | ------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------------- | | **What it represents** | Standardized leveraged looping position | Yield rights (organic yield and/or points) from the underlying collateral | | **Primary user** | Leveraged yield seekers; traders wanting managed exposure | Loopers hedging yield risk; buyers speculating on yield | | **Key benefit** | Tradeable exit liquidity for looping positions; no forced unwinding | Fixed yield upfront for sellers; leveraged yield exposure for buyers | | **Secondary market** | Staple AMM / OTC swap | FIFO queue with time-decay pricing | | **Unique differentiator** | Fungible, actively managed leveraged position token | Bundle or split sale (GYT-O + GYT-P independently) |