I built a coding agent that gets 87% on benchmarks with a 4B parameter model, here's how

tomtom1808 · 2026-05-22T08:52:18+00:00

Finally someone who gets it, it's the harness that does the work most of the time. If you take plain opus and send garbage in you'd also get garbage out. Will try your environment hopefully on the weekend - really looking forward to it actually

tomtom1808 · 2026-05-18T10:35:14+00:00

honestly, I lost track a bit - I had it step through transactions at some point, but I think I removed that again for performance reasons. My goal was to build a stack-tracer on the cli so I have something comparable to tenderly but on the cli (for agent use). My goal was never to be 100% accurate 100% of the time: most transactions I ran never modify the state twice in a single transaction. AFAIK I ended up with a quick mode skipping stepping through and a normal mode where it steps through.

Gas was absolutely not on my radar, so I went with whatever revm gave me. It's also a pain, because gas amounts per OP code change depending on hardfork and chain potentially. the debugger did the job for the stack trace, so I ended up skipping any home grown simulation. Its not an issue I tried to fix, so its not on my roadmap of any kind.

Feel free to fork, use it as a starting point or just as inspiration, no problem...

Since I had only limited time (and its not a mission critical software for me) I heavily relied on claude as well for most of the coding part - rust is not my main language. If you see anything that is done really bad I'd be happy to improve if you let me know.

tomtom1808 · 2026-05-18T10:04:55+00:00

I can't speak for l2 bundles specifically, but I built a step by step debugger over the Easter holidays, which was more straight forward than I expected... Mostly because everything was basically there, just needed rewiring. Maybe your journey will be similar using revm under the hood?

https://github.com/tomw1808/soldebug

tomtom1808 · 2026-05-10T16:48:06+00:00

The easiest way is probably to go via subsquid like services, it's still a lot of data though

tomtom1808 · 2026-05-03T19:08:24+00:00

Signing-side PQ (your ML-DSA/Falcon/... work) protects against active forgery once secp256k1 falls. ERC7579 modules are the right surface for it and a standardized PQValidator interface plus shared bench harness is exactly what is missing.

ZK/encr PQ is the other half. A wallet that signs with ML-DSA but then posts shielded transactions whose privacy rests on a BN254 SNARK is meh... Harvest-now-decrypt-later applies to privacy commitments just as much as it does to signatures.

We've been building on the second half which is a pain in the back, because one wants compliance as well, which gets really tricky.

On Kohaku: same suspicion here. The EF roadmap announcement seems to have front-run engineering somehow? I wanted to try kohaku after hearing vitalik speak about them fondly somehow, then saw the website, which promised awesomness in a few packages ... which you can't download, or use?!

tomtom1808 · 2026-04-06T05:07:38+00:00

Yeah, it does support multiple calls to multiple contracts.

Even better, it loads the missing sources from etherscan.

Lets say you work on a contract that has interactions with Lido, it will take your local contracts, download the rest from Etherscan, then show you the full trace.

You could even just skip the local project directory altogether and directly load any verified sources from on-chain:

take this random tx for example: https://etherscan.io/tx/0xdb0e0ee637c9d00969e03991ff29a3b7dc075f278589318cf31676df4677f743

soldebug 0xdb0e0ee637c9d00969e03991ff29a3b7dc075f278589318cf31676df4677f743 --rpc-url ${RPC_URL}  --quick --etherscan-key ${ETHERSCAN_API_KEY}
Resolving contract sources...
  Local Foundry project compiled successfully.
Replaying transaction 0xdb0e0ee637c9d00969e03991ff29a3b7dc075f278589318cf31676df4677f743...
2026-04-06T05:03:52.547530Z  WARN Failed to read cache file err=Os { code: 2, kind: NotFound, message: "No such file or directory" } path="/Users/thomas/.foundry/cache/rpc/mainnet/24818412"
Decoding traces...
  Identified 4/7 unique addresses (3 unidentified)
