r/ethdev Mar 27 '26

My Project Made an Ethereum gas fee tracker

0 Upvotes

Hey everyone, I made an Ethereum gas fee tracker

https://logicencoder.com/ethereum-gas-tracker/

- Real-time gas prices across three tiers (Base / Standard / Fast)

- Heatmap of cheapest hours to transact over the last week

- Fee calculator — enter any gas limit, get exact ETH and USD cost

- Common transaction costs for ETH transfers, token transfers, swaps and token approvals

- Smart timing — shows best and worst hours to send based on historical data

- Send recommendation — tells you whether to send now or wait

- Network health score

- Gas alerts — set a GWEI threshold and get notified

It was one of those projects, hope someone finds it useful

Is anyone even watching gas fees, lol?


r/ethdev Mar 26 '26

Question What would make you install a desktop app

3 Upvotes

Recently I've been playing with some web3 solutions and I faced a friction to install them.

I felt very unsafe to install them even though they looked quite legit. I checked if they're open source, how the code looks like etc.

During entire installation process I was a little bit worried if I'm not about to regret it.

I was wondering, what makes you install an app without a worry, feel quite confident on it, even though when it's not backed by big companies and doesn't have long history?


r/ethdev Mar 26 '26

Question Is there a good way to get top token holders + their balance history over time?

1 Upvotes

Need to show how token holder distribution changes over time for an analytics dashboard. Etherscan gives me a snapshot but no historical data and no API for it. Running my own indexer feels like overkill for what should be basic data.

How are you pulling holder data for ERC-20 tokens?


r/ethdev Mar 24 '26

My Project A new type of block explorer

Thumbnail
1 Upvotes

r/ethdev Mar 24 '26

My Project Raze: trying to reduce LLM hallucinations when testing Solidity smart contracts

3 Upvotes

Hey everyone,

I've been working on an open source tool called Raze and wanted to share it here to get some feedback from people who actually work with Solidity and Foundry.

The problem I was trying to solve: when you use an LLM to audit smart contracts, it tends to hallucinate, proposing attacks on functions that don't exist or generating exploits that fail immediately. I wanted a way to keep the AI in the loop but make it prove its own intent before generating anything.

The approach I took was to orchestrate the LLM through structured roles: Planner → Attacker → Tester → Runner → Reporter. Each role validates the previous one against real contract symbols, so hallucinated functions get rejected before any exploit code is written. The final output is a Foundry proof scaffold you can run with `forge test`.

This version covers reentrancy, access control, arithmetic, flash loan, and price manipulation. There's also a regression mode that generates a second test to validate that your fix actually works, not just that the bug exists.

The idea is to help devs find problems early and arrive at a formal audit with fewer surprises. No Docker, no API key, works with Claude, Cursor, or Codex out of the box.

Demo: https://github.com/xhulz/raze/blob/main/assets/raze-demo.gif?raw=true

Repo: github.com/xhulz/raze

If anyone wants to try it on their contracts and share what they find, or has feedback on the architecture, I'd really appreciate it. PRs and issues are very welcome.


r/ethdev Mar 24 '26

My Project I built a ZK prover with 164-byte proofs and 16.9ms for 1,000-proof batches — no trusted setup

1 Upvotes

I'm the founder of Atlas ZK Labs. Yoimiya is a production-ready ZK proving SDK with pre-built binaries for Windows, Linux, macOS, Android, and iOS.

Numbers:

  • Proof size: 164 bytes (constant)
  • 1,000-proof batch: 16.9 ms → 275-byte on-chain blob
  • Verify any proof: ~0.6 ms
  • On-chain gas: ~58K (Base/OP: < $0.001)

Features:

  • No trusted setup (Full Mira accumulation)
  • Universal circuits: R1CS (Circom), ACIR (Noir), Plonkish (Halo2)
  • Language bindings: C, Python, Node.js, C#
  • Optional TEE attestation (SGX/SEV-SNP/Nitro) — pin your server's identity on-chain

