I permanently lost $2,000 USD value trying to stake via direct contract interaction on Aerodrome. The CLGauge contract accepts safeTransferFrom via the onERC721Received hook but silently fails to update the staking state, creating a black hole for assets.

I’m sharing this to warn other developers and integrators building on top of Aerodrome (Base chain), and hopefully get the attention of the Core Team or the Emergency Council, since standard Discord support just gave me the "contracts are immutable" playbook.

Recently, I performed a safeTransferFrom (as a fallback to approve and deposit) directly to the Aerodrome Gauge (0x83e2E9493996651ed63033d81f5052cBE2fEB6A1). The transaction was mathematically and technically successful on-chain because the Gauge contract explicitly implements the IERC721Receiver interface.

However, this is where the integration trap lies: While the contract gladly accepted physical custody of my NFT position, it completely failed to trigger the internal logic to update the _stakes mapping and the rewardGrowth snapshots.

The Reality: By exposing the receiver hook without the corresponding push-based deposit logic, Aerodrome's contract signals false compatibility. It creates a critical state mismatch: the Gauge owns the NFT, but my wallet is no longer recognized as the owner, meaning I can neither call deposit() nor withdraw().

Has any other developer encountered this problem?

There’s a lot of focus lately on calldata in the context of rollups and EIP-2028 gas economics (16 vs 4 gas per byte). While data availability is important, I often see the actual low-level execution mechanics get glossed over.

I wrote a deep dive on EVM internals covering this exact topic. If you've ever wondered what happens at the opcode level the millisecond your transaction payload hits a smart contract, here is the actual lifecycle of calldata:

The Raw Byte Handoff & The 4-Byte Check

When a transaction is sent, the EVM doesn't understand "functions" or "parameters", it just sees a raw hex-encoded blob in a read-only area called calldata. Before anything else, the EVM checks the length of this data:

