DSS

DSS 2026 / Day 2 / Amber Hall

Clear Signing with ERC7730

Kaan Uzdoğan

16:18 · 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:01Hello everyone.

0:03My name is Khan. I'm working on Sorsify

0:05and under Argo Collective and we will

0:08today talk about clear signing. I think

0:10this is something everyone has seen at

0:15least once sending a transaction in

0:17crypto in Web three and yeah, it's a

0:20nightmare.

0:21So I'll just walk you through

0:23just a normal day in Web three.

0:25This is how it looks like just hex bytes

0:28gibberish. You don't know what's

0:30happening. You have no idea what's going

0:32on. You're trying to decode.

0:34Am I going to lose my money? Am I going

0:35to lose all my life savings?

0:37And you just hope for the best and sign

0:40whatever they offer you.

0:43But why is this so like why does it have

0:46to be like this?

0:48It's been 10 years almost more than 10

0:50years in Ethereum and we haven't still

0:53figured out a way to solve this, right?

0:58The main reasons of course there are

0:59many reasons to this, but the main

1:00reason is like the action space is

1:03unbounded like when you're sending a

1:05bank transfer, you're talking about just

1:07sending money. It's a simple action.

1:09There's nothing else you can do. That's

1:11why we don't have blind signing problem

1:13in token transfers or ETH transfers,

1:15right? Because you we know what it is

1:17and there is only one thing you can do

1:19and it's clear

1:20and we can decode it very easily.

1:23But in contracts it's not the case like

1:25the EVM is Turing complete. You can do

1:28whatever you like in EVM and it's

1:30basically impossible to

1:32predict and see what's going on.

1:36And in general, I would say technical

1:38problems are easy to solve. Like we can

1:39solve them, but this is a coordination

1:41problem. This is we have to first solve

1:43this on the technical level and then

1:45roll it out. Hope everyone will adapt.

1:48Hope there won't be

1:50any competing standards, which is not

1:52the case here. There's a lot of

1:54proposals. Everyone claims they have

1:56solved the issue

1:58not to say like these

2:01these these are all very valuable

2:03proposals that I've been

2:06around for a while around 2021 and so on

2:09but we need something that works for

2:11everyone right and I think

2:14and we also tried it I was going to say

2:17at Sourcify at the time when we started

2:19we we thought we could decode contracts

2:22decode transactions with nut spec and

2:26solid metadata

2:27but we weren't able to figure it out

2:29because

2:30we were a small team and in the end we

2:32focused on what we do best

2:34and we did we focused on source code

2:36verification and I also wrote about this

2:39so we started the transactions working

2:41group at the time in 2023 then we

2:44stopped it

2:45and after the by by bit hack I also

2:48wrote about what we learned from trying

2:51to do this and what are the solutions

2:53out there but I think this time it's

2:54different and I think this time we have

2:56a working solution that can

2:59finally fix for everyone and that's ERC

3:017730

3:03the spec this is a EIP this is a spec

3:07written by Ledger initially

3:09I guess more than two or three years ago

3:12but over time we were able to

3:14transition this into a working group

3:16from consisting of multiple parties

3:19multiple ecosystem stakeholders

3:22and we moved the registry so there's a

3:26there's a registry for the metadata for

3:27the

3:28descriptors

3:29we moved this from Ledger to the

3:32Ethereum namespace to under Ethereum

3:33Foundation as a neutral host for now

3:37and yeah as I said I think why this spec

3:41can finally solve this is that it has

3:44the critical mass of stakeholders it has

3:45Ledger Trezor and many other important

3:48players

3:50and as I said this is a EIP it's a very

3:53detailed spec it's a very long spec if

3:55you want to read it I would recommend

3:57you to read it with an agent and ask ask

4:00questions otherwise it's a very long

4:02page You it would be almost impossible

4:04to understand it at once.

4:08So it's a spec and the spec defines or

4:11explains a JSON schema. So this is a

4:14JSON schema. On the left hand side you

4:16can see the different versions of that

4:18schema. Right now we have I think 2.1

4:23we switched over to version two after

4:25forming the working group

4:26and basically

4:28what this says is

4:30so this defines how the JSON files that

4:35describe a contract looks like. So any

4:38file, any descriptor you are going to

4:40write should has to conform this JSON

4:43schema.

4:45And there's a registry. So

4:47each and every single file, each JSON

4:50file describes a contract and these

4:52contracts are in a in a registry. So

4:57the registry Do I have a pointer? No. To

5:00have a The registry has the spec on top

5:03and then under registry for each project

5:05you have

5:07the contracts. For example, under

5:08Uniswap you have the call data for the

5:10Uniswap V3 router. You also have

5:13descriptors for EIP 712

5:16signatures

5:17and there are tests. So this is how the

5:19registry looks like

5:21and the registry right now, as I said,

5:23is under the Ethereum namespace under

5:25Ethereum Foundation's GitHub repo

5:28and it's a GitHub repo. So the repo

