Secure Digital Voting System Blockchain, Solidity, JavaScript

Okay, here's a simplified example of a secure digital voting system using Blockchain (specifically, a local Hardhat environment for development), Solidity for the smart contract, and JavaScript for deployment and interaction.  This is a basic example to illustrate the core concepts. A production system would require much more rigorous security audits, testing, and considerations for scalability and usability.

**Project Setup (Requires Node.js and npm/yarn installed):**

1.  **Create a project directory:**

    ```bash
    mkdir voting-system
    cd voting-system
    ```

2.  **Initialize a Node.js project:**

    ```bash
    npm init -y
    ```

3.  **Install Hardhat:**

    ```bash
    npm install --save-dev hardhat
    npx hardhat
    ```

    Choose "Create a basic sample project" during the Hardhat setup.  This will create the necessary directories and files.

4.  **Install other dependencies:**

    ```bash
    npm install --save-dev @nomicfoundation/hardhat-toolbox dotenv
    npm install --save ethers
    ```

**1. Solidity Smart Contract (contracts/Voting.sol):**

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Voting {

    address public owner;
    mapping(address => bool) public voters; // Voter whitelist
    mapping(uint256 => string) public candidates; // Candidate names
    mapping(address => uint256) public votes; // Address -> candidate index
    uint256 public candidateCount;
    bool public votingOpen;

    event Voted(address voter, uint256 candidate);
    event CandidateAdded(uint256 candidateId, string name);

    constructor() {
        owner = msg.sender;
        votingOpen = false; // Voting initially closed
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function.");
        _;
    }

    modifier onlyVoters() {
        require(voters[msg.sender], "Only whitelisted voters can call this function.");
        _;
    }

    function addVoter(address _voter) public onlyOwner {
        voters[_voter] = true;
    }

    function addCandidate(string memory _name) public onlyOwner {
        candidateCount++;
        candidates[candidateCount] = _name;
        emit CandidateAdded(candidateCount, _name);
    }

    function startVoting() public onlyOwner {
        votingOpen = true;
    }

    function stopVoting() public onlyOwner {
        votingOpen = false;
    }

    function vote(uint256 _candidate) public onlyVoters {
        require(votingOpen, "Voting is not open.");
        require(_candidate > 0 && _candidate <= candidateCount, "Invalid candidate.");
        require(votes[msg.sender] == 0, "You have already voted."); // Prevent double voting

        votes[msg.sender] = _candidate;
        emit Voted(msg.sender, _candidate);
    }

    function getVote(address _voter) public view returns (uint256) {
        return votes[_voter];
    }

    function getCandidateName(uint256 _candidateId) public view returns (string memory) {
        return candidates[_candidateId];
    }

    function getCandidateCount() public view returns (uint256) {
        return candidateCount;
    }

    function getVotingOpen() public view returns (bool) {
        return votingOpen;
    }

}
```

**Explanation of the Solidity Contract:**

*   **`pragma solidity ^0.8.0;`**: Specifies the Solidity compiler version.
*   **`contract Voting { ... }`**:  Defines the smart contract named `Voting`.
*   **`address public owner;`**: Stores the address of the contract owner (the deployer).
*   **`mapping(address => bool) public voters;`**:  A mapping to whitelist voter addresses. Only whitelisted addresses can vote.
*   **`mapping(uint256 => string) public candidates;`**: Maps a candidate index (uint256) to the candidate's name (string).
*   **`mapping(address => uint256) public votes;`**:  Maps a voter's address to the candidate they voted for.  If the value is `0`, it means they haven't voted yet.
*   **`uint256 public candidateCount;`**: Tracks the number of candidates.
*   **`bool public votingOpen;`**: A boolean flag indicating whether the voting is currently open or closed.
*   **`event Voted(address voter, uint256 candidate);`**: An event emitted when a voter successfully votes.
*   **`event CandidateAdded(uint256 candidateId, string name);`**:  An event emitted when a new candidate is added.
*   **`constructor() { ... }`**:  The constructor, executed only once when the contract is deployed.  It sets the contract owner to the address that deployed the contract and initializes `votingOpen` to `false`.
*   **`modifier onlyOwner() { ... }`**:  A modifier that restricts access to a function to only the contract owner.
*   **`modifier onlyVoters() { ... }`**:  A modifier that restricts access to a function to only whitelisted voters.
*   **`addVoter(address _voter) public onlyOwner { ... }`**:  Allows the owner to add an address to the voter whitelist.
*   **`addCandidate(string memory _name) public onlyOwner { ... }`**:  Allows the owner to add a new candidate.  The candidate's name is stored in the `candidates` mapping.
*   **`startVoting() public onlyOwner { ... }`**:  Allows the owner to open the voting period.
*   **`stopVoting() public onlyOwner { ... }`**:  Allows the owner to close the voting period.
*   **`vote(uint256 _candidate) public onlyVoters { ... }`**:  Allows a whitelisted voter to vote for a candidate.  It checks if voting is open, if the candidate is valid, and if the voter has already voted.
*   **`getVote(address _voter) public view returns (uint256) { ... }`**:  Returns the candidate a specific voter voted for.  Returns 0 if the voter hasn't voted.
*   **`getCandidateName(uint256 _candidateId) public view returns (string memory) { ... }`**: Returns the name of a candidate.
*   **`getCandidateCount() public view returns (uint256) { ... }`**: Returns the number of candidates.
*   **`getVotingOpen() public view returns (bool) { ... }`**: Returns the state of the voting status.

**2. Deployment Script (scripts/deploy.js):**

```javascript
const { ethers } = require("hardhat");

