init voting concept

Signed-off-by: avichalp <[email protected]>

Author: avichalp

src/token/Voting.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
+
+contract Voting is Ownable(msg.sender) {
+    // Vote allocation structure
+    struct VoteAllocation {
+        uint256 voteCount;
+        uint256 expiryTimestamp;
+    }
+    
+    // Mapping to track vote allocations by address
+    mapping(address => VoteAllocation) public voteAllocations;
+    
+    // Week duration in seconds (7 days)
+    uint256 private constant WEEK_DURATION = 7 * 24 * 60 * 60;
+    
+    // Events
+    event VotesAllocated(address indexed voter, uint256 voteCount, uint256 expiryTimestamp);
+    event VoteCast(address indexed voter, uint256 remainingVotes);
+    
+    /**
+     * @notice Allocate votes to an address
+     * @param voter Address to allocate votes to
+     * @param voteCount Number of votes to allocate
+     */
+    function allocateVotes(address voter, uint256 voteCount) external onlyOwner {
+        // Set expiry timestamp to the end of the current week
+        uint256 expiryTimestamp = block.timestamp + WEEK_DURATION;
+        
+        // Overwrite any existing allocation
+        voteAllocations[voter] = VoteAllocation({
+            voteCount: voteCount,
+            expiryTimestamp: expiryTimestamp
+        });
+        
+        emit VotesAllocated(voter, voteCount, expiryTimestamp);
+    }
+    
+    /**
+     * @notice Cast a vote
+     * @dev Reduces the caller's vote count by 1 if they have unexpired votes
+     * @return success Whether the vote was successfully cast
+     */
+    function vote() external returns (bool success) {
+        VoteAllocation storage allocation = voteAllocations[msg.sender];
+        
+        // Check if votes are still valid
+        require(block.timestamp < allocation.expiryTimestamp, "Votes expired");
+        require(allocation.voteCount > 0, "No votes available");
+        
+        // Reduce vote count
+        allocation.voteCount -= 1;
+        
+        emit VoteCast(msg.sender, allocation.voteCount);
+        return true;
+    }
+    
+    /**
+     * @notice Check if an address has votes remaining
+     * @param voter Address to check
+     * @return hasVotes Whether the address has unexpired votes remaining
+     */
+    function hasVotes(address voter) external view returns (bool hasVotes) {
+        VoteAllocation memory allocation = voteAllocations[voter];
+        return allocation.voteCount > 0 && block.timestamp < allocation.expiryTimestamp;
+    }
+    
+    /**
+     * @notice Get the remaining vote count for an address
+     * @param voter Address to check
+     * @return The number of votes remaining (0 if expired)
+     */
+    function getRemainingVotes(address voter) external view returns (uint256) {
+        VoteAllocation memory allocation = voteAllocations[voter];
+        
+        // Return 0 if votes have expired
+        if (block.timestamp >= allocation.expiryTimestamp) {
+            return 0;
+        }
+        
+        return allocation.voteCount;
+    }
+}