5:31currently hosts the CI, it hosts the

5:34JSON files.

5:36Yeah. [snorts]

5:38And now we will walk through with an

5:40example. So this is a

5:43Aave

5:45contract. It's the pool instance, I

5:47guess.

5:49Yeah. So this

5:51This is the top of the file. So you

5:53start with this section in the JSON and

5:55this shows

5:57where this contract is deployed at. So

5:59on mainnet at this address, on base on

6:02this address and so on. You collect the

6:04deployments of this contract.

6:06Below,

6:07you have the definitions

6:10of how to

6:13decode each function. So this is the

6:16one of the most common functions of our

6:18it's borrow function. And this is the

6:21full

6:22function signature. So a function

6:24signature normally does not have the

6:26function parameter names. Here you can

6:29also see the parameter names. So this

6:32gives us a complete picture of what the

6:35function looks like.

6:37Um

6:38on top you see the intent. So this is

6:41the action you want to take. You want to

6:43borrow something.

6:45And then the fields define how to decode

6:48each of these fields. So

6:50before that, let's have a look at an ABI

6:53decode decoding of this call data. So

6:55imagine we have this call data. This is

6:57the selector of this function borrow.

7:00And then the call data looks like this.

7:02And when you ABI decode it, you have

7:04like the asset is this, amount is this,

7:06but this is the raw call data. So it's

7:08not easily understandable.

7:11And then what we do is we say, okay,

7:13this is the intent.

7:15And then

7:16the next parameter is the amount. So

7:19what is this? The label of this is the

7:21amount to borrow.

7:23And this is a token amount format. So we

7:26have formatters in within descriptors.

7:29And [snorts] this is a for example, a

7:31token amount standard which defines and

7:34describes how a token amount is

7:36displayed.

7:37And for example, it says, okay, the

7:40amount is the variable amount. You go

7:44get the amount from there.

7:46And then this token amount gets some

7:48parameters. Of course, for example, we

7:50know the amount, but which asset, right?

7:52And then this is the asset.

7:54So the token path

7:56is the so the asset address. So we go

7:59from this address, we pull the decimals,

8:01we pull the ticker.

8:03And then we decode the whole amount. And

8:05then

8:06you have interest mode. This is an enum.

8:08And you can say variable or fixed

8:10interest mode depending on what you

8:12chose.

8:13And you say okay like you are borrowing

8:15on behalf of this address and this is

8:17the address formats and this is a yeah

8:20this can be an EOA.

8:22And you can pull this address from your

8:23local address book or you can

8:26try to find the ENS.

8:28And yeah referral code in in this sense

8:31is not relevant so we just don't show

8:33it.

8:34And in the end you can show something

8:35like this hopefully. So instead of blind

8:37signing on the left

8:39on the right you can see a much more

8:42understandable view. Yeah the the

8:44registry today has a lot of

8:47descriptors.

8:48We were able to get a lot of descriptors

8:51in recently.

8:53And

8:54I've actually kind of white coded this

8:56dashboard to see how many

8:58recent transactions like what percentage

9:00of the recent transactions are actually

9:02clear signable. And I wish this this

9:05this was the full picture but this

9:06includes the token trades and E

9:08transfers.

9:09So in reality it looks like this. So if

9:11of course token transfers, E transfers

9:13these are trivial and if we exclude them

9:16and we also exclude unverified contracts

9:18because you can't decode an unverified

9:21contract.

9:22It was 3.9% around these numbers but

9:26recently we were able to get a lot more

9:28transactions, a a lot more descriptors.

9:31And we now we're now around this

9:33percent. So

9:35almost 14 15% you can see live if you

9:38want if you visit this

9:40website [snorts] you can see live

9:42how it's going.

9:44And this website also has

9:47contracts by transaction count from most

9:50to least. So the idea is so the the

9:54good news is there's a big power law in

9:57play here. So most of the transactions

9:59are only just on a few contracts.

10:02That means if we I think if I remember

10:04correctly if we have descriptors for

10:07maybe 500 contracts then we can get 80

10:0990 percent of all transactions on

10:12Ethereum mainnet to be clear signed. So

10:15we can take this advantage and we start

10:17from this list and we we're already

10:20trying to build descriptors for this for

10:22the for these all contracts using AI

10:25and hopefully we can increase this

10:27number quickly.

10:30And you can also try it out on our

10:31website on Sourcefy website. We have a

10:34new website recently and you can just

10:36paste

10:38the transaction hash here and it will

10:41decode the transaction for you if it's

10:43clear signable.

10:46And this

10:48website as well as other in other places

10:51we have the clear signing SDK. This is a

10:54reference implementation for clear

10:55signing Sourcefy builds. It's a

10:58TypeScript implementation and it's quite

11:00easy to use. You can just npm install it

11:03then you give the chain ID, the address

11:05and the call data and

11:08in the below it will show you the

11:10intent, the fields and yeah the rest of

11:12the information you can display to your

11:14users.

11:15But in our experience most of the

