Merkle airdrop
Merkle Tree，也叫默克尔树或哈希树，是区块链的底层加密技术，被比特币和以太坊区块链广泛采用。Merkle Tree允许对大型数据结构的内容进行有效和安全的验证（Merkle Proof）。对于有N个叶子结点的Merkle Tree，在已知root根值的情况下，验证某个数据是否有效（属于Merkle Tree叶子结点）只需要ceil(log₂N)个数据（也叫proof），非常高效。如果数据有误，或者给的proof错误，则无法还原出root根植。 忘记的同学可以参考下方。
所以我们可以利用Merkel的特性。在链下，创建以账户地址和数量为叶子（addr， amount）的Merkel数，并计算出root hash。然后将roothash放到链上，这样就不需要在链上记录大量address和amount，节省gas。当空投开始后，不需要项目方花费gas，去给每一位用户空投，用户可以自行调用合约领取；
有用户想要领取空投时，可以进行调用合约进行claim，其实就是验证merkel的roothash；由于链上已经保存了一份roothash，只要在链上使用用户提供的信息生成的roothash与之前保存的一致，就可以证明该用户享有领取空投的权利。
准备工作
利用openzeppelin/merkle-tree，生成拥有空投资格用户的Merkel树.
javascript
import * as fs from 'fs'
import {StandardMerkleTree} from '@openzeppelin/merkle-tree'
// 1. build a tree
const elements = [
['0x0000000000000000000000000000000000000001', 1],
['0x0000000000000000000000000000000000000002', 2],
['0x0000000000000000000000000000000000000003', 3],
['0x0000000000000000000000000000000000000004', 4],
['0x0000000000000000000000000000000000000005', 5],
['0x0000000000000000000000000000000000000006', 6],
['0x0000000000000000000000000000000000000007', 7],
['0x0000000000000000000000000000000000000008', 8],
]
let merkleTree = StandardMerkleTree.of(elements, ['address', 'uint256'])
const root = merkleTree.root
const tree = merkleTree.dump()
console.log(merkleTree.render());
fs.writeFileSync('tree.json', JSON.stringify(tree))
fs.writeFileSync('root.json', JSON.stringify({root:root}))
// get proof
const proofs = []
const mtree = StandardMerkleTree.load(JSON.parse(fs.readFileSync("tree.json", "utf8")));
for (const [i, v] of mtree.entries()) {
proofs.push({'account':v[0], 'amount':v[1],'proof':mtree.getProof(i)})
if (v[0] === '0x0000000000000000000000000000000000000001') {
const proof = mtree.getProof(i);
console.log('Value:', v);
console.log('Proof:', proof);
}
}
fs.writeFileSync('proofs.json', JSON.stringify(proofs))首先我们使用StandardMerkleTree.of 生成了一个八个账户的merkel树并且记录了roothash；然后我们使用，getProof给每个用户都生成他自己的验证proof。用户想要领取空投的时候，需要提供自己proof------其实就是mekle的验证路径，这个一般都是由项目方保存就行了，保存在链下就可以了。这里还输出了三个json文件，这个三个文件，后边测试的时候，需要用到；
- tree.json:merkle tree的信息；
- root.json:merkle的roothash
- proofs.json:所有用户的proof数据
链上合约
merkle 合约，这个我们使用openzeppelin的MerkelProof库，主要是把验证函数实现一下，就可以了。验证的时候，需要提供用户的proof，address，amount，就可以了；
javascript
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol";
contract MerkleAirdrop {
using MerkleProof for bytes32[];
bytes32 private _root;
constructor(bytes32 root) {
_root = root;
}
function verify(
bytes32[] memory proof,
address account,
uint amount
) public view returns (bool) {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(account, amount)))
);
return proof.verify(_root, leaf);
}
function verifyCalldata(
bytes32[] calldata proof,
address account,
uint amount
) public view returns (bool) {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(account, amount)))
);
return proof.verifyCalldata(_root, leaf);
}
}airdrop合约，主要实现了claim，享有空投资格的用户，调用之后，而就可以领取空投了；
javascript
contract Airdrop is MerkleAirdrop{
event Claim(address to, uint256 amount);
MockIToken public token;
constructor(address _token, bytes32 _root) MerkleAirdrop(_root){
token = MockIToken(_token);
}
function claim(bytes32[] memory proof, address account, uint256 amount)
external returns (bool)
{
verify(proof, account, amount);
token.mint(account, amount);
emit Claim(account, amount);
}
}
interface MockIToken {
function mint(address to, uint256 amount) external;
}
contract MockToken is ERC20 {
constructor(string memory name, string memory symbol)
ERC20(name, symbol) {}
function mint(address account, uint amount) external {
_mint(account, amount);
}
}foundry测试
使用foundry进行，测试部分比较简单，就是测试了，merkelproof的verify函数以及airdrop的cliam函数；这次测试比较有趣的部分是foundry的json解析部分。也不是特别难，大家可以自行搜索foundry的文档进行学习与联系。
javascript
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "forge-std/Test.sol";
import {stdJson} from "forge-std/StdJson.sol";
import "../src/MerkleAirdrop.sol";
import "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
contract MerkleAirdropTest is Test {
using stdJson for string;
struct Proof {
address account;
uint amount;
bytes32[] proof;
}
string private _jsonTree = vm.readFile("test/data/tree.json");
string private _jsonRoot = vm.readFile("test/data/root.json");
string private _jsonProofs = vm.readFile("test/data/proofs.json");
bytes32 private _rootHash = _jsonRoot.readBytes32(".root");
MerkleAirdrop private _testing;
Airdrop private airdrop;
MockToken private token;
function setUp() public {
_testing = new MerkleAirdrop(_rootHash);
token = new MockToken("test", "TEST");
airdrop = new Airdrop(address(token), _rootHash);
}
function test_verify() external {
Proof[] memory proofs = abi.decode(_jsonProofs.parseRaw(""), (Proof[]));
for (uint i = 0; i < proofs.length; ++i) {
assertTrue(
_testing.verify(
proofs[i].proof,
proofs[i].account,
proofs[i].amount
)
);
}
}
function test_claim() external {
Proof[] memory proofs = abi.decode(vm.parseJson(_jsonProofs), (Proof[]));
for (uint i = 0; i < proofs.length; ++i) {
vm.expectEmit();
emit Airdrop.Claim(proofs[i].account, proofs[i].amount);
airdrop.claim(
proofs[i].proof,
proofs[i].account,
proofs[i].amount
);
assertEq(token.balanceOf(proofs[i].account), proofs[i].amount);
}
}
}