Introducing Multisig Inspector for Safe Wallets

A multisig is only as secure as its current state. Once a Safe is deployed, its owners, permissions, and pending transactions can all change, or be misread, without anyone noticing until it matters. Multisig Inspector exists to remove that uncertainty.

What We Built

Multisig Inspector is a free, read-only tool for Safe wallets, built around two functions. The first reads a Safe's current configuration directly from chain: its owners, signature threshold, active modules, guards, and the contract implementation it runs. The second reads a pending transaction, decodes what it actually does, and independently computes its hash so it can be checked against what a hardware wallet displays.

Both functions are read-only by design. The tool never requests a wallet connection, never asks for a signature, and stores nothing outside the local session. Its purpose is narrow and specific: to confirm, before an approval is made, that a Safe's configuration and a transaction's contents match what the signer actually expects.

Why Now

Most large multisig losses over the past two years did not originate from a flaw in Safe's contracts. They originated from an approval that didn't reflect what the signer actually intended.

In February 2025, Bybit signers approved a transaction that appeared to be a routine transfer. It was in fact a delegatecall that changed the Safe's underlying implementation, and $1.5B moved as a result. The Safe's contracts functioned exactly as written. What was missing was any indication to the signers of what the transaction actually contained.

The same category of failure has repeated since. In 2026, a minting multisig operating on a 1-of-3 threshold allowed a single compromised key to mint $10M in stablecoins, a configuration that had gone unreviewed since it was set up. Separately, an airdrop distribution was redirected to an address sharing the same opening characters as the intended recipient, moving $5.66M before the difference was noticed.

In each case, a multisig was in place. What was absent was an independent way to confirm, at the moment of signing, that the Safe's configuration and the transaction's contents matched what the team believed them to be.

Safe Inspector

Safe Inspector answers one question directly: what does this Safe actually look like right now. A Safe's security isn't just its threshold. It's the full set of owners who can approve, the number of signatures actually required, the contract code it's running, and any modules or guards attached to it. All of this can change after deployment, and none of it is visible unless something reads it directly.

Paste in a Safe address and Safe Inspector reads back the current owners directly from chain, before anything else is generated.

Confirming the owner list opens the full result: threshold, nonce, version, singleton, fallback handler, guard, modules, and a security score based on all of it together.

This Safe has 7 owners and a 4-of-7 threshold, and scores 78 out of 100 with one high-severity finding: an enabled module that doesn't match anything in the known Safe registry. The scan doesn't conclude the module is malicious, only that it can't be verified against known deployments, which is enough to warrant a manual check before treating it as routine.

That's the level of detail Safe Inspector surfaces from a single address, in seconds. What each field and finding means in more depth, and how the score itself is calculated, is a longer discussion, worth its own piece rather than an introduction.

Transaction Inspector

Transaction Inspector asks a different question than Safe Inspector. Instead of the Safe's overall configuration, it looks at one specific pending transaction and answers what it actually does, and whether the hash a signer is being asked to approve genuinely matches it.

Point it at a Safe address and it lists what's currently queued: local drafts, transactions awaiting signatures, and anything ready to execute.

Loading this Safe surfaces one transaction awaiting signatures, at nonce 10, with 1 of 2 required confirmations collected so far.

Opening it returns the full pre-signing review.

It decodes the transaction so you see what it actually calls: the target contract, the call type, and any value moved, instead of raw hex. It recomputes the hash independently and checks it against what was provided, so you're not just trusting the number your hardware wallet shows. It tells you your own role in the approval, including when your signature is the one that executes the transaction. It also runs a balance simulation and checks the destination against known threat intelligence, adding two more layers of confidence before you sign.

Even a transaction that looks routine can decode into something worth a second look, like a zero-value call that turns out to be a permanent action rather than a simple transfer. That's exactly the kind of detail Transaction Inspector is built to surface rather than leave buried in calldata.

Built to Be Trusted by Default

The tool's design follows from what it's meant to do. A verification layer that requires a wallet connection or a signature introduces the exact kind of trust dependency it exists to remove. For that reason, Multisig Inspector never connects to a wallet, never requests a signature, and stores no data outside the local session.

This also means the tool can be run against a Safe you don't control, since nothing is written on-chain and nothing beyond a public address is required.

Try It

Enter a Safe address to see its current configuration. Before approving a pending transaction, run it through Transaction Inspector first.

Both tools are live at Multisig Inspector.

Multisig Inspector is open source. The code, the detection logic, and the roadmap are public, and contributions are welcome, whether that's a bug report, a new check, or support for an additional chain. Find the repository on GitHub.