Task, Aggrgator added

frank4591 · frank4591 · commit 029627d5d2e9 · 2024-11-15T18:05:11.000+05:30
diff --git a/Python/InitShell.py b/Python/InitShell.py
@@ -0,0 +1,12 @@
+
+import os
+
+commandFile = "Shell/Command.sh"
+
+exit_code= os.system(commandFile)
+
+
+if exit_code == 0:
+    print("Script executed successfully.")
+else:
+    print("Script failed with exit code:", exit_code)
diff --git a/Python/SoraAI.py b/Python/SoraAI.py
@@ -0,0 +1,31 @@
+
+from web3 import HTTPProvider, Web3, AsyncWeb3
+import asyncio
+import time
+
+w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))
+
+if not w3.is_connected():
+    raise Exception("Unable to connect to the blockchain")
+
+def call_python_function(data):
+    print(f"Function called from blockchain on server with data: {data}")
+    # Your logic here
+
+contract_address= "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+contract_abi = [{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"registerSubNetOwner","inputs":[],"outputs":[],"stateMutability":"payable"},{"type":"function","name":"setStackingAmount","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"subNetRegisterd","inputs":[{"name":"subnetOwner","type":"address","indexed":False,"internalType":"address"},{"name":"subnetID","type":"uint256","indexed":False,"internalType":"uint256"}],"anonymous":False}]
+
+contract = w3.eth.contract(address=contract_address, abi=contract_abi)
+
+def main():
+    event_filter = contract.events.subNetRegisterd.create_filter(from_block='latest')
+    print("registered event filter")
+    while True:
+        for event in event_filter.get_new_entries():
+            print(event.args)
+            call_python_function(event.args.subnetID)
+            call_python_function(event.args.subnetOwner)
+        time.sleep(10)
+
+if __name__ == '__main__':
+    main()
diff --git a/README.md b/README.md
@@ -1,17 +1,10 @@
-## Foundry
+## testnet BlockChain Layer of Sora AI
 
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
-
-Foundry consists of:
-
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+** This layer consists of blockchain layer of Aggregrator, validator , Trainer nodes of Sora **
 
 ## Documentation
 
-https://book.getfoundry.sh/
+http://docs.thesorachain.com
 
 ## Usage
 
@@ -21,24 +14,6 @@ https://book.getfoundry.sh/
 $ forge build
 ```
 
-### Test
-
-```shell
-$ forge test
-```
-
-### Format
-
-```shell
-$ forge fmt
-```
-
-### Gas Snapshots
-
-```shell
-$ forge snapshot
-```
-
 ### Anvil
 
 ```shell
@@ -56,11 +31,3 @@ $ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --pri
 ```shell
 $ cast <subcommand>
 ```
