← back to blog

Using A Multisig Safe To Hold Farm Proceeds Instead Of Hot Wallets

Workers and a vault

Most farms blur two very different jobs into the same wallets. One job is doing things: connecting to dapps, bridging, swapping, signing quests, claiming. The other job is holding things: keeping the value that farming produced somewhere it won’t disappear because of one bad click.

The first job needs speed and tolerates risk. The second needs the opposite. When the same hot wallet does both, the risk profile of the whole farm becomes the risk profile of its most careless session. A wallet that signed a sketchy approval on Tuesday is also, on Wednesday, the place where a claimed allocation is sitting.

The argument of this piece is that the two jobs should be split on purpose. Farming wallets are workers. They hold enough to do their job and nothing more. They’re expected to touch dubious contracts sometimes, and if one is compromised, the loss is capped by what it held. Proceeds, once they’ve been claimed and are worth protecting, move out of the workers and into a vault. For many operators, the right vault is a multi-signature wallet, where moving funds requires approval from more than one key, and those keys live on separate devices.

A multisig won’t make you rich or safe. It’s a structure that removes single points of failure from the part of the operation that matters most. It has real costs, mostly in speed and complexity, and there are ways to set one up badly that are worse than not having one.

This piece covers how multisig vaults work at a practical level, how to choose a threshold, what happens when a signer is lost or compromised, the deployment traps people fall into, and when a multisig is overkill. It doesn’t compare hardware wallet brands, which is covered separately. It assumes you already understand why a hardware wallet protects keys.

What a multisig actually is

A normal wallet, sometimes called an externally owned account, is controlled by one private key. Whoever holds the key controls the funds. There’s no second opinion.

A multisig on EVM chains is a smart contract account. It holds funds itself and has a list of owners, each of which is an ordinary address with its own key. It also has a threshold: the number of owners who must approve a transaction before the contract will execute it. A two-of-three multisig has three owners and needs any two of them to agree.

When you want to move funds out, one owner proposes a transaction. The others review it and add their approvals, which are signatures. Once enough signatures are collected to meet the threshold, someone submits the transaction to the chain, and the contract checks the signatures and executes it.

The most widely used implementation on EVM chains is Safe, formerly known as Gnosis Safe, which provides the contracts, a web interface and a service that collects signatures off-chain until they’re ready to execute. Other ecosystems have their own equivalents. Solana, for example, has multisig programs that work on the same principle with different mechanics.

The important property is that no single key can move the funds. If one owner’s key is stolen, the thief still needs another owner to agree. If one owner’s device breaks, the remaining owners can still operate the vault, as long as there are enough of them to meet the threshold.

That’s the whole benefit. It changes the question from “is this one key safe?” to “is it likely that enough keys fail at once?”, which is a much easier question to answer well.

Why proceeds belong somewhere else

Consider what a typical farming wallet goes through over a campaign. It connects to several dapps, some new and lightly tested. It signs approvals to contracts you’ve read a little about. It visits claim pages during launches when drainer sites are everywhere. It may run inside a browser profile with other extensions. It may be controlled by a seed that also backs a dozen other wallets.

None of that is reckless. It’s the job. But it means every farming wallet has a meaningful chance, over a long enough period, of being exposed through one of those routes. The sensible response is to assume that some workers will eventually be compromised and to design so that when it happens, the damage is small.

Holding claimed proceeds in the workers does the opposite. It concentrates value exactly where exposure is highest. A worker that just received a large claim is also a worker whose stale approvals, if any are malicious, now have something big to drain.

Moving proceeds out changes the picture. The workers keep only what they need for gas and activity. The vault receives value and does almost nothing else. It doesn’t connect to new dapps, doesn’t sign quests and doesn’t visit claim pages. Its signers are only used for vault transactions.

This doesn’t require a multisig. A single hardware wallet used only as a vault already captures much of the benefit. The multisig adds protection against the failure of that one device or the theft of that one seed, which becomes more important as the amount held grows.

The structure matters more than the tool. Workers and vault, with value flowing one way unless you deliberately move it back.

Choosing a threshold

The threshold is the most important decision, and it’s a trade-off between protection against theft and protection against loss.

Theft protection improves as the threshold rises. With two-of-three, an attacker needs two keys. With three-of-five, three keys.

Loss protection depends on the gap between the number of owners and the threshold. With two-of-three, you can lose one key and still operate. With three-of-five, you can lose two. With two-of-two, you can lose none: if either key is gone, the vault is locked forever.

That last point catches people. A two-of-two feels secure, and it is against theft, but it has two single points of failure instead of one. Losing either key is permanent. For almost everyone, that’s worse than a single hardware wallet.

