Snowman Merkle Airdrop

AI First Flight #10

Beginner FriendlyFoundrySolidityNFT

EXP

View results

Previous Next

Submission Details

Severity: low

Valid

Missing Claim Check in claimSnowman() Function

r7al38

Root + Impact

The claimSnowman function lacks a check to prevent multiple claims from the same address, allowing users to claim repeatedly as long as they can re‑acquire the required Snow tokens.

Description

Normal behavior: The contract intends to allow each eligible user to claim a Snowman NFT exactly once. A mapping s_hasClaimedSnowman is supposed to track whether an address has already claimed.
problem: There is no require(!s_hasClaimedSnowman[receiver]) at the beginning of the function. The mapping is only set to true at the very end, after all token transfers and minting. This means that if a user can obtain the same amount of Snow tokens again (for example, by buying them on the market), they can reuse the same Merkle proof and signature to claim another NFT.s

function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)

external nonReentrant

{

if (receiver == address(0)) {

revert SA__ZeroAddress();

}

if (i_snow.balanceOf(receiver) == 0) {

revert SA__ZeroAmount();

}

if (!_isValidSignature(receiver, getMessageHash(receiver), v, r, s)) {

revert SA__InvalidSignature();

}

uint256 amount = i_snow.balanceOf(receiver);

bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));

if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {

revert SA__InvalidProof();

}

i_snow.safeTransferFrom(receiver, address(this), amount); // send tokens to contract... akin to burning

@> s_hasClaimedSnowman[receiver] = true; // set only after everything else

emit SnowmanClaimedSuccessfully(receiver, amount);

i_snowman.mintSnowman(receiver, amount);

}

Risk

Likelihood:

A user who has claimed once can claim again whenever they manage to re‑acquire the same amount of Snow tokens (e.g., by purchasing them from a decentralized exchange or receiving them from another address).
The signature and Merkle proof remain valid forever because the signed message does not include a nonce or expiration, and the Merkle leaf is recomputed from the current balance (which can become the original amount again).

Impact:

An attacker can mint an unlimited number of Snowman NFTs without any additional eligibility, draining the NFT supply.
Each claim transfers the user’s Snow tokens to the contract (effectively burning them), so the contract accumulates an arbitrary amount of Snow tokens, potentially exceeding what was intended to be burned.
Legitimate users may be unable to claim if the NFT supply is exhausted by repeated claims from the same address.

Proof of Concept

The following Foundry test demonstrates the vulnerability. It shows a user claiming twice after replenishing their Snow balance::

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import "forge-std/Test.sol";

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

import {SnowmanAirdrop} from "../src/SnowmanAirdrop.sol";

contract Snow is ERC20 {

constructor() ERC20("Snow", "SNOW") {}

function mint(address to, uint256 amount) external {

_mint(to, amount);

}

contract Snowman is ERC721 {

uint256 private _nextTokenId = 1;

constructor() ERC721("Snowman", "SNOWMAN") {}

function mintSnowman(address to, uint256 amount) external {

_safeMint(to, _nextTokenId++);

}

contract SnowmanAirdropTest is Test {

SnowmanAirdrop public airdrop;

Snow public snow;

Snowman public snowman;

address public user;

uint256 public userPrivateKey;

address public deployer;

address public helper;

uint256 public constant AMOUNT = 1000 * 10**18; // كمية التوكن

bytes32 public merkleRoot;

bytes32[] public merkleProof;

function setUp() public {

deployer = address(this);

userPrivateKey = 0x123456;

user = vm.addr(userPrivateKey);

helper = address(0x789);

snow = new Snow();

snow.mint(deployer, 10000 * 10**18);

snowman = new Snowman();

vm.prank(deployer);

snow.transfer(user, AMOUNT);

bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(user, AMOUNT))));

merkleRoot = leaf;

merkleProof = new bytes32[](0); // proof فارغ

airdrop = new SnowmanAirdrop(merkleRoot, address(snow), address(snowman));

vm.prank(user);

snow.approve(address(airdrop), AMOUNT);

}

function testDoubleClaim() public {

// 1. توليد التوقيع

bytes32 digest = airdrop.getMessageHash(user);

(uint8 v, bytes32 r, bytes32 s) = vm.sign(userPrivateKey, digest);

// 2. المطالبة الأولى

vm.prank(user);

airdrop.claimSnowman(user, merkleProof, v, r, s);

// التحقق من نجاح المطالبة الأولى

assertEq(snowman.balanceOf(user), 1, "User should have 1 NFT after first claim");

assertEq(snow.balanceOf(user), 0, "User snow balance should be 0 after first claim");

// 3. إعادة تمويل المستخدم بنفس المبلغ

vm.prank(deployer);

snow.transfer(user, AMOUNT);

assertEq(snow.balanceOf(user), AMOUNT, "User should have snow again");

// الموافقة مرة أخرى

vm.prank(user);

snow.approve(address(airdrop), AMOUNT);

// 4. المطالبة الثانية بنفس proof والتوقيع

vm.prank(user);

airdrop.claimSnowman(user, merkleProof, v, r, s);

// التحقق من نجاح المطالبة الثانية

assertEq(snowman.balanceOf(user), 2, "User should have 2 NFTs after second claim");

assertEq(snow.balanceOf(user), 0, "User snow balance should be 0 again");

// التحقق من أن العقد استلم ضعف المبلغ

assertEq(snow.balanceOf(address(airdrop)), AMOUNT * 2, "Airdrop contract should have double the amount");

}