-
-### Help
-
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
-```
diff --git a/Shell/Command.sh b/Shell/Command.sh
@@ -0,0 +1 @@
+echo "Hello from command"
diff --git a/foundry.toml b/foundry.toml
@@ -2,5 +2,6 @@
 src = "src"
 out = "out"
 libs = ["lib"]
+remappings = ["forge-std/=lib/forge-std/src/"]
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
diff --git a/script/Counter.s.sol b/script/Counter.s.sol
diff --git a/script/TheSoraChain.s.sol b/script/TheSoraChain.s.sol
@@ -0,0 +1,18 @@
+// //// SPDX-License-Identifier: MIT
+
+// pragma solidity <0.9.0;
+
+// import {TheSoraChain} from "./../src/TheSoraChain.sol";
+// import {Script} from "forge-std/Script.sol";
+
+
+// contract DeployTheSoraChain is Script{
+//     TheSoraChain public soraContract;
+
+//     function run() external returns(TheSoraChain){
+//        vm.startBroadcast();
+//        TheSoraChain chain =  new TheSoraChain();
+//        vm.stopBroadcast();
+//        return chain;
+//     }
+// }
diff --git a/src/BaseTask.sol b/src/BaseTask.sol
@@ -0,0 +1,33 @@
+//// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+abstract contract BaseTask {
+    struct Task {
+        uint id;
+        address creator;
+        uint reward;
+        uint totalstaked;
+        bool isActive;
+        address[] trainers; //we can add validators and aggregrator as well later
+        mapping(address => uint) stakes;
+        mapping(address => bytes) modelUpdates;
+    }
+
+    uint public taskCounter;
+    mapping(uint => Task) public tasks;
+
+    // Stake requirements for different roles
+    //can be changed by the contract owner
+    uint public CREATOR_STAKE = 5 ether;
+    uint public AGGREGATOR_STAKE = 3 ether;
+    uint public TRAINER_STAKE = 2 ether;
+
+    event TaskCreated(uint taskID, address indexed creator, uint rewards);
+    event ModelSubmitted(
+        uint taskID,
+        address indexed trainer,
+        bytes modelUpdates
+    );
+    event AggregrationComplete(uint taskID, bytes aggregrationModel);
+    event RewardDistributed(uint taskID, address indexed trainer, uint reward);
+}
diff --git a/src/Counter.sol b/src/Counter.sol
diff --git a/src/Staking.sol b/src/Staking.sol
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "./TaskManagement.sol";
+/*
+To-Do
+*Trainer can unstake  to asign trainer to different task
+*Task Creater can unstake and mark it as complete
+*/
+
+contract Staking is TaskManagement {
+    enum Role {
+        TaskCreator,
+        Aggregrator,
+        Trainer
+    }
+
+    uint public constant MINIMUM_STAKE = 1 ether;
+
+    function stakeTokens(
+        uint taskID,
+        Role role
+    )
+        public
+        payable
+        onlyActiveTask(taskID)
+        hasToken(role)
+        hasNotStackedEarlier(taskID)
+    {
+        Task storage task = tasks[taskID];
+        task.stakes[msg.sender] = msg.value;
+        task.totalstaked += msg.value;
+        if (role == Role.Trainer) {
+            task.trainers.push(msg.sender);
+        }
+    }
+
+    modifier hasToken(Role role) {
+        require(msg.value != 0, "Stake Tokens not found");
+        if (role == Role.TaskCreator) {
+            require(msg.value >= CREATOR_STAKE);
+        } else if (role == Role.Aggregrator) {
+            require(msg.value >= AGGREGATOR_STAKE);
+        } else if (role == Role.Trainer) {
+            require(msg.value >= TRAINER_STAKE);
+        } else {
+            revert("Invalid Role");
+        }
+        _;
+    }
+
+    modifier hasNotStackedEarlier(uint taskID) {
+        require(
+            tasks[taskID].stakes[msg.sender] == 0,
+            "Already stacked for the task"
+        );
+        _;
+    }
+}
diff --git a/src/TaskManagement.sol b/src/TaskManagement.sol
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./BaseTask.sol";
+
+contract TaskManagement is BaseTask {
+    function createTask(uint reward) public payable {
+        require(msg.value == reward, "reward must be deposited");
+
+        Task storage newTask = tasks[taskCounter];
+        newTask.id = taskCounter;
+        newTask.creator = msg.sender;
+        newTask.reward = reward;
+        newTask.isActive = true; //should be set for specific time eventually
+
+        emit TaskCreated((taskCounter), msg.sender, reward);
+        taskCounter++;
+    }
+
+    modifier onlyTaskCreator(uint taskId) {
+        require(tasks[taskId].creator == msg.sender, "Not the task creator");
+        _;
+    }
+
+    modifier isCreatorRole(uint reward) {
+        require(
+            msg.value >= CREATOR_STAKE,
+            "Insufficient stake for task creation"
+        );
+        require(
+            msg.value == reward + CREATOR_STAKE,
+            "Reward and stake must be deposited"
+        );
+    }
+
+    modifier onlyActiveTask(uint taskId) {
+        require(tasks[taskId].isActive, "Task is not active");
+
+        _;
+    }
+}
diff --git a/src/TheSoraChain.sol b/src/TheSoraChain.sol
@@ -0,0 +1,43 @@
+// //// SPDX-License-Identifier: MIT
+// pragma solidity <0.9.0;
+
+// import {console} from  "forge-std/console.sol";
+
+// contract TheSoraChain{
+    
+//     event  subNetRegisterd(address subnetOwner, uint subnetID);
+    
+//     address minter;
+//     mapping(address => uint) balances;
+//     address[] subnets;
+    
+//     uint stackingAmount;
+
+//     constructor(){
+//         minter = msg.sender;
+//         stackingAmount =10;
+//     }
+
+//     modifier onlyContractOwner(){
+//         require(msg.sender == minter);
+//         _;
+//     }
+//     function setStackingAmount(uint value) onlyContractOwner() public {
+//         stackingAmount = value;
+//     } 
+
+//     function registerSubNetOwner() public payable{
+//         require(msg.sender != minter,"contract owner can not register subnet");        
+//         console.log("counting subnets length %d" , subnets.length);
+//         for (uint256 index = 0; index < subnets.length; index++) {
+//             console.log("counting subnets");
+//             require(subnets[index]!= msg.sender,"subnetalready regisiterd");
+//             console.log("subnets checked");
+//         }
+//         require(msg.value> stackingAmount );
+//         console.log("stacking confirmed,pushing" );
+//         subnets.push(msg.sender);
+//         emit subNetRegisterd(msg.sender, subnets.length -1);
+        
+//     }
+// }
diff --git a/test/Counter.t.sol b/test/Counter.t.sol
