Update Contest.sol

contracts/Contest.sol

@@ -1,69 +1,65 @@
 pragma solidity 0.5.16;
 
-contract Contest{
-
-	struct Contestant{
-		uint id;
-		string name;
-		uint voteCount;
-		string party;
-		uint age;
-		string qualification;
-	}
+contract Contest {
+    address private admin;
+    uint private contestantsCount;
+    PHASE private state;
+    enum PHASE { Reg, Voting, Done }
+
+    struct Contestant {
+        uint id;
+        string name;
+        uint voteCount;
+        string party;
+        uint age;
+        string qualification;
+    }
 
-	struct Voter{
-		bool hasVoted;
-		uint vote;
-		bool isRegistered;
-	}
+    struct Voter {
+        bool hasVoted;
+        uint vote;
+        bool isRegistered;
+    }
 
-	address admin;
-	mapping(uint => Contestant) public contestants; 
-   // mapping(address => bool) public voters;
-    mapping(address => Voter) public voters;
-	uint public contestantsCount;
-	// uint public counter;
-	enum PHASE{reg, voting , done}
-	PHASE public state;
+    mapping(uint => Contestant) private contestants;
+    mapping(address => Voter) private voters;
 
-	modifier onlyAdmin(){
-		require(msg.sender==admin);
-		_;
-	}
-
-	modifier validState(PHASE x){
-	    require(state==x);
-	    _;
-	}
+    modifier onlyAdmin() {
+        require(msg.sender == admin, "Only admin can call this function");
+        _;
+    }
 
-	constructor() public{
-		admin=msg.sender;
-        state=PHASE.reg;
-		// counter = 0;
+    modifier validState(PHASE x) {
+        require(state == x, "Invalid state transition");
+        _;
+    }
 
-	}
+    constructor() public {
+        admin = msg.sender;
+        state = PHASE.Reg;
+    }
 
-    function changeState(PHASE x) onlyAdmin public{
-		require(x > state);
+    function transitionToPhase(PHASE x) public onlyAdmin {
+        require(uint(x) > uint(state), "Invalid state transition");
         state = x;
     }
 
-	function addContestant(string memory _name , string memory _party , uint _age , string memory _qualification) public onlyAdmin validState(PHASE.reg){
-		contestantsCount++;
-		contestants[contestantsCount]=Contestant(contestantsCount,_name,0,_party,_age,_qualification);
-	}
+    function addContestant(string memory _name, string memory _party, uint _age, string memory _qualification) public onlyAdmin validState(PHASE.Reg) {
+        contestantsCount++;
+        contestants[contestantsCount] = Contestant(contestantsCount, _name, 0, _party, _age, _qualification);
+    }
 
-	function voterRegisteration(address user) public onlyAdmin validState(PHASE.reg){
-		voters[user].isRegistered=true;
-	}
+    function registerVoter(address user) public onlyAdmin validState(PHASE.Reg) {
+        voters[user].isRegistered = true;
+    }
 
-	function vote(uint _contestantId) public validState(PHASE.voting){
+    function vote(uint _contestantId) public validState(PHASE.Voting) {
+        require(voters[msg.sender].isRegistered, "Voter is not registered");
+        require(!voters[msg.sender].hasVoted, "Voter has already voted");
+        require(_contestantId > 0 && _contestantId <= contestantsCount, "Invalid contestant ID");
 
-		require(voters[msg.sender].isRegistered);
-		require(!voters[msg.sender].hasVoted);
-        require(_contestantId > 0 && _contestantId<=contestantsCount);
-		contestants[_contestantId].voteCount++;
-		voters[msg.sender].hasVoted=true;
-		voters[msg.sender].vote=_contestantId;
-	}
-}
+        contestants[_contestantId].voteCount++;
+        voters[msg.sender].hasVoted = true;
+        voters[msg.sender].vote = _contestantId;
+    }
+}

contracts/Migrations.sol

@@ -1,19 +1,15 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.4.22 <0.8.0;
+pragma solidity ^0.8.0;
 
 contract Migrations {
-  address public owner = msg.sender;
-  uint public last_completed_migration;
+    address public owner = msg.sender;
+    uint public lastCompletedMigration;
 
-  modifier restricted() {
-    require(
-      msg.sender == owner,
-      "This function is restricted to the contract's owner"
-    );
-    _;
-  }
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Restricted to the contract's owner");
+        _;
+    }
 
-  function setCompleted(uint completed) public restricted {
-    last_completed_migration = completed;
-  }
+    function setCompleted(uint completed) external onlyOwner {
+        lastCompletedMigration = completed;
+    }
 }