For a solo operator, two-of-three is the common starting point. Three keys, any two can sign. You keep two for regular use and store the third somewhere separate as a backup, so that if one of your regular keys is lost, you use the backup to replace it.

For small teams or partnerships, where more than one person should agree before funds move, three-of-five or two-of-three with keys held by different people are common. The design question becomes who holds which key and what happens if a person becomes unavailable.

Higher thresholds add friction to every transaction. Three-of-five means collecting three signatures every time, which is fine for a vault that moves funds rarely and painful for one used weekly.

Pick the threshold for the vault’s actual job. If it moves funds a few times a year, a higher threshold costs little. If you need to move proceeds often, you might keep a smaller operating multisig and a larger, stricter one behind it.

Where the signer keys live

A multisig with all its keys in one place is a single wallet with extra steps. The point is separation.

Separate devices are the minimum. Each signer key should live on a different hardware wallet. Keys on software wallets in the same computer offer much less, since one compromise of that computer reaches all of them.

Mixing hardware wallet vendors adds another layer. If a vulnerability affects one vendor’s devices, keys on a different vendor’s devices aren’t exposed to it. This is a common recommendation, with the cost of learning two interfaces.

Separate seeds are essential. Each signer should come from its own seed phrase, generated on its own device. Deriving several signers from one seed defeats the entire design, because anyone who gets that seed has all of them.

Separate locations protect against physical events. If all three devices and all three seed backups sit in one drawer, a fire or burglary takes them together. A common pattern is to keep the two regular signers at your main location, in different spots, and keep the backup signer and its seed somewhere else entirely.

Separate from the farm matters too. None of the signer keys should ever be used as farming wallets. They shouldn’t connect to dapps, receive airdrops or appear in any farming activity. Their only on-chain role is owning the vault.

Write down which device is which signer, and where each seed backup is. Keep that record safe, but not so safe that you can’t find it. A vault nobody can reconstruct when a device fails is simply lost.

What happens when you lose a signer

This is where multisigs earn their keep, and it’s worth walking through before it happens.

Say you have a two-of-three vault and one hardware wallet breaks, or is lost, and its seed backup can’t be found either. You still have two working signers, which meets the threshold. The vault is fine. But you’ve lost your margin: one more loss would lock it.

The fix is an owner change. Using the two remaining signers, you propose and approve a transaction that removes the lost signer from the owner list and adds a new one, generated on a new device with a new seed. After that transaction executes, you’re back to two-of-three with a full margin. The vault’s address doesn’t change, and the funds never move.

This is one of the big advantages over a single wallet. With a single hardware wallet, a lost device and a lost seed means the funds are gone. With a multisig, it means an owner change.

If a signer is stolen rather than lost, the same procedure applies, with more urgency. The thief has one key and needs another to act. Remove the stolen key from the owners as quickly as possible using the remaining signers.

The case to avoid is falling below the threshold. If a two-of-three vault loses two signers, the contract will never accept a transaction again. There’s no recovery process, no support desk and no override. That’s the flip side of the security: the contract doesn’t care who you are.

So test this. Before putting real value in a vault, practise an owner change with a small balance. Knowing the process works, and that you can do it, is worth the gas.

The speed you give up

The biggest practical cost of a multisig is time. Every transaction needs several approvals, often on several devices, sometimes from several people.

For a solo operator with two-of-three, a transaction means connecting the first hardware wallet, proposing, disconnecting, connecting the second, reviewing and signing, then executing. That’s a few minutes if everything is at hand. If the second device is in another room or another building, it’s longer.

For teams, the wait is for people. A transaction proposed in the morning might not be signed until the evening, depending on when the other owners are available.

This is fine for a vault’s job. Proceeds arrive, get moved in, and sit. When you need to withdraw, you plan it. The slowness is part of the protection, because it gives you time to notice a strange proposal before it executes.

It’s a bad fit for anything time-sensitive. You won’t want to farm from a multisig, chase a claim window, react to a depeg or rebalance a position quickly. For those, the workers are the right tool, and the vault should fund them in planned batches rather than on demand.

A useful pattern is to keep an operating float in a single hardware wallet, enough to cover a few weeks of worker funding, and top it up from the vault occasionally. The float gives you speed. The vault holds everything else.

Costs matter too. Multisig transactions use more gas than simple transfers, because the contract checks several signatures. On an expensive chain, that adds up. Deploying the vault itself also costs gas, once per chain.

Deploying on the right chains

This is the trap that has caught very experienced people, so it deserves its own section.

A multisig is a contract, which means it only exists on a chain where it’s been deployed. Many multisig implementations derive the contract’s address from its setup parameters, so the same setup can produce the same address on several chains. That’s convenient. It also creates a danger.

