DSS

DSS 2026 / Day 2 / Amber Hall

Valid Signatures, Fragile Accounts: PQC on Ethereum

Magnus Woodgate

23:33 · Recording

Watch on YouTube ↗Open recording viewerOriginal programme entry
Download plain textDownload timestamped JSON

Source: YouTube automatic caption track · Exported 2026-11-16. Timestamps link to the source video. Cue end times were not supplied.

Transcript

0:02Hello everyone.

0:06>> Cool. So here to talk today about some

0:09postquantum crypto uh specifically

0:11Ethereum's road map and some of the

0:13stuff involved there. Um yeah, I want to

0:15highlight that we're going to cover like

0:16a lot of different stuff. So this is

0:17kind of like a lay of the land rather

0:19than a deep dive into any specific

0:20topic. Um although we'll get into it. Uh

0:22and yeah, the focus here is security

0:24practitioners. So, um, not necessarily

0:26cryptographers, but you guys, auditors,

0:28L1 devs, core devs, that sort of thing.

0:31Cool. So, I'm Magnus Gate. I lead one of

0:33the security engineering teams over at

0:34Asymmetric. Uh, we do a ton of different

0:36stuff. Uh, I focus on kind of the white

0:38hat research and continuous security.

0:40Uh, yeah, Asymmetric, for those of you

0:43who don't know, I think a few people

0:44here do. Um, we work on a ton of

0:47different stuff, not just web 3. Uh, and

0:49we're included with the like embedded in

0:51the protocol teams from the beginning

0:52ideally. uh and we we don't do audits,

0:54we do continuous security, but you can

0:56talk to me about that and check us out

0:57afterwards. Cool. So the you know today,

1:02like I said, I want to talk about

1:03Ethereum's road map for postquantum

1:05migrations and specifically security

1:07practitioners. Um we're going to cover a

1:09lot of different stuff. So the aims here

1:11is that you know some of the terms, some

1:13of the terminologies that you can go

1:14away with and take a look and start

1:15digging.

1:17So brief outline of the talk. Um we're

1:20going to cover some building blocks and

1:21background and I want to focus here on

1:23the implementation risks a brief note on

1:24assurance and limitations but we'll get

1:26into that. So the background one of the

1:30things I want to start with is is

1:31account abstraction specifically. Um so

1:34the question you know that we're going

1:36to be talking about today the most is

1:37the valid signature part that you can

1:38see highlighted here in yellow. Uh the

1:40question is is the state safe to sign?

1:43Do the bytes match? I mean these are all

1:45things that you see in classical crypto

1:46today that we have. Um, but there's some

1:48other parts that this kind of enables

1:50that you might see an in ERC 4337

1:52mentioned there about the is the policy

1:54intended. Um, you know, can this account

1:57or user actually do the thing that you

1:59want it to do? And then does the account

2:00behavior actually behave as intended?

2:03So, you know, does the thing change the

2:05state that you want it to?

2:07So there's obviously a lot that changes,

2:10but I think I want to focus here on the

2:11stuff that stays the same because it's

2:12it's it's, you know, the most relevant

2:14in terms of when you're reviewing this

2:16from a security perspective. So the

2:18existing obligations do not change. You

2:20still need to worry about intent, replay

2:21protection and whatnot. Um access

2:23control, all of that stuff. Uh the

2:25access policies say the same. The thing

2:27that does change is the signature

2:28specific work. Um specifically around

2:30limited use state, but we'll get into

2:32that. Uh and then I want to draw like

2:34last attention to this last point about

2:36uh retiring authorities because that's

2:38going to be a big one uh when it comes

2:40up and there's some EIPs around that.

2:42But yeah, there's a lot of overlapping

2:43risks, but the things that are probably

2:45going to be interesting for you guys in

2:46an operational capacity is what you need

2:48to recheck. So brief reminder here, um

2:52we're not going to go too much into

2:54this, but effectively Shaw's algorithm

2:56lets you efficiently factoriize the

2:59discrete logarithm problem and you can

3:01recover the private key. uh given a

3:03public key point on the elliptical

3:04curve. Um yet you can take a look into

3:07this, but this is kind of why we're

3:09looking to do the postquantum migration

3:10today. Um not there yet in theory.

3:14So yeah, some caveat here. Those of you

3:17who already know, um the public key

3:20isn't actually exposed until something

3:22is signed. So that doesn't mean

3:23necessarily broadcast the Ethereum

3:25network. Um but that could also be an

3:27off-chain signature stored in like a web

