DSS 2026 / Day 1 / Pearl Hall
The Signer's Blind Spot: What Safe Decoders Don't Show You
Uri Kirstein
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
- 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: 222b522b4a67fc1e10f2526ced21169d4ed995e3b423b991cd07eb83d5690de4