If you share your vault’s address and someone sends funds to it on a chain where it hasn’t been deployed yet, the funds sit at an address with no contract. Depending on how the address was derived, you may be able to recover them by deploying the same vault with the same setup on that chain. Or someone else may be able to deploy something different at that address first, if the deployment method allows it. A well-known trading firm once lost a large token allocation this way, when tokens were sent to its multisig address on a chain where the contract didn’t exist yet and a third party managed to deploy there first.

The lesson is simple. Deploy the vault on every chain where it will receive funds, before anything is sent to it there. When you give the address to anyone, including an exchange or yourself for a withdrawal, confirm the chain and confirm the vault is live on it.

Some interfaces show a vault’s address the same way across networks, which makes this easy to forget. Check that the vault shows as deployed on the specific chain you’re about to receive on.

A related caution: exchanges may not credit or allow withdrawals to contract accounts on every network, or may handle them differently. Test with a small amount before relying on a route.

Signing what you actually see

Multisigs protect against one key being stolen. They don’t protect against every signer approving the wrong transaction.

This became painfully clear in early 2025, when one of the largest exchange thefts on record involved the signers of a multisig approving a transaction whose displayed details had been tampered with. The signers saw what looked like a routine transaction in the interface. What they signed was something else. The multisig worked exactly as designed: enough owners approved, so it executed.

The multisig did its job. The takeaway is that the interface is a point of trust, and when every signer uses the same interface on similar machines, a single compromise of that interface can fool them all.

A few habits reduce this risk. Verify on the hardware wallet screen. When a hardware wallet signs a multisig transaction, it shows a hash or structured details of what it’s signing. Compare those with what you expect. Some tools let you independently compute the expected hash of a multisig transaction from its parameters, so you can check that the device and the tool agree.

Use more than one interface or machine among signers. If one signer reviews in the official web interface and another verifies with an independent tool on a separate machine, a single compromised interface is less likely to fool both.

Be wary of unusual transaction types. A plain transfer is easy to understand. A transaction that calls another contract, especially using a delegate call that lets external code act as the vault, deserves much more scrutiny. Most vault transactions should be simple transfers and owner changes.

Moving proceeds from many workers into one vault has a consequence worth stating plainly: the vault becomes a common destination, and common destinations are one of the signals clustering reviews look at.

This is a separate topic, covered in more depth in the piece on consolidating after a claim. The short version is that many wallets sending claimed tokens into one address forms a fan-in shape that analysts and later distribution designers can read. A multisig is still one address receiving from many, so that shape stays the same.

This site’s editorial line is that operators should understand those signals defensively, not look for ways around a project’s rules. So the honest guidance is to make the vault decision with that in mind. If your wallets represent genuinely separate activity, think about whether one vault for everything is the right structure, or whether separate vaults fit your situation better. If they don’t, consolidation will make that visible, and no vault design changes it.

What the vault does change is custody. Proceeds sit behind several keys instead of one. That’s a security benefit independent of any clustering question.

Also worth noting: the vault’s owner addresses are visible on-chain. Anyone can see which addresses own a multisig. If those owner addresses have history of their own, that history becomes linked to the vault. Using fresh signer addresses that exist only to own the vault keeps that simple.

When a multisig is overkill

Not every farm needs one. A multisig adds setup work, gas costs, slower transactions and more things to keep track of. Whether that’s worth it depends on how much you’re protecting and what your realistic failure modes are.

If proceeds are small, a single hardware wallet used only as a vault is usually enough. It separates holding from doing, which is most of the benefit, with far less friction.

If you’re not confident you can manage several devices and seed backups reliably, a multisig may increase your risk of loss. A vault is only as recoverable as its weakest backup plan. People lose seeds. People forget which device is which. Two-of-three helps with one loss, but it can’t help if your record keeping was poor to begin with.

If you mostly hold assets on chains where multisig tooling is immature, the practical benefits may be smaller, and the risk of mistakes higher.

Where a multisig clearly helps is when the amount held is large enough that losing it would be serious, when you want protection against one device being stolen or failing, or when more than one person should agree before funds move. Many operators move to a multisig when their vault crosses whatever threshold makes a single-device failure feel unacceptable, rather than at a fixed amount.

One claim, from worker to vault

A worked example makes the flow concrete. The numbers are illustrative, not from any real campaign.

An operator runs a set of worker wallets and a two-of-three vault. Each worker holds a small gas balance and whatever it needs for the activity it’s doing. The vault holds everything the farm has produced so far. There’s also an operating float in a single hardware wallet, used to fund workers.

A distribution goes live. Several workers are eligible. The operator claims from each worker during the claim window, using the lean signing profile and the official claim page reached from the project’s own site. The claimed tokens now sit in the workers.

