DSS 2026 / Day 2 / Amber Hall
Clear Signing with ERC7730
Kaan Uzdoğan
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
- Names, organizations, technical terms, code and numbers may be misrecognized.
- Source wording and disfluencies are preserved; no editorial corrections were applied.
- Export contains whole-second cue starts only; cue ends and subsecond timing are unavailable.
- A full caption-track export does not establish that every spoken word is represented.
- Automatic YouTube captions; not human-verified against the audio.
Source export SHA256: a0b1c0c9f2c4d4aa2182a62a876b0acc0f1cd13bc474b2d915c340e099df790c