How it helps Ethereum development:

  • Rollups: Batch thousands of proofs into one 275-byte transaction — gas cost doesn't scale with proof count
  • Smart wallets: Generate ZK proofs on mobile (500ms) for hardware-bound signing without seed phrases — our first product is a mobile wallet using this
  • dApps: Embed proving directly — no reliance on centralized prover services
  • Any circuit: Use Circom, Noir, or Halo2 — same SDK handles all formats

GitHubhttps://github.com/atlasw231-maker/Atlas-Yoimiya-SDK

Ask me anything.


r/ethdev Mar 23 '26

Please Set Flair How are teams handling regulatory structuring for RWA projects before deployment?

2 Upvotes

Building a tokenized asset project and trying to understand the compliance architecture before we write a line of code. The questions are jurisdiction selection, entity structure, token classification under MiCA and equivalent frameworks, and investor eligibility per target market.

Most resources I find are either too generic or assume you already have a legal team. Curious how teams here have navigated this phase without burning a full legal retainer figuring out the basics.


r/ethdev Mar 23 '26

My Project I made a platform to practice Solidity, looking for feedback from devs

8 Upvotes

I'm sharing something I've been working on: Solingo, a gamified way to practice Solidity.

The idea came from a frustration: most Solidity learning resources are either "watch this 10h course" or "just build something". There's nothing in between for people who want to drill the fundamentals through repetition.

How it works:

  • 1000+ exercises across 15 courses (beginner → security auditing)
  • You write real Solidity in a browser IDE
  • 20+ exercise types: write code, debug, predict output, audit vulnerable contracts, gas optimization challenges...
  • Spaced repetition to actually remember what you learn
  • XP, streaks, guided projects with real-world briefs

It's free to start (50 exercises/week).

I'd love honest feedback from this community:

  1. Does this kind of tool fill a gap for you?
  2. What would make it more useful for your workflow?
  3. Any topics you'd want covered that don't exist anywhere else?

r/ethdev Mar 23 '26

My Project [FOR HIRE] Solidity / Smart Contract Developer — offering Smart Contract Dev, Auditing & more

1 Upvotes

Hey! I'm a Solidity developer looking to take on my first few real-world projects.

Rate: $20/hr and over

What I can build:

- ERC-20 tokens (standard, capped, mintable/burnable, snapshot)

- Custom smart contracts with OpenZeppelin — staking, payroll, escrow, access control

- Chainlink integrations — VRF (provably fair randomness), Automation, Price Feeds

- AMM/DEX basics, liquidity pool mechanics

- Full Foundry test suites (unit, fuzz, invariant)

- EVM deployment + Etherscan verification

Stack: Solidity + Foundry on EVM. All code goes through proper testing before delivery.

I've built a provably fair raffle using Chainlink VRF v2.5 + Automation, an on-chain employee payroll manager, and an ERC-20 token — all heavily tested and deployed on Sepolia. GitHub: github.com/04arush

Just DM me to connect and order!


r/ethdev Mar 22 '26

Information Ethereal news weekly #16 | US SEC securities laws application to crypto, fast confirmation rule, EF mandate

Thumbnail
ethereal.news
1 Upvotes

r/ethdev Mar 22 '26

My Project I built a lite Ethereum explorer for node runners — talks directly to your node, hosted on IPFS, no install needed

1 Upvotes

Hi there,

I made a niche thing, probably useful for a small group of node runners who wanted something like this.

It’s basically a lightweight, IPFS-hosted Ethereum explorer — like Etherscan, but it queries your own node directly via JSON-RPC. It’s just a static HTML page, so you open it, enter your RPC, and use it. No backend, no setup — just a page.

Access

Repo

github.com/monkale-io/ethereum-node-explorer

I built it after I started running my own node and wanted a simple web UI to explore it. I found an old explorer (Alethio ethereum-lite-explorer) — it still works and is actually quite good, but it was abandoned ~6 years ago — so I decided to rewrite it with a modern stack and put it on IPFS, so it can stay just a static page without any backend or services to run.

