arnau

[koeppelmann @koeppelmann]

Not sure I have ever been as productive in my life as in the last ~10 weeks:

An extremely challenging yet worthwhile goal.
The crazy progress of AI coding and heavy use of it.
A very small team, world-class skills, and now the ability to multiply output thanks to AI.

The result is @etheconomiczone — with a live devnet already: https://t.co/QdcOZEycLu.
What is this? It will be:

a) A new rollup that is fully composable with Ethereum.
This means you can do either cheap transactions on this chain that only interact with contracts on this rollup, or more expensive transactions (similar to L1 costs) that can interact in a fully composable way between L1 and L2. So, for example, if you trade on this rollup, the routing can dynamically decide to use only L2 liquidity for a small trade, or for a larger trade — where the extra gas costs are worth it — to use both L2 and L1 liquidity.

b) A whole framework that will allow new rollups, as well as existing L2s and sidechains (yes @gnosischain!!) to integrate into this “(Ethereum) economic zone.”
Imagine: one could make a trade today simultaneously using Ethereum liquidity, but also Arbitrum, Base, or all the other L2s. This is what EEZ will allow.

Now, let’s talk about the tech:
Essentially, there are two core concepts that make all of this possible:

1) Proxy contracts
2) Real-time proving

1) Proxy contracts are basically a way to overcome the challenge that ~99% of all contracts are written in a way that only deals with addresses from a single chain. For example, a token or an NFT can be sent to an address, but not to an address on a specific other chain. Proxy contracts fix this.

An address “A” on chain “n” will get a deterministic proxy representation, “A*”, on all other chains. So now, if, for example, A is a DAO on Ethereum and it should control, say, a fee switch in contract D (a DEX) on another chain, this can easily be done by setting A* as the owner of D. A (the DAO), on the other hand, can now call D* (the proxy representation of the DEX contract D) on Ethereum. All the cross-chain message passing in between is abstracted away — the contracts just call another contract and do not realize it is actually on another chain.

2) Real-time proving
The proxy design already addresses the problem that there is no widely supported cross-chain message-passing standard in EVM land. So it alone would already be helpful for asynchronous calls, or better, calls that do not expect or require a return value. However, this would still not quite bring us to “synchronous composability.”
Imagine a DEX trade: you do the first part of the trade on L1 and the second part on L2. You want to know the result of the second part — and if it did not get you the expected amount, you want to be able to revert the first part. This requires the call that triggers the DEX trade on L2 to have a return value.

This was long assumed to be impossible - but with real-time proving, it no longer is. Basically, because Ethereum blocks are only produced every 12 seconds (and this would still work with, say, 6 seconds), that is now long enough to build and prove the L2 block that contains, for example, this L1→L2 DEX trade.

If you want to learn more, don’t miss the talk by @tw_tter and @jbaylina on Tuesday at @EthCC!
Let’s make Ethereum ONE again!

[James @jamesdawes_]

I’ve had the absolute privilege of working with some amazing Polygon folks who are now exploring their next chapter.

If you’re hiring in the space and would like intro's to some of the best in the industry, my DMs are open and I’m very happy to help.

If you're not hiring, please help by sharing across your networks 💜

[Ethproofs @eth_proofs]

🚀 Excited to share a major milestone for execution client diversity on Ethproofs.

We’ve received the first proofs from a prover operated by @class_lambda running @ethrex_client as a guest program on the @ziskvm zkVM. This marks the fourth independent guest program in our benchmarks:

1️⃣ revm
2️⃣ ZKsync OS
3️⃣ Zilkworm
4️⃣ Ethrex

A huge step toward robust, multi-client proving of Ethereum L1 blocks.

Welcome to Ethproofs LambdaClass and Ethrex!

[arnau @arnau_eth]

The future is now

[ziskvm @ziskvm]

This is the result of two year of hard work @ziskvm

We are committed to prove Ethereum in real time

Our Girona cluster (16×5090) delivers all requirements for real-time Ethereum proving:

• 128-bit security target
• <300 kB proof size
• Post-quantum readiness
• <10 kW power envelope

We extend our appreciation to @drakefjustin and @eth_proofs team for the leadership and standards that continue to strengthen the Ethereum ecosystem.

[Fede’s intern 🥊 @fede_intern]

The integration of @ziskvm with @ethrex_client looks too good to be true. We will be reviewing the PR internally and with the Zisk team. In the next few days it should be merged. more or less 4 minutes for every block with a rtx4090.

[arnau @arnau_eth]

@QuintenFrancois What about @itstuyo ?

[DeFi Dad ⟠ defidad.eth @DeFi_Dad]

I feel like we're back in DeFi fundamentals season!

And p2p swaps between Bitcoin and Ethereum is something every self-sovereign DeFi investor should at minimum be aware of, now live on @rifthq.

@rifthq allows you to move from BTC on Bitcoin direct to cbBTC on Ethereum or from ETH, wBTC, cbBTC, USDC, or USDT on Ethereum to native BTC on Bitcoin.

Given the massive liquidity in BTC and the unlimited DeFi utility on Ethereum, this is the world I wanna live in.

Caution: This is new and undergoing audits so approach like any new code keeping in mind something could go wrong, don't assume you cannot lose funds to some unforeseen bug.

[arnau @arnau_eth]

@VitalikButerin @colludingnode I think @vocdoni has coercion resistance with just ZK

[arnau @arnau_eth]

Awesome work!

[RIFT @RIFTHQ]

Introducing RIFT: the first peer to peer Bitcoin trading protocol

Self custody swaps between Ethereum and Bitcoin, with no middle men.