This is the most exposed moment. The workers hold more than they usually do, and claim windows are when drainer sites and fake support agents are busiest. So the operator doesn’t leave the tokens there longer than needed. They also don’t rush straight into a single batch of identical transfers, since both timing and destination patterns carry information, as covered elsewhere.

When the operator moves proceeds, the destination is the vault’s address on that specific chain, confirmed as deployed. They pick it from the wallet’s address book, not from history. Each worker’s transfer is signed with that worker’s key alone, because moving funds into a multisig needs no approval from its owners.

Later, the operator wants to sell a portion or fund the float. That’s a vault transaction. They propose it with signer one, verify the details on the device screen, then sign with signer two on a separate machine using an independent check of the transaction hash. It executes. The float is topped up, and the workers are funded from the float over the following weeks.

At no point did a vault key touch a dapp, a claim page or a farming session. The workers did the risky work. The vault did the holding.

Planning for someone else to find it

A vault that only you can operate has a failure mode nobody likes to think about: you. Illness, accident or simply being unreachable for a long period can leave funds stranded, however well the keys are protected.

Multisigs can make this easier to plan than a single wallet. With two-of-three, you might keep two signers and give the third, sealed, to a trusted person or a secure storage arrangement, along with instructions. That person can’t move funds alone, because one key isn’t enough. But if you’re unavailable and they have access to one of your signers through your documented arrangements, two keys together can operate the vault.

The details depend heavily on your situation, and there’s no universal pattern. What matters is that some plan exists and has been written down. A runbook that explains what the vault is, which chains it’s deployed on, where each device and seed backup is, and how to sign a transaction is the minimum. Without it, even someone with all the keys may not know what they’re looking at.

Keep the plan honest about what each person holds. Nobody should hold enough keys to act alone unless that’s the intent. And revisit the arrangement when your setup changes, because a plan that points to a device you retired last year is worse than useless.

This isn’t legal or tax advice, and anyone holding significant value should get proper advice for their own jurisdiction. The on-chain part is simple by comparison. The hard part is making sure the humans involved know what to do.

A setup you could do this week

If you’ve decided a multisig fits, here’s a sensible order of operations.

Get the devices. Three hardware wallets for a two-of-three, ideally from at least two vendors, bought from the manufacturers or authorised sellers.

Generate a fresh seed on each device. Write each backup on durable material. Label them so you know which seed belongs to which device, without writing anything that would help a thief.

Create the vault with the three device addresses as owners and a threshold of two. Deploy it on the chains where it will receive funds, before sharing its address.

Practise. Send a small amount in. Propose a transfer out and sign it with two devices. Then practise an owner change: remove one signer and add it back, or swap it for a fourth test device. Confirm you understand each step.

Store the backup signer and its seed away from the other two.

Write a short runbook: what the vault is, where each device and seed is, how to sign, how to change owners. Keep it where someone you trust could find it if they needed to.

Only then move real proceeds in, and set a routine for moving claimed value from workers to the vault on a schedule you choose.

What people get wrong about vaults

A few misconceptions come up repeatedly.

“More signers is always safer.” More signers help against theft only if they’re truly independent. Five signers on five devices in one drawer, or derived from one seed, are one signer with extra steps.

“A multisig protects against scams.” It protects against a single key being compromised. If all signers approve a malicious transaction, it executes. It doesn’t read transactions for you.

“I can recover a vault through support.” There’s no support desk that can override a contract. If you fall below the threshold, it’s over.

“The vault address is the same everywhere, so it works everywhere.” It only works where it’s deployed.

“Keeping all proceeds in the vault means I’m safe.” The vault is only one part. Your workers, exchange accounts and signing machines still need their own care.

Where this advice stops working

I want to be clear about the limits. A multisig vault reduces the risk of losing funds to a single stolen key or a single failed device. It does nothing about the market value of what you hold, the risk of the tokens themselves, or smart contract risk in protocols your funds are deposited in. It’s custody, and only custody.

It also relies on the multisig contracts themselves being sound. Widely used implementations have long track records, but “long track record” is evidence, not proof.

And it relies on you. The structure only works if signers stay separate, backups stay findable and you actually read what you sign. Most multisig losses in practice have come from the people and interfaces around the contract, not the contract itself.

I haven’t run a formal comparison of vault setups, and I won’t pretend to numbers about how often each configuration fails. The mechanics make the trade-offs clear enough: the vault is slower on purpose, harder to steal from and harder to lose, provided you set it up and test it properly.

For more on wallet structure, custody and the tools we actually use to protect what a farm produces, head back to the Airdrop Farming homepage.

Get new guides and videos first — join the Telegram channel.

need infra for this today?