Output:

[⠰] Compiling...

No files changed, compilation skipped

Ran 1 test for test/SnowmanAirdrop.t.sol:SnowmanAirdropTest

[PASS] testDoubleClaim() (gas: 232334)

Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 22.84ms (10.75ms CPU time)

Ran 1 test suite in 41.38ms (22.84ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)

Recommended Mitigation

Add a check at the beginning of claimSnowman to ensure the receiver has not already claimed, and consider moving the state update earlier (though the check alone is sufficient with nonReentrant)

function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)

external nonReentrant

{

if (receiver == address(0)) {

revert SA__ZeroAddress();

}

if (i_snow.balanceOf(receiver) == 0) {

revert SA__ZeroAmount();

}

+ if (s_hasClaimedSnowman[receiver]) {

+ revert SA__AlreadyClaimed();

+ }

if (!_isValidSignature(receiver, getMessageHash(receiver), v, r, s)) {

revert SA__InvalidSignature();

}

uint256 amount = i_snow.balanceOf(receiver);

bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));

if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {

revert SA__InvalidProof();

}

i_snow.safeTransferFrom(receiver, address(this), amount);

s_hasClaimedSnowman[receiver] = true;

emit SnowmanClaimedSuccessfully(receiver, amount);

i_snowman.mintSnowman(receiver, amount);

}

Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge 7 days ago

Submission Judgement Published

Validated

Assigned finding tags:

[L-01] Missing Claim Status Check Allows Multiple Claims in SnowmanAirdrop.sol::claimSnowman

# Root + Impact   **Root:** The [`claimSnowman`](https://github.com/CodeHawks-Contests/2025-06-snowman-merkle-airdrop/blob/b63f391444e69240f176a14a577c78cb85e4cf71/src/SnowmanAirdrop.sol#L44) function updates `s_hasClaimedSnowman[receiver] = true` but never checks if the user has already claimed before processing the claim, allowing users to claim multiple times if they acquire more Snow tokens. **Impact:** Users can bypass the intended one-time airdrop limit by claiming, acquiring more Snow tokens, and claiming again, breaking the airdrop distribution model and allowing unlimited NFT minting for eligible users. ## Description * **Normal Behavior:** Airdrop mechanisms should enforce one claim per eligible user to ensure fair distribution and prevent abuse of the reward system. * **Specific Issue:** The function sets the claim status to true after processing but never validates if `s_hasClaimedSnowman[receiver]` is already true at the beginning, allowing users to claim multiple times as long as they have Snow tokens and valid proofs. ## Risk **Likelihood**: Medium * Users need to acquire additional Snow tokens between claims, which requires time and effort * Users must maintain their merkle proof validity across multiple claims * Attack requires understanding of the missing validation check **Impact**: High * **Airdrop Abuse**: Users can claim far more NFTs than intended by the distribution mechanism * **Unfair Distribution**: Some users receive multiple rewards while others may receive none * **Economic Manipulation**: Breaks the intended scarcity and distribution model of the NFT collection ## Proof of Concept Add the following test to TestSnowMan.t.sol ```Solidity function testMultipleClaimsAllowed() public { // Alice claims her first NFT vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest = airdrop.getMessageHash(alice); (uint8 v, bytes32 r, bytes32 s) = vm.sign(alKey, aliceDigest); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v, r, s); assert(nft.balanceOf(alice) == 1); assert(airdrop.getClaimStatus(alice) == true); // Alice acquires more Snow tokens (wait for timer and earn again) vm.warp(block.timestamp + 1 weeks); vm.prank(alice); snow.earnSnow(); // Alice can claim AGAIN with new Snow tokens! vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest2 = airdrop.getMessageHash(alice); (uint8 v2, bytes32 r2, bytes32 s2) = vm.sign(alKey, aliceDigest2); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v2, r2, s2); // Second claim succeeds! assert(nft.balanceOf(alice) == 2); // Alice now has 2 NFTs } ``` ## Recommended Mitigation **Add a claim status check at the beginning of the function** to prevent users from claiming multiple times. ```diff // Add new error + error SA__AlreadyClaimed(); function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external nonReentrant { + if (s_hasClaimedSnowman[receiver]) { + revert SA__AlreadyClaimed(); + } + if (receiver == address(0)) { revert SA__ZeroAddress(); } // Rest of function logic... s_hasClaimedSnowman[receiver] = true; } ```

Rewards breakdown

This contest has a flat reward structure with the following payouts:

Live

The contest is live. Earn rewards by submitting a finding.

Judging

Submissions are being reviewed by our AI judge. Results will be available in a few minutes.

View all submissions

Rewards Distribution

The contest is complete and the rewards are being distributed.

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!