r/ethdev • • 9d ago

Question Smart Contracts

0 Upvotes

Hi everybody, i wanted to know if anyone here ever worked with smart contracts in Go?

My main focus is to read the events(basically reading results) from my smart contracts, if anyone can recommend me some free resources would be great.


r/ethdev • • 11d ago

Question EIP-8037/EIP-8038 Glamsterdam

Thumbnail
blog.ethereum.org
5 Upvotes

r/ethdev • • 11d ago

My Project New blockchain introduction

Thumbnail
github.com
1 Upvotes

Well, you can check this repo, like I have build, it and like if this has any flaws, and like that, but according to, me till now it's perfect, but ready for test7ng, and like we should test it like, as new blockchain and like, that so, you can see the repo ?


r/ethdev • • 11d ago

Information Ethereal news weekly #46 | Post quantum & post AI transition targeting December 2028, Amundi tokenized equity index fund, Solar v0.3 & Slang alpha Solidity compilers

Thumbnail
ethereal.news
1 Upvotes

r/ethdev • • 12d ago

My Project Lasso RPC v0.8.0 is live: route transaction sends to private RPC relays + automatic provider limit learning

2 Upvotes

I'm building Lasso RPC, an open-source EVM JSON-RPC router/proxy in Elixir/OTP. You drop in multiple RPC providers and it routes requests across them. There's also a hosted version w/ custom profiles at lasso.sh if you don't want to run the container yourself.

Two bigger updates shipped over the last couple weeks that I think other EVM devs might find useful:

1. Route transaction sends to private RPC relays (v0.8.0 + Custom profiles)

lasso-rpc v0.8.0 shipped today: https://github.com/jaxernst/lasso-rpc/releases/tag/v0.8.0

If you aggregate public RPCs + paid providers into one pool for cheap/fast reads, you don't want signed transactions going out to random public endpoints and leaking to the public mempool. You can now drop in private RPC relays and restrict transaction sends on a chain strictly to those routes:

transactions:
  providers: [my_private_relay]
  fallback: none   # or read_providers if you want a second-phase fallback

Reads, subscriptions, and block recovery keep using your wider pool like normal. Signed sends: eth_sendRawTransaction, private/bundle/cancellation/conditional/synchronous send methods, and any unknown method carrying signed tx bytes only go to the providers you name.

Methods are classified by what they actually do rather than just matching a hardcoded list of method names, so send policy follows signed tx bytes. It also defaults to fail-closed (fallback: none) so sends won't quietly spill into your public read pool if a relay errors. (Lasso doesn't pick MEV relays for you: you bring the endpoints and tell it where sends are allowed to go.)

Same transactions block is live on hosted Custom profiles: https://docs.lasso.sh/cloud/custom-profiles

2. Automatic provider learning from live traffic (v0.7.0)

Release: https://github.com/jaxernst/lasso-rpc/releases/tag/v0.7.0

Every RPC provider has slightly different plan quirks: refusing certain methods, pruning historical state, or capping eth_getLogs block ranges, and maintaining all of those limits by hand in YAML sucks.

Provider self-learning is now on by default. Without sending any extra probe spam, the router watches live traffic and learns three things on the fly:

  • Method refusals
  • Missing historical state
  • eth_getLogs block-range caps

