0xBaloo

Baloo.eth | BTC ‘13 ETH ‘17 Decentralization Maxi

[CoinDesk @CoinDesk]

NEW: Illinois Governor Pritzker has signed a 0.2% tax on crypto transactions into law including transfers between personal wallets, with the Crypto Council for Innovation calling it "the most punitive digital asset tax in the country."

[willo2 @willo2_Poly]

I was just scammed for $500K by Polymarket.

I am "willo2", the top holder of YES on "MicroStrategy sells Bitcoin by May 31st".

Here's what happened:

[🍜 @cprkrn]

HOLY FUCKING SHIT OMG CLAUDE JUST CRACKED THIS SHIT, THANK YOU @AnthropicAI THANK YOU @DarioAmodei NAMING MY KID AFTER YOU 😍

https://t.co/gObNirRDpS

[Wazz @WazzCrypto]

Hundreds of wallets (many of which haven't been active in 7+ years) just got drained by the same address on ETH mainnet

Seems like a new live exploit, worth flagging

[Alex Shevchenko 🇺🇦 @AlexAuroraDev]

10h ago @litecoin experienced a coordinated attack on the chain that resulted in 13 blocks reorg that took more than 3h to generate.
During this time attackers were performing double spend attacks on multiple cross-chain swapping protocols.
We are investigating the situation.

[koeppelmann @koeppelmann]

To clarify: the correct approval address for Cowswap is: 0xc92e8bdf79f0507f65a392b0ab4667716bfe0110 on all networks. On Mainnet the contract is almost 5 years old. Those approvals are totally fine. You are only potenitally effected if you set a new approval in the last hours.

[vitalik.eth @VitalikButerin]

A very important document. Let's walk through this one "goal" at a time. We'll start with fast slots and fast finality.

I expect that we'll reduce slot time in an incremental fashion, eg. I like the "sqrt(2) at a time" formula (12 -> 8 -> 6 -> 4 -> 3 -> 2, though the last two steps are more speculative and depend on heavy research). It is possible to go faster or slower here; but the high level is that we'll view the slot time as a parameter that we adjust down when we're confident it's safe to, similar to the blob target.

Fast slots are off in their own lane at the top of the roadmap, and do not really seem to connect to anything. This is because the rest of the roadmap is pretty independent of the slot time: we would need to do roughly the same things whether the slot time is 2 seconds or 32 seconds

There are a few intersection areas though. One is p2p improvements. @raulvk has recently been working on an optimized p2p layer for Ethereum, which uses erasure coding to greatly improve on the bandwidth/latency tradeoff frontier. Roughly speaking: in today's design, each node receives a full block body from several peers, and is able to accept and rebroadcast it as soon as it receives the first one. If the "width" (number of peers sending you the block) is low, then one bad peer can greatly delay when you receive the block. If width is high, there is a lot of unneeded data overhead. With erasure coding, you can choose a k-of-n setup, eg: split each block into 8 pieces so that with any 4 of them you can reconstruct the full block. This gives you much of the redundancy benefits of high width, without the overhead.

We have stats that show that this architecture can greatly reduce 95th percentile block propagation time, making shorter slots viable with no security tradeoffs (except increased protocol complexity, though here the performance-gain-to-lines-of-code ratio is quite favorable)

Another intersection area is the more complex slot structure that comes with ePBS, FOCIL, and the fast confirmation rule. These have important benefits, but they decrease the safe latency maximum from slot/3 to slot/5. There's ongoing research to try to pipeline things better to minimize losses (also note: the slot time is lower-bounded not just by slot latency, but also by the fixed-cost part of ZK prover latency), but there are some tradeoffs here.

One way we are exploring to compensate for this is to change to an architecture where only ~256-1024 randomly selected attesters sign on each slot. For a fork choice (non-finalizing) function, this is totally sufficient. The smaller number of signatures lets us remove the aggregation phase, shortening the slots.

Fast finality is more complex (the ultimate protocol is IMO simpler than status quo Gasper, but the change path is complex). Today, finality takes 16 minutes (12s slots * 32 slot epochs * 2.5 epochs) on average. The goal is to decouple slots and finality, so allow us to reason about both separately, and we are aiming to use a one-round-finality BFT algorithm (a Minimmit variant) to finalize. So endgame finality time might be eg. 6-16 sec.

Because this is a very invasive set of changes, the plan is to bundle the largest step in each change with a switch of the cryptography, notably to post-quantum hash-based signatures, and to a maximally STARK-friendly hash (there are three possible responses to the recent Poseidon2 attacks: (i) increase round count or introduce other countermeasures such as a Monolith layer, (ii) go back to Poseidon1, which is even more lindy than Poseidon2 and has not seen flaws, (iii) use BLAKE3 or other maximally-cheap "conventional" hash. All are being researched).

Additionally, there is a plan to introduce many of these changes piece-by-piece, eg. "1-epoch finality" means we adjust the current consensus to change from FFG-style finalization to Minimmit-style finalization.

One possible finality time trajectory is: 16 min (today) -> 10m40s (8s slots) -> 6m24s (one-epoch finality) -> 1m12s (8-slot epochs, 6s slots) -> 48s (4s slots) -> 16s (minimmit) -> 8s (minimmit with more aggressive parameters)

One interesting consequence of the incremental approach is that there is a pathway to making the slots quantum-resistant much sooner than making the finality quantum-resistant, so we may well quite quickly get to a regime where, if quantum computers suddenly appear, we lose the finality guarantee, but the chain keeps chugging along.

Summary: expect to see progressive decreases of both slot time and finality time, and expect to see these changes to be intertwined with a "ship of Theseus" style component-by-component replacement of Ethereum's slot structure and consensus with a cleaner, simpler, quantum-resistant, prover-friendly, end-to-end formally-verified alternative.

[vitalik.eth @VitalikButerin]

There have recently been some discussions on the ongoing role of L2s in the Ethereum ecosystem, especially in the face of two facts:

* L2s' progress to stage 2 (and, secondarily, on interop) has been far slower and more difficult than originally expected
* L1 itself is scaling, fees are very low, and gaslimits are projected to increase greatly in 2026

Both of these facts, for their own separate reasons, mean that the original vision of L2s and their role in Ethereum no longer makes sense, and we need a new path.

First, let us recap the original vision. Ethereum needs to scale. The definition of "Ethereum scaling" is the existence of large quantities of block space that is backed by the full faith and credit of Ethereum - that is, block space where, if you do things (including with ETH) inside that block space, your activities are guaranteed to be valid, uncensored, unreverted, untouched, as long as Ethereum itself functions. If you create a 10000 TPS EVM where its connection to L1 is mediated by a multisig bridge, then you are not scaling Ethereum.

This vision no longer makes sense. L1 does not need L2s to be "branded shards", because L1 is itself scaling. And L2s are not able or willing to satisfy the properties that a true "branded shard" would require. I've even seen at least one explicitly saying that they may never want to go beyond stage 1, not just for technical reasons around ZK-EVM safety, but also because their customers' regulatory needs require them to have ultimate control. This may be doing the right thing for your customers. But it should be obvious that if you are doing this, then you are not "scaling Ethereum" in the sense meant by the rollup-centric roadmap. But that's fine! it's fine because Ethereum itself is now scaling directly on L1, with large planned increases to its gas limit this year and the years ahead.

We should stop thinking about L2s as literally being "branded shards" of Ethereum, with the social status and responsibilities that this entails. Instead, we can think of L2s as being a full spectrum, which includes both chains backed by the full faith and credit of Ethereum with various unique properties (eg. not just EVM), as well as a whole array of options at different levels of connection to Ethereum, that each person (or bot) is free to care about or not care about depending on their needs.

What would I do today if I were an L2?

* Identify a value add other than "scaling". Examples: (i) non-EVM specialized features/VMs around privacy, (ii) efficiency specialized around a particular application, (iii) truly extreme levels of scaling that even a greatly expanded L1 will not do, (iv) a totally different design for non-financial applications, eg. social, identity, AI, (v) ultra-low-latency and other sequencing properties, (vi) maybe built-in oracles or decentralized dispute resolution or other "non-computationally-verifiable" features
* Be stage 1 at the minimum (otherwise you really are just a separate L1 with a bridge, and you should just call yourself that) if you're doing things with ETH or other ethereum-issued assets
* Support maximum interoperability with Ethereum, though this will differ for each one (eg. what if you're not EVM, or even not financial?)

From Ethereum's side, over the past few months I've become more convinced of the value of the native rollup precompile, particuarly once we have enshrined ZK-EVM proofs that we need anyway to scale L1. This is a precompile that verifies a ZK-EVM proof, and it's "part of Ethereum", so (i) it auto-upgrades along with Ethereum, and (ii) if the precompile has a bug, Ethereum will hard-fork to fix the bug.

The native rollup precompile would make full, security-council-free, EVM verification accessible. We should spend much more time working out how to design it in such a way that if your L2 is "EVM plus other stuff", then the native rollup precompile would verify the EVM, and you only have to bring your own prover for the "other stuff" (eg. Stylus). This might involve a canonical way of exposing a lookup table between contract call inputs and outputs, and letting you provide your own values to the lookup table (that you would prove separately).

This would make it easy to have safe, strong, trustless interoperability with Ethereum. It also enables synchronous composability (see: https://t.co/9jy6v1X6Fw and https://t.co/gZmu3YjebM ). And from there, it's each L2's choice exactly what they want to build. Don't just "extend L1", figure out something new to add.

This of course means that some will add things that are trust-dependent, or backdoored, or otherwise insecure; this is unavoidable in a permissionless ecosystem where developers have freedom. Our job should make to make it clear to users what guarantees they have, and to build up the strongest Ethereum that we can.

[The Kobeissi Letter @KobeissiLetter]

BREAKING: Coinbase, $COIN, announces it has integrated Jupiter Exchange directly into its onchain trading stack.

This means that millions of Solana-based tokens can now be traded on Coinbase for the first time ever, all through Jupiter.

Rather than the slow, manual process of listing tokens on a centralized order book, Coinbase is now using onchain technology to grant instant access to Solana-native assets.

Under the new integration, users can deploy existing Coinbase balances and payment methods to trade tokens from a self-custodial wallet.

Even centralized exchanges are moving onchain.

[Gizmo Memes @GizmoMemes]

JD Vance is too smooth 😎

[vitalik.eth @VitalikButerin]

Now that ZKEVMs are at alpha stage (production-quality performance, remaining work is safety) and PeerDAS is live on mainnet, it's time to talk more about what this combination means for Ethereum.

These are not minor improvements; they are shifting Ethereum into being a fundamentally new and more powerful kind of decentralized network.

To see why, let's look at the two major types of p2p network so far:

BitTorrent (2000): huge total bandwidth, highly decentralized, no consensus

Bitcoin (2009): highly decentralized, consensus, but low bandwidth - because it’s not “distributed” in the sense of work being split up, it’s *replicated*

Now, Ethereum with PeerDAS (2025) and ZK-EVMs (expect small portions of the network using it in 2026), we get: decentralized, consensus and high bandwidth

The trilemma has been solved - not on paper, but with live running code, of which one half (data availability sampling) is *on mainnet today*, and the other half (ZK-EVMs) is *production-quality on performance today* - safety is what remains.

This was a 10-year journey (see the first commit of my original post on DAS here: https://t.co/Fa0jKFgObW , and ZK-EVM attempts started in ~2020), but it's finally here.

Over the next ~4 years, expect to see the full extent of this vision roll out:

* In 2026, large non-ZKEVM-dependent gas limit increases due to BALs and ePBS, and we'll see the first opportunities to run a ZKEVM node
* In 2026-28, gas repricings, changes to state structure, exec payload going into blobs, and other adjustments to make higher gas limits safe
* In 2027-30, large further gas limit increases, as ZKEVM becomes the primary way to validate blocks on the network

A third piece of this is distributed block building.

A long-term ideal holy grail is to get to a future where the full block is *never* constituted in one single place. This will not be necessary for a long time, but IMO it is worth striving for us at least have the capability to do that.

Even before that point, we want the meaningful authority in block building to be as distributed as possible. This can be done either in-protocol (eg. maybe we figure out how to expand FOCIL to make it a primary channel for txs), or out-of-protocol with distributed builder marketplaces. This reduces risk of centralized interference with real-time transaction inclusion, AND it creates a better environment for geographical fairness.

Onward.

[Ethereum @ethereum]

The Fusaka upgrade is today.

Ethereum is securely scaling.

[Pudgy Penguins @pudgypenguins]

Pudgy Penguins X @NHL

We will be collaborating with the NHL for the 2026 Discover NHL Winter Classic from December to January, starting this week at Art Week Miami.

From giveaways to Pengu meeting NHL fans and more, these activations will bring Pengu into the world of the NHL.

[zoomer @zoomerfied]

[ ZOOMER ]

COINBASE TO LAUNCH PLATFORM FOR TOKEN SALES, FIRST ICO TO BE MONAD NEXT WEEK

[0xBaloo @BalooFinance]

@zoomerfied

[zoomer @zoomerfied]

[ ZOOMER ]

PAYPAL'S PYUSD MINTS $300T ON ETHEREUM

[Jevgenijs Kazanins @jevgenijs]

Ok, let me try explaining (mostly to myself) what the x402 protocol, launched by Coinbase, means:
✔️ When you type a URL into the browser, your browser ("the client") tries connecting to a server that hosts the website (e.g., Bloomberg). If it successfully connects, the server returns status 200, which means “all good.”
✔️ If you type a wrong URL, the server tells your browser that this page does not exist by returning a 404 error (you’ve definitely seen this one).
✔️ So…the 402 is a new type of response (or rather, it has existed for a long time, but was never used), which means: “hey, the URL exists, but you need to pay for it.”
✔️ If you are a human, you see a paywall and enter your credit card to access the content….
✔️ BUT…if you are a machine (e.g., an AI agent), you actually have no idea that you need to pay. You just get a 200 response, but for a paywall page, not the page that you tried to access.
✔️ 402 solves this issue: it tells you, in a machine-readable way, that accessing the URL requires a payment, and again in a machine-readable way, gives you the accepted payment types (“schemes”).
✔️ The machine can then add payment info and send it back to the server to access the content. I’m not sure it would be cool to send your card details, and a machine can’t have a card anyway…
✔️ BUT…a machine can construct a stablecoin payment: create a signature authorizing the transfer. This is safer than sending card details, because you sign a specific transfer (including the recipient address and the amount), instead of giving general access to your wallet.
✔️ What happens then is the content provider sends it to a Facilitator. You can think of it as a merchant acquirer that processes such requests (collecting signed authorizations and posting them to a blockchain).
✔️ After the payment is processed (“settled”), the machine can access the paid content.

Cool things about it:
✔️ This essentially enables AI agents and similar types of interfaces to pay for things online. There is no need for a human in between.
✔️ It creates a new entity, “Facilitator”, which is a new breed of merchant acquirer (Coinbase launched the protocol and offers such a Facilitator).
✔️ This creates a new use case for stablecoins

SOUNDS FREAKING COOL!!!

[Eric Balchunas @EricBalchunas]

BOOM: SEC has approved the generic listings standards that will clear way for spot crypto ETFs to launch (without going through all this bs every time) under '33 Act so long as they have futures on Coinbase, which currently incl about 12-15 coins.

[zoomer @zoomerfied]

[ ZOOMER ]

POLYMARKET FILES FORM WITH SEC SHOWING "OTHER WARRANTS" OFFERED IN LATEST RAISE, TYPICALLY USED TO MEAN TOKENS, OPENING THE DOOR TO A POLYMARKET TOKEN LAUNCH: FILING