feat: Smart contracts version 1.0 (first final)

Author: imiskii

src/TaskCreatorAccess.sol src/TaskAccess.solsrc/TaskCreatorAccess.sol renamed to src/TaskAccess.sol

@@ -1,77 +1,91 @@
-// SPDX-License-Identifier: GNU
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.24;
 
-import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
+import { AccessControlEnumerable } from "@openzeppelin/contracts/access/extensions/AccessControlEnumerable.sol";
 
 
-contract TaskCreatorAccess is AccessControlEnumerable {
+contract TaskAccess is AccessControlEnumerable {
 
-  EnumerableSet.AddressSet private _candidates; // candidates under voting
   mapping(address => uint256) public voteCount; /// vote count of each task creator
-  mapping(address => mapping(address => bool)) public hasVoted; // voter => candidate => voted
+  mapping(address => uint256) public candidateEpoch; /// epoch of each candidate
+  mapping(address => mapping(address => uint256)) public lastVotedEpoch; /// last epoch a voter voted for a candidate
 
   bytes32 public constant TASK_CREATOR_ROLE = keccak256("TASK_CREATOR_ROLE");
 
-  event CandidateProposed(address indexed candidate);
   event Voted(address indexed voter, address indexed candidate, uint256 votes);
   event Unvoted(address indexed voter, address indexed candidate, uint256 votes);
   event TaskCreatorAdded(address indexed newCreator);
   event TaskCreatorRemoved(address indexed exCreator);
+  event AdminAdded(address indexed newAdmin);
+  event AdminRemoved(address indexed exAdmin);
 
 
-  constructor(address initialCreator) {
+  constructor() {
     _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
   }
 
-  /// @dev Check if an address is a TaskCreator
-  function isTaskCreator(address account) public view returns (bool) {
-    return hasRole(TASK_CREATOR_ROLE, account);
-  }
-
-  /// @dev Get the number of TaskCreators
-  function taskCreatorCount() public view returns (uint256) {
-    return getRoleMemberCount(TASK_CREATOR_ROLE);
-  }
 
   /// @dev Dynamic voting threshold based on number of TaskCreators
   function threshold() public view returns (uint256) {
     uint256 n = taskCreatorCount();
     if (n <= 20) {
       return (n / 2) + 1; // majority
     } else if (n < 200) {
-      return n / 3;       // ~1/3 when moderately sized
+      return (n + 2) / 3;       // ~1/3 when moderately sized
     } else {
       return 100;         // capped threshold
     }
   }
 
+  /// TaskCreator FUNCTIONS
+
   /// @dev Vote for a new TaskCreator
   function voteForTaskCreator(address candidate) external onlyRole(TASK_CREATOR_ROLE) {
+    require(candidate != address(0), "Zero address");
+    require(candidate != msg.sender, "Self-vote not allowed");
     require(!hasRole(TASK_CREATOR_ROLE, candidate), "Already TaskCreator");
-    require(!hasVoted[msg.sender][candidate], "Already voted");
+    require(lastVotedEpoch[msg.sender][candidate] < candidateEpoch[candidate], "Already voted");
 
-    hasVoted[msg.sender][candidate] = true;
+    lastVotedEpoch[msg.sender][candidate] = candidateEpoch[candidate];
     voteCount[candidate]++;
 
     emit Voted(msg.sender, candidate, voteCount[candidate]);
 
     if (voteCount[candidate] >= threshold()) {
+      candidateEpoch[candidate] += 1;
+      voteCount[candidate] = 0; // reset votes
       _grantRole(TASK_CREATOR_ROLE, candidate);
       emit TaskCreatorAdded(candidate);
     }
   }
 
   /// @dev Remove vote for a TaskCreator
-  function unvoteTaskCreator(address candidate) external {
-    require(voteCount[candidate] > 0, "Candidate has no votes");
-    require(hasVoted[msg.sender][candidate], "Not voted");
+  function unvoteTaskCreator(address candidate) external onlyRole(TASK_CREATOR_ROLE) {
+    require(candidate != address(0), "Zero address");
+    require(lastVotedEpoch[msg.sender][candidate] == candidateEpoch[candidate], "Epoch mismatch");
 
-    hasVoted[msg.sender][candidate] = false;
+    lastVotedEpoch[msg.sender][candidate] = 0; // reset epoch
     voteCount[candidate]--;
 
     emit Unvoted(msg.sender, candidate, voteCount[candidate]);
   }
 
+  /// @dev Check if an address is a TaskCreator
+  function isTaskCreator(address account) public view returns (bool) {
+    return hasRole(TASK_CREATOR_ROLE, account);
+  }
+
+  /// @dev Get the number of TaskCreators
+  function taskCreatorCount() public view returns (uint256) {
+    return getRoleMemberCount(TASK_CREATOR_ROLE);
+  }
+
+  function getTaskCreators() public view returns (address[] memory) {
+    return getRoleMembers(TASK_CREATOR_ROLE);
+  }
+
+  /// ADMIN FUNCTIONS
+
   /// @dev Directly grant TaskCreator role
   function addTaskCreator(address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
       _grantRole(TASK_CREATOR_ROLE, account);
@@ -87,10 +101,20 @@ contract TaskCreatorAccess is AccessControlEnumerable {
   /// @dev Add new Admin
   function addAdmin(address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
       _grantRole(DEFAULT_ADMIN_ROLE, account);
+      emit AdminAdded(account);
   }
 
   /// @dev Remove Admin
   function removeAdmin(address account) external onlyRole(DEFAULT_ADMIN_ROLE) {
       _revokeRole(DEFAULT_ADMIN_ROLE, account);
+      emit AdminRemoved(account);
+  }
+
+  function isTaskAdmin(address account) public view returns (bool) {
+    return hasRole(DEFAULT_ADMIN_ROLE, account);
+  }
+
+  function getAdmins() public view returns (address[] memory) {
+    return getRoleMembers(DEFAULT_ADMIN_ROLE);
   }
 }

src/TaskManager.sol

@@ -1,13 +1,13 @@
-// SPDX-License-Identifier: GNU
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.24;
 
 import "./TaskToken.sol";
-import "./TaskCreatorAccess.sol";
+import "./TaskAccess.sol";
 import "./Verifier.sol";
 
 contract TaskManager {
   TaskToken public taskToken; // The ERC-1155 token contract
-  TaskCreatorAccess public accessControl; // Access control for task creators
+  TaskAccess public accessControl; // Access control for task creators
   Groth16Verifier public verifier; // zkSNARK verifier contract
   mapping(uint256 => Task) public tasks; // taskId => Task
 
@@ -27,11 +27,19 @@ contract TaskManager {
     _;
   }
 
+  /// @dev Restrict to only TaskAdmins
+  modifier onlyTaskAdmin() {
+    require(accessControl.isTaskAdmin(msg.sender), "Not TaskAdmin");
+    _;
+  }
+
   constructor(
     address _taskToken,
+    address _access,
     address _verifier
   ) {
     taskToken = TaskToken(_taskToken);
+    accessControl = TaskAccess(_access);
     verifier = Groth16Verifier(_verifier);
   }
 
@@ -44,7 +52,7 @@ contract TaskManager {
   }
 
   /// @dev Deactivate a task to prevent further solving
-  function deactivateTask(uint256 taskId) onlyTaskCreator external {
+  function deactivateTask(uint256 taskId) onlyTaskAdmin external {
     Task storage task = tasks[taskId];
     require(task.active, "Task not active");
     task.active = false;
@@ -57,7 +65,7 @@ contract TaskManager {
     uint[2] calldata a,
     uint[2][2] calldata b,
     uint[2] calldata c,
-    uint[] calldata publicSignals
+    uint[4] calldata publicSignals
   ) external {
     Task storage task = tasks[taskId];
     // Check if task is active

src/TaskToken.sol

@@ -1,25 +1,37 @@
-// SPDX-License-Identifier: GNU
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.24;
 
-import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import { ERC1155 } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 
 
 contract TaskToken is ERC1155, Ownable {
   mapping(uint256 => string) private _taskURIs; // Mapping: taskId => metadata URI
   uint256 public nextTaskId = 1; // Optional: track existing task IDs
+  address public manager;
 
-  constructor(address _accessControl) ERC1155("") Ownable(msg.sender) {}
+  constructor() ERC1155("") Ownable(msg.sender) {}
+
+  /// @dev Restrict to only TaskManager
+  modifier onlyManager() {
+    require(msg.sender == manager, "Not TaskManager");
+    _;
+  }
+
+  /// @dev Restrict to only TaskManager
+  function setManager(address _manager) onlyOwner external {
+    manager = _manager;
+  }
 
   /// @dev Add a new task token with its metadata URI
-  function addTaskToken(string memory taskURI) onlyOwner external returns (uint256 taskId) {
+  function addTaskToken(string memory taskURI) onlyManager external returns (uint256 taskId) {
     taskId = nextTaskId++;
     _taskURIs[taskId] = taskURI;
   }
 
   /// @dev Mint token
   /// TODO: restrict to only solvers of the task!
-  function mint(address to, uint256 taskId) onlyOwner external {
+  function mint(address to, uint256 taskId) onlyManager external {
     require(bytes(_taskURIs[taskId]).length > 0, "Invalid taskId");
     require(balanceOf(to, taskId) == 0, "Already claimed");
     _mint(to, taskId, 1, "");
@@ -47,4 +59,19 @@ contract TaskToken is ERC1155, Ownable {
   function exists(uint256 taskId) public view returns (bool) {
     return bytes(_taskURIs[taskId]).length > 0;
   }
+
+  /// Disable approvals and transfers
+
+  function setApprovalForAll(address, bool) public virtual override {
+      revert("Approvals disabled");
+  }
+
+  function safeTransferFrom(address, address, uint256, uint256, bytes memory) public virtual override {
+      revert("Transfers disabled");
+  }
+
+  function safeBatchTransferFrom(address, address, uint256[] memory, uint256[] memory, bytes memory) public virtual override {
+      revert("Transfers disabled");
+  }
+
 }