updated access mofifiers.

Author: frank4591

.gitignore

@@ -1,6 +1,7 @@
 # Compiler files
 cache/
 out/
+/bin/src
 
 # Ignores development broadcast logs
 !/broadcast

src/AggregationAndValidation.sol

@@ -68,15 +68,15 @@ contract AggregationAndValidation is BaseTask {
         task.isActive = false;
 
         // Store the aggregated model hash on-chain
-        trainerNodeContract.storeModelUpdate(taskId, aggregatedModelHash);
+        // trainerNodeContract.storeModelUpdate(taskId, aggregatedModelHash);
 
         emit AggregatedModelStored(taskId, aggregatedModelHash);
 
         // Distribute rewards to trainers
         distributeRewards(taskId);
     }
 
-    modifier onlyTaskCreator(uint taskId) virtual  {
+    modifier onlyTaskCreator(uint taskId) virtual {
         require(tasks[taskId].creator == msg.sender, "Not the task creator");
         _;
     }

src/BaseTask.sol

@@ -11,10 +11,18 @@ abstract contract BaseTask {
         uint totalstaked;
         bool isActive;
         address[] trainers; //we can add validators and aggregrator as well later
+        address[] aggregrators; //we can add validators and aggregrator as well later
         mapping(address => uint) stakes;
         mapping(address => bytes) modelUpdates; //state change od model done by a trainer for the task
     }
 
+    struct TaskSummary {
+        uint id;
+        string description;
+        bool isActive;
+        address assignedTo;
+    }
+
     uint public taskCounter;
     mapping(uint => Task) public tasks;
 

src/ModelSubmission.sol

@@ -5,7 +5,7 @@ import "./BaseTask.sol";
 // import "./Staking.sol";
 
 contract ModelSubmission is BaseTask {
-    function submitModelUpdate(uint taskId, bytes memory modelUpdate) public {
+    function submitModelUpdate(uint taskId, bytes memory modelUpdate) internal {
         require(tasks[taskId].isActive, "Task is not active");
         Task storage task = tasks[taskId];
         require(task.stakes[msg.sender] >= TRAINER_STAKE, "Must be a staked trainer");

src/RoleBasedAccess.sol

@@ -27,15 +27,36 @@ contract RoleBasedAccess {
         _;
     }
 
+    modifier onlyCreator(address sender) {
+        require(
+            roles[sender] == Role.TaskCreator,
+            "Only Task Creation role is applicable"
+        );
+        _;
+    }
+
     // Assign roles
     // function assignRole(address user, Role role) public onlyOwner {
     //     roles[user] = role;
     // }
 
-    function assignStackedRole(address user, Role role) public {
+    function assignStackedRole(address user, Role role) internal {
         roles[user] = role;
     }
 
+    modifier isRoleAssigned(address user) {
+        Role role = roles[user];
+
+        if (
+            role == Role.TaskCreator ||
+            role == Role.Aggregator ||
+            role == Role.TrainerNode
+        ) {
+            revert("Role is already assigned");
+        }
+        _;
+    }
+
     // Get role for the caller
     function getMyRole() public view returns (string memory) {
         Role role = roles[msg.sender];
@@ -51,7 +72,7 @@ contract RoleBasedAccess {
         }
     }
 
-     // Check if an address is a TaskCreator
+    // Check if an address is a TaskCreator
     function isTaskCreator(address user) public view returns (bool) {
         return roles[user] == Role.TaskCreator;
     }

src/Staking.sol

@@ -45,9 +45,23 @@ contract Staking is TaskManagement, RoleBasedAccess {
         task.totalstaked += msg.value;
         if (role == Role.TrainerNode) {
             task.trainers.push(msg.sender);
+            assignStackedRole(msg.sender, Role.TaskCreator);
+        } else if (role == Role.Aggregator) {
+            task.aggregrators.push(msg.sender);
+            assignStackedRole(msg.sender, Role.Aggregator);
+        } else {
+            assignStackedRole(msg.sender, Role.None);
         }
     }
 
+    function stakeCreatorTokens(
+        // Role role,
+        uint reward
+    ) public payable isRoleAssigned(msg.sender) {
+        createTask(reward , msg.value);
+        assignStackedRole(msg.sender, Role.TaskCreator);
+    }
+
     modifier hasToken(Role role) {
         require(msg.value != 0, "Stake Tokens not found");
         if (role == Role.TaskCreator) {

src/TaskManagement.sol

@@ -6,8 +6,14 @@ pragma solidity ^0.8.0;
 import "./BaseTask.sol";
 
 contract TaskManagement is BaseTask {
-    function createTask(uint reward) public payable isCreatorRole(reward) {
-        require(msg.value >= reward, "reward must be deposited");
+    // Event to log task creation
+    event TaskCreated(uint id, string details, address creator, uint timestamp);
+
+    function createTask(
+        uint reward,
+        uint stakeValue
+    ) internal isCreatorRole(reward, stakeValue) {
+        require(stakeValue >= reward, "reward must be deposited");
 
         Task storage newTask = tasks[taskCounter];
         newTask.id = taskCounter;
@@ -25,13 +31,13 @@ contract TaskManagement is BaseTask {
         _;
     }
 
-    modifier isCreatorRole(uint reward) {
+    modifier isCreatorRole(uint reward, uint stakeValue) {
         require(
-            msg.value >= CREATOR_STAKE,
+            stakeValue >= CREATOR_STAKE,
             "Insufficient stake for task creation"
         );
         require(
-            msg.value >= reward + CREATOR_STAKE,
+            stakeValue >= reward + CREATOR_STAKE,
             "Reward and stake must be deposited, currently reward is  {$reward} stake {$CREATOOR_STAKE} "
         );
         _;
@@ -42,4 +48,51 @@ contract TaskManagement is BaseTask {
 
     //     _;
     // }
+
+    // Get incomplete tasks
+    function getAvailableTasks() public view returns (TaskSummary[] memory) {
+        uint count = 0;
+
+        // Count the number of incomplete tasks
+        for (uint i = 0; i < taskCounter; i++) {
+            if (!tasks[i].isActive) {
+                count++;
+            }
+        }
+
+        // Create a temporary array to hold TaskSummary
+        TaskSummary[] memory availableTasks = new TaskSummary[](count);
+        uint index = 0;
+
+        for (uint i = 0; i < taskCounter; i++) {
+            if (!tasks[i].isActive) {
+                availableTasks[index] = TaskSummary({
+                    id: tasks[i].id,
+                    description: "assigned",
+                    isActive: tasks[i].isActive,
+                    assignedTo: tasks[i].creator
+                });
+                index++;
+            }
+        }
+
+        return availableTasks;
+    }
+    // Get task details by ID
+    // function getTaskById(uint taskId) public view returns (Task memory) {
+    //     require(taskId < nextTaskId, "Task ID does not exist");
+    //     return taskById[taskId];
+    // }
+
+    // Get the last task added
+    function getLastTask() public view returns (TaskSummary memory) {
+        require(taskCounter > 0, "No tasks available");
+        TaskSummary memory availableTasks = TaskSummary({
+            id: tasks[taskCounter - 1].id,
+            description: "assigned",
+            isActive: tasks[taskCounter - 1].isActive,
+            assignedTo: tasks[taskCounter - 1].creator
+        });
+        return availableTasks;
+    }
 }

src/TrainerNode.sol

@@ -23,7 +23,7 @@ contract TrainerNode is BaseTask {
     );
 
     // Function to store a model update as an IPFS hash
-    function storeModelUpdate(uint taskId, string memory ipfsHash) public {
+    function storeModelUpdate(uint taskId, string memory ipfsHash) internal {
         require(tasks[taskId].isActive, "task not active");
         Task storage task = tasks[taskId];
         require(