r/ethdev

Hey, I have a problem: I'm currently learning to code, including Solidity. The thing is, I write a lot of test projects, but when I get to a point where I'm stuck because of a lack of experience, I tend to quickly ask an AI, which makes me feel like I'm not really learning properly. I’m aware of the problem now, but I don’t know how else to learn new things without using AI to look things up. Sure, I could just manually look up things I don’t know on the internet, but that takes a lot more time and amounts to the same thing. My question for the more experienced devs here: How did you effectively learned to program back in the day without AI, and what did you do when you got stuck or encountered a bug you couldn’t figure out? What would you recommend as the best way for me to learn with avoiding AI (or should I avoid using AI for learning altogether?)? What’s the alternative to AI for debugging and research?

glnc is a single-binary CLI that does the read-side of Etherscan (balances, tx decoding, gas, positions, history, alerts) from your shell. MIT, free, open source. No
account, no API key required, no telemetry. Install via Homebrew or curl.

  $ glnc balance vitalik.eth                                                                                                                                                 
  $ glnc balance 0xAbc... 0xDef... --watch --positions --nfts                                                                                                              
  $ glnc tx 0x7c... --json | jq '.data.decoded.calls[] | select(.protocol=="UniswapV3")'                                                                                     
  $ glnc gas --json | jq '.data.chains.ethereum.priority.p50'                                                                                                                
  $ glnc history 0xAbc... --csv > out.csv                                                                                                                                    

What it actually does

• balance — 6 chains (Ethereum, Polygon, Arbitrum, Base, plus Solana and Bitcoin as a bonus). Auto-detects chain from address format. ENS resolves. Token auto-discovery via the Uniswap default token list (~1,400 per chain, 24h disk-cached). Solana uses getTokenAccountsByOwner for true full SPL discovery. Multi-wallet portfolios with per-wallet tables + grand total.
• --watch — re-polls on an interval, prints in-place +0.5 ETH / -100 USDC deltas, runs in the alternate screen buffer so your scrollback survives Ctrl+C. Snapshots
  persisted to ~/.glnc/snapshots.json.
• tx <hash> — decodes calldata for Uniswap V2/V3, Universal Router, ERC-20, WETH, and decodes receipt logs into token movements from tx.from's perspective.
• gas — live gas across 9 chains. EVM tiers are p10/p50/p90 priority percentiles from the last 64 blocks via eth_feeHistory. Includes BTC mempool fees and Solana priority fees.
• --positions — Aave V3 health factor via getUserAccountData, Uniswap V3 LP NFT enumeration.
• --nfts — top collections via Reservoir's public API.
• history — CSV/JSON export via the Etherscan V2 unified endpoint. Works keyless; optional GLNC_ETHERSCAN_KEY raises the rate limit.
• alert — conditional alerts to a webhook. SSRF hardening: scheme allowlist, then DNS-resolved IP checked against RFC1918 / IMDS (169.254.169.254) / loopback / CGNAT /
  link-local / IPv6-ULA / IPv4-mapped / 6to4 / NAT64 before every fire. Redirects blocked. Re-validated each invocation, not just at config time.

Dev angle

All RPCs are free public endpoints (publicnode, mainnet.base.org, blockstream, mempool.space, etc.). Prices via CoinGecko with a 60s in-memory cache. Output is stable
versioned JSON envelopes (glnc.balance/v1, glnc.tx/v1, etc.), NDJSON when streaming. --json makes stdout data-only; all chatter goes to stderr, so it pipes cleanly into jq / xargs / cron without contamination.

Honest tradeoffs

• Token discovery is bounded by the Uniswap default list. Truly exhaustive ERC-20 discovery for an arbitrary wallet needs an archive node or a paid indexer (Alchemy/Moralis) — this is the conscious tradeoff for "no API keys."
• CoinGecko free tier is ~30 req/min. The 60s cache absorbs most of it but you can hit the wall on big portfolios.
• No test framework in the repo yet. It's in the README, calling it out here too.
• BTC and Solana support is in there; not the headline for this sub, just useful if you have a multi-chain treasury.

Repo: https://github.com/aryarahimi1/glnc

