Snowman Merkle Airdrop

Severity Critical
Confidence High
Likelihood High — occurs every time a second user calls earnSnow() within 1 week of the first caller; an attacker front-runs weekly to monopolize the free allocation
Impact Critical — only 1 Snow token per week is minted system-wide instead of 1 per user per week, breaking the entire token distribution model for the full 12-week farming duration
Scope Snow.earnSnow(), Snow.buySnow()
Status Confirmed (cross-validated)
File src/Snow.sol, lines 24, 91-95
Description
The Snow contract is designed to allow each user to earn 1 free Snow token per week via the earnSnow() function, with a 1-week cooldown enforced per user to prevent farming more than the intended rate.

The cooldown timer s_earnTimer is declared as a single global uint256 instead of a per-user mapping(address => uint256). When any user calls earnSnow(), it resets this shared timer, which blocks every other address from earning for the next 7 days. Only the first caller each week successfully earns; all subsequent callers revert with S__Timer.

// Snow.sol
@> uint256 private s_earnTimer; // global, not per-user

function earnSnow() external canFarmSnow {
@> if (s_earnTimer != 0 && block.timestamp < (s_earnTimer + 1 weeks)) {
revert S__Timer();
}
_mint(msg.sender, 1);
@> s_earnTimer = block.timestamp; // resets timer for ALL users
}
Risk
Likelihood:

Occurs every time any second user calls earnSnow() within 1 week of the first caller — this is the default usage pattern in a multi-user system
An attacker monitoring the mempool front-runs earnSnow() transactions each week to monopolize the free Snow allocation
Impact:

Only 1 Snow token per week is minted across the entire system instead of 1 per user per week, breaking the intended token distribution model
All users except the fastest front-runner lose gas on reverted transactions every week for the full 12-week farming duration
Proof of Concept

// test/TestGlobalEarnTimer.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {Snow} from "../src/Snow.sol";
import {MockWETH} from "../src/mock/MockWETH.sol";

contract TestGlobalEarnTimer is Test {
Snow snow;
MockWETH weth;
address collector = makeAddr("collector");

address alice = makeAddr("alice");
address bob = makeAddr("bob");

function setUp() public {
    weth = new MockWETH();
    snow = new Snow(address(weth), 5, collector);
}

function testGlobalTimerBlocksOtherUsers() public {
    // Alice earns first — succeeds
    vm.prank(alice);
    snow.earnSnow();
    assertEq(snow.balanceOf(alice), 1);

    // Bob tries to earn immediately after Alice — REVERTS
    // because the GLOBAL s_earnTimer was just reset by Alice
    vm.prank(bob);
    vm.expectRevert(Snow.S__Timer.selector);
    snow.earnSnow();

    // Even after 6 days, Bob still cannot earn
    vm.warp(block.timestamp + 6 days);
    vm.prank(bob);
    vm.expectRevert(Snow.S__Timer.selector);
    snow.earnSnow();
}

function testOnlyOneEarnerPerWeek() public {
    // Week 1: Alice earns
    vm.prank(alice);
    snow.earnSnow();

    // Week 1: Bob is blocked
    vm.prank(bob);
    vm.expectRevert(Snow.S__Timer.selector);
    snow.earnSnow();

    // After exactly 1 week, someone can earn again
    vm.warp(block.timestamp + 1 weeks);

    // Bob earns this week
    vm.prank(bob);
    snow.earnSnow();

    // Now Alice is blocked
    vm.prank(alice);
    vm.expectRevert(Snow.S__Timer.selector);
    snow.earnSnow();

    // After 12 weeks, only 2 Snow total were minted
    // (1 per week instead of 2 per week for 2 users)
    assertEq(snow.balanceOf(alice), 1);
    assertEq(snow.balanceOf(bob), 1);
}

}
Recommended Mitigation

• uint256 private s_earnTimer;

• mapping(address => uint256) private s_earnTimer;

  function earnSnow() external canFarmSnow {

• if (s_earnTimer != 0 && block.timestamp < (s_earnTimer + 1 weeks)) {
  

• if (s_earnTimer[msg.sender] != 0 && block.timestamp < (s_earnTimer[msg.sender] + 1 weeks)) {
      revert S__Timer();
  }
  _mint(msg.sender, 1);
  

• s_earnTimer = block.timestamp;
  

• s_earnTimer[msg.sender] = block.timestamp;
  

  }