What's eating your LP profits 🥢💸

Toxic MEV
Not all MEV is the same. There's MEV like liquidations, backruns that don't hurt anyone. And there's toxic MEV - the kind that directly extracts value from users and LPs.

Two big types:
➖ Sandwich attacks - a bot frontruns your swap, moves the price then you trade at a worse rate and bot backruns to take the spread
➖ Arbitrage against stale prices - market price moves on a CEX, your AMM pool still quotes the old price, arb bots buy the underpriced asset from the pool and sell it on CEX. The difference comes directly from LP pockets

Sandwiches hurt traders. But for LPs, the real killer is stale price arbitrage.

LVR: Loss-Versus-Rebalancing
LVR measures the cost LPs pay every time an arb bot corrects the pool price to match the real market price.

How it works:
1️⃣ ETH price moves on Binance
2️⃣ Your Uniswap pool still quotes the old stale price
3️⃣ Arb bot buys cheap ETH from the pool, sells on CEX at the real price
4️⃣ Pool price updates but LPs sold ETH at a discount compared to the true market

That gap between what LPs gave and what the asset was actually worth - that's LVR. And it happens every single block where the market moved.

IL vs LVR - not the same thing
➖ IL (Impermanent Loss) compares your LP value vs just holding at two points in time. When price comes back —> IL = 0. It's a snapshot.
➖ LVR is the cumulative cost of being arbitraged block by block along the entire price path. Even if ETH goes $2000 —> $2500 —> $2000, IL is zero but LVR is not 😁. Arb bots took their cut on every move in both directions.

On concentrated liquidity pools (V3/V4), LVR gets amplified, so higher capital efficiency = higher arb profit per block. Research shows LVR costs LPs 5-7% of their liquidity annually. Hundreds of millions across DeFi.

Why LPs keep ignoring this
1️⃣ Dashboard lie. LP UIs show "fees earned" and "IL." Usually they don't show LVR.
2️⃣ APR marketing. Those juicy APRs don't factor in LVR. Like advertising salary without mentioning the 60% tax.
3️⃣ "Impermanent" sounds harmless. People think the loss will reverse. But the LVR component is already extracted, means the price coming back doesn't un-extract value.
4️⃣ It's invisible. No tx in your wallet says "LVR: -$420”. It's baked into the prices your pool traded at.

Can you actually fight this? Yes, and I'll cover the main approaches in the next post, including what I’ve built with EigenAuction to redirect arb profits back to LPs 🔥

I recommend to read this article about LVR from Cow DAO

AVS - the thing that actually consumes restaking security

What is an AVS
AVS stands for Actively Validated Service - external system that needs its own group of operators watching it, checking it, and being economically punished if they lie about it, and that borrows EigenLayer's restaked capital to do that instead of bootstrapping its own.

An oracle network, a bridge, a data availability layer, a shared sequencer, my own auction contract - all of these can be AVSs. The common thread: they all need not only computation, but also a verification, and EigenLayer brings it for them.

The analogy that made it click for me
When you want to build an application, you build an application server. When you want to build a *verifiable* application, you build a rollup.
The internet lets applications talk to each other. Ethereum lets rollups verifiably talk to each other.

Building every component of your app server yourself is hard, so servers integrate SaaS tools that solve specialized problems for them.
Building every component of your rollup yourself is hard too, so rollups lean on AVSs to solve specialized problems (data availability, oracles, sequencing) in a verifiable way.

Hosting your own server and all your SaaS yourself is hard, so you rent a cloud provider that runs everything for you at scale.
Running your own rollup and your own AVSs securely is just as hard, so you lean on EigenLayer - it's the "cloud provider" that lets rollups and AVSs borrow verifiable, economically-backed security instead of building it themselves.

The components. Who does what
1️⃣ Restakers - deposit ETH or LSTs into EigenLayer, delegate to an operator. They take on the risk, they earn the extra yield.
2️⃣ Operators - run the actual node software for one or more AVSs. They opt in to specific services, and specific slashing conditions come with that opt-in.
3️⃣ The AVS itself - a set of smart contracts (registration, task assignment, reward + slashing logic) plus the off-chain job the operators are actually doing.
4️⃣ Consumers - the apps or protocols that use the AVS's output and trust it because it's economically backed, not because they trust a person.

