DSS

DSS 2026 / Day 1 / Pearl Hall

The Signer's Blind Spot: What Safe Decoders Don't Show You

Uri Kirstein

15:11 · 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:00Hello everyone. My name is Uri. I work

0:03at Fortified, an institutional MPC

0:06wallet. And today we're going to talk

0:08about

0:09two different types of technologies for

0:12keeping your

0:13on-chain funds safe.

0:16One is going to be on-chain multisigs

0:18and the other are MPC wallets.

0:24So today we're going to explain what an

0:27on-chain multisig is, what is an MPC

0:29wallet, how can you combine the two

0:31together,

0:33and what are the remaining gaps, mostly

0:35on the wallet side.

0:39So I assume most of the audience already

0:41knows what safe is. Safe is a smart

0:45contract

0:46that holds your funds and requires an M

0:49out of N signatures in order to move the

0:52funds away.

0:53So as you can see here in the

0:54screenshot, whenever you set up your

0:56safe, you configure a set of signatures,

0:59which are the owners, and you set up a

1:01threshold, and at least that amount of

1:03signatures have to sign before

1:06any action is is executed on the safe.

1:09And it's very very popular, as you can

1:11see some metrics here on the screen.

1:16And why do people use on-chain

1:18multisigs? So the obvious one is that

1:21that way you don't rely on a single key

1:24taking the funds away, right? And you

1:26can distribute it between different

1:28parties.

1:30But also since it's on-chain, it's

1:32transparent, you can see what the keys

1:34are. You can see what is the threshold.

1:36You can see the entire transaction

1:38history.

1:39And that's a hard requirement for some

1:42users, such as DAOs, such as users that

1:45care about transparency and regulation.

1:49But the downside, so from a security

1:51perspective,

1:53the safe is only as secure as the

1:54weakest threshold amount of signatures.

1:58Also it has some operational

2:00complexities.

2:01It requires a lot of coordination

2:03between the parties by design, because

2:06we need all the different signatures,

2:08but it also makes it complex to rotate

2:11the keys, because every rotation when we

2:13want to add a key and remove a key, we

2:15we should regularly do, will each time

2:18require a new round of approval and

2:20coordination. And also since it's a

2:23smart contract, it needs to be deployed

2:25on chain, and if we deploy it on several

2:27different EVM chains, it will have a

2:29different address, and those safes could

2:32have different nonces,

2:34which is an operational

2:35complexity that we will need to manage.

2:41So from a bird's eye level view, how

2:44does it work usually on let's say the

2:47naive flow? You use the safe wallet UI

2:50to propose a transaction,

2:52pass it on to the signers. Each of them

2:55will independently review it, decide if

2:57it's safe or not.

2:59If enough of them sign, we reach the

3:00threshold, we send it to the safe for

3:02execution.

3:04But as we know, this naive setup is not

3:07safe enough. We know from the Bybit hack

3:10our

3:111.4 billion dollars were lost. This

3:14number was a lot more impressive a few

3:15days ago.

3:19So we need to explore ways to harden our

3:22security.

3:23And one such way to do that is an MPC

3:27wallet.

3:29The key idea for an MPC wallet, which

3:31stands for multi-party computation, is

3:34that you take a key, a private key,

3:37and split it into different shards.

3:40So none of the shards can sign for that

3:43key, and we need to somehow combine them

3:46together.

3:48But that's where the computation part

3:50comes in. We don't actually take all the

3:52shares and reconstruct the key anywhere,

3:55because that would be a single point of

3:56failure.

3:57Instead of that, we do some sort of an

3:59interactive computation where each

4:02share key shareholder is interacting and

4:05they are able to generate a signature

4:08together without any of them knowing

4:10about the shares of the others.

4:12And how that usually looks like in

4:14practice is that we usually split the

4:16key into two and require both shares to

4:19to construct and usually one share will

4:21be kept in a server or in a computer and

4:23the other will be kept in a mobile

4:25device.

4:27So

4:28the main reason to use that again if the

4:30mobile device is compromised it's still

4:33fine because there is another share at

4:34the computer and vice versa.

4:36So we're not

4:38we're not totally wrecked if a single

4:40device is lost.

4:43Also we can add to the MPC wallet

4:45another layer of organizational controls

4:48which are off-chain

4:51and we

4:52can enforce them

4:53and

4:55since it's just a key it will be the

4:56same key across all chains so we have a

4:58lower operation complexity compared to

5:01dealing with smart contracts.