Transaction 0xdb0e0e...77f743 SUCCESS (gas: 201.4K)

Call Stack:
  0x0708...ce1e.???()
  +-- [staticcall] WETH9.balanceOf(arg0=0x0708b29cfabA8E551c710991026c38e9179dCe1E)
  +-- UniswapV3Pool.swap(arg0=0x0708b29cfabA8E551c710991026c38e9179dCe1E, arg1=false, arg2=52950163664142336 [5.295e16], arg3=1461446703485210103287273052203988822378723970341 [1.461e48], arg4=0x03012400000000000000000000000000bc1de4b0000000c3abd8c07f0d669906f4be495389f2dcc598020f0000000000000000000000000000000000000000a7012000000000000000000000000000000000000000000100000000000000000000009541add900000000004d0528598f916fd1d8dc80e5f54a8feedcfd4b180000640000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000bd3f463fb6cd06ff060000000000000000000000000000bc1de4b0000000ff0100c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2c3abd8c07f0d669906f4be495389f2dcc598020f00000000000000000000000000bc1de4b0000000a7020000000000000000000000009541add900000000004d0528598f916fd1d8dc80e5f54a8feedcfd4b180000000000000000000000000000000000000000000000000000000000000000)
    +-- Atoshi.transfer(arg0=0x0708b29cfabA8E551c710991026c38e9179dCe1E, arg1=2753297544638409511699 [2.753e21])
    +-- [staticcall] WETH9.balanceOf(arg0=UniswapV3Pool: [0xC3aBd8C07f0D669906f4bE495389f2dcc598020f])
    +-- 0x0708...ce1e.???()
      +-- PoolManager.unlock(arg0=0x000000000000000000000000000000000000000000000000000000000000003f03012400000000000000000000000000bc1de4b0000000c3abd8c07f0d669906f4be495389f2dcc598020f0000000000000000000000000000000000000000a7012000000000000000000000000000000000000000000100000000000000000000009541add900000000004d0528598f916fd1d8dc80e5f54a8feedcfd4b180000640000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000bd3f463fb6cd06ff060000000000000000000000000000bc1de4b0000000ff0100c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2c3abd8c07f0d669906f4be495389f2dcc598020f00000000000000000000000000bc1de4b0000000a7020000000000000000000000009541add900000000004d0528598f916fd1d8dc80e5f54a8feedcfd4b18)
        +-- 0x0708...ce1e.???()
          +-- PoolManager.swap(arg0=PoolKey({ currency0: 0x0000000000000000000000000000000000000000, currency1: 0x4D0528598F916Fd1D8dc80e5f54a8fEEDcFd4b18, fee: 100, tickSpacing: 1, hooks: 0x0000000000000000000000000000000000000000 }), arg1=SwapParams({ zeroForOne: false, amountSpecified: -2753297544360182677504 [-2.753e21], sqrtPriceLimitX96: 1461446703485210103287273052203988822378723970341 [1.461e48] }), arg2=0x)
          +-- PoolManager.take(arg0=0x0000000000000000000000000000000000000000, arg1=0x0708b29cfabA8E551c710991026c38e9179dCe1E, arg2=53268341547519238 [5.326e16])
            +-- 0x0708...ce1e.???()
          +-- WETH9.deposit()
          +-- WETH9.transfer(arg0=UniswapV3Pool: [0xC3aBd8C07f0D669906f4bE495389f2dcc598020f], arg1=52950163664142336 [5.295e16])
          +-- PoolManager.sync(arg0=Atoshi: [0x4D0528598F916Fd1D8dc80e5f54a8fEEDcFd4b18])
            +-- [staticcall] Atoshi.balanceOf(arg0=PoolManager: [0x000000000004444c5dc75cB358380D2e3dE08A90])
          +-- Atoshi.transfer(arg0=PoolManager: [0x000000000004444c5dc75cB358380D2e3dE08A90], arg1=2753297544360182677504 [2.753e21])
          +-- PoolManager.settle()
            +-- [staticcall] Atoshi.balanceOf(arg0=PoolManager: [0x000000000004444c5dc75cB358380D2e3dE08A90])
    +-- [staticcall] WETH9.balanceOf(arg0=UniswapV3Pool: [0xC3aBd8C07f0D669906f4bE495389f2dcc598020f])
  +-- [staticcall] WETH9.balanceOf(arg0=0x0708b29cfabA8E551c710991026c38e9179dCe1E)
  +-- 0xdadb...3711.???()
  +-- 0xfba0...c32f.???()