An operator who signs off on a bad result doesn't just lose reputation - they lose staked capital. That's the whole point.

EigenAuction AVS

This is where my project lives. AuctionServiceManager.sol is the AVS in EigenAuction:
➖ Operators run MEV/LVR auction every block and select the searcher who propose the highest bid
➖ They BLS sign the auction result and send it to aggregator who commit that result on-chain
➖ There's a challenge window - if the committed winner is wrong or the operator cheats, anyone can dispute it
➖ If the dispute holds up, the operator gets slashed

I definitely didn't want LPs to just trust that whoever wins the auction actually pays what they promised, this is a wrong design. I needed that commitment to be verifiable on-chain and backed by real capital, so cheating is expensive and everyone understands that. That's the entire reason EigenAuction is built as an AVS instead of a normal off-chain service with a multisig and a promise.

Currently I running the contracts locally in Mainnet fork on Anvil with the contracts deployed on it. I spin up the off-chain services: relay, aggregator, redis and 3 operators via Aspire and feed different bids + 1 swap intent to operators quorum.
I am following a replication model so each operator has the auction final bids batch + intents. All 3 operators successfully select the correct bid and BLS sign it. After that aggregator committed the result to EigenAuctionTaskManager, and a randomly selected operator settles the searcher trade and then intents.

P.s: If you joined a UHI-10, then you can use my EigenAuction protocol to build smth yours, because it directly matches the topic of this cohort hackathon 😉

It’s time to ask community for a help 😁

I’ll be short.
I am actively looking for a job atm with the focus on DeFi engineer role, and I am also ready to consider a full-stack roles (smart contracts + backend). I am looking for a roles in these domains: AMMs, Vaults, Liquidity Optimisation, Stablecoins Payment infra, AI x DeFi + ready to consider other areas.

If you:
➖ know someone who is hiring
➖ hiring personally
➖ can refer/recommend me
I will really appreciate any help.

Quick Info and what I am looking for
5 years in software engineering, 3 years with smart contracts. Main expertise in vaults, AMMs, MEV Auctions.

My stack: Solidity, TypeScript, Go (ask for a CV to see more about experience/skills or check LN)
Available: immediately
Format: remote in priority, but ready to consider relocation (US, Asia, Europe)
Portfolio: https://github.com/ohMySol
X: https://x.com/ohMySolboy
LN: https://www.linkedin.com/in/anton-holovchenko/

If you can repost my LN and X post and help me to reach more ppl - that will help a lot. If I’ll land on the job by your recommendation/help, I’ll reward you with USDC bonus 💰

Feel free to DM at any time. CV will be shared by request.

Cool analysis of Capital Efficiency from 1inch in Concentrated Liquidity pools. Worth to read if you LPing.

Core idea I highlight for myself after reading: concentrated liquidity was a real improvement over constant product AMMs, but capital efficiency is still far from solved.
It is obvious that liquidity is no longer a bottleneck, instead the capital efficiency/utilization is.

Key points from doc:
➖ 29.5% of capital (avg. ~$542M/week across the four protocols studied) sat fully outside its active price range over H1 2026. In simple words this $542M capital is inside DEX pool, but owners earn nothing.
➖ Including "in-range but never actually traded against" capital, ~85% is underutilized overall. Though that's still a big improvement over prev. concentrated liquidity AMMs (Uniswap v2, etc.), where ~98.7% of capital sits unused.
➖ Idle capital costs LPs an estimated ~$150M/year in foregone fees.

Also wasn’t surprise for me, but it’s worth to mention that a Uniswap V4 is no better. Despite the newest design and optimisation of the swaps, LPing, flash loaning, its idle capital share ~30.5% matches Uniswap V3. You can say - they have hooks to put idle capital to work, and some pools really do this, but none of the measured pools in this analysis.

And that’s only the capital efficiency question. You remember that there is also IL and LVR waiting for you.

Invariants and why they are so important in your contracts.

