
-prev:distributed halo2 proof gen | zk engineer @powdr_labs - Web3 Security Researcher - interested in Verifiable computation, cryptography
Joined December 2021
- Tweets752
- Following3.8K
- Followers926
- Likes14.4K
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Experimenting with conjuring proofs for cryptographic code
arkworks (@arkworks_rs) is a comprehensive optimized toolkit for a wide range of snark-related cryptography
EthLib is a Lean spec for Ethereum related algorithms, including cryptography, that was published recently
1/7
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Real-time Ethereum proving, still on a single machine with 4 GPUs, and now with:
✅ 128-bit provable security
✅ final proofs under 300 KB
✅ a fully open-source stack, CPU and GPU
Pico 3.1 is live. 🧵
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
If Echidna has ever helped you find a bug, now is your chance to help Echidna: initiatives.thedao.fund/init…
Only $12k is needed for it to qualify for the DAO vote
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Most think vibecoding at scale is slop. Here’s a counterexample.
Today we release a 16M-line formalization of the entire Stacks Project, critical infra underlying modern math, with optimized code quality and its highly interconnected structure preserved.
A mathematical city 🌆
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
I am happy to share FlashProve: our performant open-source prototype for provable inference. We believe that this has significant implications for security, pacing AI development, integrity guarantees, and more.
FlashProve allows a provider to commit to model weights, and then prove that replies originate from the committed model. The proof leaks no information about the weights, and the verifier can efficiently verify it on consumer hardware.
Our library is performant, proving a 400B parameter MoE model at 100 tok/s. We have open-sourced the associated code and Lean formalization. We hope that it catalyzes further progress in verification of inference, and look forward to seeing it.
New Anthropic research: progress on provable inference for large language models.
Here, we introduce FlashProve. Building on established cryptographic techniques, FlashProve allows developers to verify whether a given response came from a given AI model. It’s substantially more efficient than prior open-source methods for doing so.
These proofs have a range of applications. They can, for instance, make it harder for attackers to hijack a chat, or enable safety evaluators to verify that the model they’re testing is the same one being served to customers.
For our full write-up, see here: anthropic.com/research/prova…
Further progress in provable inference will likely be an important part of improving trust in AI deployment. To that end, we're open-sourcing FlashProve’s code, here: github.com/anthropics/FlashP…
We’re grateful to our collaborators: Alessandro Chiesa, @GiacomoFenzi, @gwberg95, @miranda__christ, Rahul Dalal (rdalal.github.io) and Ben Mayer (@transmissions11).
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
evm.asm, our collaboration with EF on an e2e verified EVM implementation for zkVMs, now has its own autoresearch competition: evm.fast
Prove the lowest runtime to validate an Ethereum block!
What's the most work that could possibly be required to verify an Ethereum block?
Today, we can't prove an answer. All we know is the validator always finishes. evm.fast is an open challenge to change that: contributors compete on a leaderboard to find mathematically guaranteed bounds for verifying Ethereum, no matter what's in a block.
Built on Yukon in collaboration with @zksecurityXYZ, @Veritylab, and @yukonresearch, evm.fast seeks provable limits that keep verification cheap, predictable, and possible on modest hardware.
Try it yourself:
evm.fast
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Anthropic @AnthropicAI ❤️ zkSTARKs:
In collaboration with @StarkWareLtd co-founder Prof. Alessandro Chiesa and other brilliant researchers, Anthropic just open sourced a zk STARK system for proving the integrity of LLM inferencing, bringing us closer to verifiable AI.
As we said long ago (since 2018), zkSTARKs are the end-game: highest scale, best security (post-quantum). Now, also AI agile and supporting AI integrity.
anthropic.com/research/prova…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
SOLAR: 100x FASTER SOLIDITY
Solar is the future of Solidity and the EVM.
It's >100x faster than Solc.
It has faster bytecode than Solady with no assembly.
Its bytecode is faster to interpret by the EVM.
Solar fixes Stack Too Deep!
foundryup
forge --use solar
Blog below.
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
EVM fast | Ethereum Foundation, zkSecurity & Yukon
Goal: Build a Ethereum validator with a lean proof that it takes less than X steps in RISC-V. For the smallest X.
We are approaching the full automation of cryptography research.
yukon.org/evm.fast
Open Frontier Science
What's the most work that could possibly be required to verify an Ethereum block?
Today, we can't prove an answer. All we know is the validator always finishes. evm.fast is an open challenge to change that: contributors compete on a leaderboard to find mathematically guaranteed bounds for verifying Ethereum, no matter what's in a block.
Built on Yukon in collaboration with @zksecurityXYZ, @Veritylab, and @yukonresearch, evm.fast seeks provable limits that keep verification cheap, predictable, and possible on modest hardware.
Try it yourself:
evm.fast
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Reading the reconstructed bytecode of the Binance EIP-7702 sweeper (`0x63e8...6fae`) is wild.
This wasn't a generic drainer. It was custom-engineered for Binance 14's architecture:
- Leaves exactly 1 ether behind (`bal - 1 ether`) when sweeping ETH so Binance's automated hot wallet queue wouldn't error on gas and trip alarms.
- Uses raw `staticcall` + `continue` loops with custom error codes (`SweepItemFailed`) so one bricked or blacklisted ERC-20 wouldn't revert the $6B batch.
- Includes a custom `callExecute` function to impersonate Binance 14 as controller of an external vault holding $823M in USDC.
They leave a comment: "robberies could be prevented if getaway cars were slower."
You can't fully blame EIP-7702, but it sped up the attack. Without 7702, draining 64 tokens plus an external $823M vault from a live exchange hot wallet meant fighting moving nonces across 70+ transactions. Defense systems would've killed it after tx #3.
With 7702, Lazarus sprayed 50 consecutive nonces in one type-4 payload, turned an EOA into a custom proxy, and atomically swept billions in a single block.
Ethereum core devs built the ultimate getaway car. Surgical state-sponsored engineering.
This could be etched onchain:
`if (bal > 1 ether) { to.call{value: bal - 1 ether}(""); }`
The Binance $5.6B drain is a masterclass in modern EVM exploitation.
It wasn't a complex logic bug. It was an EIP-7702 delegation hijack:
1. Setup: Attacker funds 0x7c86 via Tornado Cash, deploys a sweep contract (0x63e8), and runs three live dry-runs on external wallets.
2. Execution: Attacker submits an EIP-7702 batch with 50 pre-signed authorizations (nonce n to n+49) to hit Binance 14's moving nonce window.
3. One authorization hits. Instantly, Binance 14 (an EOA) is reprogrammed to run the attacker's contract bytecode.
4. Execution looks totally organic: Binance 14 sweeps itself clean. Internal threshold alerts don't trigger because, from the nodes' perspective, the hot wallet is just executing its own transaction.
5. Binance 16 immediately auto-refills 28,000 ETH due to automated treasury rebalance scripts, feeding the exploit loop.
The cold truth: you cannot forge an EIP-7702 delegation list.
For this to execute, the attacker already held the raw private key or unconstrained signing access to Binance 14's HSM/KMS.
But hey, 5.64 billion drained across ETH, BTC, and Tron. 2.54 billion frozen by Tether, Circle, Ripple, and World Liberty within hours.
Code is law until the stablecoin admin keys log in.
Binance got bailed out by the very centralized choke points the cypherpunks warned you about.
Hardware wallets leak your home address.
Centralized exchanges leak the keys to the kingdom.
Self-custody on native, non-delegated chains remains the only honest baseline.
At least you know what to avoid.
Readers added context they thought people might want to know
The quoted comment appears only in an AI-reconstructed source (explicitly labeled not original) uploaded to explorers; no source comments exist in deployed bytecode, and core features match independent decompilations/on-chain data.
etherscan.io/address/0x63e8…
gist.wavey.info/Ta3FgAxastgj42…
x.com/thearsondragon…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
The Binance hacker might have just pulled off one of the smartest moves I’ve seen in crypto.
First, Tether froze $1.5 billion in USDT.
Then Circle froze another $800 million in USDC.
At that point, it looked like the hacker’s money was trapped.
But apparently, he had already planned for that.
Instead of holding the stolen USDT in a wallet, he allegedly deposited it into Aave and used it as collateral to borrow ETH.
Then he walked away.
That’s where the story gets crazy.
Tether can freeze the USDT sitting in the wallet.
But it can’t freeze the ETH he already borrowed.
So now Aave is left holding frozen collateral, while the hacker is sitting on liquid ETH.
And unless the protocol can recover it somehow, he may not even need to pay the loan back.
Two companies froze billions of dollars in seconds.
But someone who understood how to use DeFi may have found a way around both of them.
Pretty insane when you think about it.
Readers added context they thought people might want to know
The frozen $1.5B+ USDT and $800M+ USDC were held in the attacker's main wallet (shown in the post's image), not Aave. Only ~$60M USDT from a related wallet was deposited into Aave pre-freeze to borrow ~$45M ETH.
governance.aave.com/t/binance-hot-…
decrypt.co/382191/binance…
coinstats.app/news/1f0734d0f…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
New post on Eth Research!
Post-quantum signatureless authorization with recursive verification
By:
- ignotusnemo
🔗 ethresear.ch/t/26196
Highlights:
- Signatureless authorization replaces digital signatures with reusable zero-knowledge proofs of knowledge of a secret bound to a specific intent (request), aiming to remain secure in a post-quantum setting.
- The key security challenge is safe reuse under adaptive, chosen-request attacks; the paper gives a quantum security reduction in an explicit “address-compatible random-completion” model and quantifies forgery probability in terms of preimage, simulation, extraction, and binding failures.
- The construction is specialized to binary fields (using F_{2^128} inside F_{2^256}) and uses a Poseidon2b-based authority relation plus masking, linear-claim reductions, and a Reed–Solomon-style code argument with fixed-before-challenge transcript structure to ensure binding and extractability.
- It is designed for recursive verification: the verifier checks the capsule using compatible binary-field arithmetic, enabling composition with proofs of execution while keeping authorization independent of public execution state for a fixed intent and authority.
- An implementation is provided with measurements: median proving around ~0.8–0.9s and verification ~25.6ms on the stated CPU setup, with capsule sizes roughly ~89–90KB and a maximum canonical size of 92,696 bytes; the verifier tile adds 16,536 incremental rows in the recursive system.
ELI5:
Normally, you prove you’re allowed to do something by signing with a private key. Quantum computers could break many of today’s signatures. This work replaces signatures with a different idea: you publish a public “commitment” (like an address) to a secret, and every time you want to authorize an action you send a fresh zero-knowledge proof that you know that secret and that it matches the requested action. The proof reveals nothing about the secret, can be safely reused many times with new randomness, and can be checked inside larger recursive proofs so systems can prove “this action was authorized and executed correctly” in one combined proof.
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
post-quantum stealth addresses on Ethereum with ERC 8441 :)
eips.ethereum.org/EIPS/eip-8…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
🚨 @binance - Loss ~$201.2M (2026-10-29)
Network: Ethereum
Type: Delegation Abuse (EIP-7702) / Private Key Compromise
Follow-up sweep in the Binance hot-wallet drain. The wallet 0x28c6…1d60 carries an EIP-7702 delegation (code 0xef0100 + 63e842b0…), pointing at the same operator-gated wallet-drainer kit. In this tx the attacker operator EOA 0x7c8601d4 (NOT the account owner) called sweep(address recipient, address[] tokens) = 0x8a179be4, and the delegate code transferred the wallet's inventory — 200.40M USDT, 369.8 ETH, plus LINK, UNI, ENA, COMP, AAVE, QNT, PEPE, SHIB, ONDO, PENDLE, IMX, MORPHO, NIL and more — to attacker collection 0x5227f603c1ee34ce3c06efe6477003bdfccb2f8c. Net ~$201.2M in this transaction. Setting a 7702 delegation requires a signature from the account's own key, so this is a signing/private-key compromise of an exchange hot wallet, extracted via an operator-gated universal sweep (one of several sweeps totaling ~$2.5B).
TX: etherscan.io/tx/0x55ba4dabc4…
Attacker: etherscan.io/address/0x7c860…
Victim: etherscan.io/address/0x28c6c…
⏱️ Real-time alerts: defimon.xyz
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Taking this opportunity to plug all the tooling built by the EF zkEVM team @ignaciohagopian @codytouchgrass @han__0110 @kevaundray @ladislaus0x and friends 🙏
📊 Hive dashboards: execution-spec tests run against every EL's execution witness and every guest × zkVM
eth-act.github.io/eest-execu…
✅ zkevm-test-monitor: tracks zkVM compliance with the zkEVM standards
eth-act.github.io/zkevm-test…
🔧 ere: one interface to compile, prove and verify across zkVMs
github.com/eth-act/ere
📦 ere-guests: the stateless EVM validator guests we're proving
github.com/eth-act/ere-guest…
🚀 zkboost: proves every block and feeds proofs to the beacon node
github.com/eth-act/zkboost
🧪 ethereum-package: spin up a local EIP-8025 devnet with provers in one command
github.com/ethpandaops/ether…
⚙️ provoor: runs the GPU proving clusters
github.com/han0110/provoor
📈 provoor runs: proving benchmarks
han0110.github.io/provoor-ru…
Let there be proofs! 🎉
Running an EIP-8025 execution-proof prover on Sepolia: blocks proven in ~6–7s on 16× RTX 5090 with OpenVM, for two guests, ethrex + reth (8 GPUs each).
36k+ proofs and counting.
Big shoutout to the prover teams, guest program teams and everyone who contributed to making this a reality!
We'll be rotating provers and guests over the coming days and weeks. Which prover + guest should we spin up next?
⚠️ Experimental: validators MUST NOT rely on execution proofs for fork choice or attestations. Keep running an execution client. (Yes, Sepolia validators are permissioned, but still 🙂)
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
We now have a first working version of leanXMSS in Lean4, available in EthLib!
This is the XMSS implementation we're planning to use for EIP-8450, Ethereum's post-quantum validator public key registry.
github.com/ethereum/EthLib/t…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
Software Verification in Lean (SVIL) comes to Stanford University on Saturday, November 7.
Co-organized by Beneficial AI Foundation and Lean FRO, it is a day of public lectures on advancing Lean’s software verification ecosystem toward production use, with a focus on end-to-end verification of security-critical systems.
Talks will cover Rust verification with the Aeneas framework, low-level software verification, and formally verified OS kernels.
Speakers include Max Tegmark, Shaowei Lin, Leonardo de Moura, Jonathan Protzenko, Andres Erbsen, and Mike Dodds.
In-person space is limited. Non-local and waitlisted registrants will receive a livestream link, and recordings will be available afterward.
Program and registration: beneficial-ai-foundation.git…
0xKitetsu.eth | Devcon8 🇮🇳 retweeted
This weekend we launched EthLib, a Lean4 library for Ethereum!
The goal is to bring Ethereum's primitives, specifications and theorems into one place, building a shared foundation for formally specifying and proving things about Ethereum.
github.com/ethereum/EthLib






