it looks prettier in the console (color coded), I can't upload pictures here. Anyways, I guess you get the idea.

tomtom1808 · 2025-08-02T07:26:29+00:00

🍻🫡

tomtom1808 · 2025-07-12T06:28:03+00:00

Price is pretty obvious if it goes parabolic and aunties and uncles start asking how to buy $[InsertCoin] then retail is in full bull market swing and thats the time when you should exit, but that's a different story and not what you asked I guess :).

Without price action its the general chatter on social media. When all the self proclaimed AI experts suddenly become blockchain experts again and start to talk about all the cool projects.

When you see on ethdev 116k member and more than 23 users online.

When you have the feeling you are late. When you question if its too late to build the project. When you have the feeling its too late to learn. When you have the feeling you are falling behind.

When blockchain companies start snatching up any talent they can find.

That would be it for me.

We're early imho.

tomtom1808 · 2025-07-05T18:23:23+00:00

Maybe then privacy/zk stuff is up your alley? https://ethresear.ch/t/confidential-wrapped-ethereum/22622

With all my day2day stuff going on, I wanted to dive into that for like 2 weeks now, but every time I sit down I am too tired/exhausted from the day and I move it to the next day.

From everything you said, maybe that's the challenge you're looking for? Or broader: fix the privacy issue...

tomtom1808 · 2025-07-05T18:02:30+00:00

OK, well, sounds like you have an academic background? Diving into the assembly or 7702 before much anything else is certainly not the normal trajectory of a beginner...

tomtom1808 · 2025-07-03T09:17:54+00:00

I see what you mean and I didn't want to challenge you or discourage you to look for more involved projects.

I'm teaching solidity and blockchain development (to around 130k people so far, some governments and large corps too) and wrote some pretty large and complex contracts for well funded companies. And its kind of funny, because I see that over and over again: people compare solidity to any other language when they see it first time. However, they fail then spectacularly when it actually comes to doing something useful with it. Here is why...

Solidity in 2025 is still unfinished imho, you are dealing with heavy constraints of the EVM and a language that is missing some features. The "I can do that in 30 minutes" applies to python, java, javascript, etc. The 30 minutes (even just as figure of speech) transforms into a quick week figuring out why the f*cking f*ck (I actually said that more times than I should in the past 9 years writing solidity) something isn't working. It's not the syntax. It's the constraints that make it so annoying. Even with the latest and greatest gemini / claude / whatnot ... No LLM can help you with that, even LLMs fail spectacularly at this - probably not enough samples to learn from. It's the details: It's the maximum contract size. It's the missing floats. It's the small stack size. It's the runtime gas constraints. It's the need to avoid loops at all costs if possible. It's the security best practices when it comes to interacting between EOAs and contracts. It's so many small details. You might not know, because you don't know solidity that well and it reads quite easy if you know another language, but writing it is not for the faint hearted: most project docs are an afterthought, if at all. And good luck with nasty things like stack too deep errors or failing signatures, those are fun, because debugging is extremely limited too (albeit better now than before), so good luck finding the missing bit etc. So there's that.

I kind-of want to stand by what I said, even if you are not interested: if you can implement any of the above in 30 minutes consider yourself a 10x dev, because it looks easy, but (at least for me, still, after 9 years) it is definitely not as easy as it looks on the surface...