Looking for feedback on the JSON envelope shape (before I have to start versioning it for real), additional protocols worth decoding in tx, and whether the SSRF blocklist is missing anything. Issues and PRs welcome.

We looked at token creation data from our Token Generator across 54,900+ tokens created since 2018.

https://preview.redd.it/x56uytthzv1h1.png?width=1284&format=png&auto=webp&s=7c6a611e6db2fd0dba0100af194bc35ecc21de09

The all-time breakdown is still dominated by two ecosystems:

• BNB Smart Chain: 48.3%
• Ethereum: 45.2%

That said, the picture changes quite a bit when looking at more recent periods.

Since 2023:

https://preview.redd.it/wswqhd1kzv1h1.png?width=1284&format=png&auto=webp&s=c48ef687ae2e2f6fa9c9a5d8d1386c5d4f211ea0

• BNB Smart Chain: 38.1%
• Ethereum: 31.2%
• Polygon: 13.2%
• Base: 8.8%
• Avalanche: 7.8%

Since 2025:

https://preview.redd.it/lh0akv9lzv1h1.png?width=1284&format=png&auto=webp&s=618d1ee87067f943d38b47135bdc32e679cef6c8

• Base: 31.8%
• BNB Smart Chain: 27.3%
• Ethereum: 22.9%
• Polygon: 13.3%

A few takeaways from our side:

BNB Smart Chain’s all-time lead seems heavily influenced by the 2021/2022 cycle, when it saw a lot of token-launch activity.

Ethereum remains consistently present across every timeframe, even as cheaper and faster environments gained traction.

Base is the most interesting recent shift. In 2025 data, it has become the top network for new token creation in our sample.

I’m curious:

When launching a new token today, would you still choose Ethereum mainnet, an L2 like Base, another Ethereum L2, or a different chain entirely?

And what matters most in that choice: security, liquidity, user distribution, gas costs, tooling, decentralization, or something else?

Hi everyone, I got tired of trawling through docs and block explorers every time I needed a stablecoin contract address or wanted to check which tokens support permit signatures, so I built a reference site!

I wanted to introduce stablemoney.dev

Covering:

• 12 major stablecoins (USDT, USDC, DAI, PYUSD, GHO, RLUSD, etc.)
• Contract addresses for every major EVM chain
• EIP/ERC compliance matrix (ERC-20, permit, proxies, compliance hooks, flash loans etc)
• On-chain wallet compliance checker (read-only eth_call - checks onchain blacklist/freeze status)
• Opinionated risk notes per coin
• Basic Market cap from DefiLlama, refreshed daily

OpenSource, no wallet connection needed, MIT licensed.

Would love feedback from anyone building with stablecoins. What’s missing that would save you time?

https://preview.redd.it/i2c8rdbtaw1h1.png?width=2040&format=png&auto=webp&s=0237b44cb3ba15461006e88c8271d1d2a50e9cdc

Hey all,

I work on EVM parsing infra (C++, low level stuff) and over the past few months I keep running into the same headaches with the existing sim and debugging tools. Wanted to see if anyone else
feels this or if it's just me.

1. Bundle simulation across L2s is painful. Tenderly is fine for single txs on L1 but the moment you want to sim a multi tx bundle against forked Arbitrum or Base or OP state, with the actual sequencing and gas and precompile behavior, you end up writing
   your own anvil + scripts setup. Every time.

2. L2 specific stuff gets silently wrong. Arbitrum's gas accounting with L1 calldata cost vs L2 execution. Optimism pre Bedrock vs post Bedrock. Base inheriting OP stack quirks. and you don't notice until your prod numbers don't match your sim.

3. Speed. Tenderly is great but slow when you're iterating.
   Foundry is fast but CLI only and the bundle UX is rough.

4. Reading traces. A complex multi call trace across a bundle is still mostly grep and squinting.

So I'm thinking about building something that goes straight atthis. Fast, bundle first, L2 accurate sim and debugger. Web UI for inspection, API and CLI for automation, actually correct L2 state and gas.

Before I build I want to know:

What does your current workflow look like when you hit these?
Is this a real pain or have you found a way around it?
Which L2s actually matter for what you do?
Searcher use case, dev use case, both?