3:292 DB. Um, and it's important to be aware

3:31of that because that DB could be leaked,

3:33for example, and you're still

3:34vulnerable. Um, the public key, if it

3:37it's not actually exposed until

3:39something's signed, um, which creates a

3:41slightly different problem. Um, it

3:42doesn't mean it's not exposed, but it

3:44requires an additional layer, uh, to

3:46shores when you're breaking it with a

3:48quantum computer. Um, but this is, yeah,

3:50it doesn't mean you're safe, but there's

3:51a slight extra layer of protection

3:53there. So, you know, how do we kind of

3:57combat this in the long term? uh the

3:59programmable authentication here um

4:02enables the postquantum migration and I

4:04guess the point here is that Ethereum's

4:06road map is very generic uh and this

4:08basically allows us to pick different

4:10algorithms. You can see here ERC 4337

4:13that you guys may be familiar with uh

4:15basically allows a user to do some

4:17intent or operation with agnostic

4:19account validation which may be

4:21different to what the L1 actually

4:22provides today and results in some

4:24execution. Those of you who haven't

4:26looked at the EIP8141, which is

4:28currently uh scheduled for native

4:30frames, basically starts to bake this

4:32intention into the L1 and then we can

4:34start to do programmable validation at

4:36the L1 layer. Uh essentially allowing us

4:38to switch out the cryptographic

4:39algorithm for signing and verification.

4:41Um there's also some other parts around

4:43this in terms of you can choose who pays

4:44for gas. Uh but at the end of the day,

4:46you still get the same result of

4:48execution, but this enable enables uh

4:50programmable validation.

4:52So yeah, back to 4337, we have a similar

4:56structure here where we have, you know,

4:58is the execution authorized? Um, and

5:00that's what we want to focus on today.

5:02But then there's also the aspect of

5:03payment, which is something you want to

5:04be considering. Um, I recommend checking

5:06out 8141 if you haven't yet.

5:11Cool. Resuming from there. Thank you

5:13guys. Um, yeah, I want to focus on

5:16existing migration risks. So this is

5:18something that you know you guys should

5:19be aware of as we start to migrate

5:21towards these approaches. Um again

5:22highly experimental but you know I want

5:24to give some takeaways that you can

5:25focus on uh more generally. So this is

5:28one interesting edge case that maybe you

5:30know is being discussed but maybe you

5:32haven't considered yet around 772

5:34delegations. So let's say that we have

5:35an account or a wallet in this case um

5:38with a postquantum signature scheme

5:39already in place. You may have delegated

5:41that wallet beforehand and that

5:43delegation is controlled by an ECDSA

5:44key. So even though you have this

5:46postquantum uh signature in place, you

5:49are not safe. So you know all it takes

5:51is u the recovering of the private key

5:54of the ECDSA key and yeah the

5:58interesting thing here is like how are

5:59you going to deal with this as a

6:00security practitioner? So one of the

6:02approaches you might think is okay well

6:04I'm just going to move every account uh

6:06over. So I'm going to move all my

6:07assets, all my positions, reassign all

6:09the roles and update all the

6:10integrations. Maybe that works for you.

6:12it might not work for everyone if you

6:13have these big monolithic applications

6:14and whatnot. Um, and I'm assume that

6:17some some of you guys are want to going

6:18to keep the same uh addresses and things

6:20in place. Now, you have to be super

6:22careful around the relationships uh and

6:24authority there and importantly retiring

6:26the old key. Um, so you want to be

6:28thinking about specifically what can the

6:29old key do? Can it do transaction

6:31delegation? Can it do upgrades and

6:33recovery? Could it overwrite all the

6:34code in your protocol? Uh, effectively

6:36you want to be checking every single

6:37entry point and this is a serious

6:39migration risk. Um, yeah,

6:42cool. So, I'm going to skip over a bunch

6:44of stuff very quickly, um, so that you

6:46guys basically get the the building

6:47blocks for this. Um, postquantum

6:50signatures, if you guys haven't seen the

6:51the three big ones that you see people

6:53talk about, MLDDSA, FNDSA, and SHDSA.

6:56Uh, today we're going to be talking

6:57about SLHDSA or hashbased cryptography.

7:00Uh, specifically some of the uh,

7:02Ethereum proposals. Um, although FNDSA

7:05and MLDDSA you'll see on many other

7:06chains. uh or but yeah

7:10to be be super clear here Ethereum

7:12doesn't have a universal postquantum

7:14signature mandate. So they're not going

