DSS 2026 — Clear Signing with ERC7730 Kaan Uzdoğan Source video: https://www.youtube.com/watch?v=9tQFSPLGK3Q Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: a0b1c0c9f2c4d4aa2182a62a876b0acc0f1cd13bc474b2d915c340e099df790c [0:01] Hello everyone. [0:03] My name is Khan. I'm working on Sorsify [0:05] and under Argo Collective and we will [0:08] today talk about clear signing. I think [0:10] this is something everyone has seen at [0:15] least once sending a transaction in [0:17] crypto in Web three and yeah, it's a [0:20] nightmare. [0:21] So I'll just walk you through [0:23] just a normal day in Web three. [0:25] This is how it looks like just hex bytes [0:28] gibberish. You don't know what's [0:30] happening. You have no idea what's going [0:32] on. You're trying to decode. [0:34] Am I going to lose my money? Am I going [0:35] to lose all my life savings? [0:37] And you just hope for the best and sign [0:40] whatever they offer you. [0:43] But why is this so like why does it have [0:46] to be like this? [0:48] It's been 10 years almost more than 10 [0:50] years in Ethereum and we haven't still [0:53] figured out a way to solve this, right? [0:58] The main reasons of course there are [0:59] many reasons to this, but the main [1:00] reason is like the action space is [1:03] unbounded like when you're sending a [1:05] bank transfer, you're talking about just [1:07] sending money. It's a simple action. [1:09] There's nothing else you can do. That's [1:11] why we don't have blind signing problem [1:13] in token transfers or ETH transfers, [1:15] right? Because you we know what it is [1:17] and there is only one thing you can do [1:19] and it's clear [1:20] and we can decode it very easily. [1:23] But in contracts it's not the case like [1:25] the EVM is Turing complete. You can do [1:28] whatever you like in EVM and it's [1:30] basically impossible to [1:32] predict and see what's going on. [1:36] And in general, I would say technical [1:38] problems are easy to solve. Like we can [1:39] solve them, but this is a coordination [1:41] problem. This is we have to first solve [1:43] this on the technical level and then [1:45] roll it out. Hope everyone will adapt. [1:48] Hope there won't be [1:50] any competing standards, which is not [1:52] the case here. There's a lot of [1:54] proposals. Everyone claims they have [1:56] solved the issue [1:58] not to say like these [2:01] these these are all very valuable [2:03] proposals that I've been [2:06] around for a while around 2021 and so on [2:09] but we need something that works for [2:11] everyone right and I think [2:14] and we also tried it I was going to say [2:17] at Sourcify at the time when we started [2:19] we we thought we could decode contracts [2:22] decode transactions with nut spec and [2:26] solid metadata [2:27] but we weren't able to figure it out [2:29] because [2:30] we were a small team and in the end we [2:32] focused on what we do best [2:34] and we did we focused on source code [2:36] verification and I also wrote about this [2:39] so we started the transactions working [2:41] group at the time in 2023 then we [2:44] stopped it [2:45] and after the by by bit hack I also [2:48] wrote about what we learned from trying [2:51] to do this and what are the solutions [2:53] out there but I think this time it's [2:54] different and I think this time we have [2:56] a working solution that can [2:59] finally fix for everyone and that's ERC [3:01] 7730 [3:03] the spec this is a EIP this is a spec [3:07] written by Ledger initially [3:09] I guess more than two or three years ago [3:12] but over time we were able to [3:14] transition this into a working group [3:16] from consisting of multiple parties [3:19] multiple ecosystem stakeholders [3:22] and we moved the registry so there's a [3:26] there's a registry for the metadata for [3:27] the [3:28] descriptors [3:29] we moved this from Ledger to the [3:32] Ethereum namespace to under Ethereum [3:33] Foundation as a neutral host for now [3:37] and yeah as I said I think why this spec [3:41] can finally solve this is that it has [3:44] the critical mass of stakeholders it has [3:45] Ledger Trezor and many other important [3:48] players [3:50] and as I said this is a EIP it's a very [3:53] detailed spec it's a very long spec if [3:55] you want to read it I would recommend [3:57] you to read it with an agent and ask ask [4:00] questions otherwise it's a very long [4:02] page You it would be almost impossible [4:04] to understand it at once. [4:08] So it's a spec and the spec defines or [4:11] explains a JSON schema. So this is a [4:14] JSON schema. On the left hand side you [4:16] can see the different versions of that [4:18] schema. Right now we have I think 2.1 [4:23] we switched over to version two after [4:25] forming the working group [4:26] and basically [4:28] what this says is [4:30] so this defines how the JSON files that [4:35] describe a contract looks like. So any [4:38] file, any descriptor you are going to [4:40] write should has to conform this JSON [4:43] schema. [4:45] And there's a registry. So [4:47] each and every single file, each JSON [4:50] file describes a contract and these [4:52] contracts are in a in a registry. So [4:57] the registry Do I have a pointer? No. To [5:00] have a The registry has the spec on top [5:03] and then under registry for each project [5:05] you have [5:07] the contracts. For example, under [5:08] Uniswap you have the call data for the [5:10] Uniswap V3 router. You also have [5:13] descriptors for EIP 712 [5:16] signatures [5:17] and there are tests. So this is how the [5:19] registry looks like [5:21] and the registry right now, as I said, [5:23] is under the Ethereum namespace under [5:25] Ethereum Foundation's GitHub repo [5:28] and it's a GitHub repo. So the repo [5:31] currently hosts the CI, it hosts the [5:34] JSON files. [5:36] Yeah. [snorts] [5:38] And now we will walk through with an [5:40] example. So this is a [5:43] Aave [5:45] contract. It's the pool instance, I [5:47] guess. [5:49] Yeah. So this [5:51] This is the top of the file. So you [5:53] start with this section in the JSON and [5:55] this shows [5:57] where this contract is deployed at. So [5:59] on mainnet at this address, on base on [6:02] this address and so on. You collect the [6:04] deployments of this contract. [6:06] Below, [6:07] you have the definitions [6:10] of how to [6:13] decode each function. So this is the [6:16] one of the most common functions of our [6:18] it's borrow function. And this is the [6:21] full [6:22] function signature. So a function [6:24] signature normally does not have the [6:26] function parameter names. Here you can [6:29] also see the parameter names. So this [6:32] gives us a complete picture of what the [6:35] function looks like. [6:37] Um [6:38] on top you see the intent. So this is [6:41] the action you want to take. You want to [6:43] borrow something. [6:45] And then the fields define how to decode [6:48] each of these fields. So [6:50] before that, let's have a look at an ABI [6:53] decode decoding of this call data. So [6:55] imagine we have this call data. This is [6:57] the selector of this function borrow. [7:00] And then the call data looks like this. [7:02] And when you ABI decode it, you have [7:04] like the asset is this, amount is this, [7:06] but this is the raw call data. So it's [7:08] not easily understandable. [7:11] And then what we do is we say, okay, [7:13] this is the intent. [7:15] And then [7:16] the next parameter is the amount. So [7:19] what is this? The label of this is the [7:21] amount to borrow. [7:23] And this is a token amount format. So we [7:26] have formatters in within descriptors. [7:29] And [snorts] this is a for example, a [7:31] token amount standard which defines and [7:34] describes how a token amount is [7:36] displayed. [7:37] And for example, it says, okay, the [7:40] amount is the variable amount. You go [7:44] get the amount from there. [7:46] And then this token amount gets some [7:48] parameters. Of course, for example, we [7:50] know the amount, but which asset, right? [7:52] And then this is the asset. [7:54] So the token path [7:56] is the so the asset address. So we go [7:59] from this address, we pull the decimals, [8:01] we pull the ticker. [8:03] And then we decode the whole amount. And [8:05] then [8:06] you have interest mode. This is an enum. [8:08] And you can say variable or fixed [8:10] interest mode depending on what you [8:12] chose. [8:13] And you say okay like you are borrowing [8:15] on behalf of this address and this is [8:17] the address formats and this is a yeah [8:20] this can be an EOA. [8:22] And you can pull this address from your [8:23] local address book or you can [8:26] try to find the ENS. [8:28] And yeah referral code in in this sense [8:31] is not relevant so we just don't show [8:33] it. [8:34] And in the end you can show something [8:35] like this hopefully. So instead of blind [8:37] signing on the left [8:39] on the right you can see a much more [8:42] understandable view. Yeah the the [8:44] registry today has a lot of [8:47] descriptors. [8:48] We were able to get a lot of descriptors [8:51] in recently. [8:53] And [8:54] I've actually kind of white coded this [8:56] dashboard to see how many [8:58] recent transactions like what percentage [9:00] of the recent transactions are actually [9:02] clear signable. And I wish this this [9:05] this was the full picture but this [9:06] includes the token trades and E [9:08] transfers. [9:09] So in reality it looks like this. So if [9:11] of course token transfers, E transfers [9:13] these are trivial and if we exclude them [9:16] and we also exclude unverified contracts [9:18] because you can't decode an unverified [9:21] contract. [9:22] It was 3.9% around these numbers but [9:26] recently we were able to get a lot more [9:28] transactions, a a lot more descriptors. [9:31] And we now we're now around this [9:33] percent. So [9:35] almost 14 15% you can see live if you [9:38] want if you visit this [9:40] website [snorts] you can see live [9:42] how it's going. [9:44] And this website also has [9:47] contracts by transaction count from most [9:50] to least. So the idea is so the the [9:54] good news is there's a big power law in [9:57] play here. So most of the transactions [9:59] are only just on a few contracts. [10:02] That means if we I think if I remember [10:04] correctly if we have descriptors for [10:07] maybe 500 contracts then we can get 80 [10:09] 90 percent of all transactions on [10:12] Ethereum mainnet to be clear signed. So [10:15] we can take this advantage and we start [10:17] from this list and we we're already [10:20] trying to build descriptors for this for [10:22] the for these all contracts using AI [10:25] and hopefully we can increase this [10:27] number quickly. [10:30] And you can also try it out on our [10:31] website on Sourcefy website. We have a [10:34] new website recently and you can just [10:36] paste [10:38] the transaction hash here and it will [10:41] decode the transaction for you if it's [10:43] clear signable. [10:46] And this [10:48] website as well as other in other places [10:51] we have the clear signing SDK. This is a [10:54] reference implementation for clear [10:55] signing Sourcefy builds. It's a [10:58] TypeScript implementation and it's quite [11:00] easy to use. You can just npm install it [11:03] then you give the chain ID, the address [11:05] and the call data and [11:08] in the below it will show you the [11:10] intent, the fields and yeah the rest of [11:12] the information you can display to your [11:14] users. [11:15] But in our experience most of the [11:17] wallets want to implement their own so [11:19] they're also welcome to do that. [11:21] Yeah of course you can decode EIP 712 [11:26] type data. [11:27] That's also part of the spec. [11:30] And the question is like can I trust [11:31] this like right? Can I trust the [11:33] descriptors? Do the descriptors really [11:35] describe the [11:38] the the contract? So we don't blindly [11:40] merge everything. We have some basic [11:43] checks. We have some [11:45] we have this this ERC 7730 CLI that does [11:48] checks if this contract is verified, [11:50] does the ABI match, um is there a test [11:53] case and so on. [11:55] And then we also do a AI review. So we [11:57] recently built this pipeline and it does [12:00] a basic AI review to be able to see okay [12:02] like there are there is no severe [12:05] missing things. [12:06] But then the main trust will come from [12:08] attestation. So the PR merge is not the [12:10] trust but we in the current scheme, we [12:13] want a testers, auditors, security [12:15] researchers, or even individuals to [12:18] attest to descriptors to say that okay, [12:20] like this descriptor is [12:22] good enough to describe this contract. [12:24] Um and how you do it is the attesters [12:27] will [12:29] do a EIAS attestation and sign it and [12:33] publish it off chains and the [12:34] revocations will be on chain so that you [12:36] can always see revocations. [12:38] And the idea is that the wallets will [12:40] have a couple addresses that they trust. [12:43] For example, I have [12:44] the ledger address, the cipher address, [12:46] whatever I trust these attesters and I [12:49] will only show the descriptor if I if [12:51] this is attested by one of the [12:53] trusted ones. [12:55] What are the challenges? [12:56] The challenges are so like the main [12:58] thing is the hardware devices are quite [13:00] limited, so we can't do arbitrary stuff [13:02] on hardware devices. [13:04] Um the device communication is not also [13:06] standardized, so hardware devices all [13:08] use their own um wire format. [13:12] And in general, creating descriptors is [13:15] not so straightforward, so like [13:17] the question of is this a good [13:19] descriptor or is [13:21] not easy to answer. So we can have a [13:24] good enough the goal is to have good [13:26] enough descriptors because the [13:27] alternative is bytes, right? So having [13:30] something to describe it is better than [13:32] having no description at all. So that's [13:34] the that's for our advantage at least. [13:37] And of course, like reviewing at scale, [13:39] verifying at scale, these are all very [13:40] difficult things. Like this is not [13:41] definitely not a trivial problem. [13:44] Um and we have a lot of coordination [13:45] too. Like we can't just sit down and [13:48] find a solution by ourselves. This is [13:50] all about how we solve this as as the [13:52] ecosystem. And then we have the other [13:54] EVM [13:56] problems like um proxies and some [13:59] contracts are non-ABI encoded call data [14:01] and then internationalization and so on. [14:03] So we have a lot to do. [14:05] Um and in the future, we hope to have an [14:07] on-chain registry. So right now, it's a [14:08] GitHub registry, [14:10] but uh we want to move this on-chain and [14:12] to make this permissionless so that [14:14] anyone can host a registry and on the [14:16] registries, of course, you can attest. [14:18] And so, we will have a more [14:21] permissionless [14:22] system. [14:23] And I am also hoping to some have [14:25] something like a nutspec plus plus where [14:27] you can write descriptors as the [14:29] comments. So, an example is like this. [14:31] For example, when you're writing the [14:32] function, you would write [14:34] the intent, the field, and so on. And [14:36] this would automatically generate a [14:39] descriptor for you. So, this would be [14:40] part of the whole contract development [14:42] pipeline, hopefully. And then there's [14:44] already a [14:46] prototype for this. [14:47] Um, yeah. [14:49] And in general, this is to remind that [14:53] this is not the silver bullet, right? [14:54] The transaction safety is not This is [14:56] only part of the transaction safety. So, [14:58] you To be able to make sure your [15:00] transaction is safe, you need [15:03] you need like the simulations you have [15:05] to have. [15:06] Uh, there's also a transaction [15:07] assertions, which I'm quite excited of. [15:09] Um, so these are all other steps you [15:11] need to take. And to make this easier, [15:14] we are trying to build a new project [15:17] called Onai with Sourceify. [15:19] And yeah, we want to bring everything [15:21] together and have give you a transaction [15:24] companion [15:26] that is read only and that is local [15:27] first. [15:30] Okay, so what should you do? If you're a [15:32] wallet, please integrate it. [15:34] If you are an interim application, [15:35] please write your descriptor. If you're [15:37] a security company, please [15:40] start [15:41] approach us. We want [15:43] to attest. We want people to attest and [15:45] we want to understand if and how you can [15:48] do it. We want to help you do that. [15:50] And if you're a user, demand it from [15:51] your wallet. And hopefully in near [15:54] future, when we see [15:57] a hex transaction, we see bytes, we will [15:59] say no, I don't want this. Where is my [16:01] clear signed transaction? Thank you. [16:05] And also Sorry, we have a Telegram group [16:07] if you want to be involved, [16:10] find me, reach out to me, and we also [16:12] have [16:13] biweekly calls to move the spec forward. [16:15] Thank you.