11:17wallets want to implement their own so

11:19they're also welcome to do that.

11:21Yeah of course you can decode EIP 712

11:26type data.

11:27That's also part of the spec.

11:30And the question is like can I trust

11:31this like right? Can I trust the

11:33descriptors? Do the descriptors really

11:35describe the

11:38the the contract? So we don't blindly

11:40merge everything. We have some basic

11:43checks. We have some

11:45we have this this ERC 7730 CLI that does

11:48checks if this contract is verified,

11:50does the ABI match, um is there a test

11:53case and so on.

11:55And then we also do a AI review. So we

11:57recently built this pipeline and it does

12:00a basic AI review to be able to see okay

12:02like there are there is no severe

12:05missing things.

12:06But then the main trust will come from

12:08attestation. So the PR merge is not the

12:10trust but we in the current scheme, we

12:13want a testers, auditors, security

12:15researchers, or even individuals to

12:18attest to descriptors to say that okay,

12:20like this descriptor is

12:22good enough to describe this contract.

12:24Um and how you do it is the attesters

12:27will

12:29do a EIAS attestation and sign it and

12:33publish it off chains and the

12:34revocations will be on chain so that you

12:36can always see revocations.

12:38And the idea is that the wallets will

12:40have a couple addresses that they trust.

12:43For example, I have

12:44the ledger address, the cipher address,

12:46whatever I trust these attesters and I

12:49will only show the descriptor if I if

12:51this is attested by one of the

12:53trusted ones.

12:55What are the challenges?

12:56The challenges are so like the main

12:58thing is the hardware devices are quite

13:00limited, so we can't do arbitrary stuff

13:02on hardware devices.

13:04Um the device communication is not also

13:06standardized, so hardware devices all

13:08use their own um wire format.

13:12And in general, creating descriptors is

13:15not so straightforward, so like

13:17the question of is this a good

13:19descriptor or is

13:21not easy to answer. So we can have a

13:24good enough the goal is to have good

13:26enough descriptors because the

13:27alternative is bytes, right? So having

13:30something to describe it is better than

13:32having no description at all. So that's

13:34the that's for our advantage at least.

13:37And of course, like reviewing at scale,

13:39verifying at scale, these are all very

13:40difficult things. Like this is not

13:41definitely not a trivial problem.

13:44Um and we have a lot of coordination

13:45too. Like we can't just sit down and

13:48find a solution by ourselves. This is

13:50all about how we solve this as as the

13:52ecosystem. And then we have the other

13:54EVM

13:56problems like um proxies and some

13:59contracts are non-ABI encoded call data

14:01and then internationalization and so on.

14:03So we have a lot to do.

14:05Um and in the future, we hope to have an

14:07on-chain registry. So right now, it's a

14:08GitHub registry,

14:10but uh we want to move this on-chain and

14:12to make this permissionless so that

14:14anyone can host a registry and on the

14:16registries, of course, you can attest.

14:18And so, we will have a more

14:21permissionless

14:22system.

14:23And I am also hoping to some have

14:25something like a nutspec plus plus where

14:27you can write descriptors as the

14:29comments. So, an example is like this.

14:31For example, when you're writing the

14:32function, you would write

14:34the intent, the field, and so on. And

14:36this would automatically generate a

14:39descriptor for you. So, this would be

14:40part of the whole contract development

14:42pipeline, hopefully. And then there's

14:44already a

14:46prototype for this.

14:47Um, yeah.

14:49And in general, this is to remind that

14:53this is not the silver bullet, right?

14:54The transaction safety is not This is

14:56only part of the transaction safety. So,

14:58you To be able to make sure your

15:00transaction is safe, you need

15:03you need like the simulations you have

15:05to have.

15:06Uh, there's also a transaction

15:07assertions, which I'm quite excited of.

15:09Um, so these are all other steps you

15:11need to take. And to make this easier,

15:14we are trying to build a new project

15:17called Onai with Sourceify.

15:19And yeah, we want to bring everything

15:21together and have give you a transaction

15:24companion

15:26that is read only and that is local

15:27first.

15:30Okay, so what should you do? If you're a

15:32wallet, please integrate it.

15:34If you are an interim application,

15:35please write your descriptor. If you're

15:37a security company, please

15:40start

15:41approach us. We want

15:43to attest. We want people to attest and

15:45we want to understand if and how you can

15:48do it. We want to help you do that.

15:50And if you're a user, demand it from

15:51your wallet. And hopefully in near

15:54future, when we see

15:57a hex transaction, we see bytes, we will

15:59say no, I don't want this. Where is my

16:01clear signed transaction? Thank you.

16:05And also Sorry, we have a Telegram group

16:07if you want to be involved,

16:10find me, reach out to me, and we also

16:12have

16:13biweekly calls to move the spec forward.

16:15Thank you.

Source and accuracy details

Source export SHA256: a0b1c0c9f2c4d4aa2182a62a876b0acc0f1cd13bc474b2d915c340e099df790c