Powered by Uniswap liquidity. Secured by TEEs.

Now live on mainnet ⬇️

[Vocdoni 🗳️ Secure digital voting @vocdoni]

🇳🇵Nepal just showed us that democracy can be born natively on the internet.

But holding votes on platforms like Discord is risky: identities exposed, easily manipulated, and no real guarantees.

https://t.co/0BktKHlY2i is the decentralized solution with all the safeguards.

[Dappnode @dappnode]

📱Your Dappnode, always with you.

Introducing the Dappnode App — get instant notifications and manage your Dappnode staking set up from your phone.

🟣 100% free
🟣 iOS &amp; Android
🟣 Setup in under 4 minutes
🟣 Same privacy. More accessible.

👇

[Ethproofs @eth_proofs]

Major RISC-V zkVM breakthrough!

The ZisK team hit 1.5GHz trace generation—10x faster than other RISC-V zkVMs. A huge unlock for the space, and it's fully open source.
With zkVMs almost all proving can be parallelised, e.g. farmed across a cluster of GPUs. The exception is the first pass of trace generation, which is inherently sequential. For low-latency proving most zkVM teams hit a wall with this minimal first-pass execution.

So far teams reached up to 150MHz RISC-V execution. @ziskvm smashes that with a 1.5GHz emulator, approaching native CPU speeds.

The trick? Custom x86 assembly via ahead-of-time (AOT) compilation. 3 or 4 x86 instructions per RISC-V/ZisK instruction, plus 2 x86 instructions to segment the trace into correctly-sized chunks.

Let's look at block number 21,926,929 which consumes 36M gas over 230 transactions. The emulator runs at 1.5GHz on a $3K gaming workstation, generating 1.5GB of traces in 0.5 seconds. The CPU is an AMD Ryzen 9 9950X3D 4.3/5.7GHz. Further performance is expected with faster RAM and a CPU tuned for single-threading.

In the short term ultra-fast RISC-V trace generation will significantly reduce the number of GPUs needed to achieve real-time proving. Longer-term we can envision ASIC trace generation being just as fast as native execution, unlocking the endgame of real-time proving.

[ziskvm @ziskvm]

🧵1/ Introducing ZisK — a new era for zero-knowledge proof systems.
A high-performance, fully open-source zkVM stack, born at @0xPolygon, now spun out as its own project.
Designed for low latency proving from the first day.
Meet ZisK 👇
https://t.co/uPbKkoa4py

[Agglayer @Agglayer]

The last time networks unified, we got the Internet.

This time, something bigger.

[Katana ⚔️ @katana]

katana is opinionated.

and its opinion is that you need deep liquidity and high yield for true defi adoption.

@davidesilverman explains

[Katana ⚔️ @katana]

wake the fk up samurai. this is katana.

not just another general purpose chain. a defi chain forged to kill idle assets via deep liquidity &amp; high yield. public mainnet coming late june.

incubated by @0xpolygon x @gsr_io

pre-deposits live ⚔️ stop sleeping on your bags

[Polygon | POL @0xPolygon]

📣 CDK goes multistack 📣

Aggregating web3 means meeting builders where they are – with more freedom and fewer limitations.

We're thrilled to announce the newest addition to Agglayer: the CDK OP Stack configuration, with native Agglayer interop. A new way to build OP Stack chains, supercharged with zk tech and maximum sovereignty. Without the silos, 15% tax, or seven-day delays.

With OP stack joining the current CDK Erigon stack, this is the first of many stacks to aggregate everything on Agglayer.

[arnau @arnau_eth]

So exciting to see that meaningful use cases that can only exist with crypto finally come through

[Vocdoni 🗳️ Secure digital voting @vocdoni]

1/2 🗳️ Introducing DAVINCI: The L2 zk-rollup for universal voting, solving the flaws of both onchain and traditional systems

🎉 We’re excited to share that we’ve raised $1M to build DAVINCI, a voting protocol that does what no governance system has done before:

Censorship-resistant, gasless, anonymous, anti-coercion, and massively scalable voting.

All backed by cryptographic guarantees and Ethereum security.

Since 2018, our L1 blockchain has powered hundreds of secure elections for political parties, local governments, associations and DAOs. We built it with the best tools available at the time.

But technology evolves and today, breakthroughs in cryptography allow us to go far beyond what was previously possible.

DAVINCI is that leap forward:
A zk-SNARK–based state machine, run by a decentralized network of offchain Sequencers with token incentivization, designed to meet every requirement for secure and accessible voting for the masses:

🔐 Votes are anonymized, unlinkable, and tamper-proof
🤐 Re-encrypted ballots make bribery and intimidation ineffective
🧱 Modular ballot logic supports any voting method
⚙️ Rules enforced with zero-knowledge proofs and smart contracts
🌐 Voting is unstoppable, thanks to a decentralized network of Sequencers fueled by a native token
📦 High scalability, as all the votes are compressed into a single zk-proof and settled on Ethereum

In summary,
— No single authority can stop you from participating.
— Voting is gasless.
— Your choices remain entirely private.
— Scalable to milions
— And it all works at a fraction of the cost of direct onchain voting, with equivalent guarantees!

📖Read our public announcement and join the waitlist:
https://t.co/Lua1Me3RgU

[arnau @arnau_eth]

@niinyarko @SuccinctLabs @Agglayer Mostly chatgpt tbh

[arnau @arnau_eth]

I prtotyped zkFlappyBird at @SuccinctLabs residency, with 0 prev experience in Rust. This was just a side project while I was working on the @Agglayer. zkVMs are a game changer. What u gonna build anon?

https://t.co/TVDOmP4jAH