@stonecoldpat0@pedrouid@alexanderchopan@SCBuergel@Uniswap you still need to define what keys control the account. and that needs to be stored somewhere. then you also want a way to change the keys. what if that requires a different quorum? this is the whole point of programmability!
@stonecoldpat0@pedrouid@alexanderchopan@SCBuergel@Uniswap well you would have to register the new PQ keypair since the address would no longer be derived from the pubkey. unless you're talking about only working with new accounts.
then have to think about how to do gas sponsorship. then multisigs. then batching. etc. it keeps going
@stonecoldpat0@pedrouid@alexanderchopan@SCBuergel@Uniswap i would prefer it to be, but currently a lot of people want to do this 8288 style of signatures to support aggregation of more than just signatures in the future. so it will probably be a frame to either a system contract or precompile
@pedrouid@alexanderchopan@SCBuergel@Uniswap we are still looking into integrating key store into frames somehow. i'm sure your experience there would be useful there. @ox_shaman has been pretty focused on this lately.
for the rest of your points, i think you are generally incorrect about 8141 complexity and UX
@stonecoldpat0@pedrouid@alexanderchopan@SCBuergel@Uniswap i mean this is exactly what 8141 does. there is not currently a pq sig scheme ready to ship with frames, we are hoping the leanSPHINCS algo is finalized in the next month or two and we can bundle it along side
@pedrouid@alexanderchopan@SCBuergel@Uniswap you said 8141 got worse - it never had the key store like defaults. the eip is mostly the same as when you originally were a fan
Everyone seems to have forgotten that code is a liability, not an asset.
That means that producing thousands of lines of code you didn’t read isn’t something to celebrate. It’s something to worry about!
Every line of code needs to be tested, secured, and maintained. Even the ones that create no value for customers and therefore no value to the business.
That’s why every line of code is a liability. And producing more liabilities isn’t good engineering or good business.
Good engineering isn't about producing more code. It's about solving problems with the least amount of code.
The asset is the solution, not the code.
@pedrouid@alexanderchopan@SCBuergel@Uniswap so you can wish for something that was never a possibility or you can embrace the direction today and help make a positive impact
@pedrouid@alexanderchopan@SCBuergel@Uniswap you seem pretty bitter about it all. i remember you originally liked 8141 and the eip really hasn’t changed much. you just liked key stores better. which is fine, but 8130 was never going to ship on mainnet.
@pedrouid@alexanderchopan@SCBuergel@Uniswap ofc it isn’t the “only” reason, but it’s not like you claim where we are again trying to “fix” batching. We’re just building a complete and flexible transaction for the future of accounts.
@pedrouid@alexanderchopan@SCBuergel@Uniswap 8141 is aimed at allowing people to choose the crypto that secures their account, to allow us to transition to pq crypto. Batching is unrelated
Quick take from my side after reading the recent posts from @potuz_eth, @ethlabs_org, @mikeneuder and @soispoke on PQAI. Definitely recommend reading all of them. Links below.
Very short summary: Potuz and Ethlabs want to go all in on PQ and only ship what's really needed. Mike thinks rushing PQ is premature, but agrees that hardening the clients is super important. Thomas wants to parallelise and keep shipping non-PQ features like FOCIL.
I think pqai will come with all kinds of threats, and AI getting better at finding bugs is the one we already experience. The PQ changes alone are already a lot of new code: new signatures, leanVM, much bigger messages on the p2p layer, new key handling. Every line of that needs to be understood by someone, tested and hardened. That's risky enough already, so I'd rather not add more features on top.
For people hunting bugs, it makes a big difference whether a fork is Frames or Frames + FOCIL. More code means more to understand and test, more interactions, and that doesn't really parallelise. So I could see the PQ work being done as "slim" feature forks (Frames, leanVM, DC), with FOCIL coming back once we know what PQ consensus looks like.
The only things I'd ship alongside are hardening and simplifications.
I think in times where AI gets crazy good at breaking things, that kind of work will be very welcome.
My comment: https://t.co/UknWdkC1TD
Potuz: https://t.co/K8VIxhZzri
Ethlabs: https://t.co/RJpaWcYOMN
Mike: https://t.co/qyXXpR017o
Thomas: https://t.co/Cfye0Okqa9
Thoughts on pqai, Hegota, and FOCIL
tldr: Let’s accelerate pqai without rushing or stopping everything else. We can parallelise workstreams to keep shipping EIPs that are ready while the cryptography, designs, and specs for PQ are being worked on and finalised.
We need to accelerate Ethereum’s transition to post-quantum, post-AI cryptography. Let’s take this as a given.
There are two ways to think about what we need to do to enable this acceleration.
1) We deprioritise everything that is not pqai critical. That means all the features we were planning to ship have to wait until after we switch to hash-based cryptography across all layers of the protocol.
To me, the downside of this approach is that we put all our eggs in one basket: if we end up taking 3 years to ship pqai, then Ethereum doesn’t move, at all, for 3 years. That’s “full sequential” mode, and it doesn’t account for important parameters, including how ready features are and what skillsets we have among researchers and client teams (e.g., not everyone is a PQ expert). The only case in which this is inevitable is if we find out that there is an actual break in our cryptography. In that case, I would argue we should be ready to make choices that go far beyond pq2027 ones, and have a concrete plan for what we need to do if we have to ship a minimal, ugly, emergency fork in a couple of weeks.
2) We parallelise. We keep working on the core, minimal features that were already SFI’d by core devs and the community, while accelerating our transition to pqai.
To me, this second approach makes sense when you look at where the forks are:
- Glamsterdam is delayed: most of the work is reaching out and making sure smart contracts don’t break because of repricing EIPs.
- Hegota is in its devnet phase and can keep progressing with FOCIL and Frames in the meantime. Some core devs in all client teams have already worked on these features, they are specced, and now it comes down to “making it work” on the implementation side.
- Importantly, the major PQ/AI upgrades are not yet ready: the specs and the cryptography are not frozen (https://t.co/aGikvd49Kf). On the CL side, we don’t even know exactly what we mean by “PQ consensus” yet. Is it PQ Gasper? PQ Decoupled Consensus? With or without aggregation (and leanVM)? We need a lot more eyes on it, but it’s not realistic to think that all core devs across all teams would be able to chime in and accelerate progress there. Process-wise, I think it’s also important not to DFI features before we even know what we are going for. For example, we will realistically need more time to ship PQ DC than PQ Gasper, and we should ideally settle on which option to go for before making decisions about Hegota.
In other words, the scenario I want to avoid is people DFI’ing features like FOCIL (and others) to get a false sense of security (“we deleted features, so surely we can go faster”), when the reality is more complex and nuanced. I also think these decisions hurt ACD’s credibility, and that we need a strong ACD the ecosystem can rely on, especially during times of uncertainty.
Zooming in
- On the EL, my opinion is that we need Frames for PQ (the only nuances are about how “light” Frames should be). In practice, we could also take the ugly/sequential approach there and ship another transaction type. But given the readiness of Frames, what they would unlock in Hegota and in the future (plus the fact that they’re already SFI’d, of course), there is no reason to settle for a hacky alternative.
- On the CL, we can apply the same type of thinking. For FOCIL, I think the most reasonable path is to derisk it as much as possible so we ensure it is (1) forward compatible with PQ, and (2) minimal enough that it doesn’t delay Hegota and/or take up too many resources from nodes (bandwidth/compute) at a time when we need those for PQ.
FOCIL in Hegota
The good news is that FOCIL is well suited for this, because of two core properties:
- Extensibility: We can fine-tune FOCIL to determine its transaction coverage. I think of it in terms of tiers: if we just want to cover regular/legacy transactions, we get FOCIL in its minimal form (lowest complexity, lowest node resource consumption). On the other hand, if we want FOCIL to cover all types of Frame transactions now and in the future, FOCIL becomes more complex and consumes more resources. In between, FOCIL can cover a limited set of Frame transactions.
- Boundedness: Inclusion lists are amongst the easiest objects to deal with in the protocol. They’re bounded in terms of both size (8 kB) and gas limit (MAX_VERIFY_GAS_PER_IL). We can also cap the gas and size per IL transaction. Inclusion lists are also ephemeral and only useful for the duration of 1 slot, after which they can be forgotten about. And they never go onchain, so they don’t grow Ethereum’s state, which is one of our scarcest resources.
For Hegota, I think FOCIL should sit in between and support a limited set of Frames with clear bounds on inclusion lists. A good approach for shipping FOCIL and Frames in general on devnets is to start with minimal FOCIL, make sure it’s ready, and then extend its transaction coverage gradually. This is a good way to guarantee we can ship FOCIL and Frames as soon as Frames are ready to go.
PQ FOCIL
“PQ FOCIL” can mean two different things, and we should differentiate them.
The first is inclusion lists being able to cover PQ transactions. Here, the simple answer is that FOCIL, without any changes, would be able to include PQ transactions using leanSPHINCS signatures. But it would be able to include a lot fewer: a leanSPHINCS signature is around 5-7 kB and an IL is capped at 8 kB, so probably just 1 PQ transaction per IL, which means up to 16 PQ txns per block (because there are 16 includers, each of them building 1 IL per block). I think that’s fine and good enough for Hegota.
Later, we will probably want FOCIL to cover PQ proofs as well, and for that we will need changes to FOCIL so each IL can include an 8288 proof (around 300 kB). The good news is that by then, we will need the machinery to handle these big recursive proofs being propagated on the network anyway. These are I*/J* considerations, but we should plan ahead and make sure the CL has the capacity to handle bigger ILs down the road.
The second is inclusion lists being PQ/AI resistant. This one is easy: just replace IL BLS signatures with leanXMSS signatures, which would increase their size by 2.4 kB (each IL becoming 10.4 kB instead of 8 kB). But it also raises an interesting question: how important is it for ILs to be signed with PQ sigs? What is the worst attack that could happen if an adversary forged an IL signature?
The worst an adversary can do with forged IL signatures is make every includer look like an equivocator. Nodes ignore ILs from an includer who signed two different lists, so forging a second IL for each of the 16 includers switches FOCIL off for that slot. So the worst thing that can happen is that FOCIL gets neutralised, which is of course far from ideal but a lot less concerning than consensus breaking or funds being stolen. Keep in mind that the adversary would also have to spend significant resources to break the keys of all 16 includers, who are only known a few minutes in advance. An adversary could also publish ILs on behalf of offline includers, but an IL can only force in transactions that are valid and fit in the block, which is what any includer can already do. And the extra load is bounded, because nodes forward at most two ILs per includer.
So even though I think we should generally switch to PQ sigs across all layers of the protocol, this one is definitely not the most urgent or worrying. ILs could potentially keep BLS signatures in Hegota and move to PQ signatures with the rest of the CL.
Closing thoughts
I agree we should accelerate pqai, and prioritise every upgrade that is ready (PQ registration, leanSPHINCS). But DFI’ing everything else won’t make the parts that aren’t ready arrive any sooner. It only guarantees that Ethereum ships no user-facing features while we wait.
PS: I want to be clear that I’m incredibly excited about the future of Ethereum. Thinking about PQ and ZK made me realise that we could completely rethink Ethereum as a cryptographic world computer, and accelerating towards this vision is very bullish. We just need to be careful not to sacrifice its other properties along the way (e.g., credible neutrality, privacy), and we have a very bright future ahead of us.
*JUDGE RULES $25M MEV HEIST THAT HONEYPOTTED OTHER SANDWICH BOTS WASN'T WIRE FRAUD, ACQUITS MIT BROTHERS
*JUDGE SAYS TRADES WERE NOT PLACED ON REGULATED MARKET BARRING THE CONDUCT
Trying to formally verify like 650 lines of code against a spec **that is already written mathematically** has burned like 24 hours of inference and is still not done, which leads me to believe that either (a) I've stumbled into the most difficult formal verification task per-line of all time, or (b) everyone's "formal verification" of their 100,000-line codebase is complete shit.