Plenty of teams came through the UHI9 hookathon, and a good share of them used Reactive Network. The judges did something more useful than count claims: they checked whether each project's reactive contract actually fired a callback on-chain. Six passed that test. This is a look at those six: what they made, and why a hook alone could not get them there.

First, the short version. A Uniswap hook is code that runs at specific moments during a swap. It is quite functional, but it has one hard limit: it only wakes up when someone trades. No swap, no hook. Fine for anything that happens during a trade, and a problem for everything that needs to happen when the pool is quiet.

A reactive contract is the other half of the story. It watches for events, including events on other chains, and when it sees one it cares about, it acts on its own by firing a callback. No human, no off-chain bot, no scheduled job on a server. When a builder says their reactive contract "emitted callbacks", they mean the watch-and-act loop actually ran. That loop is the thread through all six projects below.

EvenFlow: The Problem With Waiting for a Swap

EvenFlow is the cleanest illustration of why any of this matters. When trading turns against liquidity providers (the people who supply the pool's capital, usually shortened to LPs), EvenFlow collects a small surcharge and holds it aside in a reserve. Once the market calms down, that reserve is meant to drip back to the LPs who stayed in range.

Here is the catch the team spotted: the payback needs something to trigger it, and the natural trigger would be a swap. But the whole point is that things have gone quiet. If nobody trades, nothing fires, and the reserve just sits there stranded. Their fix was a reactive cron, a time-based reactive contract that releases the funds cross-chain whether or not anyone shows up to trade. It is a small idea with a big implication, and EvenFlow states it more plainly than anyone else in the cohort: a hook can’t rescue capital during a quiet spell, because it is exactly when a hook is asleep.

Unistrata: Settling the Books With No One at the Desk

Unistrata treats a liquidity pool the way finance treats a bond structure. There is a senior tranche with protected principal and a coupon priced off volatility, sitting on top of a junior tranche that takes the first loss in exchange for more upside. First in line to get paid, versus first to absorb the hit.

At the end of each epoch (a fixed settlement period), someone has to work through that waterfall and decide who gets what. Unistrata does it with a reactive contract and nothing else. No keeper, no bot, and, notably, no external price oracle. The volatility figure that prices the coupon is read straight from the pool's own price movements, the path its ticks actually took. The settlement then fires cross-chain on its own. It is the same lesson as EvenFlow wearing a different suit: the moment that matters is a moment of stillness, and stillness is where reactive contracts do their best work.

TrancheShield: A Risk Dial That Turns Itself

TrancheShield takes the watching loop and points it at the pool's own health. A reactive contract prices the pool's risk continuously and adjusts three levers cross-chain as conditions shift: the swap fee, the level of impermanent-loss coverage (protection against the pool losing value compared to simply holding the two tokens), and whether new deposits are allowed in at all.

What is curious here is the framing. The reactive contract does not live inside the pool; it sits outside it and holds the authority to reconfigure it. When volatility spikes, or reserves start to look thin, or everyone heads for the exit at once, the dial turns without anyone touching it. It is less a trigger and more a control plane, quietly keeping the settings honest while the pool goes about its business.

lambda: Hedging on a Market Your Hook Has Never Visited

lambda tackles a problem LPs know well. Provide liquidity, watch the price move, and you can end up worse off than if you had simply held the two tokens. The field has a name for that drift: loss-versus-rebalancing, or LVR. The usual answer is to hedge on a derivatives market, and the usual trouble is that the market you would hedge on lives somewhere your pool does not.

lambda's positions sit on Unichain, and each one is automatically hedged on Hyperliquid, a separate perpetuals venue (a market for no-expiry futures). A reactive contract is the bridge that lets a hook on one chain act on a market on another, with no off-chain bot in between. The result is an LP position that stays close to delta-neutral (gains on one side roughly cancelling losses on the other) instead of bleeding value on every price swing. This is Reactive doing the one thing a hook fundamentally can’t: reaching past the edge of its own chain.

Maestro: Letting a Contract Run the Pool

Most of these projects use a reactive contract to assist a pool. Maestro hands it the keys.

Here the reactive contract is the pool manager. It subscribes to a live Pyth ETH/USD feed (an on-chain source of the current price) on one chain and fires callbacks to Unichain to keep the pool's liquidity concentrated around the real market price. The right to be that manager is sold through a continuous, self-assessed auction (a Harberger auction, if you want the term), and the rent flows back to LP shareholders block by block. The manager is not a person, and it is not a bot idling on a server. It is a contract that watches a price and acts. Maestro's team makes a fair claim to a first here: a concentrated-liquidity, auction-managed AMM whose manager is fully autonomous and lives across chains.

Veritas: What the Chain has Already Seen

Veritas is the most quietly interesting of the six, because its real subject is trust. A reactive contract on Lasna testnet watches for attestation events (on-chain records vouching that some content is authentic) over on Unichain Sepolia. When a near-duplicate of previously attested content appears on-chain, the contract fires a callback that raises that asset's "dilution score", which in turn feeds into how much fee protection LPs receive on the next swap.

The team's reasoning is the sharpest line to come out of the whole hookathon, and it is worth sitting with. An off-chain oracle has to sign its data, and anything that can be signed can, in principle, be bribed. A dilution floor built from what the chain has already witnessed can’t be pushed below the record, because you can’t ‘un-happen’ an on-chain event. So instead of trusting a signer, Veritas trusts the ledger's memory, and the reactive contract is what turns that memory into a live signal the pool can use.

Common Thread 

Line them up and a pattern appears. EvenFlow releases capital during a quiet spell. Unistrata settles when the epoch closes. TrancheShield adjusts when conditions move. lambda hedges on a venue elsewhere. Maestro re-centers when the price drifts. Veritas reacts to what another chain has recorded. Almost every one of them acts at a moment when nothing else is prompting anything to happen, and reaches across chains to do it. That is not a coincidence of theme. It is the shape of the space where a hook runs out of road and a reactive contract keeps going.

Quite a few teams at UHI9 chose Reactive for exactly this kind of job, and these six carried the idea all the way to a callback that fired on-chain. Their repositories are open if you would like to see how they did it. And since this is only the first wave, there are others still working their way toward the same finish line.

About Reactive Network

Reactive Network is an EVM automation layer built around reactive contracts, event-driven smart contracts for cross-chain, on-chain automation. It runs on CometBFT consensus, providing instant finality and roughly 1-second block times while maintaining full EVM compatibility.

Reactive contracts subscribe to event logs across EVM chains and execute Solidity logic automatically when matching events occur, deciding autonomously when to send cross-chain callback transactions. This model supports conditional cross-chain state changes and continuous cross-chain workflows.

Website | Blog | X | Telegram | Discord | Docs

Build once — react everywhere!