# Based Pariksha

Solving real-life problems is, in my opinion, the best way to contribute to our country and humanity. This project is crucial, and I believe we can fully realize it. The main challenge I faced was joining the Based India hackathon late, which hindered my ability to create a working demo. However, I have developed the basic code for the project, which is ready for testing on the blockchain. Together, we can make a significant impact in combating paper leaks and restoring trust in our education system.<br>

<pre><code>// Based Pariksha Concept Code
// SPDX-License-Identifier: MIT 
pragma solidity ^0.8.17;

contract OnChainExam {
<strong>    // Admin address
</strong>    address public admin;
    
    // Struct to represent a student
<strong>    struct Student {
</strong>        address studentAddress;
        bool isRegistered;
        string studentName;
    }
    
    // Struct to represent an exam
    struct Exam {
        uint256 examId;
        string examHash; // IPFS hash of encrypted exam
        uint256 unlockTime; // Time when the exam can be accessed
        bool isActive; // Is the exam active
    }
    
    // Mapping of student addresses to student details
    mapping(address => Student) public students;
    // Mapping of exam ID to exam details
    mapping(uint256 => Exam) public exams;
    
    // Total number of students and exams
    uint256 public studentCount;
    uint256 public examCount;
    
    // Modifier to allow only admin to execute certain functions
    modifier onlyAdmin() {
        require(msg.sender == admin, "Only admin can call this function");
        _;
    }
    
    // Modifier to check if student is registered
    modifier onlyRegisteredStudent() {
        require(students[msg.sender].isRegistered, "You are not registered as a student");
        _;
    }
    
    // Event for student registration
    event StudentRegistered(address studentAddress, string studentName);
    
    // Event for new exam created
    event ExamCreated(uint256 examId, string examHash, uint256 unlockTime);
    
    // Constructor to initialize the contract
    constructor() {
        admin = msg.sender; // Set the deployer as admin
    }
    
    // Function to register a new student
    function registerStudent(address _studentAddress, string memory _studentName) public onlyAdmin {
        require(!students[_studentAddress].isRegistered, "Student already registered");
        students[_studentAddress] = Student(_studentAddress, true, _studentName);
        studentCount++;
        
        emit StudentRegistered(_studentAddress, _studentName);
    }
    
    // Function to create an exam
    function createExam(string memory _examHash, uint256 _unlockTime) public onlyAdmin {
        require(_unlockTime > block.timestamp, "Unlock time must be in the future");
        
        examCount++;
        exams[examCount] = Exam(examCount, _examHash, _unlockTime, true);
        
        emit ExamCreated(examCount, _examHash, _unlockTime);
    }
    
    // Function to access the exam (returns the IPFS hash)
    function accessExam(uint256 _examId) public view onlyRegisteredStudent returns (string memory) {
        Exam memory exam = exams[_examId];
        require(exam.isActive, "Exam is not active");
        require(block.timestamp >= exam.unlockTime, "Exam is locked until the unlock time");
    
        return exam.examHash;
    }
    
    // Function for admin to deactivate an exam after the exam window is over
    function deactivateExam(uint256 _examId) public onlyAdmin {
        require(exams[_examId].isActive, "Exam is already inactive");
        exams[_examId].isActive = false;
    }
}
</code></pre>

#### Key Features:

1. **Admin Role**: Only the admin can register students and upload exams.
2. **Student Registration**: Admin registers students using their wallet addresses.
3. **Exam Creation**: The admin uploads the exam paper (stored on IPFS) and sets a time when students can access it.
4. **Time-based Exam Access**: The contract checks the current block timestamp against the `unlockTime` to ensure students can only access the exam after it is released.
5. **Exam Deactivation**: Admin can deactivate the exam after it's done.

#### IPFS Integration:

You would store the encrypted exam paper on IPFS and include the IPFS hash in the `examHash` field of the contract. When students access the exam, they receive the IPFS link to download and decrypt the exam.

#### Additional Features (Next Steps):

1. **Exam Submissions**: A function to allow students to submit answers (possibly by uploading another IPFS hash containing their answers).
2. **AI Integration**: You can integrate off-chain AI verification systems for identity verification (e.g., face scanning) and store results on-chain.
3. **Smart Contract Security**: Implement security measures to prevent unauthorized access and tampering.

This is the foundation. we can expand it further with more features/


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://hetal.gitbook.io/hetal/~/changes/3AZuy1aUQarovZckWC7e/based-pariksha.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.