changed from cooldown to global limit

src/DailyDonut.sol

@@ -2,29 +2,40 @@
 pragma solidity 0.8.23;
 
 contract DailyDonut {
-    mapping(address => uint256) public lastClaimTimestamp;
-
-    uint256 public _claimId;
+    mapping(address => uint256) public lastClaimDay;
+    uint256 public claimId;
 
     event Transfer(address indexed from, address indexed to, uint256 claimId);
 
-    function claimDonut() public {
-        require(lastClaimTimestamp[msg.sender] == 0 || block.timestamp >= lastClaimTimestamp[msg.sender] + 24 hours, "You can only claim once every 24 hours");
+    function getCurrentDay() public view returns (uint256) {
+        return block.timestamp / 1 days;
+    }
 
-        lastClaimTimestamp[msg.sender] = block.timestamp;
+    function claimDonut() public {
+        uint256 currentDay = getCurrentDay();
 
-        _claimId++;
+        require(
+            lastClaimDay[msg.sender] < currentDay,
+            "You can only claim once per day"
+        );
 
-        emit Transfer(address(0), msg.sender, _claimId);
+        lastClaimDay[msg.sender] = currentDay;
+        claimId++;
+        emit Transfer(address(0), msg.sender, claimId);
     }
 
-    // Function to check the time remaining until next claim
-    function timeUntilNextClaim() public view returns (uint256) {
-        uint256 timeSinceLastClaim = block.timestamp - lastClaimTimestamp[msg.sender];
-        if (timeSinceLastClaim >= 24 hours) {
+    function timeUntilNextClaim(
+        address _address
+    ) public view returns (uint256) {
+        uint256 currentDay = getCurrentDay();
+        if (lastClaimDay[_address] < currentDay) {
             return 0;
         }
-        return 24 hours - timeSinceLastClaim;
+        uint256 nextMidnight = (currentDay + 1) * 1 days;
+        return nextMidnight - block.timestamp;
     }
 
-}
+    function canClaimToday(address _address) public view returns (bool) {
+        return lastClaimDay[_address] < getCurrentDay();
+    }
+}

test/DailyDonut.t.sol

@@ -9,28 +9,37 @@ contract DailyDonutTest is Test {
 
     function setUp() public {
         dailyDonut = new DailyDonut();
+
+        vm.warp(100 days);
     }
 
     function test_claimDonut() public {
         dailyDonut.claimDonut();
-        assertEq(dailyDonut._claimId(), 1);
+        assertEq(dailyDonut.claimId(), 1);
+        assertEq(dailyDonut.timeUntilNextClaim(address(this)), 24 hours);
 
         // expect to revert if claiming again before 24 hours over
-        vm.expectRevert("You can only claim once every 24 hours");
+        vm.expectRevert("You can only claim once per day");
         dailyDonut.claimDonut();
 
         // but another address can
         vm.startPrank(vm.addr(1));
+        assertEq(dailyDonut.timeUntilNextClaim(vm.addr(1)), 0);
+
+        dailyDonut.claimDonut();
+        assertEq(dailyDonut.claimId(), 2);
+        vm.warp(block.timestamp + 10 seconds);
+        assertEq(dailyDonut.timeUntilNextClaim(vm.addr(1)), 24 hours - 10 seconds);
+
+        vm.expectRevert("You can only claim once per day");
         dailyDonut.claimDonut();
-        assertEq(dailyDonut._claimId(), 2);
+
         vm.stopPrank();
 
         // in 24 hours can claim again
-        vm.warp(24 hours + 1);
+        vm.warp(block.timestamp + 24 hours);
 
         dailyDonut.claimDonut();
-        assertEq(dailyDonut._claimId(), 3);
+        assertEq(dailyDonut.claimId(), 3);
     }
-
-
 }