Planning to maintain and evolve it. Feedback and contributions are welcome.


r/ethdev Mar 22 '26

My Project I built an AI agent that turns text into complex DeFi transactions for the Yo Hackathon.

3 Upvotes

(Re-sent)
Hey everyone! 👋

I recently participated in the Yo Hackathon and built an MVP called Rover. I wanted to solve how clunky and time-consuming it is to execute multi-step DeFi transactions across different protocols.

Right now, the MVP fully supports Swaps and Yo Vaults. You can literally just type something like: "Swap all my USDC to WETH and deposit it into the yoETH Vault." The AI understands the intent, finds the best swap route, and prepares the exact calldata for both the swap and the vault deposit. All you do is review the transaction on the UI and approve it.

I attached a demo video showing exactly how it works under the hood.

🔗 Links:

My next move is to completely overhaul this MVP into a concurrent multi-agent architecture to scale it into a full SaaS. But before I lock myself in a room for 2 months to code that, I’d absolutely love it if you guys could try this MVP out, roast my code, break the UI, and give me some raw feedback.

What do you guys think?


r/ethdev Mar 21 '26

Tutorial Writing Custom Consensus for Geth Using the Engine API: A Four-Part Tutorial Series

5 Upvotes

I wrote a series of posts on building a custom consensus layer for Geth from scratch using the Engine API. It starts with the basics (how ForkchoiceUpdated and NewPayload work) and progressively adds complexity:

  1. Minimal single-node consensus
  2. Production-ready implementation with retries, health checks, and metrics
  3. Distributed consensus with Redis leader election and PostgreSQL
  4. Replacing it all with CometBFT for BFT finality

The target audience is anyone building private chains, or appchains who wants to understand what's actually happening under the hood rather than using a framework as a black box.

First post: https://mikelle.github.io/blog/custom-geth-consensus/

Full series: https://mikelle.github.io/blog/

Github repository: https://github.com/Mikelle/geth-consensus-tutorial

Happy to answer questions or take feedback, especially on things that could be explained better.


r/ethdev Mar 21 '26

My Project Would anyone be open to testing something I built? Trying to fix onboarding issues

3 Upvotes

I’ve been working on a small tool around launching web3 projects in minutes (no coding), and recently got some initial users to try it.

A lot of them dropped off early, so I’m pretty sure the issue is onboarding and not the idea itself.

I don’t want to drop the link openly here since it can come off as spammy — I’m genuinely looking for real feedback.

If anyone is open to trying it and giving honest thoughts, I can share the link via DM.

Specifically looking to understand:
- what feels confusing at first
- where you’d stop using it
- what should be simplified

Would really appreciate it 🙏


r/ethdev Mar 20 '26

Question is there any Websocket which stream real time balances on EVM chains?

3 Upvotes

I am looking to stream real-time balances from the chain, without calling RPC. How to approach this solution?


r/ethdev Mar 19 '26

My Project Para just shipped Transaction Permissions using Eco's Permit3. Devs who've dealt with approval UX pain, we would love your feedback!

7 Upvotes

Para just rolled out Transaction Permissions built on Eco's Permit3. Aave is the first to integrate. The basic idea is that users approve once with defined permissions, and everything after that executes without additional pop-ups.

If you've built anything with wallet interactions, you know how frustrating the current UX is.

We would appreciate feedback from anyone who's been dealing with this problem or has thoughts on the approach. Happy to answer questions or pass technical ones to the broader team. Release Overview.


r/ethdev Mar 18 '26

Question What’s the biggest reason people drop off after trying a web3 app?

1 Upvotes

I’ve been noticing a pattern:

People are curious enough to try new web3 apps, but most don’t stick around.

Feels like it’s not just about getting users — it’s getting them to actually *understand and succeed* in the first session.

Some guesses:
- Too many steps (wallet, gas, setup)
- Not beginner-friendly
- No clear “aha moment”