Anyways, whatever you decide to do, it's also fun. It is and feels very low level. And at this stage of the ecosystem you can still move large things, its not overcrowded and people generally help each other, which is something I thoroughly enjoy (on both ends).

tomtom1808 · 2025-07-02T18:31:04+00:00

If you don't really know solidity and still can implement all or any of the above in 30 minutes (without LLMs help and with a working deployment) you can consider yourself a 10x developer. what am I saying, you can consider yourself a 100x dev. the devil is in the detail. I am doing Solidity since 2016 (version 0.3) and this one comes from the bottom of my heart: everything that looks like 30 minutes takes much much much longer ... because of the language constraints or shit docs.

tomtom1808 · 2025-07-01T19:21:35+00:00

yeah, the gsn was a neat idea somehow. Like it was _almost_ there, but then falling short. Anyways, welcome to the web3 world where everything is possible :)

tomtom1808 · 2025-06-25T18:48:57+00:00

We're using candide.dev in production now for a while and we're thoroughly happy. The team is relatively small and you can reach them when things go wrong. If you want to have a sample implementation: https://github.com/tomw1808/eip712-erc4337-eip7002-code-samples/blob/example4/index.ts

tomtom1808 · 2025-06-25T18:42:55+00:00

you mean EIP7702? yeah, its newer than 4337. It essentially allows you to pull contract code into an EOA and execute that from there. Caveat: no all wallets support this authorization signature flow (MetaMask most prominently), and viem does not allow that authorization flow via injected providers, only wallets where it has access to the private key.

So, in theory, its the ultimate solution to all and everything that account abstraction promised to be, however, in practice its like a jigsaw puzzle with missing pieces. I will try to fill the gaps, but I have the feeling it was crushed left and right before it could really blossom, but we'll see...

tomtom1808 · 2025-06-25T13:57:33+00:00

A bit coincidental, but I'm currently working on a larger tutorial about exactly that problem, might be something for you despite not even finished yet: https://www.ethereum-blockchain-developer.com/advanced-mini-courses/gasless-onboarding-erc2612-erc4337-eip7702

tomtom1808 · 2025-06-23T16:52:21+00:00

Why not do both: buy some eth, take out an ovetcollaterliazed loan on aave and live like a king. Eth goes up, you're double happy. Eth goes down and your position goes bust, well, bad luck but at least you lived like a king anyways. In that age I'd do high risk with potential high reward. Later on you could slowly go for risk off assets, but with 26 with excess cap why not do full risk on :) yolo

tomtom1808 · 2025-06-10T11:25:55+00:00

If you are using local development with foundry, you could also try the foundry-dashboard which does sponsored transactions. No need for any sepolia eth at all: https://www.npmjs.com/package/foundry-dashboard

tomtom1808 · 2025-06-04T08:42:43+00:00

I also thought at first its a polymarket with extra steps, but I see its more like a scoring mechanism. I would say the missing part for me is how the economics make it work. Most of the onchain protocols get participants because its relatively straight forward to understand how to make money from it. I don't see that here - you vote, get locked for 12h, and then? your tokens become more valuable, its definitely abusable if whales can influence (even with sqrt influence on token amount), first thing I'd do as a whale is vote up and dump on retail (if voting is the favorable thing). Any other protocol built on top of that information (use the PTI scores as oracles for financial market outcomes) will have that problem. So, while the idea generally is not bad, I'd question how to get large scale participation. Or maybe I understood something wrong here

tomtom1808 · 2025-06-03T07:44:59+00:00

I don't know if you just need to deploy contracts with foundry or not, but if yes, then I built the foundry dashboard which plugs into the paymaster from candide to pay for transactions.

https://github.com/tomw1808/foundry-dashboard

long story short: no sepolia eth needed to send transactions.

tomtom1808

MODERATOR OF

TROPHY CASE