# Safe Multisig Checker: Owners, Threshold and Modules

> Safe multisig checker: a Safe's owners, signing threshold, modules, guards, fallback handler and recent owner changes, read from its contract on each chain.

Markdown copy of https://voltfincrypto.com/apps/safe-multisig-checker

**Question:** Who signs for this Safe, how many signatures does it need and which modules can move funds without them?

- Kind: Table in Voltfin Strata
- Topic: [Wallets and whales](https://voltfincrypto.com/topics/wallets)
- Chains: Multi-chain, Ethereum, Base, Arbitrum, OP Mainnet, Gnosis
- Status: Planned. The data is not published yet, so this page states no figure; each figure will open its receipt when it is.

A Safe is a smart account that moves funds only when enough of its owners sign. This table reads a Safe's configuration straight from its contract on each chain: every owner, the number of signatures required, the modules that can execute transactions without those signatures, the guards that check transactions and the fallback handler.

Most of the risk in a multisig sits in that configuration. A low threshold, a recently added owner, an unfamiliar module or a changed guard can each give someone control without the signers a user expects. Each row shows when its setting was added and the transaction that added it, so recent changes stand out.

Enter a Safe address and filter by chain or role; sort by date added to see the latest changes first. The table describes the configuration; it does not certify a Safe as secure.

## Blueprint

One row: One row per owner, module, guard or fallback handler of the looked-up Safe, per chain, at the latest block

- **Safe** (`safe`): The Safe's address, linked to its receipt on the row's chain.
- **Chain** (`chain`): The chain whose contract this row describes; each chain's Safe is configured on its own.
- **Role** (`role`): Owner, module, transaction guard, module guard or fallback handler.
- **Address** (`address`): The owner's address or the contract's address.
- **Label** (`label`): Who the address belongs to where a public source supports it, with that source.
- **Threshold** (`threshold`): Signatures required out of the number of owners, such as three of five, repeated on each row of the Safe.
- **Acts without signatures** (`acts_alone`): Yes for modules, which can execute through the Safe on their own; for owners, yes only when the threshold is one.
- **Added** (`added`): The day the owner, module or contract was set, from the Safe's events.
- **Added in** (`added_tx`): The transaction that added or last changed this setting.
- **Last activity** (`last_activity`): For an owner, the last executed transaction it signed; for a module, its last execution through the Safe.
- **Safe version** (`version`): The Safe contract version, since features such as module guards differ between versions.
- **Receipt** (`receipt`): The block, hash and calls behind the row.

## How it will be measured

- Owners, threshold and nonce are read with getOwners(), getThreshold() and nonce() at the latest block on each chain where the Safe is deployed.
- Modules come from getModulesPaginated(); the transaction guard, the module guard and the fallback handler are read from the storage slots the Safe contracts define for them.
- The date and transaction that set each owner, module or guard come from the Safe's SafeSetup, AddedOwner, ChangedThreshold, EnabledModule and ChangedGuard events.
- Last activity comes from ExecutionSuccess and ExecutionFromModuleSuccess events, with owners' signatures recovered from the execTransaction calls they signed.
- The Safe's version is read with VERSION(); owner and module labels come from public sources recorded with each label.

## Data it needs

- `treasury_balances_daily` (to build): Balances of DAO, protocol and multisig treasuries per asset at day end, and their inflows and outflows.
- `address_labels` (to build): Labels for known addresses: exchanges, bridges, protocols, funds, treasuries, sanctioned addresses and known attackers.
- Source: getOwners(), getThreshold(), nonce() and VERSION() via eth_call at the latest block on each covered chain
- Source: getModulesPaginated() and the guard, module guard and fallback handler storage slots
- Source: SafeSetup, AddedOwner, RemovedOwner, ChangedThreshold, EnabledModule, DisabledModule and ChangedGuard events
- Source: ExecutionSuccess and ExecutionFromModuleSuccess events, and the signatures in execTransaction calldata

## Questions

### How do I see who owns a Safe multisig?

Enter its address. The table reads getOwners() from the Safe's contract on each chain and lists every owner, with a label where a public source supports one and the transaction that added each owner.

### What is a Safe threshold?

The number of owner signatures needed to execute a transaction. A Safe with five owners and a threshold of three needs any three of them to sign; a threshold of one lets every owner act alone.

### What are Safe modules and why do they matter?

Modules are contracts a Safe has enabled to execute transactions through it without collecting owner signatures, for example for recurring payments or recovery. A module can act with the full power of the Safe, so an unknown or recently added module deserves close attention.

### What is a Safe guard?

A guard is a contract that checks every transaction before and after it runs and can block the ones that break its rules. A guard can protect a Safe, but a faulty or malicious guard can also lock its owners out.

### Is a Safe the same as a Gnosis Safe?

Yes. Safe was called Gnosis Safe until it became a project of its own; existing Safes kept their addresses and contracts. The checker reads Safes of every version on the covered chains.

### Can a Safe have different owners on different chains?

Yes. A Safe deployed at the same address on two chains is two separate contracts, each with its own owners, threshold and modules; the two can drift apart. The table shows each chain's configuration on its own rows.

## Glossary

- **Threshold**: The number of owner signatures a Safe needs before it will execute a transaction.
- **Module**: A contract enabled on a Safe that can execute transactions through it without owner signatures.
- **Guard**: A contract that checks a Safe's transactions before and after execution and can reject them.
- **Fallback handler**: A contract that answers calls the Safe itself does not implement, such as signature checks requested by other contracts.

## Related apps

- [DeFi Admin Keys: Multisig Thresholds and Timelocks](https://voltfincrypto.com/apps/defi-admin-keys-multisig-timelocks)
- [DAO Treasuries Ranked by On-Chain Holdings](https://voltfincrypto.com/apps/dao-treasuries-ranking)
- [Smart Contract Upgrade Tracker: Proxy and Owner Changes](https://voltfincrypto.com/apps/smart-contract-upgrade-tracker)
- [Wallet Balance Checker: Every EVM Chain in One View](https://voltfincrypto.com/apps/wallet-balance-checker)
- [Crypto Address Checker: Flagged, Sanctioned or Hacked](https://voltfincrypto.com/apps/crypto-address-checker)
- [ETH Rich List: Top Ethereum Addresses by Balance](https://voltfincrypto.com/apps/eth-rich-list)

Build it in Voltfin Studio: https://app.voltfincrypto.com/signup?next=%2F