# Multisig, explained: tutorial

What a Bittensor multisig is, how M-of-N works, and how to create a wallet, run public and private transactions, and cancel one, with video walkthroughs.

_Source: https://taostats.io/docs/concepts/security/multisig-tutorial_

_Last reviewed: 2026-10-30_

A normal wallet has one key. Whoever holds that key controls everything, and if it leaks, everything is gone, irreversibly. A **multisig** ("multi-signature") account fixes that by requiring several keys to agree before anything moves. This tutorial covers why you would use one, how it works, and how to create, run and cancel multisig transactions in [Taostats Actions](https://taostats.io/docs/understanding-taostats/taostats-actions/multisig).

## Why you'd use one

A single key is a single point of failure in both directions:

- **If it's stolen.** A compromised laptop, a phished seed phrase or one bad dependency, and an attacker drains the account. There is no undo, no support line and no chargeback.
- **If it's lost.** Lose the one key (a dead drive, a forgotten phrase) and the funds are frozen forever. Same finality, opposite cause.

A multisig removes that single point of failure. Funds live at an address controlled by a **group** of keys, and a transaction only goes through once enough of them approve. That gives you:

- **Theft protection.** A thief with one key can *propose* a transfer but cannot execute it. The other signers see the pending request and never co-sign.
- **Loss protection.** Lose a key and you have lost nothing: the remaining signers can still move the funds to a fresh account.
- **Shared control.** A team treasury where no one person can move money alone. Every payment needs a second (or third) pair of eyes.

> [!TIP]
> **The everyday version**
>
> A bank vault that needs two managers to turn their own keys at the same time. Neither can open it alone, and if one manager loses their key, the others can still get in. Nobody holds "the vault key", because there isn't one. That's a multisig.

## How they work: M-of-N

A multisig is described by two numbers, written **M-of-N**:

- **N** is the total number of member keys (the signatories).
- **M** is the threshold: how many of them must approve before anything happens.

A **2-of-3** multisig has three member keys and needs any two of them to sign. A **3-of-5** has five members and needs any three.

### The address is derived, not created

There is no key that unlocks a multisig. Its address is calculated from the member set plus the threshold: the same keys and the same M always give the same address, on any machine. Nobody holds "the multisig key"; there are only the members' own keys, working together.

> [!WARNING]
> **Change the members or threshold, get a new account**
>
> Because the address *is* the member set plus the threshold, changing either one changes the address. Add a signer, remove a signer, or change 2-of-3 to 3-of-3, and you get a completely different account. To swap a signer, create a new multisig and move the funds across.

### Picking your numbers is a trade-off

Raising the threshold M makes the account harder to attack but easier to lock yourself out of. The gap between N and M is your safety net: how many keys you can lose and still transact.

| Setup | Thief needs | Keys you can lose | Good for |
|---|---|---|---|
| **2-of-3** | 2 | 1 | The classic. One rogue or one lost key, no problem. |
| **2-of-4** | 2 | 2 | Keys spread across places or people; survives two losses. |
| **3-of-5** | 3 | 2 | The strongest balanced choice for a larger team treasury. |

> [!WARNING]
> **Never run N-of-N**
>
> A setup like 3-of-3 has no safety net. Lose a single key and the funds are frozen forever, because the threshold can never be reached again. Always keep at least one spare (N − M ≥ 1).

### Create a multisig wallet

In Taostats Actions, **Import or Create New Multisig Wallet** takes the signatories and the threshold and derives the address. Because the address comes from those two things, importing an existing multisig and creating a new one are the same step. Nothing goes on chain until the multisig has its first transaction.

[Taostats Actions: Create a Multisig Wallet](https://www.youtube.com/watch?v=ashPOq_HObw)

## Public or private transactions

When someone starts a multisig transaction, they choose how much of it is visible on chain *while it waits* for the other signatures. This is the one real choice you make each time, a trade-off between transparency and privacy.

- **Public** (`as_multi`): the full transaction goes on chain immediately. Anyone can read exactly what is proposed. Co-signers look it up and approve, and nothing needs to be sent around.
- **Private** (`approve_as_multi`): only a **hash** of the transaction goes on chain. The chain shows that a transaction with this fingerprint is pending, but not *what* it does, until it executes.

### What the hash is

A hash is a short, unique fingerprint of the transaction. You can compute the fingerprint from the transaction, but you cannot work backwards from the fingerprint to the transaction. In the private flow the chain only sees the fingerprint, so the transaction itself (its call data) has to reach the other signers separately: a copy-paste, a link or a shared file.

> [!WARNING]
> **The golden rule of the private flow**
>
> When a co-signer receives the call data, their tool recomputes its hash and checks that it **matches the one already on chain**. Match: safe to sign. Mismatch: someone changed it, so refuse. That check is what makes it safe to pass the transaction around off chain. Never skip it.

### One subtlety about "private"

Private hides the details of a transaction only if those details can't be guessed. Anyone can compute a hash from a transaction, so an observer who can **guess what you're doing** can hash their guess and compare it with the pending one. If you always do the same thing (say, 50 TAO to the same wallet every Thursday), the private version isn't hidden: a watcher tries the obvious call and sees it match. The hash is doing its job; the leak is that the transaction is predictable.

Two fixes for predictable transactions:

1. Add a random **remark** to the transaction. It changes the hash every time, so nobody can guess it. In Taostats Actions this is the **Make unguessable** option.
2. Use the [MEV shield](https://taostats.io/docs/concepts/chain-runtime/mev-shield) when the transaction executes, so it can't be front-run at that moment.

The remark protects the waiting period; the shield protects the execution.

| | Public (`as_multi`) | Private (`approve_as_multi`) |
|---|---|---|
| On chain while pending | The **whole** transaction | Only its **hash** |
| Co-signers get the details from | The chain (automatic) | You, sent separately |
| Visible to the public before it runs | Yes | No |
| Extra step for signers | None | Paste in the call data to check the hash |
| Best when | Simplest and most transparent: the default | You don't want the pending action public early |

**Either way, it becomes public in the end.** When the approval that reaches the threshold is submitted, the transaction executes on chain and everyone can see it. That final approval must carry the full call data, because it is what runs the call. "Private" only means hidden while waiting for signatures.

### Public transaction walkthrough

[Taostats Actions: Create and Complete a Public Multisig Transaction](https://www.youtube.com/watch?v=RNr4SpebTdw)

### Private transaction walkthrough

[Taostats Actions: Create and Complete a Private Multisig Transaction](https://www.youtube.com/watch?v=lGqfgXrl960)

## Cancel a pending transaction

A pending multisig transaction can be cancelled at any point before it executes, with `cancel_as_multi`. Only the signatory who started it (the first approval, which reserved the deposit) can cancel it. The cancel names the multisig (threshold and the other signatories), the timepoint of that first approval, and the call hash. On success the pending transaction is removed, its deposit is returned to the signer who started it, and the chain emits `MultisigCancelled`.

Cancelling needs only the hash, not the call data. That makes it the way out of a private transaction whose call data has been lost: it can never be executed, but it can be cancelled. In Taostats Actions, **View or Cancel Multisig Transactions** lists your pending transactions and cancels one.

[Taostats Actions: Cancel a Multisig Transaction](https://www.youtube.com/watch?v=EMqM6_2Dt-4)

## Summary

1. A multisig is an account controlled by a **group of keys**, needing **M of N** to approve any action.
2. It protects you from both **theft** (one key can't act alone) and **loss** (one lost key doesn't lock you out).
3. Its address is **derived from the members and the threshold**: change either and it's a new account.
4. Each transaction is **public** (the whole transaction on chain) or **private** (only its hash on chain, call data passed around separately).
5. Before signing, always confirm the transaction's **hash matches the chain**.
6. The signer who started a pending transaction can **cancel** it before it executes and gets the deposit back.

## Related

- [Multisig: worked examples](https://taostats.io/docs/concepts/security/multisig-examples) — Real multisig operations decoded from the chain, showing what public and private look like on chain.
- [Securing a wallet: ledgers, multisig & proxies](https://taostats.io/docs/concepts/security/securing-a-wallet) — How multisig fits alongside hardware wallets and proxy accounts.
- [Extrinsics: multisig](https://taostats.io/docs/understanding-taostats/extrinsics/multisig-extrinsics) — The underlying extrinsics and their arguments.
- [Actions: multisig](https://taostats.io/docs/understanding-taostats/taostats-actions/multisig) — Create, approve and cancel multisig transactions in your browser.