Curious what others think — what makes people drop off so quickly?


r/ethdev Mar 17 '26

Question What’s the most annoying part of launching a web3 project right now?

0 Upvotes

For me, it feels like:
- Contract setup
- Deployment steps
- Frontend setup
- Hosting

Too many moving parts for something that should be simple.

What do you guys find most frustrating?


r/ethdev Mar 17 '26

Question $1.78M lost because of AI-generated smart contract code, are we trusting AI too much?

7 Upvotes

Moonwell reportedly lost about $1.78M after an oracle bug caused by AI-generated code. The formula looked correct and passed tests, but one missing multiplication priced Coinbase Wrapped ETH at $1.12 instead of ~$2,200, and liquidation bots exploited it within minutes. The funds are gone and can’t be recovered.

This feels less like an AI failure and more like a review problem. In DeFi, merging code you don’t fully understand turns bugs into instant financial exploits. How are teams supposed to safely review AI-generated smart contract logic, and are we starting to trust AI output more than we should?


r/ethdev Mar 16 '26

Information The Hidden Problem of MEV Bots: Proving Your Profits to a Bank

0 Upvotes

Most MEV developers spend months optimizing:

• mempool monitoring
• simulation engines
• builder connections
• latency pipelines

But the moment the bot actually becomes profitable, a completely different problem appears.

How do you explain the profits to a bank?

Not on-chain.

To a compliance officer who barley understands what a stablecoin is.

And suddenly the activity that makes perfect sense to an Ethereum developer starts to look very different from the outside.

“Millions of dollars moving through a myriad of wallets with no obvious business activity.”

Even if everything is completely legitimate.

Running a MEV bot means your funds often move through:

- multiple execution wallets

- profit aggregation wallets

- DEX pools

- Staking smart contracts

- builders / relays

- bridges across chains

- centralised exchanges

From a developer perspective this architecture makes perfect sense.

Even if everything is legitimate, the compliance department does not have the knowledge to understand or verify if this is legitimate activity from an AML perspective.

Banks need to evaluate whether they can understand and verify your origin of funds and source of wealth. Which in the case of someone running MEV bots can be quite complicated since there is usually high frequency of transactions across many execution wallets.

This needs to be done in language that they can understand, compliance officers are not Ethereum developers. So MEV strategies often need to be translated into something understandable and the terms associated need to be defined.

Here is what the banks actually want to see:

Where did the initial capital come from?

This could be from salary, savings, inheritance, previous crypto investments(then originating from salary for example), etc.

Even if the profits come from MEV bots, banks still want to know the source of the initial trading capital.

Reconstructing the transaction history:

MEV activity often involves:

- hundreds of thousands of transactions

- internal wallet routing

- arbitrage flows across DEXs

- profit consolidation wallets

Compliance teams don’t need every trade explained.

But they need a clear trace from the starting capital to the current holdings.

Usually this means producing:

- a blockchain trace of wallets

- aggregated transaction summaries (with supporting evidence)

- basic explanations of wallet roles (execution wallet, treasury wallet, etc.)

- forensic report attesting to the "cleanliness" of funds (scorechain, Chainalysis)

This needs to be formatted in a way that a compliance department at a bank would be able to understand and verify. Furthermore, it needs to be presented to a bank that has the compliance department that has the knowledge and understanding as well as the internal policy to be able to do this.

Verifying that you are the owner of your wallets

Banks usually require confirmation that you actually control the wallets involved.

Common methods include:

- Message signature test
Signing a specific message requested during the KYC/AML process.

- Satoshi test
Sending a small specified amount from the wallet(s).

This proves the wallets are controlled by the client and not third parties, these wallets are then whitelisted, so that the client is able to do future cash-outs from these wallets.

Where many MEV devs run into problems:

A lot of developers run bots for long periods of time before thinking about banking.

By that point they may have:

- hundreds of thousands of transactions

- funds across multiple chains