Not selling anything. Honestly mostly just trying to figure out if this is worth building or if it's a problem only I have.

Cheers.

Heyy Guys, im back from learning foundry and next looking to build some projects and host them in the testnet.

I was thinking of building a standard and solid project (like DAO/DEX) instead of small projects..

So when i looked up, i came to know that uniswap is very useful in developing commercial level projects and has many built-in features ideal for production grade apps..

Now should i learn Uniswap and then build a solid project or just build a project and then learn Uniswap..

Thanks in advance...

I’ve been working on a small Go library for Ethereum signature verification. The part I’m still unsure about is the policy around the main Verify function.

The narrow case is:

address + already-computed common.Hash + signature -> valid?

Repo: github.com/yermakovsa/erc6492-go

It handles:

• EOA recovery
• EIP-1271 for deployed smart contract wallets
• ERC-6492 signatures through a configured deployed verifier

I’m intentionally keeping the scope small: no message building, no EIP-712/SIWE/EIP-191 hashing, no wallet deployment, no RPC client management, and no embedded deployless verifier bytecode. Anything before the final hash exists is outside the package.

The main Verify path currently does:

ERC-6492 wrapped signature
→ WithERC6492Factory wrapping path
→ EIP-1271 if signer has code
→ EOA fallback

There are also narrower entry points: VerifyEOA, VerifyEIP1271, and VerifyERC6492.

This is v0.1.0, so I’m trying to catch bad API/policy decisions before the package hardens.

I’m unsure about a few things:

1. If the signer has code and EIP-1271 returns a clean invalid result, like wrong magic value or revert, should Verify fall back to EOA recovery? Or would you expect contract-wallet verification to be strict once code exists?
2. ERC-6492 currently requires a deployed verifier address. I avoided embedding deployless verifier bytecode because I didn’t want copied bytecode in the package without pinned source, compiler settings, and reproducible provenance. Is that too conservative, or reasonable for a small library?
3. Does this error split feel right?

​

invalid signature, including malformed/non-canonical EOA signatures
→ Result{Valid:false, Method:...}, nil

RPC / ABI failure / malformed ERC-6492 wrapper / unexpected verifier output
→ error

Also curious if the overall Go API shape feels natural: one main Verify plus narrower explicit functions.

Would appreciate blunt feedback from anyone who has dealt with EOA / contract wallet / counterfactual wallet signature verification.

Most blockchain tools stop at transaction viewing.

I wanted to explore what happens after that:
investigations, fund-flow tracing, cybercrime analysis, compliance workflows, and forensic reporting.

So I started building Blockchain Sentinel OS — a digital financial investigation platform focused on:
• multi-hop wallet tracing
• blockchain crime intelligence
• case workflows
• forensic-style reporting
• India-focused compliance direction

Still evolving heavily, but the platform is finally starting to feel like a real investigation workspace instead of just another explorer.

Would genuinely love feedback from people in security, forensics, compliance, AML, or blockchain infra.

https://blockchain-sentinel-os.vercel.app/

A question for Web3 developers who have actually worked as developers at relevant companies: What does the actual day-to-day work of a Web3 developer look like? What percentage of the work is *actually* spent writing smart contract code, and what does the rest of the job entail? I would also be grateful for a brief insider's perspective on the current job market.

We've all seen the scenario where our agents plan the perfect holiday, find the perfect hotel and ticket deals and you just approve the transaction: "Yes, buy them". I do think this is definitely in the future of agentic payments, but not the current reality.

After doing some research, I noticed two different layers normally get lumped together as "Agentic Payments". The payment layer is x402 (Coinbase started it, Linux Foundation now), agents programmatically paying for things. Then we have the execution layer which looks more like OKX's Agent Trade Kit, Kraken's CLI, Binance AI Agent Skills, etc, basically agents placing orders directly on exchanges. Some teams stack both, pay for market data (Coingecko, CMC) via x402 and execute via CEX toolkit.

x402 is mostly agents paying for their own APIs/infra. Hyperbolic for GPU inference. Neynar for Farcaster data. Cloudflare's pay per crawl. Token Metrics swapping subscriptions for per call analytics. The agent isn't buying for a human (at least not directly), it's keeping itself running.