Why unit tests alone aren't enough?
You all know what invariants are - conditions that must hold true after every state change, no matter what. The problem is most people still test them with unit tests, checking one specific scenario at a time. That's one path out of thousands.
Invariant testing with a fuzzer like Echidna is a different game, it throws thousands of random, chaotic action sequences at your contract and checks after every single one: does the property still hold?

I collected below Core DeFi invariants you should be testing
1️⃣Total supply == sum of all balances.
If these don't match, your protocol is creating or destroying tokens from air. Most basic accounting check.

2️⃣ Reserves match deposited assets.
Internal accounting must equal what's actually sitting in the contract. When balanceOf(address(this)) differs from your tracked deposits, that's how protocols silently drain. Also test what happens when someone sends tokens directly without calling deposit(). Most protocols don't handle this and it either creates an exploit or locks tokens forever.

3️⃣ No path lets users withdraw more than deposited.
Rounding errors live here. Solidity rounds down, and with dust amounts those errors compound across deposit/withdraw sequences.

4️⃣ Admin functions can't drain user funds.
It means compromised admin key = drained protocol. Sounds obvious, but when the key is already compromised, your protocol should not let attacker with Admin rights to easily drain it with 1 function call (in best case ofc even 50 func calls shouldn’t let drain anything). And don't forget soft rugs - can admin set fees to 100%? Pause withdrawals forever? And so on.

5️⃣ Timelocks actually wait.
Classic bug: >= vs > lets someone execute one second early. Test at exact boundaries.

6️⃣ Protocol is never insolvent.
Total assets >= total liabilities, always. For example, for vaults - total redeemable shares at current price must always be coverable by actual assets. Fuzzer should hammer this around liquidations and bad debt scenarios.

Invariants as a design tool
In my opinion this is the part most people miss, me as well. Invariant testing isn't just about finding bugs after you write the code, it changes how you design the protocol in the first place.

When you start thinking in invariants from the beginning of the project, you're essentially defining the rules your system can never break before writing a single line of logic. "Reserves must always match deposits" isn't just a test, it's an architectural constraint that defines how you write your deposit, withdraw, and fee functions. You catch bad design decisions at the architecture level, not after 2 months of development when changing anything costs rewriting full module or a feature.

Since I started fuzzing with Echidna, the way I build protocols changed. I noticed that the invariant mindset forces you to think more about edge cases and different state change scenarios that can produce these cases. I saw several times a “fuzzing experience” requirement in JDs, and I think this is a skill every DeFi dev should 100% have and use on each project. Unit tests are not enough, especially with the current hacks amount, so my advice is simple - test your system under the pressure to have as much confidence in it as you can.

Maybe someone will be interested to check what US CLARITY Act will bring to the market. Most of the Web 3 projects work in the US, have customers from there, registered there, so this regulatory framework will touch a lot of businesses I guess (correct me if I am wrong). The goal of this Act is to reduce the pressure on legitimate entrepreneurs to operate offshore and create the better version of the regulation for the secure blockchain/DeFi infra on top of which stablecoins will work (GENIUS Act).

From what I understood these points “might be potentially improved”:
➖ DeFi gets explicit protections. The legislation exempts DeFi protocols and applications from the regulatory requirements that the bill establishes for intermediaries like exchanges and brokers. If your startup builds DeFi protocols, you wouldn't be regulated like a centralized exchange as long as your system doesn't act as an intermediary.
➖ Insider selling restrictions. If you're a founder or early investor, you won't be able to dump tokens until the network hits the "mature" threshold, which is defined by seven objective, measurable criteria around eliminating centralized control.

What I think might potentially slow down the startups on early stages is this:

applying more oversight and stringent regulatory burdens during a blockchain system’s formative stages — when there’s centralized control, and so the risks associated with that blockchain system’s native digital asset most resemble those of securities

and reduced regulatory requirements as the projects mature.
From one side makes sense, and I agree that on early stages startups are too centralised, but from the other side you face heavier disclosure rules, which might slow down your product launch I think.

I think, projects working with the US will have an increased financial burden due to lawyers and compliance. As I understood US customers = US jurisdiction.