MPC wallets or multisig: which should secure your Web3 treasury? This guide compares both architectures on key compromise, onchain auditability, gas costs, and cross-chain use, using the Bybit ($1.5B) and Drift Protocol ($285M) hacks as case studies, plus when a hybrid setup makes sense for DAOs and protocol teams.

MPC wallets or multisig: which should secure your Web3 treasury? This guide compares both architectures on key compromise, onchain auditability, gas costs, and cross-chain use, using the Bybit ($1.5B) and Drift Protocol ($285M) hacks as case studies, plus when a hybrid setup makes sense for DAOs and protocol teams.
Before a DAO or a founding team ever writes a treasury policy, sets signer thresholds, or rotates keys, one decision sits upstream of all of it: what the treasury's funds actually sit behind. Web3 treasury security options split into two architectures, MPC wallets and multisig smart contracts, and picking between them shapes every control you can and cannot add later. This post compares both through two 2026 hack post-mortems, not vendor marketing, so you can see where each architecture's stated advantage held up and where it didn't.
A web3 treasury is a pool of onchain assets, usually native tokens, stablecoins, or LP positions, controlled by something other than a single externally owned account, or EOA, private key. Holding treasury funds behind one key is a single point of failure that most teams rule out by the time they raise a seed round or launch a token.
That leaves two dominant architectures. Multi-Party Computation, or MPC, wallets split a single private key into cryptographic shares distributed across separate parties or devices, then sign transactions offchain by combining threshold shares without ever reconstructing the full key. Multisig wallets, by contrast, use multiple independent private keys and a smart contract that only executes a transaction once a set number of those keys have signed onchain, as Safe explains in its own comparison of the two models.
Both solve the same underlying problem, no single compromised credential should be able to move funds, but they solve it in different layers: MPC pushes the trust boundary into offchain infrastructure, while multisig pushes it into an onchain smart contract that anyone can inspect. That difference drives everything else in this comparison, including where each architecture has actually failed in production.
The mechanical difference is simple to state and easy to underestimate: MPC never lets a complete private key exist in one place, while multisig lets complete keys exist but requires several of them to agree before a contract will move funds.
In an MPC setup, a key is generated using a distributed protocol so that no single party, device, or server ever holds the full private key, only a share of it. To sign a transaction, a threshold number of shares run a cryptographic computation together and produce a valid signature, without ever combining the shares into a reconstructable key at any point in the process.
Because the signing happens offchain, the resulting transaction looks identical to one signed by a normal single-key wallet. It settles onchain as a standard signature with no visible fingerprint of the threshold scheme underneath it. QuillAudits' earlier explainer on Multi-Party Computation introduces MPC as a cryptographic primitive and flagged this exact MPC-versus-multisig comparison as a follow-up topic rather than covering it there.
A multisig wallet is a smart contract, not a cryptographic protocol. It holds a list of authorized signer addresses and a threshold, commonly written as M-of-N, such as 3-of-5. When someone proposes a transaction, the contract logs each signature as signers approve it, and only executes the transfer once the threshold is met.
Every signer, every approval, and every executed transaction lives on a public ledger. Anyone can query the contract and see exactly who signed what and when, which is the property Safe highlights in its own comparison of the two models: "Multisig externalizes trust into verifiable code. MPC internalizes trust into systems and infrastructure that cannot be fully verified on-chain."
The core tradeoff is this: MPC removes the single point of key compromise but asks you to trust infrastructure you can't fully audit onchain, while multisig gives you a fully verifiable approval trail but depends on every signer and every attached module staying honest and uncompromised. Two 2026 incidents show exactly where each promise broke down.
Because no complete key ever exists, an attacker who compromises one device, one employee's laptop, or one server doesn't get a usable key share. Safe frames this directly in its comparison of the two models: "A single key compromise cannot authorize a transaction. An attacker must compromise multiple independent signers." That statement describes the signer-redundancy logic both MPC and well-run multisig share, but MPC gets there without ever materializing a single key an attacker could seize.
The tradeoff is that an attacker doesn't need the key at all if they can manipulate what signers see before they sign, or compromise the infrastructure coordinating the threshold computation. That's an infrastructure-trust problem, and it doesn't show up as a line item on a smart contract explorer the way a multisig approval does.
Multisig's real strength is that its approval logic is public. A treasury using a 4-of-7 Safe, for instance, lets any contributor, auditor, or community member verify the signer set and the threshold without trusting a vendor's internal controls.
That auditability has a blind spot most treasuries don't check: modules. Safe allows a signer set to attach modules that extend wallet functionality, and QuillAudits' research into Safe module risk found that those modules can sidestep the approval flow entirely. "Once a module is enabled, it can execute transactions directly from your Safe. No signatures. No threshold. No approval flow," as QuillAudits put it in its breakdown of Safe modules and guards risk. A perfectly configured signer threshold tells you nothing about what a malicious or compromised module attached to that same Safe can do.
Two incidents, one on each side of the MPC/multisig line, show where the theoretical advantage of each architecture met a real attacker.
Bybit, February 21, 2025 ($1.5 billion). Attackers compromised infrastructure tied to the Safe{Wallet} front end and injected malicious code. Signers saw what looked like a legitimate transaction in their interface, while the underlying contract logic the transaction actually executed redirected funds to the attacker, as Check Point Research documented in its forensic writeup. The multisig contract itself worked exactly as designed, the threshold was met, the signatures were valid, but the thing signers were approving wasn't the thing they thought they were approving. Onchain auditability after the fact couldn't have stopped a front-end compromise that happened before the signature.
Drift Protocol, April 1, 2026 ($285 million). This exploit targeted the human side of a Solana multisig rather than its code. Halborn's incident analysis traces weeks of social-engineering effort against two of the five signers on Drift's Security Council multisig, beginning March 11, 2026, before the attackers used Solana's durable-nonce feature to pre-sign governance transactions that bypassed normal signature expiry windows. Critically, the Security Council had reduced its threshold to 2-of-5 and removed timelock protections just days before the attack, a change Halborn's analysis says "made the attack easier by requiring fewer approvals and making malicious transactions instantly irreversible" once approved. Once the attackers had their pre-signed transactions, they drained the treasury across 31 rapid withdrawals in roughly 12 minutes.
Neither incident was a cryptographic break. Bybit was a trust-the-interface failure inside a multisig flow; Drift was a governance and threshold-discipline failure inside a multisig flow. Both point to the same lesson for any treasury, MPC or multisig: the architecture only enforces the guarantees you actually configure and keep configured.
Architecture also drives day-to-day operating cost, not just incident risk. Because multisig enforces its threshold through onchain contract logic, every signature verification happens as a transaction the network has to process and charge gas for. Blockdaemon's analysis of Ethereum gas costs estimates that a simple single-approver Ethereum withdrawal costs around 21,000 gas, while the combined deposit and withdrawal flow through a Gnosis Safe multisig can run close to 200,000 gas, nearly 10 times more, because signature verification happens onchain rather than offchain. MPC transactions settle as a standard single-signature transaction, so they carry no added gas premium for the threshold scheme itself, per the same analysis.
Run that gap forward for an operating treasury rather than a single withdrawal. A DAO disbursing payroll and vendor payments weekly through a Safe multisig pays that roughly 10x gas premium on every single disbursement, fifty-two times a year, purely for onchain signature verification the MPC equivalent doesn't incur. None of that spend buys additional security against the failure modes in the case studies above; it buys auditability on a transaction type, routine payroll, that rarely needs a public approval trail in the first place. That's the calculation worth running before defaulting every wallet in a treasury's stack to the same architecture.
That cost gap compounds for teams operating across multiple chains. A multisig deployment is a separate smart contract per chain, meaning separate signer configuration, separate gas budgeting, and separate audit surface on every network a treasury touches. MPC key shares aren't tied to a specific chain's contract standard, so the same threshold signing setup can authorize transactions on EVM chains, Solana, or other ecosystems without redeploying contract logic each time. For a DAO or protocol treasury holding assets on three or four chains, that difference shows up directly in both gas spend and operational overhead per chain.
| Dimension | MPC Wallets | Multisig Wallets |
|---|---|---|
| Key structure | Single key split into cryptographic shares; never fully reconstructed | Multiple independent full keys |
| Approval enforcement | Offchain threshold computation | Onchain smart contract logic |
| Onchain auditability | Low; signing happens off-chain and settles as a normal signature | High; signer set and approvals are publicly verifiable |
| Attack surface | Signing infrastructure, device/server compromise, UI manipulation before signing | Signer social engineering, front-end spoofing, attached modules/guards |
| Per-chain deployment | Reusable across chains without redeploying contract logic | Separate contract deployment and configuration per chain |
| Relative transaction cost | Standard single-signature gas cost, no added premium | Can run close to 10x a single-signer transaction (roughly 21,000 gas vs ~200,000 gas combined) |
| 2026 failure mode observed | Not the architecture tested in either case study below | Front-end spoofing (Bybit) and signer social engineering plus threshold reduction (Drift) |
Treating this as a binary choice misses how most sizable treasuries actually operate in 2026. A hybrid setup, MPC for day-to-day operational wallets and multisig for the treasury's core reserve, lets each architecture do the job it's actually good at.
Operational wallets that handle frequent, smaller transactions, such as payroll, vendor payments, and cross-chain bridging, benefit from MPC's lower per-transaction cost and chain flexibility, since those wallets move funds often enough that a 10x gas multiplier adds up fast. The core treasury reserve, the pool that moves rarely but matters most when it does, benefits from multisig's public, contract-enforced approval trail, which lets a DAO's community or an external auditor verify governance decisions without trusting any single vendor's internal controls.
Institutional money is already treating custody architecture as serious infrastructure rather than a startup's internal choice. CoinDesk reported that digital asset custodian BitGo debuted on the NYSE on January 22, 2026 at a valuation of roughly $2 billion. Custodians operating at that scale typically offer both MPC and multisig products precisely because serious treasuries don't pick one and discard the other.
A hybrid setup only works if the boundary between the two wallets is itself governed: clear rules for how much sits in the operational MPC wallet at any time, and a documented, auditable process for topping it up from the multisig reserve.
Neither architecture is safe by default, and neither failure in this post happened because the underlying cryptography broke. Bybit's contract executed exactly what it was told to sign; Drift's multisig executed exactly what two socially engineered signers authorized. The question to ask isn't "which is more secure" in the abstract, it's which failure mode your team is better equipped to prevent and detect.
If your treasury moves funds frequently across chains and your main risk is operational cost and complexity, MPC's chain-agnostic signing and flat transaction cost are the stronger fit, provided you trust and can vet whichever infrastructure provider coordinates your key shares. If your treasury's main asset is community trust and verifiable governance, multisig's public approval trail is hard to replace, but only if you treat signer vetting, module review, and threshold changes with the same rigor you'd apply to a smart contract upgrade. Drift's attackers didn't break multisig; they found a Security Council that had just weakened its own threshold and removed its timelock days before the attack.
Whichever architecture you land on, the operational habits around it matter more than the label. QuillAudits has published a working checklist of multisig security habits that actually matter for teams running Safe-based treasuries, and a free Multisig Inspector tool that checks an existing Safe's signer threshold, modules, and guards. Teams earlier in the process, still deciding what else belongs on a treasury's security checklist beyond custody architecture, can start from QuillAudits' broader web3 security checklist and research library at quillaudits.com/research.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.