7:16to you know fully commit to one if

7:18something comes out that you know if for

7:19example if SLHDSA gets broken uh through

7:21some new quantum algorithm then the

7:23benefit of programmable uh account

7:25validation is that we can change it

7:27whenever we want. Cool. So start

7:30starting with what's the winter's

7:31onetime signature scheme uh plus and

7:33plus c you may see a compressed variance

7:35and more secure versions effectively

7:37it's it's a a hash chain that provides a

7:40onetime signature uh this is a building

7:42block for SLXSA that we'll go into XMSS

7:46uh very easy to say extended Merkel

7:48signature scheme basically builds a

7:50Merkel tree with watts keys as the root

7:52here uh and yeah you can basically do

7:55use this to combine trees where you have

7:57an XMSSS tree a watts key that signs the

7:59root of another tree and then that tree

8:01is then basically bound and you can

8:02traverse the whole path.

8:04Falls the forest of random subsets is

8:06one of the final building blocks and

8:08basically sits at the bottom and these

8:11uh where the the the leaves are

8:12essentially secrets and you can reveal

8:14them bit by bit um and then they

8:16consider use but we'll go we'll go into

8:18this.

8:20Cool. So the I spoke about winets

8:22onetime signatures uh fors actually has

8:24a few time signature properties. So if

8:26you do double sign uh if you do reveal

8:29multiple parts about the tree uh then

8:31the it's not immediately game over

8:33unlike watts uh effectively you can see

8:35the bit strength decreases and this is

8:37something you want to be careful with uh

8:39as as you're you know reviewing this

8:41from a security perspective did

8:42something get signed twice and we'll go

8:44into some of the instance and edge cases

8:45around that but it's not game over

8:47immediately unlike with watts cool so

8:50piecing those all together you can take

8:51a look at how SLHDSA works at a high

8:53level you have the fours uh forest

8:55random subsets at the bottom. You have

8:57it connected with a W signature to the

8:59fors route uh to some bottom XMSSS layer

9:02uh and it goes up to an upper XM XSS

9:05layer uh all the way to the trusted

9:06public route. So you can think of like

9:08this massive tree structure that's

9:10really complicated and you can choose

9:12the number of layers and falls

9:16jardin which is you know you guys might

9:18have seen uh one of the proposals here

9:19is to take ethereum's modifi modified

9:22version of SHDSA with a different hash

9:24function uh based off catch to be

9:26optimized for EVM um also known as in

9:29the sphinx minus family and you

9:31basically get this two trade-offs so you

9:33have the stateless spx which is the

9:34hypertree structure you just saw for

9:36SHCSA And then you have compact jardin

9:38signing. Um the idea is that you know

9:41the stateless one you can always fall

9:42back to if you need it but you want to

9:44use the jardin one for dayto-day because

9:46the the proof is significantly smaller

9:47and the signing is significantly faster.

9:50The way it works is basically you use

9:52this hypertree structure to sign uh like

9:55fours instances. So then you basically

9:57have like a pool of signing instances

9:59and then you use you basically every

10:02time you use one of the instances you

10:03you use it and throw it away. So because

10:05of this property of fours uh you can

10:08sign you can reveal more information

10:10about it uh but then the bit strength

10:11lowers and you keep a track of this with

10:14you know in this case q= 1= 2= 3 and so

10:16on um and once you've used the queue you

10:19need you need to get rid of it one of

10:20the experiments here you can actually

10:22see an onchain implementation um with

10:254337 and it combines the ECDSA and spx

10:28so you actually get both so uh in this

10:30case a quantum computer we need to get

10:32to solve the discrete logarithm problem

10:34and you'd have to find an SPX

10:35implementation breach or or

10:36cryptographic break.

10:39Cool. So, the intended life cycle here

10:40is that Q selects a fors instance under

10:42the root. Um, you reserve it, you

10:44persist it, and then you sign. You might

10:46go, well, why do you need to do this?

10:48Uh, it's very similar with atomic

10:49signing. You don't want to double sign.

10:51Uh, so you want to make sure that

10:53instance Q is always persisted even if

10:56you didn't actually broadcast it. If you

10:57think there's a chance that it was

10:58broadcast anywhere, uh, you never want

11:00to rewind Q, otherwise you risk losing

11:02some of the bit strength there.

11:04And to put this in perspective, uh the

11:07current implementation I believe took

11:0847.3 seconds on uh spx stateless signing

11:12on a legend. I know S+. So these

11:14signatures are massive. You don't want

