DSS 2026 — The Signer's Blind Spot: What Safe Decoders Don't Show You Uri Kirstein Source video: https://www.youtube.com/watch?v=XjOfDypuL2c Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: 222b522b4a67fc1e10f2526ced21169d4ed995e3b423b991cd07eb83d5690de4 [0:00] Hello everyone. My name is Uri. I work [0:03] at Fortified, an institutional MPC [0:06] wallet. And today we're going to talk [0:08] about [0:09] two different types of technologies for [0:12] keeping your [0:13] on-chain funds safe. [0:16] One is going to be on-chain multisigs [0:18] and the other are MPC wallets. [0:24] So today we're going to explain what an [0:27] on-chain multisig is, what is an MPC [0:29] wallet, how can you combine the two [0:31] together, [0:33] and what are the remaining gaps, mostly [0:35] on the wallet side. [0:39] So I assume most of the audience already [0:41] knows what safe is. Safe is a smart [0:45] contract [0:46] that holds your funds and requires an M [0:49] out of N signatures in order to move the [0:52] funds away. [0:53] So as you can see here in the [0:54] screenshot, whenever you set up your [0:56] safe, you configure a set of signatures, [0:59] which are the owners, and you set up a [1:01] threshold, and at least that amount of [1:03] signatures have to sign before [1:06] any action is is executed on the safe. [1:09] And it's very very popular, as you can [1:11] see some metrics here on the screen. [1:16] And why do people use on-chain [1:18] multisigs? So the obvious one is that [1:21] that way you don't rely on a single key [1:24] taking the funds away, right? And you [1:26] can distribute it between different [1:28] parties. [1:30] But also since it's on-chain, it's [1:32] transparent, you can see what the keys [1:34] are. You can see what is the threshold. [1:36] You can see the entire transaction [1:38] history. [1:39] And that's a hard requirement for some [1:42] users, such as DAOs, such as users that [1:45] care about transparency and regulation. [1:49] But the downside, so from a security [1:51] perspective, [1:53] the safe is only as secure as the [1:54] weakest threshold amount of signatures. [1:58] Also it has some operational [2:00] complexities. [2:01] It requires a lot of coordination [2:03] between the parties by design, because [2:06] we need all the different signatures, [2:08] but it also makes it complex to rotate [2:11] the keys, because every rotation when we [2:13] want to add a key and remove a key, we [2:15] we should regularly do, will each time [2:18] require a new round of approval and [2:20] coordination. And also since it's a [2:23] smart contract, it needs to be deployed [2:25] on chain, and if we deploy it on several [2:27] different EVM chains, it will have a [2:29] different address, and those safes could [2:32] have different nonces, [2:34] which is an operational [2:35] complexity that we will need to manage. [2:41] So from a bird's eye level view, how [2:44] does it work usually on let's say the [2:47] naive flow? You use the safe wallet UI [2:50] to propose a transaction, [2:52] pass it on to the signers. Each of them [2:55] will independently review it, decide if [2:57] it's safe or not. [2:59] If enough of them sign, we reach the [3:00] threshold, we send it to the safe for [3:02] execution. [3:04] But as we know, this naive setup is not [3:07] safe enough. We know from the Bybit hack [3:10] our [3:11] 1.4 billion dollars were lost. This [3:14] number was a lot more impressive a few [3:15] days ago. [3:19] So we need to explore ways to harden our [3:22] security. [3:23] And one such way to do that is an MPC [3:27] wallet. [3:29] The key idea for an MPC wallet, which [3:31] stands for multi-party computation, is [3:34] that you take a key, a private key, [3:37] and split it into different shards. [3:40] So none of the shards can sign for that [3:43] key, and we need to somehow combine them [3:46] together. [3:48] But that's where the computation part [3:50] comes in. We don't actually take all the [3:52] shares and reconstruct the key anywhere, [3:55] because that would be a single point of [3:56] failure. [3:57] Instead of that, we do some sort of an [3:59] interactive computation where each [4:02] share key shareholder is interacting and [4:05] they are able to generate a signature [4:08] together without any of them knowing [4:10] about the shares of the others. [4:12] And how that usually looks like in [4:14] practice is that we usually split the [4:16] key into two and require both shares to [4:19] to construct and usually one share will [4:21] be kept in a server or in a computer and [4:23] the other will be kept in a mobile [4:25] device. [4:27] So [4:28] the main reason to use that again if the [4:30] mobile device is compromised it's still [4:33] fine because there is another share at [4:34] the computer and vice versa. [4:36] So we're not [4:38] we're not totally wrecked if a single [4:40] device is lost. [4:43] Also we can add to the MPC wallet [4:45] another layer of organizational controls [4:48] which are off-chain [4:51] and we [4:52] can enforce them [4:53] and [4:55] since it's just a key it will be the [4:56] same key across all chains so we have a [4:58] lower operation complexity compared to [5:01] dealing with smart contracts. [5:04] However the downside is that it's since [5:06] it's not on chain it's not transparent [5:08] and that's a no go for DAOs and other [5:10] institutions and we also rely on our MPC [5:14] provider. [5:15] So for most MPC providers you are [5:19] in self-custody of your funds meaning [5:21] you have the backup and the servers [5:23] don't have your share of the key. So [5:25] it's not that the provider can steal [5:27] your funds [5:28] is that if the provider malfunctions [5:31] you're not able to enjoy the MPC [5:32] benefits anymore. So you rely on the [5:34] provider for the security benefits. [5:41] So we can use both and the way that will [5:43] look like is that we'll use the same [5:46] flow as before except that each signer [5:48] now will use an MPC wallet. [5:51] So again someone will propose the [5:53] transaction and send it for all the [5:55] owners to verify and sign except now [5:58] each of those owners will have let's say [6:00] one share of the key on the server, one [6:03] share on their mobile device. So each of [6:05] them will be [6:07] uh harder to compromise. And then, as [6:09] usual, we'll gather the signatures and [6:11] send to the safe for execution. [6:19] So what do we gain by joining and [6:21] merging the two together? So we do not [6:23] rely on a single key [6:25] um to move funds away, and that's [6:27] because of the multi of the uh multi sig [6:31] on chain, right? We do not just rely on [6:33] a single vendor, let's say MPC. If we [6:35] use several different vendors, we can [6:37] see prevent that. So each owner can use [6:39] a different vendor. [6:41] It's still transparent. It's still on [6:43] chain. You can still see who are the [6:45] keys that can sign for the safe and what [6:47] is the transaction history. [6:49] We do not rely on a single device. [6:51] That's because of the MPC side. Uh we [6:53] can add another layer of off-chain [6:55] organizational controls on top of our [6:56] smart contracts. [6:59] Um however, uh there are still some [7:01] downsides to this um to this approach. [7:04] So we still have uh the operational [7:06] complexity of smart contracts on chain, [7:09] and whichever controls we add on top of [7:13] the multi sig will not be on chain, will [7:15] not be auditable. [7:19] So there are a few capabilities that we [7:22] expect all wallets, including MPC [7:24] wallets, to support. [7:27] One of them is risk detection. We [7:30] expect our wallets to tell us if we're [7:32] trying to do something uh potentially [7:35] dangerous or misleading or let's say [7:37] it's a phishing attack. Maybe we're [7:38] trying to move funds to a known [7:40] malicious address and so on. We want the [7:42] wallet to tell us, hey, look more [7:44] closely here. [7:47] We also expect wallets to give us some [7:49] sort of simulation where they're trying [7:51] to predict what will be the outcome of [7:53] that transaction, [7:55] and we can compare that to what was our [7:57] intent. [7:59] And also we want to be able to label [8:02] addresses and not compare addresses by [8:04] two byte, give them uh human-readable [8:07] friendly names [8:08] and um well it's usually have some [8:11] permission and access control so we can [8:13] set different user levels, different [8:14] visibilities, we can um [8:18] white list certain recipients, allow [8:20] only outflow of certain amounts or for [8:22] certain periods of time [8:24] and so on and so forth. [8:28] And all of these rely to some extent [8:32] on correct decoding of transactions. [8:37] Unfortunately decoding safe transactions [8:39] is not a straightforward [8:42] way [8:43] like we have with the usual ABI decoding [8:45] for smart contracts. [8:49] And the reason for that I'll go into a [8:51] little more detail on the journey that a [8:54] transaction has to go through in safe. [8:57] So someone has to propose the [8:58] transaction and send it to the signers [9:01] except that the signers are not signing [9:03] the transaction [9:05] that the safe will execute. They are [9:08] signing a permission for the safe to [9:11] execute that transaction. [9:13] And that permission is a hash. [9:17] So it's not just decoding with an [9:20] with an [9:21] ABI. [9:23] Then later [9:25] all the signatures are collected and all [9:27] that part happens off-chain, let's say [9:29] at safe servers, [9:30] then it's submitted to the chain to the [9:32] safe smart contract. The safe then [9:35] counts and sees that we have gathered [9:36] enough signatures to clear the threshold [9:39] and also make sure that all the permits [9:41] actually agree with each other for the [9:44] transaction that the safe should [9:46] execute. [9:47] So the signers don't see [9:51] the execution at the end, they only see [9:52] the hashes. So we as the wallet [9:55] see the hashes and we need to decode it. [9:59] And that's not the only problem. So we [10:01] have different hash versions for [10:03] different safe versions, different [10:05] versions of the smart contract. [10:07] Say a safe can send a batch and that's [10:09] another uh level of complexity. They can [10:12] use a a multi-send, which is a packed [10:14] format and not ABI. [10:16] And also we can have nested safes where [10:19] one safe owns another safe or we can [10:22] send to several different uh safes in a [10:24] batch. [10:25] So that all adds a lot of complexity. [10:30] And the difference is pretty big. We can [10:32] see here on the left how it looks like [10:34] when it's not decoded and on the right [10:35] when it is decoded. [10:37] On the left here we see the recipient is [10:39] uh a proxy token. We don't actually see [10:42] that it's a transfer. Uh we don't know [10:45] which funds are moving which token. [10:47] On the right we do see when it's [10:49] decoded. We do have some simulation [10:51] results. We can see how many tokens are [10:53] leaving the sender entering um the [10:56] recipient. Uh we can see that uh they [10:59] have actually human-readable labels. In [11:01] this case they're both [11:02] uh safe smart accounts. [11:05] And that's not just for us for [11:08] conveniency for us to look at it. It's [11:10] also um this data is fed into the risk [11:13] engine of the wallet and also into its [11:15] policy engine. So it's actually critical [11:17] to unlock most uh security features. [11:23] So [11:25] I think I skipped the slide. No. [11:29] How does decoding work today? [11:31] So you have an option to call Safe's API [11:34] for decoding. [11:36] And usually we have to use Safe's API [11:38] anyway for all the off-chain operations [11:40] I told you about in the last slide uh [11:42] proposing a transaction, verifying, [11:44] signing, and collecting signatures. [11:48] The problem with that is that um we are [11:52] using uh both the Safe's UI to propose [11:55] the transaction [11:57] and using Safe also to verify it. And we [12:00] would prefer to use different vendors [12:02] for this. We don't want to verify with [12:04] the same service that also proposed the [12:06] transaction. [12:08] And uh unfortunately uh no wallet today [12:11] does this. [12:12] Uh most wallets don't uh decode uh safe [12:15] transactions at all, and those that do [12:17] use Safe's API. [12:22] So one way to circumvent this is to use [12:25] independent verification uh decoding, [12:28] sorry. Uh [12:29] you decode separately at the wallet [12:30] level, not call the API. [12:32] Another option is to propose safe [12:35] transactions from the wallet and uh [12:37] let's say initiate transfers or create [12:40] safes, deploy them, uh add new owners to [12:43] the safe, change the threshold. [12:45] Um unfortunately something that uh the [12:47] vast majority of wallets don't do today. [12:50] Even the more basic action of just [12:53] seeing the balances of your safe [12:55] is usually not supported at all. [13:00] So here I uh looked at uh three wallets [13:04] that I found had the most advanced and [13:07] robust safe support. [13:09] All of them decode it but using Safe's [13:11] API. [13:12] Only Ambr also decodes inner calls. [13:15] The other two don't. [13:17] Um Rabbi and Ambr are browser wallets [13:21] and Fortify is an MPC wallet, so not [13:23] exactly one to one. [13:25] Um in all of them you can see the safe [13:27] balances but you cannot send transfer [13:30] out of the safe in Fortify. [13:32] Uh in Fortify you do have an integration [13:34] in the policy engine, so you can reason [13:36] about what the safe is trying to do. [13:38] Uh in Ambr you have it uh linked into [13:41] the risk engine [13:42] and in Rabbi you don't. [13:46] And in terms of initiating uh safe [13:48] transactions from the wallet [13:50] we only have Ambr that allows you to [13:52] create an existing safe uh that exists [13:55] on one chain on other chains [13:57] and that's basically it. [14:02] So to sum it up um there are two [14:04] different types of technologies, [14:06] multisig and MPC. You can use an MPC [14:09] wallet as a signer [14:10] for your safe and the reason to do that [14:12] is is add another uh layer of uh [14:16] security by not relying on a single [14:18] device being compromised and you can add [14:21] uh another layer of controls by adding [14:23] another policy layer that is off-chain. [14:26] If we do that, we do lose some [14:28] transparency cuz that uh layer of [14:29] off-chain uh policy will not be [14:32] transparent and auditable. [14:35] And if we want to use an MPC wallet as a [14:37] signer um for an on-chain multisig, we [14:40] need to make sure that it can uh decode. [14:43] Preferably, it can do it independently, [14:45] but none of the wallets still support it [14:46] today. [14:47] Uh we want to have visible balances. [14:50] And we want to uh be able to initiate uh [14:53] as many transactions from the wallet [14:56] itself, [14:57] uh which unfortunately today is a bit [14:58] lacking. [14:59] So uh one of the calls for this talk for [15:02] all the wallet builders out there, uh [15:04] please help us uh close this gap. [15:08] Thank you.