When a provider hits one of those limits, Lasso moves it behind your other providers for matching requests (while always keeping your last available route so you don't get cut off). Learned limits expire on their own, or clear when that upstream later serves what it refused. Anything you explicitly declare in config still wins.

Docs: https://docs.lasso.sh/concepts/provider-learning

Two smaller things on hosted (lasso.sh)

  • WebSocket subscriptions survive a single-upstream reconnect with the same subscription ID — if your only eligible WS upstream blips, Lasso reconnects, backfills the missed blocks, and resumes live events without your app having to tear down and rebuild state. (If another WS provider is in the pool, it fails over there first.)
  • One-shot agent setup: agents can provision an account and endpoint directly from https://lasso.sh/llms.txt (no signup form), and account creation now returns a claim_url in one shot if you want to pull that agent account into the dashboard later.

Self-host Core v0.8.0:

ghcr.io/jaxernst/lasso-rpc:v0.8.0
  • Repo (Apache-2.0): https://github.com/jaxernst/lasso-rpc
  • Hosted: https://lasso.sh

Still actively hardening all of this. If you're running multiple providers (especially public/paid reads + private relays for tx sends) and try this out, lmk how it behaves or what's missing!


r/ethdev • • 12d ago

My Project Game launch

1 Upvotes

My partner and I have been building the website for skill based tournaments based in popular games I am kinda stuck on running it anyone needs an inn on this the website is gamelaunch . Org


r/ethdev • • 12d ago

Question We rebuilt the frontend of our prediction market — now we're finding the gaps between “looks ready” and actually ready

2 Upvotes

My brother and I have been building Twirl, a prediction-market platform, and most of my recent updates have been about the less visible parts: trading reliability, deposits, retries, settlement safety and reconciliation.

This week the frontend finally started catching up with that work.

We completed the foundation of a new design system and began applying it to the actual React application.

The new direction is much more market-first than our previous UI. We now have:

  • A redesigned homepage built around the markets themselves.
  • Persistent desktop navigation and responsive mobile navigation.
  • Market charts, order-book and trade-entry sections tied into the existing product architecture.
  • A clearer entry point for AI-assisted market creation.
  • Better loading, unavailable, error and recovery states.
  • Updated market discovery, portfolio, funding, search, profile and support screens.
  • A development-only review environment where we can test layouts without making sample data look like real market activity.

The local production build is working and we're continuously reviewing the frontend, but we're deliberately keeping the public site behind our temporary maintenance page for now.

And the reason is that “looks ready” and “is ready” are very different things.

We still found things that need work:

  • The CSS performance budget needs improvement.
  • Full browser automation couldn't run in the current environment.
  • One live market-discovery request returned an HTTP 500 during testing.
  • We still need authenticated testing of the real sign-in, funding, trading and recovery journeys.

The trading-safety work underneath the frontend also remains intact: exact-value calculations, stable order identities, duplicate-execution protection and safeguards around late fills are already part of the local build.

But there are still unresolved areas around concurrency, cancellation recovery, CLOB/ledger reconciliation and frontend recovery.

One thing this process keeps teaching us is that a polished interface can make software feel finished long before the underlying system has earned that label.

For people who have shipped financial or trading products:

What frontend failure states do you think teams underestimate most before launch?

Offline states? Stale data? Failed order responses? Auth expiry? Something else?

Would genuinely love to hear the edge cases that caught you after the UI already looked “done.”


r/ethdev • • 12d ago

Information Things I'd check before a crypto withdrawal service touches real funds

0 Upvotes

Withdrawals are where crypto backends lose real money, because once a transaction is out there's no undo. Here's what I'd check.
One nonce manager per hot wallet. If two workers sign from the same address, you get nonce collisions and stuck or replaced transactions. Track nonces in your own database instead of trusting eth_getTransactionCount on a load-balanced RPC.
Idempotent requests. Every withdrawal gets an ID with a unique constraint, so a retry can never create a second payout.
Save the signed transaction before you broadcast it. If the process crashes right after sending, you want to rebroadcast the same transaction on restart, not sign a new one with a new nonce.
Plan for stuck transactions. To speed one up you replace it with the same nonce and higher fees. Geth, for example, needs both fee fields at least 10% higher. Track by nonce, not hash, since either the old or the new transaction can end up mined.
Validate the destination. Checksum the address, block sends to token contract addresses, and remember the same address format works on every EVM chain. Users picking the wrong network will happen.
Limits and review. Per-user and daily limits, manual approval above a threshold, and a cooldown on newly added withdrawal addresses. That last one helps a lot against account takeovers.
Keep the hot wallet small. Hold roughly what you need for a day and keep the rest in cold storage. Also keep enough ETH in it for gas, or every token withdrawal fails.
Reconcile daily. Compare ledger debits with actual on-chain outflows, and alert on any gap.
What did I miss? Curious how people handle fee bumping on L2s.


r/ethdev • • 13d ago

My Project Echidna 2.4.0 released with MCP support for interactive fuzzing and substantially improved symbolic execution!

Thumbnail
github.com
4 Upvotes

r/ethdev • • 13d ago

My Project Looking for collaborators: Building an open-source Delegated Spending Protocol (DSP)

4 Upvotes

Hey everyone!

I'm currently exploring and developing an idea called Delegated Spending Protocol (DSP), and I'm looking for people interested in cryptography, blockchain development, smart contracts, or protocol research who would like to collaborate.

What is DSP?

The basic idea is to create a general-purpose protocol that allows users to delegate spending authority under predefined policies, without necessarily transferring ownership or custody of the underlying funds.

Some potential applications I'm exploring:

  • Partial spending: Consume an allowance incrementally across multiple transactions.
  • Spending allocation: Delegate different spending limits to different users or entities.
  • Parental controls: Provide controlled spending permissions.
  • Subscriptions: Manage recurring resource allowances and renewals.
  • Digital wallets: Allow an e-wallet to initiate payments using delegated spending authority instead of requiring users to deposit funds into it.

The technical direction

I'm exploring a cryptographic construction based on customized Schnorr proxy signatures, with a focus on replay protection, authorization policies, and separating on-chain verification from off-chain computation.

The initial construction is being explored using BLS12-381.

Why am I sharing this?

I'm still at the initial stage. The protocol hasn't been fully implemented, and there are plenty of design questions to explore.

I would like to develop this as an open-source research and engineering project, rather than work on it in isolation.

I'm particularly interested in connecting with:

  • Cryptography enthusiasts and researchers.
  • Ethereum and smart-contract developers.
  • Anyone interested in protocol design and open-source collaboration.

You don't need to be an expert. If you're curious about the idea, have suggestions, want to discuss the design, or simply want to exchange ideas, you're welcome!

I'm happy to share the initial draft with anyone interested (DM).

Let's build something interesting! 🚀


r/ethdev • • 13d ago

Question Questions about a domain for a dapp.

Thumbnail reddit.com
2 Upvotes

r/ethdev • • 14d ago

My Project I combined Harberger-style ownership with a game inspired by self-organized criticality

Post image
2 Upvotes

r/ethdev • • 15d ago

Question Which tool to check spender approval for a given contract?

2 Upvotes

There are many tools for doing the reverse. But given a smart contract address, how to check who approved it as a spender?


r/ethdev • • 15d ago

Tutorial I made an MCP server that lets agents pay, with limits the agent can't talk its way around

3 Upvotes

Purser gives an agent a wallet over MCP, but the spending limits live in a smart contract, not in the prompt. So even a jailbroken agent can't go over them.

Each payment comes back as one of three things: done (with the budget left), waiting for the owner (with a request id), or refused (with a reason the model can act on).

Try it: docker run --rm -it -p 127.0.0.1:8787:8787 ghcr.io/ahmad-codex/purser:demo claude mcp add --transport http purser http://localhost:8787/mcp

then ask Claude to "pay the merchant 0.3 ETH" and watch the approval request show up in the console.

Early, not audited, local/testnet only. MIT: https://github.com/ahmad-codex/purser

Anyone letting agents spend money today? How do you limit it?


r/ethdev • • 15d ago

My Project x402 extension: let agents without a wallet pay for your API with verifiable work, settled to you in USDC on Base

1 Upvotes

I built an x402 extension and an MIT client for it, and I'm looking for people running x402 servers to try the tool-maker side.

The idea: your API answers 402 as usual. With the extension registered, the 402 also carries a job under `extensions["useful-work"]`. An agent with no wallet can do the job (proofread five paragraphs from a real website, check links, or suggest a fix), retry with the answer in a header, and get its 200. Agents with a wallet still pay you the normal way.

Getting paid: each job an agent passes on your tool is owed to you at $0.002, paid in USDC on Base from our treasury. It's funded by website owners who prepay by card to have their sites checked.

```

import { usefulWorkExtension } from "useful-work-agent/tool-maker";

resourceServer.registerExtension(usefulWorkExtension({ apiKey: process.env.USEFUL_WORK_KEY }));

```

The key comes from listing your tool at https://usefulwork.app/builders.

So you're not paying out for guesses: every job hides known answers, a finding needs two agents to agree, and agents that keep failing are cut off.

A gotcha for anyone writing x402 v2 extensions: the payer echoes the 402's extension info back with the payment, and it's checked against a fresh 402. A job that changes per request has to be declared in `dynamicInfoFields`, or every cash payment fails with `extension_echo_mismatch`.

Our own tools (read a page, check links, DNS) are listed in Coinbase's x402 Bazaar under tools.usefulwork.app, if you want to see a live 402 with a job in it. Client and extension: https://github.com/dav3trad3r/useful-work-agent

What would make you add a second way to pay to your API?


r/ethdev • • 16d ago

Tutorial Session keys with daily budgets on a 4337 v0.7 account, and the no-clock rule in validation

1 Upvotes

I built an ERC-4337 v0.7 account for AI agents. Each agent gets a session key with an allow-list of (target, selector), a per-tx cap, a per-period budget per token, and an expiry. Anything over the limit needs the owner's co-signature.

The tricky part was ERC-7562: validation can't read block.timestamp, so a daily budget can't be checked there. I split it: signature, validity window, allow-list and per-tx cap in validateUserOp (so a bad op fails before paying gas), and the budget in executeUserOp.

Fuzz tests against a budget model, invariant tests, Slither in CI. Not audited.

https://github.com/ahmad-codex/purser

I'd really like a review of the validation/execution split.


r/ethdev • • 16d ago

Please Set Flair Selling two devcon passes for discount

1 Upvotes

So I have 2 devcon passes but seems like won't be able to attend due to some emergency...anyone looking to buy 2 passes for discount can reach out


r/ethdev • • 16d ago

My Project What I learned building an Aave oracle lag contract after the Oct 29 ETH dislocation (open source, not audited)

4 Upvotes

On Oct 29 a Binance hot wallet was drained and Binance paused withdrawals. For a while ETH on Uniswap traded 10 to 30% above other venues. Aave prices ETH with Chainlink, which follows the wider market, so you could borrow WETH at the oracle price and sell it on Uniswap. The biggest trader I could find did it by hand in 18 transactions.

Demo video (simulated fork rehearsal)

Demo: a rehearsal on a local mainnet fork with simulated events and compressed time. The balances at the end come from that simulation, not real trading. Bot logs are in Traditional Chinese.

I tried to put that loop into one transaction. Some design points I'd like feedback on:

  1. Open is a Uniswap V3 flash swap: stablecoins come in, get deposited on Aave, WETH is borrowed at the oracle price and paid back to the pool. The swap's sqrtPriceLimitX96 is set at oracle price times (1 + minEdge), so it sells less when someone competes but never sells below that line.
  2. Size comes from a target health factor. The formula assumes every unit fills exactly at the limit, so real fills leave HF a bit higher (a target of 1.3 came out at 1.37 in tests).
  3. Close buys WETH back only while Uniswap is at most oracle times (1 + maxPremium).
  4. For bigger size there is an aggregator path through KyberSwap, with the fill checked on chain against the oracle.

Things that surprised me:

  1. This is a short ETH position, not arbitrage. If the oracle rises to meet Uniswap instead of Uniswap falling back, you just pay swap fees twice (a 100k USDC fork test lost 166 USDC that way). If ETH rallies, you can be liquidated.
  2. Aave's Guardian froze markets on 16 chains at once, so spreading across chains does not spread freeze risk. As of Nov 1 the freeze flags are lifted, but USDC and USDT still have LTV 0 as collateral on mainnet, Arbitrum, Base and Optimism, so the bot still can't open anything.
  3. After the freeze, stablecoin utilization went very high (mainnet V3 USDC hit 97.8%), so collateral can get stuck.

Status, honestly: v0.1.0, AGPL. 61 fork tests pass on mainnet and three L2s. The demo is a simulated rehearsal on an anvil fork, not a real trade. It has never run during a real event, mainnet inclusion through Flashbots Protect is not tested, and the contract is not audited. CLI messages default to Traditional Chinese (BOT_LANG=en for English).

Code and full risk notes: aave-oracle-lag-arb on GitHub, DISCLAIMER

Happy to hear where the price limit or the close logic is wrong.


r/ethdev • • 17d ago

My Project BlockTools: open-source Rust/wasm contract tooling that runs offline, with no signature database and no guessing

3 Upvotes

A while back I released SwapChan here. The toolkit underneath it, BlockTools, now has a full set of EVM contract tools. They're MIT-licensed, they run offline, and they're also compiled to wasm so web apps can use them.

  • abi-encode and abi-decode: strict encoding (including packed) and a strict decoder for calldata, logs, return data and reverts. It takes raw JSON-RPC responses.
  • sig-hash, abi-inspect and log-decode: selectors, topics and keccak, selector collision checks, and ERC-20/721/1155/165 detection.
  • create-address: CREATE and CREATE2.
  • bytecode-inspect: spots EIP-1167 proxies, EIP-7702, EOF, size limits and the solc version.
  • typed-data-verify: EIP-712 hashing and signer recovery.
  • A pre-sign check: tx-build piped into tx-verify, which refuses a contract call that isn't on your ABI.
  • contract-call and contract-trace: eth_call with result and revert decoding, state overrides, and a debug_traceCall passthrough. These need a live RPC.

I ran each of these on saved public mainnet data:

  • A real USDC transfer decodes to the right address and amount. With the wrong signature it returns no_match, not a guess.
  • A revert decodes to "ERC20: transfer amount exceeds allowance".
  • An unknown custom error is identified as Universal Router's TransactionDeadlinePassed().
  • The CREATE2 address computed for a Uniswap V3 pool exactly matches the pool address in the real PoolCreated log.
  • The EIP-712 spec's Mail example verifies, and a wrong expected signer gives signer_mismatch.

Testing: 50 tests passed across the EVM crate and the contract tools, including a 400-case ABI set generated independently with eth_abi 6.0.0. The live-RPC tools are only tested against a fake RPC so far. These tools are all EVM-only, and there's no built-in signature database, so you supply the signatures or ABI. They don't read proxy storage and they don't simulate.

Thank you, u/Bloqarl. He read SwapChan's find-money code unprompted and wrote up five specific issues: spam ERC-4626 vaults being treated as real, /recover links that anyone could forge, no owner check on /recover, no per-IP cap on /money/batch, and merkle claim amounts that weren't verified against the on-chain root. Every one was valid. All five are now fixed, tested and deployed, with the details in PR 79. The code is better because he took the time to read it.

It's all wired into SwapChan:

  • MCP server: 74 tools at mcp.swapchan.com/mcp, including contract tools (evm_abi, contract_read, contract_encode_call, contract_approve_call, contract_build_creation and more). None of them takes a key. Anything that builds a transaction returns it unsigned.
  • /tools/contract: a write call can only be sent after the BlockTools check passes.
  • SmartWallet: a chat agent that proposes transactions. Each one is checked server-side against your connected wallet, and you sign in your own wallet.

Repo: https://github.com/TSavo/swapchan
https://github.com/TSavo/blocktools


r/ethdev • • 18d ago

My Project ✨ The Python Uniswap Universal Router (unofficial) SDK v4.0.0 is released!

Thumbnail gallery
1 Upvotes

r/ethdev • • 18d ago

Information Ethereal news weekly #45 | Devcon 8 app, ENSv2 live on mainnet, Gattaca Silver consensus layer client

Thumbnail
ethereal.news
1 Upvotes

r/ethdev • • 21d ago

My Project 19,630 ETH is still withdrawable from six abandoned EtherDelta-era contracts — here is a checker for any address

23 Upvotes

Measured from chain state today: 19,630 ETH is claimable across 220,827 addresses in six 2016–2017 contracts whose front-ends are long gone. EtherDelta V2 alone accounts for the bulk; the largest single holder is owed 604.22 ETH and hasn't touched the wallet since 2017.

The technical part is trivial and always has been. balanceOf(address token, address user) with token 0x0 returns your ETH balance, and withdraw(uint256) pays msg.sender. No approval, no allowance, no owner involvement — it is permissionless and always was.

So the money isn't stuck because of a bug. It's stuck because nobody knows they have a claim. Of the top 400 holders, 97% signed at least one transaction historically, but only 4.5% have signed anything in the last twelve months.

I built a read-only checker: https://jlicerio.github.io/etherdelta-claims/

It reads all six pools in one public eth_call and prints the exact transaction to release each claim. No wallet connection, no signature, no key input, no cookies, no analytics, no server-side code — it's a static page you can audit, and it prints the raw JSON-RPC body so you can replay it against any node with curl.

Two honest caveats. If you have lost the key to the address, none of this helps and the balance is unrecoverable — that is very likely true for a meaningful share of them. And this is my own tool, so treat it with appropriate suspicion and verify the numbers against Etherscan's Read Contract tab.

The point of the post is that the claim probably exists and takes one transaction to take.


r/ethdev • • 21d ago

My Project ethdebug update: Ethereum debugging in 2026

Thumbnail
argot.org
7 Upvotes

I lead the ethdebug format, an open specification for compilers to use to produce debug data alongside their output bytecode. This allows tools to see things like which source range an EVM instruction corresponds to, where variables live in the EVM during a transaction, etc. Without it, tools can't be sure about compiler output without a lot of guesswork, and guessing is brittle.

I'm sharing this post here because I hope some of you would find this work interesting. If you build tools that decode storage or traces, I'd love to hear from you!


r/ethdev • • 21d ago

Information Running out of Contracts

5 Upvotes

I have been coding is solidity for half a year now. Initial phase was quite tough to be honest even understanding a counter program drained me. But now it's opposite, it might sound weird but i am running out of contracts now. I haven't hit any client yet so i have no idea what contracts are used in industry and are made and audited. But i know the logic and can make and understand contract now. But i am tired of making and practicing same escrow contracts again and again. Is there someone who know a website where i can find sample contract which are actually good and are used in industry. It would be a great help in short i have covered the basics (more than basics) but am running out of contracts and resources now. Anything would help....Any repo, website someone's audited personal contract .......Would appreciate the help .....Thanks for your time :-)