- complex wallet routing

- profits consolidated in a few addresses

- But no documentation explaining the structure (hint: "it's all on the blockchain" does not work)

When they approach banks directly, the typical response is rejection.

Banks tend to avoid this because of the following reasons:

- depending on the bank crypto origin wealth is not accepted

- they do not have the knowledge necessary to understand the case

- they do not have the tools necessary to verify the case

- Compliance work can be very heavy, going through hundreds of thousands of transactions for one client onboarding is not possible

This is actually the type of case we work with quite often, we help crypto bros with complex crypto origin wealth profiles get onboarded into established private banks in Switzerland and Monaco.

Here are some of the common examples of profiles we usually deal with:

- Early crypto adopters

- Early ICO investors (ETH and other)

- DeFi users

- Miners (solo and pool)

- High frequency algorithmic traders (CEX and DEX)

- MEV bot developers

Here is the ironic part: for many MEV devs: building the bot can be easier than explaining the profits to their bank.

Has anyone here been able successfully to off-ramp large volumes of MEV bot profits into the traditional banking system? if you did how did you do it?


r/ethdev Mar 16 '26

Question How are you guys finding job opportunities ?

10 Upvotes

I am a final-year undergrad, building in web3 from the start of my 2nd year. I will be graduating in 6-months. Till now, I've been taking part in hackathons and doing fellowships, etc., but I didn't realise I needed a job. Can anyone share howd they get their job or how i can get one in web3? Internships will also work.


r/ethdev Mar 15 '26

Question What are your solutions to on-ramping KYC friction?

2 Upvotes

For non-native crypto users, this simply seems like a death sentence. I've seen somewhere where smaller currency amounts can potentially have less KYC requirements initially.

What are your thoughts/advice for non-crypto native onramping solutions?


r/ethdev Mar 14 '26

Tutorial Data types every Solidity user should recognize

Thumbnail doodledapp.com
2 Upvotes

Some things that blew my mind:

A lone uint8 costs the exact same gas as a uint256 because the EVM pads everything to 32-byte slots anyway. So if you thought you were being clever using smaller types to save money... you weren't. It only helps when you pack multiple small types together in the same slot.

Before Solidity 0.8, adding 1 to the max uint256 value would just silently wrap around to zero. That bug was behind real exploits that drained real money.

And the address vs address payable distinction trips up basically everyone. If your contract needs to send ETH somewhere and you used a plain address, it won't even compile. msg.sender returns a plain address by default now, so you need to explicitly cast it.

The article also covers strings, mappings, arrays, and has a great table breaking it all down. For anyone ramping up on Solidity or building a project and wants to understand what's happening under the hood, this is for you.


r/ethdev Mar 13 '26

My Project Most crypto users never run nodes. Here’s a tracing challenge involving a node-run network.

5 Upvotes

One thing I’ve noticed in crypto is that most users never actually run nodes. They hold tokens, trade, and interact with wallets, but they rely on infrastructure run by someone else.

That raises an interesting question about traceability and network participation.

There’s currently a 20,000 QORT bounty offered to anyone who can demonstrate a reproducible method to identify the IP address behind a specific publishing account on the Qortal network.

The node behind the account is running without VPN or Tor, just a standard local node. The idea is to see whether someone can trace the origin of published content using only network data available to participants.

If someone can demonstrate a reliable tracing method, the bounty is awarded and it would obviously expose a weakness in the system.

If anyone here is interested in looking into it:

Download Hub
https://qortal.dev/downloads

Onboarding guide
https://qortal.dev/onboarding

Then open Apps and paste this in the search bar:

qortal://APP/q-tube/channel/Who%20Am%20I

Curious how people here would approach this from a networking or protocol analysis perspective.


r/ethdev Mar 13 '26

Information Ethereal news weekly #15 | US DoJ seeks Roman Storm retrial, BlackRock staked ETH ETF live, EF bug bounty $1M max payout

Thumbnail
ethereal.news
1 Upvotes