async function main() {
    const Voting = await ethers.getContractFactory("Voting");
    const voting = await Voting.deploy();

    await voting.deployed();

    console.log("Voting contract deployed to:", voting.address);
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });
```

**Explanation of the Deployment Script:**

*   **`const { ethers } = require("hardhat");`**: Imports the `ethers` library from Hardhat, which is used to interact with the Ethereum blockchain.
*   **`async function main() { ... }`**:  Defines an asynchronous `main` function, which is the entry point for the deployment script.
*   **`const Voting = await ethers.getContractFactory("Voting");`**:  Gets a contract factory for the `Voting` contract.  A contract factory is an abstraction used to deploy new smart contracts.
*   **`const voting = await Voting.deploy();`**:  Deploys a new instance of the `Voting` contract.
*   **`await voting.deployed();`**:  Waits for the contract to be deployed to the blockchain.
*   **`console.log("Voting contract deployed to:", voting.address);`**:  Logs the address of the deployed contract to the console.
*   **`main() ...`**:  Calls the `main` function and handles any errors that occur.

**3.  Interaction Script (scripts/interact.js):**

```javascript
const { ethers } = require("hardhat");
require('dotenv').config();

const CONTRACT_ADDRESS = "YOUR_CONTRACT_ADDRESS"; // Replace with the deployed contract address

