Imagine a bank vault that requires multiple keys to open, ensuring no single person can access it alone. That’s the idea behind multi-signature wallets in blockchain. These wallets enhance security by requiring multiple approvals for transactions, making them ideal for teams, businesses, or shared funds. In this beginner-friendly tutorial, we’ll build a multi-signature wallet on Ethereum using Solidity and Ethers.js. Let’s get started!
What Is a Multi-Signature Wallet?
A multi-signature (multisig) wallet is a blockchain wallet that requires multiple private keys to authorize a transaction. For example, a 2-of-3 multisig wallet needs two out of three designated signers to approve a transaction. This adds security and trust, especially for:
- Team Funds: DAOs or companies managing shared crypto assets.
- Escrow Services: Ensuring funds are only released with mutual agreement.
- Personal Security: Protecting your crypto from theft or loss.
Our goal is to create a multisig wallet where a majority of owners must approve transactions before they execute.
Why Use Multi-Signature Wallets?
Multisig wallets offer several advantages:
- Enhanced Security: Multiple approvals reduce the risk of hacks or insider theft.
- Decentralized Control: No single point of failure, ideal for group governance.
- Flexibility: Configurable thresholds (e.g., 3-of-5 signatures) suit various use cases.
For developers, building a multisig wallet is a great way to learn about smart contracts and blockchain security.
Tools You’ll Need
To build our multisig wallet, gather these tools:
- Node.js: For running JavaScript. Download from nodejs.org.
- Hardhat: For smart contract development. Install via
npm install --save-dev hardhat. - Ethers.js: For interacting with Ethereum. Install via
npm install ethers. - MetaMask: For wallet integration. Install from metamask.io.
- Code Editor: Visual Studio Code or any editor you prefer.
With these, you’re ready to create a secure multisig wallet.
Step-by-Step: Building a Multi-Signature Wallet
We’ll create a Solidity smart contract for a multisig wallet, deploy it to the Sepolia testnet, and build a React front-end to interact with it. Follow these steps to bring it to life!
Step 1: Set Up the Hardhat Project
Create a new directory and initialize a Hardhat project:
mkdir multisig-wallet
cd multisig-wallet
npx hardhat
npm install @openzeppelin/contracts
Choose the JavaScript project option and install OpenZeppelin for secure contract utilities.
Step 2: Write the Multisig Wallet Contract
Create a file named contracts/MultiSigWallet.sol with the following code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MultiSigWallet {
address[] public owners;
uint public required;
struct Transaction {
address to;
uint value;
bytes data;
bool executed;
uint approvalCount;
}
mapping(uint => mapping(address => bool)) public approvals;
Transaction[] public transactions;
event TransactionSubmitted(uint indexed txId, address indexed to, uint value, bytes data);
event TransactionApproved(uint indexed txId, address indexed owner);
event TransactionExecuted(uint indexed txId);
modifier onlyOwner() {
bool isOwner = false;
for (uint i = 0; i < owners.length; i++) {
if (owners[i] == msg.sender) {
isOwner = true;
break;
}
}
require(isOwner, "Not an owner");
_;
}
constructor(address[] memory _owners, uint _required) {
require(_owners.length > 0, "Owners required");
require(_required > 0 && _required <= _owners.length, "Invalid required approvals");
owners = _owners;
required = _required;
}
function submitTransaction(address _to, uint _value, bytes memory _data) external onlyOwner {
uint txId = transactions.length;
transactions.push(Transaction({
to: _to,
value: _value,
data: _data,
executed: false,
approvalCount: 0
}));
emit TransactionSubmitted(txId, _to, _value, _data);
}
function approveTransaction(uint _txId) external onlyOwner {
Transaction storage tx = transactions[_txId];
require(!tx.executed, "Transaction already executed");
require(!approvals[_txId][msg.sender], "Already approved");
approvals[_txId][msg.sender] = true;
tx.approvalCount++;
emit TransactionApproved(_txId, msg.sender);
if (tx.approvalCount >= required) {
executeTransaction(_txId);
}
}
function executeTransaction(uint _txId) internal {
Transaction storage tx = transactions[_txId];
require(!tx.executed, "Transaction already executed");
require(tx.approvalCount >= required, "Not enough approvals");
tx.executed = true;
(bool success, ) = tx.to.call{value: tx.value}(tx.data);
require(success, "Transaction failed");
emit TransactionExecuted(_txId);
}
receive() external payable {}
}
This contract:
- Stores a list of owners and required approvals.
- Allows owners to submit transactions (e.g., sending ETH).
- Tracks approvals and executes transactions when the required threshold is met.
Step 3: Deploy the Contract
Create a deployment script in scripts/deploy.js:
const hre = require("hardhat");
async function main() {
const owners = ["0xOwner1Address", "0xOwner2Address", "0xOwner3Address"]; // Replace with real addresses
const required = 2;
const MultiSigWallet = await hre.ethers.getContractFactory("MultiSigWallet");
const wallet = await MultiSigWallet.deploy(owners, required);
await wallet.deployed();
console.log("MultiSigWallet deployed to:", wallet.address);
}
main().catch((error) => {
console.error(error);
process.exitCode = 1);
});
Update hardhat.config.js with Sepolia network details (use an API key from Infura or Alchemy):
require("@nomicfoundation/hardhat-toolbox");
module.exports = {
solidity: "0.8.0",
networks: {
sepolia: {
url: "https://sepolia.infura.io/v3/YOUR_API_KEY",
accounts: ["YOUR_PRIVATE_KEY"]
}
}
};
Deploy with npx hardhat run scripts/deploy.js --network sepolia. Note the contract address.
Step 4: Build a React Front-End
Create a React app to interact with the multisig wallet:
npx create-react-app multisig-dapp
cd multisig-dapp
npm install ethers
Replace src/App.js with:
import { useState } from 'react';
import { ethers } from 'ethers';
import './App.css';
const walletAddress = 'YOUR_MULTISIG_CONTRACT_ADDRESS';
const walletABI = [/* YOUR_CONTRACT_ABI */]; // From Hardhat artifacts
function App() {
const [account, setAccount] = useState(null);
const [to, setTo] = useState('');
const [value, setValue] = useState('');
const [txId, setTxId] = useState('');
const connectWallet = async () => {
if (window.ethereum) {
const provider = new ethers.BrowserProvider(window.ethereum);
const accounts = await provider.send('eth_requestAccounts', []);
setAccount(accounts[0]);
} else {
alert('Install MetaMask!');
}
};
const submitTransaction = async () => {
if (!account || !to || !value) return;
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const contract = new ethers.Contract(walletAddress, walletABI, signer);
await contract.submitTransaction(to, ethers.parseEther(value), "0x");
alert('Transaction submitted!');
};
const approveTransaction = async () => {
if (!account || !txId) return;
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const contract = new ethers.Contract(walletAddress, walletABI, signer);
await contract.approveTransaction(txId);
alert('Transaction approved!');
};
return (
Multi-Signature Wallet DApp
{!account ? (
Connect Wallet
) : (
Connected: {account}Submit Transaction setTo(e.target.value)}
/>
setValue(e.target.value)}
/>
Submit TransactionApprove Transaction setTxId(e.target.value)}
/>
Approve Transaction
)}
);
}
export default App;
Add styling in src/App.css:
.App {
text-align: center;
padding: 50px;
font-family: Arial, sans-serif;
}
input {
padding: 10px;
margin: 10px;
width: 200px;
}
button {
padding: 10px 20px;
margin: 10px;
cursor: pointer;
background-color: #0288d1;
color: white;
border: none;
border-radius: 5px;
}
button:hover {
background-color: #0277bd;
}
Run with npm start. Connect MetaMask to Sepolia, submit a transaction, and approve it with another owner’s account. Get test ETH from sepoliafaucet.com.
Step 5: Test the Wallet
Test the wallet with multiple MetaMask accounts:
- Fund the wallet by sending test ETH to its address.
- Submit a transaction (e.g., send 0.1 ETH to another address).
- Approve the transaction with the required number of owners.
- Verify the transaction executes automatically once approvals are met.
Use Hardhat’s console or Alchemy to monitor events.
Benefits of Multi-Signature Wallets
Multisig wallets offer key advantages:
- Robust Security: Multiple signatures protect against theft or loss.
- Team Collaboration: Enables shared control for DAOs or businesses.
- Trustless Escrow: Facilitates secure agreements without intermediaries.
These benefits make multisig wallets a must-have for secure blockchain applications.
Challenges of Multi-Signature Wallets
Despite their strengths, multisig wallets have limitations:
- Complexity: Managing multiple keys can be cumbersome for users.
- Gas Costs: Each approval requires a transaction, increasing fees.
- Key Loss Risk: If owners lose keys, funds may become inaccessible.
Mitigate these by using user-friendly interfaces and secure key storage solutions.
Tips for Developers Building Multisig Wallets
To create robust multisig wallets:
- Audit Contracts: Use MythX or Slither to check for vulnerabilities.
- Optimize Gas: Minimize storage operations in your contract to reduce costs.
- Enhance UX: Build intuitive front-ends to simplify transaction approvals.
- Test Thoroughly: Simulate attacks on testnets using Hardhat.
These practices ensure your wallet is secure and user-friendly.
Resources for Learning More
Deepen your multisig wallet knowledge with these resources:
- Ethereum Docs: Smart contract security at ethereum.org.
- Gnosis Safe: A popular multisig wallet at gnosis-safe.io.
- Blockchain Communities: Join discussions on Ethereum Stack Exchange or DAO forums.
Stay curious to master blockchain security.
Conclusion
Multi-signature wallets are a powerful tool for securing blockchain transactions, offering decentralized control and enhanced safety. By building a multisig wallet with Solidity and Ethers.js, you’ve learned how to implement this critical feature for Ethereum DApps. Keep experimenting with advanced features like timelocks or recovery mechanisms, and share your multisig wallet ideas in the comments below!
