HTML/CSS dev・decentralized data wrangler @0xBlockhead @walletbeat・hackathon bounty hunter・techno-optimist・prev @dYdX @ritualnet @spindl_xyz @coinbase・26
Joined February 2015
- Tweets10.3K
- Following9.8K
- Followers3.2K
- Likes223K
Pinned Tweet
Introducing the newly redesigned @Walletbeat!
• 24+ independent reviews of software + hardware wallet brands in a compact table format for quick comparison
• color-coded pie charts, tooltips, hierarchical columns and rows that collapse and expand to reveal details
• filters and sorts for variants, hardware models, attribute ratings, categories, stages and more
• dynamically generated wallet report cards with detailed explanations of rating criteria, sources and research methodologies
Today, we’re announcing Ternary Bonsai 2 27B.
Based on Qwen3.8 27B, Bonsai 2 27B is 9x smaller than its full-precision counterpart while retaining 98.2% of its aggregate benchmark performance.
Two months after the first Bonsai 27B release, the biggest change is quality. The footprint remains 5.9 GB, but the gap to full precision has narrowed materially, with particularly strong gains in agentic coding, multimodal reasoning, and long-horizon tool use.
Ternary Bonsai 2 27B is available today under Apache 2.0.
Darryl Yeo 🛠️ retweeted
Today, @walletbeat asked: Can your wallet send and receive tokens without exposing your transaction history to others?
Privacy remains a major blind spot across the popular-wallet ecosystem. At @ambire we’re working to address it sooner rather than later 💪
Railgun privacy achieved internally in @ambire, thanks to #Kohaku SDK / @ethereumfndn.
For the demo, we have 2 public and 2 private ZK accounts: RailgunA and RailgunB.
0:00 - Shielding ETH from public RailgunA to its derived private ZK account.
1:00 - Sending privately between the two ZK accounts.
2:30 - Unshielding from RailgunA's private ZK account to public RailgunB, with no onchain traceability.
Shield txn: sepolia.etherscan.io/tx/0xf4…
Unshield txn: sepolia.etherscan.io/tx/0x04…
Our end goal is built-in privacy in Ambire. With the Kohaku SDK evolving, we're continuing to expand the integration and explore what's possible with Privacy Pools @0xprivacypools.
The path is long, but the direction is clear 🛡️
Darryl Yeo 🛠️ retweeted
It's an increasingly common take that AI hacking means cybersecurity is doomed.
I disagree. I think cybersecurity is naturally defense-favoring once people get their shit together. And anyone who continues to hold cryptocurrency (including me, ~90% of my net worth) is implicitly making that bet.
Here's why I am making that bet.
First, the oversimplified punchy one-line statement:
If AI can prove Navier-Stokes and FLT, then AI can prove the statement "this program is secure" as a mathematical theorem. Even if the program is very complicated.
Now, the nuance:
(See also: vitalik.eth.limo/general/202… )
The word "secure" is hiding all kinds of skeletons in the closet in terms of what it actually means. What does it mean for Signal (the encrypted messenger) to be "secure"?
The most basic definition you might think of is: no one who doesn't hold the recipient's secret key can read the contents of the message.
But:
* Did you remember to include _other_ critical forms of security? Can the adversary forge messages? Can the attacker prevent messages from reaching the recipient? Can they cause your client to crash by sending malformed messages?
* Have you made sure that your model of the adversary includes attackers that interfere with the protocol actively and not just passively? And attackers that interfere by replaying messages to you or the recipient that either of you sent over the wire at any point earlier?
* What if the adversary hacked (or _is_) the Signal server?
* How did you learn which public key belongs to the recipient in the first place? What if that process was tampered with?
* What if your device gets hacked at some point in the past or future - is your message still safe then?
* What if your key leaks because of a bug in your operating system? Or because you got a bugged version of the Signal client? Or what if the database is corrupted?
* Or the libraries, interpreter or compiler of the programming language you wrote it in?
* What if your key leaks because tiny perturbations in perceptible signals generated by the hardware leak mathematical relationships that can extract the key a few hundredths of a bit at a time?
* Are you hiding the *size* of the payload? Does that matter?
* You're definitely not hiding the identity of the sender and the recipient, and the exact time each message was sent (think: not just time-of-day, but also time deltas between one message and the next). Is that not enough to deduce a lot of important facts about what relationships you have, and what *kinds* of conversations you are having?
So ... even definitions can be over a thousand lines of code, and need deep careful thought to figure them out.
Working on making definitions more human-readable is of extreme importance - it's perhaps the only "high-level language" that matters right now.
But even still, even despite all of the above, for security-critical components, the definition is a much smaller attack surface than the implementation. Verifying that the definition is adequate is a much more tractable task than scanning over the code directly - and can become even more tractable with better tooling.
Definitions are also _additive_: if two groups have two different definitions A and B, then, well, you can just prove that the program satisfies both A and B. Code is not additive in this way: if a program is A + B, a bug in A _or_ B can sink the whole thing. Definitions are additive. And if you can't satisfy A and B at the same time, you've isolated the most important philosophical issue for your project to spend its next few weeks grappling with.
Sometimes, definitions are not much smaller than the implementation - UI components might be one example. But for many of the most critical components - message-passing protocols, sandboxes, cryptography like SNARKs and FHE - the asymmetry is real.
Historically, a large class of failures with this approach have come from people only verifying a small portion of their code, that they self-declared to be the security-critical portion, and ignoring the rest - and it turns out that something in the rest of the code is security-critical too.
This was reasonable back when verification was difficult and scarce. The solution today: sorry, you have to verify over literally your entire program, including database, networking, any caching layers, everything. Modern AI can do it.
So it's not about "the good guys find all the vulnerabilities before the bad guys do" - that could maybe work too, after all a finite program only has a finite number of vulns, but it's riskier - it's specifically an asymmetric strategy of making code that is much more resilient in the first place.
This is the kind of direction that Ethereum is going in for the next few years. There is no future for blockchains - especially blockchains with scalability and privacy - without doing this. We need to make software actually secure. And we have already made a lot of progress.
Darryl Yeo 🛠️ retweeted
just 2-3 years ago, there was a widespread consensus that privacy and ZK tech was somehow at odds with good UX
shoutout to everyone involved in the shift. Amazingly, ZK-powered privacy apps are now heralded as some of crypto's best products.
Darryl Yeo 🛠️ retweeted
unlike with crypto where I tried hard from the start to be a 'power user' I've generally taken a very 'basic bitch' approach to AI usage & I feel like the market has generally rewarded my laziness as the margins from prompt engineering, agent harness fiddling, etc., seem to have eroded very quickly and probably a lot of people wasted a lot of effort in the meantime building up their supposed "AI skills"
the one thing I think may be genuinely useful is building a deep understanding of local AI usage in terms of hardware procurement and configuration etc. as the frontier labs have no incentive to commoditize that and make it user-friendly, and it has potentially large payoff in self-sovereignty that could pay large dividends as the frontier labs inevitably become more evil and captured
Darryl Yeo 🛠️ retweeted
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions
AFAICT the shortest path to AI-based economic revolution
Hello, iOS 27. 👋
Take a tour of the latest updates, including the introduction of Siri AI, an entirely new version of Siri that draws on your personal context and helps you search for content or take action across a variety of apps.
See what's new: apple.co/iOS-27
Darryl Yeo 🛠️ retweeted
This is the end of an era for crypto policy.
We’ve pursued a comprehensive market structure bill for many years. The Clarity Act is the latest, and best, in a long line of attempts. I expect it’s the last.
We either do this now or we go back to the drawing board on legislation.
Darryl Yeo 🛠️ retweeted
we are pro-stack, not 1 silver bullet.
It helps to use different tools, practices depending on personal & collective context. Especially, when tech products can ship for years.
Darryl Yeo 🛠️ retweeted
I'm sad to report that the AA collab between 8130 and 8141 (Frames) broke down last week, and Base and Ethereum are now going separate ways to implement different AA standards.
I want to share some reflections on this collab and on the future of the EVM.
For a long time, the EVM has been a unifying force between L1 and L2s. Thanks to a standard account model (EOA) and a standard transaction type (EIP-1559), users have been able to enjoy their wallets working seamlessly across EVM chains. Similarly, a AA standard shared across L1 and L2s would ensure a consistent multi-chain UX for smart accounts, including post-quantum (PQ) accounts which we will eventually all use.
As the crypto industry matures, however, L1 and L2s are starting to diverge in the values they provide and the use cases they target:
- For the L1, it's all about CROPS -- censorship-and-capture resistance, open source, privacy, and security. In short, Ethereum L1 wants to be the most decentralized programmable settlement layer of the world, which is what makes it a good base layer for L2s in the first place.
- For L2s, it's all about scaling, customization, and compliance -- things that commercial and enterprise use cases demand, and that the L1 does not provide.
These diverging needs have pushed the shared layer -- the EVM -- to its limit, and AA proved to be the breaking point. While L1 and L2s both value core AA use cases such as gasless transactions and passkey wallets, they differ sharply in what these features must comply with:
- For the L1, AA transactions must be uncensorable, private, and quantum-resistant, which call for a transaction type optimized for PQ signature aggregation and privacy protocols, and an account model that can be freely programmed and extended by developers without permissions from the chain. These needs lead to AA standards such as ERC-4337, EIP-7701, and now EIP-8141 aka Frame Transactions.
- For L2s, AA transactions must work at high scale, and they must be legible such that the protocol can enforce clear rules about what kinds of accounts/transactions are permitted vs not. These needs lead to AA standards such as Tempo Transactions and now EIP-8130 by Base.
With the AA collab, the authors of 8130 and 8141 tried to define a shared standard that can work for both L1 and L2s. While we identified a number of technical solutions, they all required one side or the other to compromise at least a little bit on their core goals. But ultimately, Ethereum wanted to be the best version of Ethereum, and Base wanted to be the best version of Base, and while both sides acknowledged the benefits of ecosystem interoperability, it was ultimately secondary to the need for each chain to achieve their core goals. So separate ways we went, putting the burden on wallets to deal with the fragmentation that ensues.
Now, just because we ended up with fragmentation doesn't necessarily mean it was a bad outcome. If reducing fragmentation comes at the cost of homogenizing chains to the point that they fail to solve problems for the users they care about, that would not be a price worth paying. While I was initially sad that the collab did not come to a successful conclusion, I took solace in the fact that both Ethereum and Base are now free to innovate on AA to the maximal extent in accordance with their own visions, unshackled from the need to accommodate the other side. If they execute well, and if the wallet community can bridge over the fragmentation, we may well end up with the best possible UX for the end users.
So where does that leave us -- the broader Ethereum community including Ethlabs -- if we want to continue pushing for a consistent UX across EVM chains? I see two paths forward:
- We can establish a coordination mechanism that encompasses more stakeholders than ACD itself (where only L1 client devs have voting powers), to govern shared L1<>L2 resources such as the EVM. That way, L2s can participate in shaping the EVM, as opposed to having to accept whatever the ACD decides, or being forced to fork if they don't like the decision (such as in this case with Base).
- We can accept that fragmentation of the EVM and wallet UX across L1 and L2s is inevitable due to their conflicting needs, and dedicate our resources to building wallets and applications that can abstract over the differences.
Indeed, the collab was an exercise in the first path -- we invited Base, Arbitrum, and other stakeholders to directly influence how native AA shapes up for the L1. While it ultimately failed in this case, I feel a better outcome could've been achieved if we had established a dialog between both sides way earlier, as opposed to well after L1 core devs had rallied around Frames.
On the other hand, I also learned from this exercise that some differences are unavoidable, and indeed it would be counterproductive to overly pursue interoperability at the cost of differentiation. In other words, we sometimes just gotta let the chains cook. For that reason, I've also become more bullish about the second path -- building wallets and applications that can speak the native transaction types of each chain, and hide the complexity from users through UX abstractions. This puts a lot of onus on the wallet/application developers of course, but on the bright side, it's also an opportunity for wallets/applications to stand out and differentiate, by competing to provide great UX across chains despite the underlying fragmentation.
Ethereum is the art of staying together while remaining different. We must accept that chains will succeed by innovating, and innovations will naturally result in differences. On the other hand, we must never give up on dialogue when we can achieve interoperability without compromising core product goals. As Ethereum and crypto grow to eat the world, the push and pull between innovation and collaboration will only intensify, and it's up to all of us -- builders across L1 and L2s, applications and wallets -- to determine whether diverse innovations will split Ethereum apart, or make it thrive as one.
the golden age of hackathons was fucking amazing. it was the easiest way to build a network, make friends and find a job in tech.
2021 to 2023 was incredible. I knew a ton of people that did hackathons full time. making thousands of dollars and flying around the world. the professional adderall hackathon class.
I knew a ton of startups that raised substantial amounts of money that started as a hackathon project. it also was my number one recommendation to find a job. you learned a ton, interacted with great companies and just built cool shit in a short amount of time.
for young engineers it was the best way to show "proof of skill". to skip leetcode and all that bs and to add something cool to your github. obviously AI nuked the whole concept. building is easy now especially if you don't care about code quality.
the idea guys took over and I'm not sure what the point is anymore. the industry was basically paying people to learn, travel and make friends. looking back, that was a pretty insane deal. I don’t know what the equivalent is for someone starting out today.
Darryl Yeo 🛠️ retweeted
Walletbeat monthly update is here!
Check out what happened across Walletbeat and the wallet ecosystem through August 👇
Darryl Yeo 🛠️ retweeted
Today we're launching Desert Ant Labs: a European frontier AI lab building on-device intelligence.
18 models across audio, vision, and text. SDKs for Swift, Kotlin, and JavaScript.
No tokens. No logins. Nothing leaves the device.
desertant.com
We’re sharing a solution to the Navier-Stokes Millennium Prize Problem, one of the deepest problems at the frontier of mathematics.
The proof was produced by a group of agents, using an OpenAI next-generation model significantly more capable than GPT-6 Astra.
The problem concerns whether the description of smooth three-dimensional fluid motion modeled by the Navier-Stokes equations can break down. It has remained unresolved for roughly 90 years.
super smash bros melee is fully decompiled, this project started in july 2020, so it took over 6 years. the progress was hugely accelerated by llms and finished off with astra. it's a very large game with 3.88mb of compiled code.
github.com/doldecomp/melee
Darryl Yeo 🛠️ retweeted
The Ethereum Foundation is working towards making Ethereum private from the moment you open your laptop until your transaction lands onchain. That includes network privacy - IP address, metadata, & more
More on all of this soon. Last time I tease it w/o actual details I promise
Darryl Yeo 🛠️ retweeted
One positive consequence of all the recent detailed thinking about transaction formats - not just 8141, also "future of state" discussions eg. UTXOs, PBT, keyed nonces, and also recursive STARK mempool - is that we have a much more explicit understanding of how transactions have "actions" and "dependencies", and we can engineer around optimizing the two separately.
An action is an effect that a transaction has.
A dependency is a fact about the transaction and/or the state that must be true for the transaction to be valid.
eg. a signature is a dependency, a Merkle proof of a UTXO is a dependency, a ZK-SNARK (or STARK) is a dependency, a call that sends ETH is an action
Dependencies can be processed in parallel. Dependencies that involve state can be reasoned about by a mempool, especially if the specific state accessed is statically declared. Dependencies that are pure (no state calling allowed) can be processed once at the mempool layer and never need to be processed again - and potentially even replaced with a STARK verifying them, allowing not just execution but also data to be elided.
In principle, dependencies and actions can all be expressed as calls (if needed, calls to precompiles). This would make the transaction format itself very bare-bones and minimalist (a list of calls, flags for the type of each call eg. dependencies would be static or pure calls, and origin, nonce, etc) and allows maximum cross-compatibility even if different EVM chains have different features.
In 2015-era Ethereum, thinking explicitly about these differences was not very important: execution was execution, there were few enough transactions that we could process them all serially, and single-key ECDSA accounts were good enough for everyone.
Ethereum's current scaling strategy, however, requires moving beyond that paradigm. Ethereum is beloved by many developers because the execution and state model is so dynamic and flexible. But dynamic and flexible is not friendly to scaling. Fortunately, >90% of Ethereum's activity by volume does not require anything dynamic and flexible. So, we require contracts, accounts and transactions to more explicitly specify what is dynamic and flexible and what is more statically-analyzable but more restrictive, and more statically-analyzable things get the lowest gas cost and thus scale the most. Effectively, learning from the best of both the 2015-era Ethereum model and a more Bitcoin-like model (reminder: Bitcoin has had what I call account abstraction since the beginning), and making a mixture of both (really, the full spectrum between both) available, with gas costs appropriate for the level of scale involved.
New state types, the recursive STARK mempool, keyed nonces, etc all go in this direction.
This all relates to transaction types, because a general-purpose transaction type is a very natural interface layer on top of which all of this can be implemented, and the current thinking around the EIP-8141 transaction type is going in this exact direction that is friendly to these kinds of future generalizations.
So in that sense, 8141 done well is not just a culmination of 10 years of account abstraction work, it's also preparation for the next few years of responsible decentralization-friendly hyper-scaling.