5:04However the downside is that it's since

5:06it's not on chain it's not transparent

5:08and that's a no go for DAOs and other

5:10institutions and we also rely on our MPC

5:14provider.

5:15So for most MPC providers you are

5:19in self-custody of your funds meaning

5:21you have the backup and the servers

5:23don't have your share of the key. So

5:25it's not that the provider can steal

5:27your funds

5:28is that if the provider malfunctions

5:31you're not able to enjoy the MPC

5:32benefits anymore. So you rely on the

5:34provider for the security benefits.

5:41So we can use both and the way that will

5:43look like is that we'll use the same

5:46flow as before except that each signer

5:48now will use an MPC wallet.

5:51So again someone will propose the

5:53transaction and send it for all the

5:55owners to verify and sign except now

5:58each of those owners will have let's say

6:00one share of the key on the server, one

6:03share on their mobile device. So each of

6:05them will be

6:07uh harder to compromise. And then, as

6:09usual, we'll gather the signatures and

6:11send to the safe for execution.

6:19So what do we gain by joining and

6:21merging the two together? So we do not

6:23rely on a single key

6:25um to move funds away, and that's

6:27because of the multi of the uh multi sig

6:31on chain, right? We do not just rely on

6:33a single vendor, let's say MPC. If we

6:35use several different vendors, we can

6:37see prevent that. So each owner can use

6:39a different vendor.

6:41It's still transparent. It's still on

6:43chain. You can still see who are the

6:45keys that can sign for the safe and what

6:47is the transaction history.

6:49We do not rely on a single device.

6:51That's because of the MPC side. Uh we

6:53can add another layer of off-chain

6:55organizational controls on top of our

6:56smart contracts.

6:59Um however, uh there are still some

7:01downsides to this um to this approach.

7:04So we still have uh the operational

7:06complexity of smart contracts on chain,

7:09and whichever controls we add on top of

7:13the multi sig will not be on chain, will

7:15not be auditable.

7:19So there are a few capabilities that we

7:22expect all wallets, including MPC

7:24wallets, to support.

7:27One of them is risk detection. We

7:30expect our wallets to tell us if we're

7:32trying to do something uh potentially

7:35dangerous or misleading or let's say

7:37it's a phishing attack. Maybe we're

7:38trying to move funds to a known

7:40malicious address and so on. We want the

7:42wallet to tell us, hey, look more

7:44closely here.

7:47We also expect wallets to give us some

7:49sort of simulation where they're trying

7:51to predict what will be the outcome of

7:53that transaction,

7:55and we can compare that to what was our

7:57intent.

7:59And also we want to be able to label

8:02addresses and not compare addresses by

8:04two byte, give them uh human-readable

8:07friendly names

8:08and um well it's usually have some

8:11permission and access control so we can

8:13set different user levels, different

8:14visibilities, we can um

8:18white list certain recipients, allow

8:20only outflow of certain amounts or for

8:22certain periods of time

8:24and so on and so forth.

8:28And all of these rely to some extent

8:32on correct decoding of transactions.

8:37Unfortunately decoding safe transactions

8:39is not a straightforward

8:42way

8:43like we have with the usual ABI decoding

8:45for smart contracts.

8:49And the reason for that I'll go into a

8:51little more detail on the journey that a

8:54transaction has to go through in safe.

8:57So someone has to propose the

8:58transaction and send it to the signers

9:01except that the signers are not signing

9:03the transaction

9:05that the safe will execute. They are

9:08signing a permission for the safe to

9:11execute that transaction.

9:13And that permission is a hash.

9:17So it's not just decoding with an

9:20with an

9:21ABI.

9:23Then later

9:25all the signatures are collected and all

9:27that part happens off-chain, let's say

9:29at safe servers,

9:30then it's submitted to the chain to the

9:32safe smart contract. The safe then

9:35counts and sees that we have gathered

9:36enough signatures to clear the threshold

9:39and also make sure that all the permits

9:41actually agree with each other for the

9:44transaction that the safe should

9:46execute.

9:47So the signers don't see

9:51the execution at the end, they only see

9:52the hashes. So we as the wallet

9:55see the hashes and we need to decode it.

9:59And that's not the only problem. So we

10:01have different hash versions for

10:03different safe versions, different

10:05versions of the smart contract.

10:07Say a safe can send a batch and that's

10:09another uh level of complexity. They can

10:12use a a multi-send, which is a packed

10:14format and not ABI.

