How did you integrate our partners, if any?

A Reactive smart contract (ILBondReactive, on Lasna) is the IL mark-to-market engine: fully event-driven, no cron or keeper.

1. Subscribes to 4 hook events on the origin chain: SwapOccurred, PositionCreated, PositionExited, ILBondDataBundle.
2. On every swap → emits a callback to prepareILBondData() on the hook, which emits a bundle of all open positions' prices.
3. On the bundle → computes impermanent loss (IL = 1 − 2√r/(1+r)) for each position inside the ReactVM, then callbacks settleILMark() to write the fresh mark on-chain.
4. Position create/exit → self-callbacks keep activeCount in sync.

Net: hook + pools on Sepolia/Unichain, IL-pricing engine on Lasna, talking purely through Reactive's event→callback loop. No centralized bot; the network re-prices IL trustlessly on every swap.

What are the key links to share? (Ex. demo video, GitHub, deck)

Github: https://github.com/Prakhar-30/schizo_UHI9 Slides: https://docs.google.com/presentation/d/1lFZoVNyTSlJt31cj_2eb6N9q5CTvGmuAjJ_kOyV2K-k/edit?usp=sharing Project Link: https://schizo-il-bond.vercel.app/ Demo Video: https://youtu.be/RMAE2iiFZEE

Problem / Background: What inspired the idea? What problems are you solving?

Impermanent loss is the single biggest reason people don't LP. You provide liquidity to earn fees, but if the price moves you can end up worse off than if you'd just held, and that downside is silent, unhedgeable, and bundled into the same position as your yield. Today an LP has no way to keep the fee income while shedding the IL risk, and a trader who wants directional/volatility exposure has no clean instrument to buy it.

I was inspired by how TradFi unbundles risk: a bond strips a cash flow from its principal, and structured products separate the coupon from the exposure.

DeFi LP positions are really two assets fused together: a fee-earning claim and a volatility-bearing claim

but AMMs force you to hold both.

schizō solves this by splitting every Uniswap v4 LP position into two tradeable tokens:

• FEE-T : the swap fees + an upfront premium (yield, no IL)
• IL-T: the underlying composition that bears impermanent loss (the risk leg a hunter buys)

This creates an on-chain bond market for impermanent loss: LPs sell their downside for cash today, and hunters take on IL exposure at a price. The hard part : continuously re-pricing each position's IL as the market moves; is solved by a Reactive Smart Contract that marks every position to market on each swap, trustlessly and without any centralized keeper.

Impact: What makes this project unique? What impact will this make?

What makes schizō different is that it actually splits the LP position into two tradeable tokens: one earns the fees, the other carries the impermanent loss. Most "IL hedging" projects bolt on insurance or an options vault on the side; schizō unbundles the position itself, which nobody's really done cleanly on Uniswap v4.

The other piece is the Reactive Smart Contract. IL is hard to trade because it changes on every swap, so you'd normally need a bot constantly re-pricing positions. We don't — the Reactive Network re-prices each position the instant a swap happens, on-chain, no keeper. That's what makes a live IL market possible at all.

The impact: LPs finally get an exit besides pulling liquidity. You can stay in, keep earning fees, and sell the downside to someone who wants it; which should bring in LPs who sit out today and deepen liquidity for everyone. And traders get a clean way to take a direct position on volatility instead of guessing through options. It's DeFi pricing risk the way TradFi does: yield-seekers and risk-takers each get the side they actually want.

Challenges: What was challenging about building this project?

• Pricing IL on every swap, trustlessly. Getting the Reactive Network loop right was the core challenge: a two-legged flow where a swap triggers the hook to emit a data bundle, then the RSC computes IL in the ReactVM and writes the mark back. Wiring the event topics, callbacks, and gas correctly across two chains took real iteration.

• Relay lag. The settleILMark write-back leg sometimes stalled on the relay even though the bundle leg landed reliably. We made the frontend derive IL client-side from live pool price as a fallback, so the UI never freezes.

• Multi-pool correctness. Our first version read one pool's price and applied it to every position: fine for one pool, corrupts marks across 45. We had to carry each position's own pool price through the bundle.

• IL math in fixed-point Solidity. The IL formula √r·√r overflowed at extreme price divergence and could brick a whole bundle. Had to saturate at 100% IL before the overflow point.

• Decimals everywhere. Pools mix 2/6/8/18-decimal tokens, so raw prices were off by huge factors — every parse, format, and chart needed per-token decimal handling.