async function main() {
  const Voting = await ethers.getContractFactory("Voting");
  const voting = await Voting.attach(CONTRACT_ADDRESS);

  const [owner, voter1, voter2] = await ethers.getSigners();

  console.log("Owner Address:", owner.address);
  console.log("Voter1 Address:", voter1.address);
  console.log("Voter2 Address:", voter2.address);

  // Add voters to the whitelist
  await voting.connect(owner).addVoter(voter1.address);
  await voting.connect(owner).addVoter(voter2.address);
  console.log("Voters added to whitelist.");

  // Add Candidates
  await voting.connect(owner).addCandidate("Alice");
  await voting.connect(owner).addCandidate("Bob");
  console.log("Candidates added.");

  // Start Voting
  await voting.connect(owner).startVoting();
  console.log("Voting started.");

  // Voter 1 votes for Alice (candidate 1)
  await voting.connect(voter1).vote(1);
  console.log("Voter 1 voted for Alice.");

  // Voter 2 votes for Bob (candidate 2)
  await voting.connect(voter2).vote(2);
  console.log("Voter 2 voted for Bob.");

  // Stop Voting
  await voting.connect(owner).stopVoting();
  console.log("Voting stopped.");

  // Check votes
  const voter1Vote = await voting.getVote(voter1.address);
  const voter2Vote = await voting.getVote(voter2.address);

  console.log("Voter 1's vote:", voter1Vote.toString());
  console.log("Voter 2's vote:", voter2Vote.toString());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

**Explanation of the Interaction Script:**

*   **`const { ethers } = require("hardhat");`**: Imports the `ethers` library.
*   **`require('dotenv').config();`**: Loads environment variables from a `.env` file (if you're using one).
*   **`const CONTRACT_ADDRESS = "YOUR_CONTRACT_ADDRESS";`**:  **IMPORTANT:** Replace `"YOUR_CONTRACT_ADDRESS"` with the actual address of your deployed contract.
*   **`async function main() { ... }`**: Defines the main asynchronous function.
*   **`const Voting = await ethers.getContractFactory("Voting");`**: Gets the contract factory for the `Voting` contract.
*   **`const voting = await Voting.attach(CONTRACT_ADDRESS);`**:  Connects to the deployed contract at the specified address.  This allows you to call functions on the deployed contract.
*   **`const [owner, voter1, voter2] = await ethers.getSigners();`**: Gets three Ethereum accounts from the Hardhat local network.  The first account is typically the deployer (owner), and the other two will be used as voters.
*   **`await voting.connect(owner).addVoter(voter1.address);`**: Calls the `addVoter` function on the contract, connecting as the `owner` account, to add `voter1` to the whitelist.  The `connect` function specifies which account is sending the transaction.
*   **`await voting.connect(owner).addCandidate("Alice");`**: Adds a candidate to the ballot.
*   **`await voting.connect(owner).startVoting();`**: Starts the voting period.
*   **`await voting.connect(voter1).vote(1);`**:  `voter1` casts a vote for candidate at index `1`.
*   **`await voting.getVote(voter1.address);`**: Retrieves the vote cast by `voter1`.
*   The rest of the script performs similar interactions, adding voters, adding candidates, starting/stopping the voting, and retrieving the votes.

**4. Configuration (hardhat.config.js):**

```javascript
require("@nomicfoundation/hardhat-toolbox");
require('dotenv').config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.19",
  networks: {
    hardhat: {
    },
    // Add your network configuration here, e.g., Goerli, Sepolia, etc.
  },
  etherscan: {
    apiKey: "YOUR_ETHERSCAN_API_KEY" // Replace with your Etherscan API key if deploying to a testnet/mainnet.
  }
};
```

**Explanation of the Hardhat Configuration:**

*   **`require("@nomicfoundation/hardhat-toolbox");`**: Imports the Hardhat toolbox, which provides various plugins and utilities for development.
*   **`require('dotenv').config();`**:  Loads environment variables from a `.env` file.  This is useful for storing sensitive information like API keys and private keys.
*   **`solidity: "0.8.19",`**: Specifies the Solidity compiler version.
*   **`networks: { ... }`**:  Configures the networks that Hardhat can connect to.  The `hardhat` network is a local, in-memory blockchain that's ideal for development and testing.  You can add configurations for other networks like Goerli, Sepolia, or mainnet, if you want to deploy to a testnet or the main Ethereum network.  To do this, you will need to provide the RPC URL and the private key of your account.
*   **`etherscan: { ... }`**: Configures Etherscan verification.  If you're deploying to a testnet or mainnet, you'll need to provide your Etherscan API key to verify your contract on Etherscan.

**5.  (Optional) Create a `.env` file:**

```
YOUR_PRIVATE_KEY=YOUR_PRIVATE_KEY_HERE
YOUR_ETHERSCAN_API_KEY=YOUR_ETHERSCAN_API_KEY_HERE
```

**IMPORTANT:** Replace `YOUR_PRIVATE_KEY_HERE` with your actual private key.  **Never commit your private key to a public repository!** `YOUR_ETHERSCAN_API_KEY_HERE` can also be set here to use when deploying to testnets.

**How to Run the Example:**

1.  **Compile the smart contract:**

    ```bash
    npx hardhat compile
    ```

2.  **Deploy the contract:**

    ```bash
    npx hardhat run scripts/deploy.js --network hardhat
    ```

    This will deploy the contract to the local Hardhat network.  Note the address that is printed to the console.  You will need this for the interaction script.

3.  **Update `scripts/interact.js`**:

    *   Replace `"YOUR_CONTRACT_ADDRESS"` with the actual contract address that was printed during deployment.

4.  **Interact with the contract:**

    ```bash
    npx hardhat run scripts/interact.js --network hardhat
    ```

    This will execute the interaction script, which adds voters, adds candidates, starts the voting, casts votes, stops the voting, and checks the votes.  You should see the results printed to the console.

**Important Considerations and Next Steps:**

*   **Security:** This is a very simplified example and is **not suitable for production use**.  A real-world voting system would require extensive security audits, formal verification, and hardening against attacks.  Considerations include:
    *   **Access Control:** Robust access control mechanisms to prevent unauthorized users from adding voters or manipulating the results.
    *   **Data Integrity:**  Mechanisms to ensure the integrity of the vote data and prevent tampering.
    *   **Privacy:**  Techniques for preserving voter privacy, such as zero-knowledge proofs or homomorphic encryption (though these add significant complexity).
    *   **DoS Protection:**  Protection against denial-of-service attacks.
*   **Gas Optimization:**  Solidity contracts can be expensive to execute.  Optimize the contract code to minimize gas costs.
*   **Testing:**  Write thorough unit and integration tests to ensure the contract functions correctly.
*   **User Interface:**  Create a user-friendly web interface for voters to interact with the system.  This would typically involve using JavaScript frameworks like React, Angular, or Vue.js.  The UI would interact with the smart contract using a library like `ethers.js` or `web3.js`.
*   **Decentralization:**  This example uses a local Hardhat network.  To make the system truly decentralized, you would need to deploy it to a public blockchain like Ethereum.  However, this would incur gas costs for every transaction.
*   **Scalability:**  Blockchain transactions can be slow and expensive.  Consider using Layer-2 scaling solutions or other techniques to improve the scalability of the voting system.
*   **Auditability:** The immutability of the blockchain allows for a transparent audit trail. Implement mechanisms for verifying and auditing the voting process.
*   **Frontend:**  The frontend would use JavaScript to interact with the contract. You would need a library like `ethers.js` or `web3.js` to connect to the blockchain and call the contract functions.  You'd use HTML, CSS, and a framework like React, Angular, or Vue.js to build the user interface.

This comprehensive example provides a solid starting point for building a more complete and secure digital voting system on the blockchain. Remember to prioritize security, testing, and gas optimization as you develop your application.  Good luck!