10:16And also we can have nested safes where

10:19one safe owns another safe or we can

10:22send to several different uh safes in a

10:24batch.

10:25So that all adds a lot of complexity.

10:30And the difference is pretty big. We can

10:32see here on the left how it looks like

10:34when it's not decoded and on the right

10:35when it is decoded.

10:37On the left here we see the recipient is

10:39uh a proxy token. We don't actually see

10:42that it's a transfer. Uh we don't know

10:45which funds are moving which token.

10:47On the right we do see when it's

10:49decoded. We do have some simulation

10:51results. We can see how many tokens are

10:53leaving the sender entering um the

10:56recipient. Uh we can see that uh they

10:59have actually human-readable labels. In

11:01this case they're both

11:02uh safe smart accounts.

11:05And that's not just for us for

11:08conveniency for us to look at it. It's

11:10also um this data is fed into the risk

11:13engine of the wallet and also into its

11:15policy engine. So it's actually critical

11:17to unlock most uh security features.

11:23So

11:25I think I skipped the slide. No.

11:29How does decoding work today?

11:31So you have an option to call Safe's API

11:34for decoding.

11:36And usually we have to use Safe's API

11:38anyway for all the off-chain operations

11:40I told you about in the last slide uh

11:42proposing a transaction, verifying,

11:44signing, and collecting signatures.

11:48The problem with that is that um we are

11:52using uh both the Safe's UI to propose

11:55the transaction

11:57and using Safe also to verify it. And we

12:00would prefer to use different vendors

12:02for this. We don't want to verify with

12:04the same service that also proposed the

12:06transaction.

12:08And uh unfortunately uh no wallet today

12:11does this.

12:12Uh most wallets don't uh decode uh safe

12:15transactions at all, and those that do

12:17use Safe's API.

12:22So one way to circumvent this is to use

12:25independent verification uh decoding,

12:28sorry. Uh

12:29you decode separately at the wallet

12:30level, not call the API.

12:32Another option is to propose safe

12:35transactions from the wallet and uh

12:37let's say initiate transfers or create

12:40safes, deploy them, uh add new owners to

12:43the safe, change the threshold.

12:45Um unfortunately something that uh the

12:47vast majority of wallets don't do today.

12:50Even the more basic action of just

12:53seeing the balances of your safe

12:55is usually not supported at all.

13:00So here I uh looked at uh three wallets

13:04that I found had the most advanced and

13:07robust safe support.

13:09All of them decode it but using Safe's

13:11API.

13:12Only Ambr also decodes inner calls.

13:15The other two don't.

13:17Um Rabbi and Ambr are browser wallets

13:21and Fortify is an MPC wallet, so not

13:23exactly one to one.

13:25Um in all of them you can see the safe

13:27balances but you cannot send transfer

13:30out of the safe in Fortify.

13:32Uh in Fortify you do have an integration

13:34in the policy engine, so you can reason

13:36about what the safe is trying to do.

13:38Uh in Ambr you have it uh linked into

13:41the risk engine

13:42and in Rabbi you don't.

13:46And in terms of initiating uh safe

13:48transactions from the wallet

13:50we only have Ambr that allows you to

13:52create an existing safe uh that exists

13:55on one chain on other chains

13:57and that's basically it.

14:02So to sum it up um there are two

14:04different types of technologies,

14:06multisig and MPC. You can use an MPC

14:09wallet as a signer

14:10for your safe and the reason to do that

14:12is is add another uh layer of uh

14:16security by not relying on a single

14:18device being compromised and you can add

14:21uh another layer of controls by adding

14:23another policy layer that is off-chain.

14:26If we do that, we do lose some

14:28transparency cuz that uh layer of

14:29off-chain uh policy will not be

14:32transparent and auditable.

14:35And if we want to use an MPC wallet as a

14:37signer um for an on-chain multisig, we

14:40need to make sure that it can uh decode.

14:43Preferably, it can do it independently,

14:45but none of the wallets still support it

14:46today.

14:47Uh we want to have visible balances.

14:50And we want to uh be able to initiate uh

14:53as many transactions from the wallet

14:56itself,

14:57uh which unfortunately today is a bit

14:58lacking.

14:59So uh one of the calls for this talk for

15:02all the wallet builders out there, uh

15:04please help us uh close this gap.

15:08Thank you.

Source and accuracy details

Source export SHA256: 222b522b4a67fc1e10f2526ced21169d4ed995e3b423b991cd07eb83d5690de4