test/Voting.t.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Test, console} from "forge-std/Test.sol";
+import {Voting} from "../src/token/Voting.sol";
+import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
+
+contract VotingTest is Test {
+    Voting public voting;
+    address public owner;
+    address public alice;
+    address public bob;
+
+    function setUp() public {
+        owner = address(this);
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+        
+        voting = new Voting();
+        
+        // Fund test accounts
+        vm.deal(alice, 10 ether);
+        vm.deal(bob, 10 ether);
+    }
+
+    function testOwnership() public view {
+        assertEq(voting.owner(), owner);
+    }
+
+    function testAllocateVotes() public {
+        // Allocate 5 votes to Alice
+        voting.allocateVotes(alice, 5);
+        
+        // Check allocation
+        (uint256 voteCount, uint256 expiryTimestamp) = voting.voteAllocations(alice);
+        assertEq(voteCount, 5, "Alice's vote count should be 5");
+        
+        // Check timestamp (roughly)
+        uint256 expectedExpiry = block.timestamp + 7 days;
+        assertApproxEqAbs(expiryTimestamp, expectedExpiry, 1, "Expiry should be about a week from now");
+    }
+    
+    function testAllocateVotesRequiresOwner() public {
+        // Try to allocate votes as Alice (not owner)
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        voting.allocateVotes(bob, 5);
+    }
+
+    function testVoting() public {
+        // Allocate 3 votes to Alice
+        voting.allocateVotes(alice, 3);
+        
+        // Alice votes
+        vm.prank(alice);
+        bool success = voting.vote();
+        assertTrue(success, "Vote should succeed");
+        
+        // Check remaining votes
+        (uint256 voteCount, ) = voting.voteAllocations(alice);
+        assertEq(voteCount, 2, "Alice should have 2 votes remaining");
+        
+        // Vote again
+        vm.prank(alice);
+        success = voting.vote();
+        assertTrue(success, "Second vote should succeed");
+        
+        // Check remaining votes again
+        (voteCount, ) = voting.voteAllocations(alice);
+        assertEq(voteCount, 1, "Alice should have 1 vote remaining");
+    }
+    
+    function testCannotVoteWithoutAllocation() public {
+        // Bob tries to vote without allocation
+        vm.prank(bob);
+        // For an address with no allocation, the expiryTimestamp is 0, so it's actually expired
+        vm.expectRevert("Votes expired");
+        voting.vote();
+    }
+    
+    function testCannotVoteAfterDepleted() public {
+        // Allocate 1 vote to Alice
+        voting.allocateVotes(alice, 1);
+        
+        // Alice votes once
+        vm.prank(alice);
+        voting.vote();
+        
+        // Try to vote again
+        vm.prank(alice);
+        vm.expectRevert("No votes available");
+        voting.vote();
+    }
+    
+    function testVoteExpiration() public {
+        // Allocate 5 votes to Alice
+        voting.allocateVotes(alice, 5);
+        
+        // Move time forward one week + 1 second
+        vm.warp(block.timestamp + 7 days + 1 seconds);
+        
+        // Alice tries to vote after expiration
+        vm.prank(alice);
+        vm.expectRevert("Votes expired");
+        voting.vote();
+    }
+    
+    function testHasVotes() public {
+        // Allocate 3 votes to Alice
+        voting.allocateVotes(alice, 3);
+        
+        // Check if Alice has votes
+        bool hasVotes = voting.hasVotes(alice);
+        assertTrue(hasVotes, "Alice should have votes");
+        
+        // Bob should not have votes
+        hasVotes = voting.hasVotes(bob);
+        assertFalse(hasVotes, "Bob should not have votes");
+        
+        // Alice votes all 3 times
+        vm.startPrank(alice);
+        voting.vote();
+        voting.vote();
+        voting.vote();
+        vm.stopPrank();
+        
+        // Alice should not have votes anymore
+        hasVotes = voting.hasVotes(alice);
+        assertFalse(hasVotes, "Alice should not have votes after using all");
+    }
+    
+    function testGetRemainingVotes() public {
+        // Allocate 5 votes to Alice
+        voting.allocateVotes(alice, 5);
+        
+        // Check remaining votes
+        uint256 remaining = voting.getRemainingVotes(alice);
+        assertEq(remaining, 5, "Alice should have 5 votes");
+        
+        // Alice votes twice
+        vm.startPrank(alice);
+        voting.vote();
+        voting.vote();
+        vm.stopPrank();
+        
+        // Check remaining votes again
+        remaining = voting.getRemainingVotes(alice);
+        assertEq(remaining, 3, "Alice should have 3 votes remaining");
+        
+        // Move time forward past expiration
+        vm.warp(block.timestamp + 7 days + 1 seconds);
+        
+        // Check remaining votes after expiration
+        remaining = voting.getRemainingVotes(alice);
+        assertEq(remaining, 0, "Expired votes should return 0");
+    }
+    
+    function testReallocation() public {
+        // Allocate 3 votes to Alice
+        voting.allocateVotes(alice, 3);
+        
+        // Alice uses 1 vote
+        vm.prank(alice);
+        voting.vote();
+        
+        // Check remaining
+        uint256 remaining = voting.getRemainingVotes(alice);
+        assertEq(remaining, 2, "Alice should have 2 votes remaining");
+        
+        // Reallocate 5 votes to Alice
+        voting.allocateVotes(alice, 5);
+        
+        // Check new allocation
+        remaining = voting.getRemainingVotes(alice);
+        assertEq(remaining, 5, "Alice should have 5 votes after reallocation");
+    }
+    
+    function testMultipleUsers() public {
+        // Allocate votes to Alice and Bob
+        voting.allocateVotes(alice, 3);
+        voting.allocateVotes(bob, 2);
+        
+        // Both vote
+        vm.prank(alice);
+        voting.vote();
+        
+        vm.prank(bob);
+        voting.vote();
+        
+        // Check remaining
+        uint256 aliceVotes = voting.getRemainingVotes(alice);
+        uint256 bobVotes = voting.getRemainingVotes(bob);
+        
+        assertEq(aliceVotes, 2, "Alice should have 2 votes remaining");
+        assertEq(bobVotes, 1, "Bob should have 1 vote remaining");
+    }
+}