We integrated Reactive Network as the execution layer for hook events. When MochiYieldHook detects PT/YT parity drift above threshold on Unichain Sepolia, it emits ParityDriftDetected; our MochiReactiveKeeper on Reactive Lasna subscribes to that event and triggers a cross-chain callback to ArbitrageRouter on the origin chain to restore parity , no centralized keeper bots required.
Github: https://github.com/karar189/mochiyeild Slides: https://www.mochiyeild.xyz/slides Project Link: https://www.mochiyeild.xyz/ Demo Video: https://youtu.be/PPvFvIPpd8k
Most people who hold yield bearing assets like wstETH face a simple problem: you either keep the whole position, or you sell it. There is no easy way to say "I want my principal back at maturity, but I want to trade or speculate on just the yield." That makes yield exposure feel all or nothing.
This gets harder when you think about impermanent loss. Liquidity providers in normal AMM pools take price risk. As the market moves, the value of their position can drift away from simply holding the asset. For yield products, that risk is not constant over time. Near maturity, price behavior and volatility are very different from months earlier, but most pools still charge the same fees and apply the same rules regardless of where you are on the curve.
Fixed income style markets try to solve this with Principal Tokens (PT) and Yield Tokens (YT). PT represents the right to redeem underlying at maturity. YT represents the future yield until that date. In theory, PT plus YT should track the underlying. In practice, these markets often break down. PT can trade above par, which implies a negative yield. Fees do not reflect how much time is left until maturity. And when PT and YT prices drift apart from the underlying, someone has to notice and arbitrage it back manually.
Older AMM designs make this even harder. Uniswap v3 and custom pools cannot easily run one shared policy across two related markets at once. You cannot atomically enforce implied rate limits, maturity based fee changes, and cross pool parity checks in a single coordinated system. That is the gap Mochi Yield is built to fill.
Mochi Yield brings fixed income logic directly into Uniswap v4 through a single hook that understands yield curves, not just swap volume. When someone trades PT or YT, the hook checks whether the trade makes economic sense given time to maturity, adjusts fees as expiration gets closer, and monitors whether PT and YT still add up correctly against the underlying.
That matters because v4 lets one hook govern multiple pools at the same time. PT and YT markets can share the same rules, the same guardrails, and the same parity checks in one place. Conservative users get a clearer path to principal focused exposure. Yield speculators can trade future yield without selling wstETH. LPs get fees that better match the actual risk they are taking over the life of the position.
We also integrated Reactive Network so the hook does more than emit events. When parity drift is detected, Reactive can trigger automated corrective action across chains instead of waiting for a manual bot or keeper. The result is a market that is easier to understand for users and more stable for everyone participating in it.
The hardest part was putting fixed income logic inside a Uniswap v4 hook without breaking how swaps are supposed to feel. Every trade needed to respect time to maturity, block trades that implied negative yield, adjust fees based on how close PT is to expiration, and still stay within reasonable gas limits. Getting those checks to work together on every swap took a lot of iteration and testing.
Coordinating two related pools at once was another major challenge. PT and YT markets need to stay aligned with each other and with the underlying asset, but most AMM designs treat each pool as its own isolated system. Building parity monitoring and shared policy rules across both pools in one hook required careful thinking about state, events, and what should happen when prices drift apart.
Integrating Reactive Network added a completely different layer of complexity. The hook runs on Unichain Sepolia, but the reactive keeper lives on Reactive Lasna and has to listen for events, decode them correctly, and send callbacks back to the origin chain. Debugging that full pipeline, from parity drift detection to automated response, was much harder than building the core contracts alone. Small mismatches in event data, subscription setup, or callback timing could break the entire flow.
We also had to make hard tradeoffs for the hackathon timeline. The reactive callback path works end to end, but executing the full PT/YT arbitrage directly inside Uniswap v4 swaps is still the next step. Balancing a polished demo, solid test coverage, and a frontend that explains a fairly abstract fixed income concept to everyday DeFi users stretched us across smart contracts, cross chain infrastructure, and product design all at once :)