Fixed supply calculation bug. Adjusted state time for testnet v2.

Author: mattjhawken

script/Deploy.s.sol

@@ -10,7 +10,7 @@ import {TimelockController} from "@openzeppelin/contracts/governance/TimelockCon
 
 // DAO Configuration
 uint256 constant TIMELOCK_DELAY = 2 days;
-uint128 constant BASE_UPDATE_TIME = uint128(8 hours);
+uint128 constant BASE_UPDATE_TIME = uint128(24 hours);
 uint8 constant PROPOSAL_THRESHOLD_PERCENTAGE = 66;
 
 contract Deploy is Script {
@@ -20,6 +20,7 @@ contract Deploy is Script {
     function run() external {
         genesis.push(msg.sender);
         genesis.push(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
+        genesis.push(0x25Fde2567cbC578e7739faD0499eD7d5056572Dd);
         address[] memory proposers = new address[](0);
         address[] memory executors = new address[](0);
 

src/SmartnodesERC20.sol

@@ -206,7 +206,7 @@ contract SmartnodesERC20 is ERC20, ERC20Permit, ERC20Votes, ReentrancyGuard {
         // Mint initial tokens to genesis nodes
         uint256 gensisNodesLength = _genesisNodes.length;
         for (uint256 i = 0; i < gensisNodesLength; i++) {
-            _mint(_genesisNodes[i], (s_validatorLockAmount * 3));
+            _mint(_genesisNodes[i], (s_validatorLockAmount) * 2);
         }
     }
 
@@ -1005,9 +1005,13 @@ contract SmartnodesERC20 is ERC20, ERC20Permit, ERC20Votes, ReentrancyGuard {
         uint256 total = totalSupply();
         uint256 reward = getEmissionRate();
 
+        // Circulating = minted tokens minus locked and escrowed
+        // (unclaimed rewards aren't minted yet, so they don't reduce circulation)
+        uint256 circulating = total - s_totalLocked - s_totalEscrowed.sno;
+
         return (
             total,
-            total - s_totalLocked - s_totalUnclaimed.sno - s_totalEscrowed.sno,
+            circulating,
             s_totalLocked,
             s_totalUnclaimed.sno,
             s_totalEscrowed.sno,

test/TokenTest.t.sol

@@ -993,4 +993,94 @@ contract SmartnodesTokenTest is BaseSmartnodesTest {
         vm.prank(address(core));
         token.escrowPayment(user1, largeAmount);
     }
+
+    /**
+     * @notice Simulate 100 reward distribution periods and claim all 100 rewards
+     */
+    function testSimulate100RewardPeriodsAndClaim() public {
+        console.log(
+            "=== Simulating 100 reward periods and claiming in batches of 100 ==="
+        );
+
+        uint256 NUM_PERIODS = 100;
+        uint256 BATCH_SIZE = 100;
+        _setupContractFunding();
+
+        // fund contract for ETH side of rewards
+        vm.deal(address(core), ADDITIONAL_ETH_PAYMENT * NUM_PERIODS);
+        vm.prank(address(core));
+        (bool sent, ) = address(token).call{
+            value: ADDITIONAL_ETH_PAYMENT * NUM_PERIODS
+        }("");
+        require(sent, "funding failed");
+
+        // pick one worker to repeatedly claim rewards
+        Participant[] memory initialWorkers;
+        uint256 dummyTotalCapacity;
+        (initialWorkers, dummyTotalCapacity) = _setupTestParticipants(5, false);
+
+        address worker = initialWorkers[0].addr;
+        uint256 workerIndex = 0;
+
+        uint256[] memory distributionIds = new uint256[](NUM_PERIODS);
+        uint256[] memory capacities = new uint256[](NUM_PERIODS);
+        bytes32[][] memory proofs = new bytes32[][](NUM_PERIODS);
+
+        // ----- CREATE 10,000 MERKLE DISTRIBUTIONS -----
+        for (uint256 i = 0; i < NUM_PERIODS; i++) {
+            Participant[] memory participants;
+            uint256 totalCapacity;
+
+            (participants, totalCapacity) = _setupTestParticipants(5, false);
+
+            require(workerIndex < participants.length, "invalid worker index");
+            capacities[i] = participants[workerIndex].capacity;
+
+            bytes32[] memory leaves = _generateLeaves(
+                participants,
+                token.s_currentDistributionId() + 1
+            );
+            proofs[i] = _generateMerkleProof(leaves, workerIndex);
+
+            vm.warp(block.timestamp + UPDATE_TIME);
+
+            (uint256 distributionId, ) = _createAndValidateDistribution(
+                participants,
+                totalCapacity
+            );
+
+            distributionIds[i] = distributionId;
+        }
+
+        uint256 preBal = token.balanceOf(worker);
+        uint256 preEth = worker.balance;
+
+        // ----- CLAIM IN BATCHES OF 100 -----
+        vm.startPrank(worker);
+
+        for (uint256 i = 0; i < NUM_PERIODS; i += BATCH_SIZE) {
+            uint256 end = i + BATCH_SIZE;
+            if (end > NUM_PERIODS) end = NUM_PERIODS;
+
+            for (uint256 j = i; j < end; j++) {
+                token.claimMerkleRewards(
+                    distributionIds[j],
+                    capacities[j],
+                    proofs[j]
+                );
+            }
+        }
+
+        vm.stopPrank();
+
+        uint256 postBal = token.balanceOf(worker);
+        uint256 postEth = worker.balance;
+
+        assertTrue(postBal > preBal, "worker SNO rewards should increase");
+        assertTrue(postEth > preEth, "worker ETH rewards should increase");
+
+        console.log(
+            "Successfully created and claimed 10,000 reward periods in batches of 100!"
+        );
+    }
 }