Ethereum Flying Spaghetti Dev. Founder @HakkaFinance Founder @Pelith_
Joined January 2019
- Tweets797
- Following223
- Followers6K
- Likes1K
ping.eth retweeted
Fun fact — we did both:
x * y = k: Gnosis did it first
P + N = 1: Gnosis Conditional Token Framework (CTF)
The framework used by @Polymarket and many others, and one that is still waiting to reach its full potential with many more things, like the options concept described here.
@CoWSwap was built to trade all of this.
We were very wrong on timelines, but will be right in the long run.
Option product never works on Ethereum because its complexity.
It’s gonna work this time.
What more significant is that it not only gonna unlock decentralized stablecoin, but also various of index tracking product (s&p 500???) safely with much better capital efficiency.
P + N = 1 will be the new x * y = k
ping.eth retweeted
these two facts are related
greater coordination among subgroups can make the whole more chaotic
ping.eth retweeted
Although the Ethereum Foundation officially announced the privacy-wallet toolkit “Kohaku” yesterday, the project had already been quietly confirmed through various channels back in June.
Kohaku spans multiple teams and components to deliver a full, reference browser-extension wallet that other wallets can learn from, with end-to-end privacy as the goal. Participants include a16z’s Helios light client, the EF’s PSE team, and projects like Ambire, Railgun, and Wonderland.
The name is a fun nod: because the project is forked from Ambire, it borrowed the Japanese word for “amber” — Kohaku. In Japanese, kohaku also refers to the classic red-and-white koi variety, so the project adopted a koi motif.
Kohaku is not a mass-market consumer wallet. It’s a set of composable privacy/security primitives and an SDK for wallet teams, plus a power-user reference wallet (browser extension) to showcase these capabilities. It’s plugin-driven, so teams can adopt “all” or “some” of the features as needed, including:
🟢 A strong-privacy/security primitives SDK
🟢 A reference wallet built on that SDK for power users
🟢 Collaboration with other wallets, adopting features fully or partially
🟢 A reference wallet forked from Ambire, mainnet-first, with L2s to follow
🟢 Plugin systems in both SDK and wallet so teams can pick the features they want
Kohaku’s privacy isn’t just “put transfers into a private pool.” It considers trust and data exposure at every step from device to node. The roadmap lays out a clear privacy/security checklist:
🟢 Helios light client (WASM) built in: verify chain state locally to reduce reliance on centralized RPC (Helios is a multi-chain Ethereum light client by a16z, compilable to WASM for embedding in wallets/dApps).
🟢 Minimal execution client + private eth_call: even read-only calls shouldn’t reveal what you’re reading. Plan: TEE + ORAM first, long-term target PIR (pure cryptography).
🟢 Private send / private receive / private payment requests: multiple privacy protocols (starting with Railgun) to enable private payments and encrypted requests.
🟢 Unified private balance view (multi-protocol aggregation): if you hold funds across several privacy protocols, the wallet aggregates them.
🟢 Avoid IP leakage & hide traffic, with optional P2P transaction broadcast (bypass traditional RPC relays).
🟢 Per-dApp accounts by default when connecting, reducing address linkage.
🟢 Social recovery with ZK (e.g., ZKEmail / ZKPassport): recover without revealing identity.
🟢 Post-quantum “kill switch”: switch to Falcon/Dilithium signatures if needed (with Solidity verifier optimizations).
🟢 Generic hardware Ethereum app / ZK hardware signer / spending-limit policies: open-source hardware flows to avoid vendor lock-in and add fine-grained spend controls.
Think of Railgun and similar on-chain privacy pools as one foundation. Kohaku then patches the other leak points — node trust, network broadcasting, frontend connections, recovery, and hardware — to achieve end-to-end minimal exposure.
ping.eth retweeted
North Korea hijacking multisigs is now the biggest loss category in crypto hacks.
After talking with teams and building three prototypes, I think I know the next security layer in fixing this, and it requires less from signers, not more. 🧵 1/14
ping.eth retweeted
1/ 🧵 What is lean Ethereum and why is it gaining momentum?
At Forschungsingenieurtagung in Berlin, @VitalikButerin and @drakefjustin laid out a bold vision for a simpler, more optimal Ethereum.
Here’s a deep dive into their R&D breakout session 👇
ping.eth retweeted
I guess that might help buy the political will, but tbh I would kinda rather we see the pain until political capitulation
ping.eth retweeted
L2s are great for building web3 as new web. L2s are great for local permissioned regional blockchains (ugh). L1 is great for the basis of the new, permissionless financial system where global settlement happens not only for blobs but also for money
ping.eth retweeted
this is a usual dumb bait, but i'll entertain.
1. using is to compare numbers is a misuse of the language and a user error. is checks identity, not equality, as in two variables pointing to the same object. small integers [-5…256] may be cached, so you might see True for those, but it's an implementation detail, not something to rely on.
2. all() checks every element in the iterable is truthy. the empty list [] has nothing to check, so it stays True. [[]] has one element, an empty list, which is falsy, so it returns False. [[[]]] has one element too, but it’s a non-empty list, so it’s truthy and returns True.
3. dict keys are deduped by hash(key) equality. you can check that hash(1) == hash(True) == hash(1.0) == 1, that's why they overwrite earlier assignments. i'd assign this user error too, because you usually have dict keys of the same type.
ping.eth retweeted
>be @dYdX
>one of the best DEXs on ethereum
>ethereum L2 appchain
>pivot to becoming alt L1
>die
why would anyone do this?
ping.eth retweeted
ELI5 why we cannot "rollback" Ethereum?
After yesterday's Bybit hack, crypto commentators are again asking why Ethereum cannot "rollback" the chain to reverse the hack.
While experienced ecosystem actors near-unanimously agree that this is infeasible, it's worth breaking down why this reasonably sounding proposal is technically intractable for less knowledgeable observers. If that's you, consider this an "ELI5" version of why this is impossible.
First, some context on rollbacks:
The idea of a blockchain "rolling back" stems from an early incident in the Bitcoin blockchain. In 2010, less than two years since Bitcoin's launch, a bug in the client software caused 184 billion (yes, *billion*) Bitcoins to be minted in block 74638.
To fix this, Satoshi released a software patch to the Bitcoin client which invalidated the transactions. This had the effect of "rolling back" the chain which had kept growing in the meantime to block 74637. In less than a day, the new chain had accumulated enough proof-of-work to become canonical and all user transactions that had been rolled back were included in the new chain. Note that at the time, Bitcoin's mining difficulty was 10 billion times lower than today, and the BTCUSD price was about 0.07$.
In short, this situation was unique in that a clear protocol bug led to the problematic transactions, which could easily be identified due to their large amount. Additionally, Bitcoin's limited adoption made it easy to distribute a new client version and quickly mine a new chain segment.
Ethereum and TheDAO:
Ethereum's early history had a superficially similar crisis which often leads to confusion about the practicality of rollbacks. In 2016, a popular Ethereum application, TheDAO, had ~15% of all ETH in existence under its control. Unfortunately, a hacker found a bug in the application's code that allowed them to steal all of these funds. This was notably different than the Bitcoin situation because the Ethereum protocol worked as intended, it was the application built **on** Ethereum that had an issue.
Luckily, the developers of TheDAO had implemented a failsafe where withdrawals from the applications were frozen for a month before they were completed. This presented a unique opportunity to address the bug: the code of the application could be changed to prevent the funds from ultimately going to the hackers.
Because there was no way in the application itself to do this, Ethereum protocol developers had to make the change directly in the blockchain's history. This is called an "irregular state change", because the "state" of the application was changed by manually updating the database, rather than, say, by a valid Ethereum transaction.
A rough comparison to the Bitcoin bug above would be to have set the balance of the addresses that received the 184 billion BTC to 0, rather than re-mining a chain excluding those transactions.
This upgrade was contentious and the Ethereum community effectively fractured over it. A subset of miners refused to run the software patch and kept mining on the chain where the hack happened, which still exists as Ethereum Classic. The chain that is known as Ethereum today is the one where this software upgrade was activated.
Again, this situation was unique. Hacked funds from TheDAO were effectively frozen for a month, giving time for the community to coordinate on a software upgrade. The funds being frozen had another major advantage: there was no "contagion" from the hack. Had the hacker been able to move funds at will, "freezing" the funds would be an impossible cat and mouse game, as the protocol is open source and any potential change which froze the funds would have to be broadcast to the hacker, giving them plenty of time to move their funds elsewhere.
Which brings us to the Bybit incident.
Why we can't rollback Ethereum
Earlier this week, the Bybit exchange had 401,346 ETH (~1.4B USD) stolen. The theft was caused by the custodian of the funds signing a misleading transaction in a compromised multisig interface.
The root cause for this hack was higher up the stack than both TheDAO and the Bitcoin overflow bug. There were no issues with the Ethereum protocol, or even with the underlying multisig application used by Bybit. Instead, a compromised interface made it appear as though a transaction was doing one thing while it was actually doing another.
From the perspective of the Ethereum protocol, there is nothing to distinguish that transaction from other legitimate transactions on the network. There is no protocol rule that was broken where patching the issue would isolate the hacked funds, like in the case of the Bitcoin exploit.
Furthermore, the funds were immediately available for the hacker to spend. Unlike in the case of TheDAO, where the community had a month to deploy a surgical intervention, here the hackers immediately started moving the funds onchain.
Even if we could solve the cat and mouse game described above, the Ethereum ecosystem is far different today than in 2016. DeFi and bridges to other chains mean that any stolen funds can easily be mixed within a web of applications. For example, stolen funds can be swapped on a decentralized exchange, with the resulting tokens being used as collateral in a DeFi protocol, where the borrowed assets are bridged to a completely separate chain.
This level of interconnectedness means that any irregular state change, even if socially palatable, would have near-intractable ripple effects. A "full rollback", where a portion of the recent chain history was invalidated, would be even worse. Any settled transaction, many of which have implications outside Ethereum (e.g. exchange sales, RWA redemptions, etc.) would be undone, with no way to revert the offchain half of it.
So, to conclude, while Bitcoin was able to "rollback" its blockchain 15 years ago, today, the interconnected nature of Ethereum and settlement of onchain <> offchain economic transactions, make this intractable today.
Technically, irregular state changes are still possible on Ethereum in cases where funds are frozen and isolated. The last time such a change was proposed, in 2018, to address a bug in Parity's multisig wallet where ~500,000 ETH were frozen (see EIP-999), it was strongly opposed by the community of the contention resulting from TheDAO.
ping.eth retweeted
When I take public transit in a new city, I like to write down my first impressions immediately. I think it’s important to remember what’s easy & hard so that we can channel that empathy to design more user-friendly, accessible transit.
So, some thoughts after 8h in Taipei...1/x
Does this mean all you need is to avoid arbitrage?
Very powerful, very beautiful.
Active LPing is akin to market making on CEXes -- it will only grow bigger over time. So we should absolutely study the early successful strategies!
Here are some more data on the active LP on base, h/t @AnthonyTeslyuk for discussion and analysis.
Look at these distributions of the ratio of CEX price to the (mid) AMM price:
The blue one is right before the LP opens a position, the orange one is before removals, and the green - at random blocks.
As you can see, removals happen mostly when the CEX price deviates from the AMM price by +-5bps, and rarely when the CEX price is close to the AMM price. This suggests that the LP is actively trying to avoid arbitrage swaps, which makes perfect sense.
What is somewhat mysterious is that liquidity additions also happen more often (albeit not to the same extent) when the CEX price is close to the spread boundary. I would expect the blue distribution to have more mass in the center, like the green one.
Here are the updated markouts (15s, which is much shorter that what I posted earlier):
The strategy is actually more consistently profitable than according to my initial plot.
And one final bit: this LP manages to avoid ~80-90% of swaps by the top arbitrageurs, while catching >50% of the swaps coming from the router. Impressive accomplishment!
MakerDAO is now Sky! Get ready to upgrade to $USDS and $SKY on 18 Sept.
Just signed up for the Early Bird Bonus on Sky.Money.
Get double rewards for the first month after launch if you're eligible @SkyEcosystem
ping.eth retweeted
🛹🎙️ Join us for this week's Skate on Air with @DysonFinance!
Learn more about the innovative Dyson Finance DEX that puts retail investors first. Skate will be working with Dyson to become Stateless across 1000s of chains.
1 pm UTC this Wednesday!
ping.eth retweeted
Ok, so you need a token, how to distribute it? My view is as widely as possible. Now I don't know if any of you are history buffs, but we actually had a great mechanism for this called token sales. But then a few overzealous regulators came in and killed the entire market.
Yes.. yes
Unless X is a block-in-block tx (ie based l2/cow batch), right?
Here is the fundamental problem I see with preconf pricing.
Read the screenshot below. Let’s say there is an arb opportunity 6s into the slot. Call this event “X.” If this opportunity is taken right away, the arbitrageur makes p1(X).
In the remaining 6s, there may arise another opportunity. Let E[p2(X)] be its expected profit.
Lastly, let E[p3(X)] be the expected arbitrageur’s profit if the first opportunity is not taken immediately (no preconf is issued), and the pool is arbed once at the end of the slot.
The screenshot says that the arbitrageur should compensate the validator for the expected reduction in MEV. So the price of the preconf must be at least
E[p3(X) - p2(X)]
from the validator’s perspective.
But the arbitrageur will not be willing to pay more than
p1(X).
It’s been shown many times that for CEX-DEX arbitrage
p1(X) < E[p3(X) - p2(X)].
Therefore, there doesn’t exist a price which is acceptable both for the arbitrageur and the validator.
It’s very difficult to break this result. For example, one might be tempted to set the preconf price at the *unconditional* expectation of E[p3(X) - p2(X)] (ie, taking one more expectation over X). Then the arbitrageur will only exercise the option to buy a preconf when p1(X) exceeds the unconditional expectation of p3–p2. In those situations, however, the unconditional expectation of p3–p2 is lower than its expectation conditional on X, leaving the validator worse off.
Tldr: preconfs make arbitrageurs compete on time. But when they compete on time, they extract less MEV in total, which reduces validators’ profits.