11:16to be using the stateless path uh

11:18unnecessarily. Um yeah, I don't know who

11:20wants to wait 47 seconds for signing,

11:22but hopefully that speeds up. Cool. So

11:24the bulk of the talk uh is

11:26implementation risk. So what do security

11:27practitioners care about now that you

11:29understand some of the basic blocks as

11:30these things roll out?

11:33I've mentioned this already, but the

11:34existing uh obligations still apply. So

11:37if you have account author like

11:39authorization, you know, you have roles

11:41uh per dexes have keepers and things

11:43like that, you want to be checking the

11:44authorization route. How do you verify?

11:46Uh is that route still active? Can some

11:49key somewhere control it? And it might

11:50be in super non-obvious ways. 7702

11:53delegations, permit 2's leaked,

11:55offchain, uh and and and the like. Um

11:58but yeah, all of the existing

11:59obligations still apply.

12:02And the thing I want to emphasize here

12:03is all of the signature families have

12:05their own invariance. Here's some of the

12:06ones you probably already checked for

12:07ECSA and BLS. Uh hashbased, you know, is

12:10is is no different. Um in this case,

12:12we're talking about the proof passing

12:14and and and whether it's stateless or

12:16not. Latis cryptography as well has its

12:18own uh parameters. So you want to be

12:20checking this with whatever you're

12:21working with postquantum or pre-quantum

12:23crypto.

12:25And the thing to that I want to

12:28emphasize around the stateful signing.

12:31So using this Q instance that I spoke

12:33about is that just because the proof

12:35verifies doesn't show that the key was

12:36unused. So you could sign multiple times

12:39where Q equals 1 and it's going to leak

12:41key material and basically make it

12:43potentially easier uh to to forge some

12:46kind of proof. Um the wallet must

12:48preserve the signing history. In that

12:49case, that's the value Q.

12:52So, here's one instance that you may be

12:55thought of with pre uh quantum crypto.

12:57Basically, you have some, you know, uh a

13:00wallet on two devices, device A and

13:01device B. Device A signs with Q= 7. It

13:04has a a crash or a power outage. So,

13:07then you and you can't recover it. So,

13:08you you clone it from device B or an

13:11attacker does uh and you sign with Q7

13:14again. So now you've got two signatures

13:15with Q equ= 7 and you've leaked more

13:17information about uh the four's uh trees

13:20than you wanted to.

13:23So what an attacker would do is they

13:24would sit there collecting all these

13:25openings uh and then basically they

13:27would start to do random offline

13:29searches where they would verify the

13:30randomizer um and they effectively need

13:33to look for some proof that you know

13:36does an action that they want to do. So

13:37that might be bypassing the frame uh

13:39validation layer to do a transfer or

13:41whatever. Uh this is why one of the

13:42reasons that if you are doing a

13:44migration today then maybe the hybrid

13:45ECDSA signature requiring both is a good

13:48approach but it's obviously going to

13:49cost more in gas.

13:52So moving on here's like a hypothetical

13:54other scenario that you want to be

13:56testing for. Um this is you know similar

13:58to classical cryptography. You basically

14:00want to be checking that the you know

14:03mutating you you want to be checking for

14:05failed close cases specifically. So in

14:07this case you want to be checking Q

14:09specifically. uh if you do a roundtrip

14:11signing test, so sign and then verify in

14:13your unit test for your code or

14:14whatever, you want to be checking that

14:16if you do vary Q um or or remove Q uh

14:19that things fail closed instead of uh

14:22silently succeeding.

14:25Similarly, you know, I think it's

14:27happened before, but in in just general

14:28Merkel uh tree implementations, you want

14:30to be checking that the proof actually

14:33verifies the message or authenticates

14:34membership of the message. you want to

14:36be doing the full walk all the way up

14:38the tree whatever you're doing stateless

14:39or stateful um and and checking that

14:42that works. So effectively the thing I

14:44want to highlight here is you want to be

14:45mutating uh inputs and checking that

14:47everything fails closed under all

14:48circumstances

14:51and the scenario here is basically an a

14:53attacker supplied root root um and yeah

14:56if you don't check the full path then

14:58you may uh be vulnerable to this. It's

15:01very similar to existing Merkel tree

15:03implementations.

15:05Cool. And this is similar. You want want

15:08to be thinking about the this mutation

15:10approach when you're looking at frame

15:11transactions as well. Uh there's a

15:13concept where you you could accidentally

15:15approve a frame that you

