For most of crypto’s history, yield has been a thing that happens to your wallet, not for it. You provide liquidity, a swap happens somewhere, and then — at some indeterminate moment, possibly weeks later — your position is worth slightly more than it was. The math says the accrual is continuous. The experience is anything but. Most LPs find out what they earned the same way you find out what your landlord did to your security deposit: after the fact, in a lump sum, with limited recourse.
We think this gap between the math and the experience is the most expensive design defect in DeFi. It distorts every downstream decision a serious capital allocator has to make. A DAO treasurer modelling next quarter’s payroll cannot honestly say what the treasury earned this week. A market maker hedging delta on a concentrated position cannot net the fee leg against the inventory leg without rebuilding state from logs. A fund reporting to LPs ends up describing returns the way a fisherman describes the one that got away — with feeling, not precision. The pool earned something. We just don’t know how much, when, or whose.
The reason is structural, not philosophical. Until very recently the cheapest place to keep per-LP fee accounting was inside the swap call itself, which meant fees moved only when swaps moved. The accounting was correct, but it was also bursty — a step function pretending to be a line. Every other piece of treasury infrastructure has spent the last decade migrating away from step functions. Payroll became streaming. Cloud billing became per-second. Subscription revenue became MRR-with-a-clock-attached. LP yield is one of the last serious financial primitives that still settles in ragged batches whenever the underlying happens to twitch.
The drip primitive
The fix is unglamorous and, in retrospect, obvious. Instead of crediting fees the moment a swap clears, you deposit them into a buffer and bleed the buffer out linearly over a fixed window. The window we’ve settled on is seven days. New fees arriving inside an active window extend the runway; the rate adjusts; the line keeps moving. The user-facing API is one function: claimable(wallet, t) returns the exact amount accrued to an address at any timestamp, and the value is differentiable with respect to t. That last property is the one that matters. You can integrate it. You can hedge it. You can amortise it. You can put it in a spreadsheet without losing your weekend.
Mechanically this is a small change. Philosophically it’s a re-categorisation. A claim that produces a continuous, time-indexed number is not the same financial object as a claim that produces a lumpy, swap-indexed number, even if the long-run integral is identical. The first one is a yield stream — it has a rate, a duration, and a shape. The second one is a coupon clipped off a random calendar. Treasuries that learn to think in rates instead of in coupons make different, and generally better, decisions about what to do with the capital underneath.
The pool earned something. We just don’t know how much, when, or whose. That is the entire problem.
Why now, why Uniswap v4
Three things had to land before this was buildable as a single, cheap contract. The first is the v4 singleton PoolManager: a hook can read and modify pool state inside the same execution frame as the swap, without round-tripping through external calls and without a per-pool contract deployment. The second is EIP-1153 transient storage. TLOAD and TSTORE at 100 gas each let us carry the per-swap delta from afterSwap through to the buffer write without ever touching cold storage. Per-swap accounting overhead falls into the low single-digit thousands of gas — an order of magnitude under what an ERC-4626 wrapper running on top of v3 used to cost.
The third thing is Unichain. A continuous-drip primitive only earns its keep if claiming the drip is itself continuous — and that means claims have to be economically rational at one-second granularity. On L1 mainnet, a 21k-gas claim every few seconds is a comedy sketch. On Unichain, with sub-second blocks and call-data compression inherited from the OP stack, the same claim costs a fraction of a cent. The drip rate and the claim rate are finally measured in the same units of time. The economics close.
What we built
Unitone is one contract: a Uniswap v4 hook whose address ends in 0x8C0, registering three permission bits — beforeAddLiquidity, beforeRemoveLiquidity, and afterSwap. On each swap the hook reads the LP-fee portion of the BalanceDelta, takes it into a per-pool drip buffer, and updates a single rate variable. On each liquidity event it syncs the affected LP’s share count and timestamps their last claim. Settlement is constant-time. The drip math is six state variables and two formulas. There is no oracle, no off-chain keeper, no admin key with a power to halt accrual. Everything important fits on one page of the spec.
What we believe
A treasury that can model its income one block at a time runs differently from one that can’t. It can sign multi-year service contracts denominated in stable cash flows. It can lend its own future yield forward, in tranches, the way real institutions do. It can hedge with instruments that have meaningful duration. It can tell its members, with a straight face and a chart that updates every second, exactly what the protocol earned last week. None of this is exotic. It is what every non-crypto financial entity above a certain size already does, and what crypto treasuries have so far had to fake with quarterly snapshots and a lot of charm.
The thesis isn’t that streaming yield is a clever feature. The thesis is that fee accrual was always supposed to be a stream, and the lumpy version we’ve been living with was a concession to the tools we had, not a property of the underlying economics. Now the tools have caught up. We expect that within the next two cycles, batched fee accrual will look as quaint as the monthly bank statement — technically correct, demonstrably functional, and obviously the wrong shape for the job. Someone has to ship the replacement primitive. We are shipping ours.
Endnote
If you run a DAO treasury, a market making book, or a fund and this thesis lands — we want to talk. We’re especially interested in operators who have already tried to retrofit streaming-style accounting on top of v3-style fee receipts and have the scar tissue to show for it. Write us at team@unitone.tech, or find us on X. The hook goes to testnet in Q3 and mainnet in Q4. Early treasury partners get a say in the next set of drip-window primitives and priority help with integration. The replacement primitive is coming either way. We’d rather build it with you in the room.