The consumer scale story lies on the execution layer. CEX agent trading, Polymarket bots, platforms like SaintQuant running across exchanges. Notice the trend? Agents trading on behalf of users, not agents buying flight for them (yet).

Is there any "real agent doing your shopping" for you out there?

I’m testing an idea and would like feedback from people who have actually built Ethereum payment flows.

The idea: file storage where the payment/auth handshake is part of the HTTP request itself.

Instead of an agent needing someone to pre-create a SaaS account, billing setup, API key, IAM policy, etc., the flow is:

request upload/read -> receive 402 Payment Required -> sign/pay -> retry same request -> continue

I built a small prototype around this for agent file handoff. It supports:

• paid uploads
• public-by-key files
• wallet-private files
• signed expiring share links
• paid large reads

The main question I’m trying to answer is not “is this better than S3 for everything?” It obviously is not.

The question is: does treating payment as a request primitive make sense for autonomous software/agent workflows where no human is sitting in the middle provisioning accounts?

A few things I’m unsure about:

• Should signed share links themselves be paid, or should only upload/read be paid?
• Is wallet-gated private file access too clunky for real agent systems?
• Would you trust an x402 storage primitive if the API shape were simple enough, or would you still prefer pre-funded API keys?
• Where do you think this pattern breaks down?

I can share the repo/SDK if useful, but I’m mostly looking for design critique before pushing it harder.

HI, I am a 3rd yr CS student with little to no development knowledge.

I am interested in web3 development and when I search for Junior/Entry Level web3 developer jobs.

I don't see any jobs for junior developer. Is it really worth it to learn web3 in 2026 ?

PS : For personal reasons I have to get a job with the next 6 to 8 months. What should i do? Please guide me

I have learned the following:

1. solidity basics using cryptozombies

2. smart contract development course from Cyfrin Updraft

3. some projects from speedrunethereum

My goal:

Actually i want to land a job early in this domain remotely

My current thought:

I am looking to further learn more with Cyfrin Updraft course, the following are my choices for now:

1. Foundry Fundamentals

2.Full-Stack Web3 Development Crash Course

3. Smart Contract Security

Am i proceeding in the right direction ?? please give me your suggestions..

Lately I’ve been thinking about whether Web3 could actually make open-source collaboration sustainable long term.

Imagine a platform where people contribute skills like development, design, content creation, moderation, marketing, etc., and instead of volunteering for free, contributors earn crypto rewards for completed tasks. The more useful projects the community

For an ML feature engineering project I need every Uniswap, Curve, PancakeSwap, and Raydium trade from 2021 onwards loaded into Snowflake.

RPC backfill on a self-hosted Ethereum archive node is going to take weeks at this volume, the existing subgraphs are missing fields we need, and Dune is great for ad-hoc but I can't COPY INTO from a query result.

Has anyone done bulk historical loading of DEX trades into a warehouse cleanly?

Specifically curious about file format (Parquet vs JSONL), how people partition by block range, and whether anyone has found a vendor that just delivers this as columnar dumps to S3 instead of forcing us to build the extraction layer ourselves.

Hello everyone,

I have spent the past five years building a career in remote community support, complemented by four years of active involvement in cryptocurrency trading and investment. While my experience in the markets is extensive, I am now strategically pivoting toward a more specialized, skill-based career path to ensure long-term financial stability.

Being based in a tier-2 city, I am committed to a remote-first career that allows me to balance my professional growth with my responsibilities toward my family. I am particularly interested in transitioning into roles such as DeFi Researcher, On-Chain Analyst, or Quantitative Researcher.

I am seeking expert perspectives on the following:

Market Viability: Is the demand for these roles sustainable, and what is the typical compensation landscape?

Entry Barrier: Are these positions accessible for those pivoting from a trading background, or do they strictly require mid-to-senior level expertise?

Roadmap: Is a 12-to-24-month preparation window realistic to land a role in this niche?

I value professional human insight over AI-generated advice and would deeply appreciate any guidance on where to focus my learning. Thank you for your time.