15:18didn't mean to approve. Um and you want

15:20to be mutating and and basically

15:21checking that you know later frames um

15:24don't don't have approvals that they

15:26they weren't authorized. Um just

15:28something to think about when you're

15:28looking at EIP 8141.

15:32Cool. So, we spoke about uh different

15:34things in your uh attacker model, mainly

15:37application logic that you'd be looking

15:38at. This one is a very interesting paper

15:40I thought I'd mention uh around the guys

15:42from Lurbec and Google. They did uh a

15:45row hammer attack uh for those of you

15:46who aren't familiar. It's where you take

15:48um an attackers controlled memory region

15:50and a victim controlled memory region

15:51and you just do a ton of writes to it to

15:53try flip the bits at a hardware level.

15:55Um, effectively they proved that this

15:57would work in OpenSSL's implementation

15:59of SLHDSA. Um, they called it slashdsa

16:03where they would basically target the

16:05the watts key signing. So this part when

16:08you register another xss tree or falls

16:10uh in the in the hyper tree and

16:13basically that would mean that the watts

16:15key would sign a different tree. Um and

16:17then maybe you can if you know engineer

16:19this so that it deterministically sign

16:21some attacker control tree or or a

16:23subset of it which would allow uh an

16:25attacker forge proof. Uh the thing is is

16:28is really like is this in your threat

16:29model. So they reported this to OpenSSL

16:31and OpenSSL said this isn't in our

16:33threat model. So um as a [clears throat]

16:35security researcher you want to be

16:36checking what what your application you

16:38know cares about. Is it remote signing?

16:40Is there RC access? Are you running in

16:41in enclaves and whatnot?

16:44And the way this works is that basically

16:47if the Watts instant get compromised

16:49similar to the the one-time signing that

16:51I mentioned before, uh you can sign

16:53something a route of a tree that's

16:55untrusted and then an attacker can

16:56provide that tree um and then initiate

16:59some action similar to you know fund

17:01transfer or or delegation or whatnot. Um

17:03and that works for XSS all fours.

17:08Cool. So the you know moving on

17:13basically under this scenario you want

17:15to be checking that recovery always

17:17preserves the security policy. So one

17:20thing to talk about here is that we

17:22spoke about the compact signing and

17:24stateless signing. Basically you want to

17:27check that the stateless signing always

17:28works. And you know this this may be

17:30because you've lost the device. You

17:32don't know the the value of Q. um the

17:34comp the keys being compromised and you

17:36you want to rotate um or you have some

17:38ECDSA key uh and and basically you want

17:40to always be checking that the intended

17:42policy matches uh what your organization

17:44wants it to do.

17:46One of the reasons I mentioned this is

17:47because for example the SPX verification

17:50uh gas implementation today I believe is

17:522676,000

17:55um whereas the draft frame transaction

17:57uh is only going to allow 100,000 gas uh

18:00for validation. So as a security

18:02researcher you might be thinking well if

18:05it takes 276,000 gas how am I going to

18:07fit this into a frame transaction. Uh

18:09this is all up for discussion still so

18:11you can or contribute today. The

18:14question here is more about the

18:15integration challenge but you might be

18:16thinking okay how how can I exploit this

18:18you know as as a as a red team. So you

18:22want to be thinking about bridges you

18:23want to be thinking about uh external

18:24edge cases. Okay. And you know, assume

18:27that they've uh an institution finds out

18:29that they've signed three times with the

18:31same queue due to some faulty um

18:33operating system or hardware. You now

18:35immediately want to do an SPX stateless

18:37transaction to register a new route uh

18:39or send to a a new account. But you the

18:41question is can you fit it in the relay

18:43or or pay master system that you want?

18:45Um and the reason I'm bringing this up

18:48is you want to be forcing the hard path

18:50uh and the and the easy path. So you

18:52might be using a stateless state full

18:54signing uh for day-to-day, but you and

18:57and stateless signing may come up

18:59relatively rarely. Imagine like an ETF

19:01that doesn't move their funds uh at all.

19:03You want to be checking that the SPX

19:05stateless path does does always work.

19:06Maybe you want to run periodic SIMs and

19:08whatnot. Um and and checking that under

19:10all current relay conditions, maybe

19:12you're doing crosschain bridging or

19:13something that this is going to work.

19:17Cool. Um I wanted to mention here some

19:20briefly about assurance and some of the

19:22limitations around that as well as some

19:24of the art in the space. Uh the and and

19:27yeah just so that you guys are aware of