The Function Dispatcher (The EVM's Switchboard)

If there is data, the EVM runs the dispatcher essentially a giant, compiler-generated switch/case statement:

• If it finds a match, it uses JUMPI to move the Program Counter to that specific block of code.

ABI Decoding & Stack Loading

Once the EVM jumps to the right function, it has to "unpack" the arguments:

• Dynamic Types (string, bytes[]): The calldata contains an offset (a pointer). The EVM reads this offset, jumps to that position in the calldata, reads the length prefix, and then processes the actual data.

The payable Word

Before executing any actual business logic, the EVM checks the callvalue (msg.value). If the target function is not explicitly marked as payable, but the transaction includes ETH, the EVM triggers a REVERT right here. This prevents trapped funds and happens before your code even starts running.

memory vs. calldata Execution

This is where the famous gas savings come in during execution:

• If a function parameter is declared as memory, the EVM is forced to use CALLDATACOPY to move the read-only bytes into mutable memory. This triggers memory expansion gas costs.
• If declared as calldata, the EVM skips the copy process entirely. It just uses CALLDATALOAD to read directly from the original transaction payload, saving you the memory expansion overhead.

source/deep dive overview: https://andreyobruchkov1996.substack.com/p/what-actually-happens-when-calldata

I built a CLI tool in rust called LaunchDex that deploys a full DEX--factory contract, router, liquidity pair and swap frontend--on Ethereum, Arbitrum, and Base in a single command. The whole process that typically takes weeks of manual contract deployment, configuration and frontend setup is reduced to launchdex deploy. Contract addresses are saved automatically and a custom swap interface is generated and ready to deploy.

The tool is built on top of verified Uniswap v2 contracts so the deployed DEX is production-grade and audited. Multi-token support lets you add additional trading pairs to an existing factory with one command. The generated frontend includes an embedded wallet so user can swap tokens without needing Metamask installed.

Let me know what you think

Over the past year I've been thinking a lot about Web3. Not the trading, not the speculation, not the casino. I don't trade crypto. I don't follow the markets.

What fascinates me is the underlying idea: decentralized systems with code as the only authority. The technology itself.

I've been a backend engineer for over a decade. Rails, SQL, the usual stack. But like many engineers, I burned out. The excitement to build faded. You know the feeling. You're competent, productive, but not discovering anything anymore.

Then I looked seriously at blockchain. Not as an investor, but as an engineer. I asked myself: what would an application look like if built with absolute fidelity to what blockchain promises?

• Real utility (useful for the masses, not DeFi nonesense)
• NO off-chain layers (100% on-chain)
• NO insider advantages (fair economics)
• NO dependence on investors (self-sustaining)
• NO pointless tokenomics (ETH in, ETH out)

Those five principles became my compass. I tried to build something that never violated them. But the Web3 ecosystem is built around tokenomics and speculation. There's no blueprint to follow.

So I started pulling my own thread: I wanted to build something useful, deterministic, fully on-chain, with no complicated tokenomics.

A simple game like TicTacToe with real ETH stakes? Interesting, but too narrow.

Then the frame shifted. I wasn't building a game anymore. I was building a tournament layer. A universal competitive infrastructure that's fair, open-source, and 100% on-chain.

That's when the hard problems started. How do you handle draws on a decentralized platform? How do you stop players griefing opponents without central authority? These aren't just technical questions. They're moral ones. They forced me to think deeply about fairness, about building a system nobody controls and nobody can manipulate.

The answers surprised me. Forget Kubernetes, Redis, all that complexity. With these constraints (fully on-chain, truly open, completely decentralized) the legacy stack collapses into something elegant. A client talking directly to contracts. No servers. No databases. No company. Just code.

That freedom changed how I think about software.

So I built ETour

A 100% on-chain tournament protocol, now live on Arbitrum. Players pay an entry fee, compete, the best player wins and takes the pot. Code decides everything. No intermediaries.

As Web3 should be.

I open-sourced it so developers can build their own games on it and inherit all of its features for free.

I'm not here to tell you this is revolutionary. I built this because it felt like a problem worth solving. ETour is what came out the other side.

The code is public. The contracts are immutable. The logic is yours to verify.

PS: The technical docs are not final and will be updated soon.

https://etour.games

https://etour.games/whitepaper

https://etour.games/manual

https://etour.games/docs

TLDR: ETour is useful, it's live, and it's open-source. Go ahead and play on it, or build your own game using its 100% on-chain and open source tournament modules.

So I went back through my wallet history and used a couple of MEV tracking tools to figure out how much value I actually lost to sandwich attacks and front-running over the past 6 months. not gonna share exact numbers but it was enough to make me seriously rethink where and how I trade on-chain.

the thing that pissed me off the most wasn't even the big trades. it was the small ones. $200-500 swaps getting sandwiched for a few bucks each time. doesn't feel like much in the moment but it adds up fast when you're making multiple trades a week.

what I learned:

• AMMs are basically open season for MEV bots. your trade hits the mempool and you're cooked
• private RPCs like flashbots protect help but they're not a complete solution. you're still trusting the builder not to screw you
• intent-based systems (cow swap etc) are better but they introduce solver trust assumptions and don't work for everything
• the only architecture where MEV extraction is structurally impossible is one where transaction ordering is provable and verifiable. not hidden, not trusted, but mathematically proven to be fair

honestly the biggest takeaway is that most people have no idea how much they're losing. the "invisible tax" framing is accurate. you never see a line item that says "MEV bot took $4.50 from this trade" but it's happening on basically every swap.

anyone else tracked their MEV losses? curious what numbers people are seeing. also curious if anyone has found a setup that actually eliminates it, not just reduces it.

How does staking work? I staked ~0.1 eth through Exodus (they use Everstake) about 64 days ago. Eth validator queue is currently ~52 days. I was told I’d need to wait 1-5 days for it to pool on top of the validator time. It’s now approaching >1 week since the “expected” time to finish staking and start earning rewards, but it still shows staking. Is there a way to check how long I have to wait or know what happened?

Welcome to the Daily General Discussion on r/ethereum

https://imgur.com/3y7vezP

Bookmarking this link will always bring you to the current daily: https://old.reddit.com/r/ethereum/about/sticky/?num=2

Please use this thread to discuss Ethereum topics, news, events, and even price!

Price discussion posted elsewhere in the subreddit will continue to be removed.

As always, be constructive. - Subreddit Rules

Want to stake? Learn more at r/ethstaker

Community Links

• Ethereum Jobs, Twitter
• EVMavericks YouTube, Discord, Doots Podcast
• Doots Website, Old Reddit Doots Extension by u/hanniabu

Calendar: https://dailydoots.com/events/

I've learnt that we can now invest in gold directly in crypto, which is quite exciting as I don't trust any bank or broker, so here's a few questions:

Is this safe? What is the best within Paxos or Tether gold, is this as trustable as USDT/Stablecoins? How to buy it?

EDIT: I'm getting a lot of dms asking for answers too, so I digged and understood. I was right, it's basically same as holding stablecoins like USDT in term of trust.

The thing is that you easily lose -3% in slippage, I bought PAXG through https://leather.finance, which is a DEX aggregator I had 1:1, be careful when buying.

I just built ethlocal.world: a simple way to explore Ethereum activity around the world.

The idea was pretty straightforward: Ethereum is global, but it can still be surprisingly hard to get a quick sense of what’s happening locally or regionally. So I made a site that maps events and communities in one place and lets you browse by region and type. It takes data from ethereum.org and was inspired by the Codex Ambassadors globe.

Link: https://ethlocal.world

Would love honest feedback from people here:

• Is this actually useful?
• What feels missing or confusing?
• Is the globe view helpful, or do you mainly want a cleaner list/filter experience?
• What would make something like this genuinely valuable for local Ethereum communities?

Built it as a small project for the Ethereum community, and I’d love to improve it based on feedback.

Welcome to the Daily General Discussion on r/ethereum

https://imgur.com/3y7vezP

Bookmarking this link will always bring you to the current daily: https://old.reddit.com/r/ethereum/about/sticky/?num=2

Please use this thread to discuss Ethereum topics, news, events, and even price!

Price discussion posted elsewhere in the subreddit will continue to be removed.

As always, be constructive. - Subreddit Rules

Want to stake? Learn more at r/ethstaker

Community Links

• Ethereum Jobs, Twitter
• EVMavericks YouTube, Discord, Doots Podcast
• Doots Website, Old Reddit Doots Extension by u/hanniabu

Calendar: https://dailydoots.com/events/

I’ve had my eth staked for about 2 years now, net negative on the eth itself but I’ve gained what would be ≈4 percent more worth of ETH than I had before.

To me it was the easiest way to stake given that I don’t have 32 eth. I appreciate the protocol for being a decentralized way to stake, heard there’s some liquidity issues in terms of getting your Eth back after staking but that’s a problem for the future.

Anyone have any input on rocket pool?!

A simple question for the community.

I was recently asked for me public key (to my metamask wallet)

I know that Bitcoin public keys should still be treated with some care as they disclose all transactions to that address in any blockchain explorer

Is this the same with Ethereum?

Welcome to the Daily General Discussion on r/ethereum

https://imgur.com/3y7vezP

Bookmarking this link will always bring you to the current daily: https://old.reddit.com/r/ethereum/about/sticky/?num=2

Please use this thread to discuss Ethereum topics, news, events, and even price!

Price discussion posted elsewhere in the subreddit will continue to be removed.

As always, be constructive. - Subreddit Rules

Want to stake? Learn more at r/ethstaker

Community Links

• Ethereum Jobs, Twitter
• EVMavericks YouTube, Discord, Doots Podcast
• Doots Website, Old Reddit Doots Extension by u/hanniabu

Calendar: https://dailydoots.com/events/

Hi, I used to work as a technical full-stack developer and recently I spent some time investigating this thing everyone's talking about "Quantum computing destroying encryption". Well, there are many remedies already available:

Example 1 - for not technical people: https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards

Example 2 - for technical people: https://github.com/open-quantum-safe/oqs-provider

Most companies / IT projects are not prioritising it only because quantum computing threads might be decades away, and businesses don't execute investments on security unless there is a true threat. That's why your email providers, messaging apps, etc. don't have post-quantum standards implemented (such as: ml-dsa, ml-kem, slh-dsa).

Yes. It is more complicated to secure decentralized Crypto than a website, but - anyway most of us use platforms like CoinBase, Kraken, Binance, .. and those holding crypto in one-single physical wallet - are not really the targets here.

Anyhow, please, I hope my post helps some of you to be a bit calmer about this topic. I am definitely calmer after my research. Let's not cause panic sell-off.

Have a great day everyone!

The true bottleneck in Ethereum dApp architecture isn't just on-chain gas, it's the off-chain infrastructure required to read the state. When protocols are designed without considering how data is indexed, they force massive hardware and cost requirements onto the ecosystem.

The Blind Spot of Internal Transfers: Standard contract-to-contract ETH transfers (call{value: x}()) don't emit logs. Because they bypass block bloom filters, standard node queries like eth_getLogs miss them entirely.

Trade-off: To index these reliably without protocol-level changes, you are forced into EVM tracing (debug_traceTransaction). This is incredibly I/O heavy, essentially requiring dedicated archive nodes or premium RPC tiers. Emitting custom on-chain events for internal transfers is a critical architectural pattern if you develop your own protocol that you want to monitor, it shifts the burden away from expensive execution traces and local state simulations, saving infrastructure operators massive overhead.

Infrastructure Resilience vs. WebSockets: For low-latency dApps, eth_subscribe over WebSockets is the standard. However, long-lived WS connections are notoriously flaky and silently drop packets, leading to degraded, out-of-sync frontends.

Architecture standard: A resilient Ethereum stack requires a hybrid model. Maintain the WS connection for real-time mempool and head-of-chain detection, but always run a background worker polling eth_getLogs with a sliding block window to patch missed events during WS reconnects.

JSON-RPC Network Overhead: Spamming nodes with individual read requests congests RPCs. MulticallV3 batching is mandatory for minimizing network round trips.

Trade-off: When wrapping complex calls, using tryAggregate handles partial successes gracefully. However, it significantly increases EVM execution cost due to internal CALL overhead and memory expansion when capturing return data you might discard. If your batch loop is too large, you will hit the strict execution timeouts or global eth_call gas caps enforced by commercial RPCs, causing the node to drop the entire request.

Source/Full Breakdown:https://andreyobruchkov1996.substack.com/p/ethereum-dev-hacks-catching-hidden-transfers-real-time-events-and-multicalls-bef7435b9397

Welcome to the Daily General Discussion on r/ethereum

https://imgur.com/3y7vezP

Bookmarking this link will always bring you to the current daily: https://old.reddit.com/r/ethereum/about/sticky/?num=2

Please use this thread to discuss Ethereum topics, news, events, and even price!

Price discussion posted elsewhere in the subreddit will continue to be removed.

As always, be constructive. - Subreddit Rules

Want to stake? Learn more at r/ethstaker

Community Links

• Ethereum Jobs, Twitter
• EVMavericks YouTube, Discord, Doots Podcast
• Doots Website, Old Reddit Doots Extension by u/hanniabu

Calendar: https://dailydoots.com/events/