Mass Token Distribution Systems: MerkleDrop, Batch Transfer & Vesting

Mass Token Distribution Systems: MerkleDrop, Batch Transfer & Vesting

Mass token distribution (airdrop) is an operation that can break a project if approached naively. Issuing transactions to tens of thousands of addresses via direct transfer() burns millions of dollars on gas and clogs blocks. Even worse — an attacker with a hundred sybil addresses claims a share intended for real users. We design systems that solve both problems: save up to 70% on gas and filter out up to 99% of sybils. Our experience spans 7+ years, with 50+ launched projects distributing over $50M+ in total.

Key challenges in mass token distribution

The choice between push and pull determines both budget and UX. On Ethereum mainnet with 50,000 recipients and gas price at $20/Gwei, a direct transfer approach would cost $50,000+ in fees alone. In a pull scenario, users pay their own gas, but to make a claim worthwhile for 10,000 people, sybils must be disincentivized. The second problem: attackers create thousands of wallets, perform minimal activity, and receive a disproportionate share. For protection we use a combination of on‑chain filters (wallet age, transaction history, fee volume) and off‑chain verification via Gitcoin Passport or social media with signatures. Tiered distribution (early participants receive 3x more) makes sybil attacks economically unattractive.

Merkle drop: the standard for mass distribution

The recipient list is packed into a Merkle tree, and only the root is stored on‑chain. Users provide a proof of their entitlement. This is the gold standard for large airdrops: gas costs are minimal, and proofs are verifiable on‑chain. Here is a basic implementation:

contract MerkleDistributor { address public immutable token; bytes32 public immutable merkleRoot; mapping(uint256 => uint256) private claimedBitMap; event Claimed(uint256 indexed index, address indexed account, uint256 amount); constructor(address token_, bytes32 merkleRoot_) { token = token_; merkleRoot = merkleRoot_; } function isClaimed(uint256 index) public view returns (bool) { uint256 claimedWordIndex = index / 256; uint256 claimedBitIndex = index % 256; uint256 claimedWord = claimedBitMap[claimedWordIndex]; uint256 mask = (1 << claimedBitIndex); return claimedWord & mask == mask; } function claim( uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof ) external { require(!isClaimed(index), "Already claimed"); bytes32 node = keccak256(abi.encodePacked(index, account, amount)); require( MerkleProof.verify(merkleProof, merkleRoot, node), "Invalid proof" ); _setClaimed(index); IERC20(token).transfer(account, amount); emit Claimed(index, account, amount); } function _setClaimed(uint256 index) private { uint256 claimedWordIndex = index / 256; uint256 claimedBitIndex = index % 256; claimedBitMap[claimedWordIndex] |= (1 << claimedBitIndex); } } 

Using a bit map instead of mapping(address => bool) saves significant storage, especially for hundreds of thousands of recipients. For off‑chain tree generation we use the OpenZeppelin MerkleProof library.

How does Merkle drop solve the gas problem?

The Merkle tree avoids storing the full list on‑chain. Instead, only the root (32 bytes) is stored. Users prove their share by providing a proof of ~2–12 hashes. Gas costs per claim are ~50,000 gas (≈$1 at 20 Gwei), which is tens of times less than in a push approach. Merkle drop outperforms batch transfer by 3–5x on gas for lists of 10,000 addresses and up.

How we design the system: a real‑world case

For a large DeFi project we implemented a hybrid scheme: 40% of tokens were distributed via Merkle drop without KYC, 60% via an interface with Gitcoin Passport. Result: 92% of whitelisted addresses claimed in the first week, and 97% of them did not sell on DEX within a month. Snapshot hunters lost 80% of their expected share due to tiered multipliers.

function disperseToken( IERC20 token, address[] calldata recipients, uint256[] calldata amounts ) external { uint256 total = 0; for (uint256 i = 0; i < amounts.length; i++) { total += amounts[i]; } token.transferFrom(msg.sender, address(this), total); for (uint256 i = 0; i < recipients.length; i++) { token.transfer(recipients[i], amounts[i]); } }