19:28what you can take a look at. There's a

19:31really cool implementation in Jasmine.

19:33Um those of you who aren't familiar with

19:34Jasmine lets you do uh low-level

19:36cryptographic implementations uh in

19:38assembly and it has constant time

19:40checkers so you can check that the

19:42implementation is constant time um and

19:45you can uh with formal verification. So

19:47the implementation here uh actually has

19:49an XMSS an XMSS MT so that's multi-ree

19:53um and you can prove that it links to

19:55the security theorem. So this is like an

19:57active area of research uh also in in

20:00the web 2 space uh just classical cryp

20:02cryptography um but these these models

20:05are available so you can start comparing

20:06them. So if you're implementing you know

20:08a new GU fork or something um with a

20:11custom XMSS implementation then you can

20:13be uh diff fuzzing and and you know

20:15checking against some of these

20:16implementations.

20:18Similarly um they actually used as well

20:20before but uh there's also a sphinx plus

20:22model that's type bound checked in easy.

20:24This is more for the model itself but uh

20:27you know if you are changing your uh

20:29tree structure and things like that like

20:31the number of layers and and whatnot um

20:33you can actually test that model in easy

20:34crypt and formally verify that as well.

20:38Cool. So, as a security practitioner,

20:41what what are you looking at? I think um

20:42formal verification always has a place.

20:44Um and so does some of the other tools.

20:46You want to be layering these wherever

20:47you can. The proof boundary definitely

20:49becomes the review boundary. So the you

20:52know, as much as this as it's great at

20:54verifying some of the implementation,

20:55you want to be checking the full stack,

20:57especially with this uh stateful

20:59stateless risk. So you want to be

21:00checking do the inputs where do the

21:02inputs come from? What are the edge case

21:04scenarios that you maybe never thought

21:05about with weird race conditions or

21:07hardware corruption? Um, and is that

21:09modeled by formal verification? If it's

21:11not, can you can you model it some other

21:13way through fuzzing or even hardware

21:15testing and things like that?

21:18Cool. So, I want to leave you guys with

21:19some key takeaways from this talk. Um,

21:22the most important one during the

21:24migration, I think, is that the just

21:26because we have postquantum crypto, it

21:28does not retire the old authority. So

21:30you need to be checking ECDSA keys and

21:32and what they control at the L1 layer.

21:34Uh um and yet you may have leaked

21:36signatures that you you are not aware

21:37of. Maybe you want to you know some

21:39teams here want to build some automation

21:41around tracing all these roots and that

21:43recovery always works. You can always

21:44upgrade your protocol and but you can

21:46never do it with the old keys.

21:49The compact proofs um we spoke about

21:51Jardin. There are also some other ones

21:53on the uh sphinx flam family um that

21:56also stateful. they do depend on durable

21:58signing history. So that that value Q

22:00that we spoke about, you need to be

22:02keeping a track of that and making sure

22:03that uh is very closely um you know

22:07durable and used. Um and you want to be

22:10testing all of the edge cases. I mean

22:11I've just mentioned a few here, but

22:13always be looking at whether you're

22:15leaking key material, which would be

22:16super important if you're regarding

22:17billions of TVL.

22:19And finally, you want to check that

22:21obviously everything uh agrees. This is

22:23more at the integration layer. Does the

22:25renewal and recovery work through real

22:27relay mechanisms which may be bridging,

22:29maybe gas relays, maybe pay masters? Um

22:32maybe as some EVM fork works differently

22:34to another one and that your spx uh

22:36stateless one, you know, the gas might

22:38be too expensive for you to actually

22:39include it in any real block. Um but

22:41we'll see where we end up. And to

22:44emphasize this, we're still super early.

22:45So these are just some things to be

22:47thinking about and some keywords you

22:48guys can go and Google afterwards. Um

22:50but yeah, a lot of this stuff is

22:52scheduled, not deployed. A lot of it's

22:53in prototypes. Um, and yeah, the

22:56engineering effort really remains here.

22:58So, uh, yeah, if you're doing wallets,

23:00L1's, L2s, um, application layer, you

23:02want to be starting to have a think

23:04about this, uh, today.

23:07So, thank you for listening. Um, yeah,

23:09you can check out asymmetric.com on the

23:11QR code. Um, and yeah, any questions?

23:16[applause]

23:30Cool. Thanks everyone.

Source and accuracy details

Source export SHA256: 393ab7ae51ccda5fe49e61862daa0a53c8008ce86cc3ae1d8aba5693953d9ec1