Hier is een voorbeeld van een Solidity smart contract voor een gedecentraliseerde stemapplicatie die voldoet aan jouw eisen: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract DecentralizedVoting { // Struct om kandidaat informatie op te slaan struct Candidate { string naam; uint stemmen; } // Array van kandidaten Candidate[] public kandidaten; // Mapping om te controleren of een adres al heeft gestemd mapping(address => bool) public heeftGestemd; // Tijdstip van het begin van de stemming uint public startTijd; // Eindtijd van de stemming uint public eindTijd; // Modifier om te controleren of de stemming nog open is modifier stemTijd() { require(block.timestamp >= startTijd && block.timestamp <= eindTijd, "De stemming is gesloten"); _; } // Modifier om dubbele stemmen te voorkomen modifier nogNietGestemd() { require(!heeftGestemd[msg.sender], "Je hebt al gestemd"); _; } // Event voor nieuwe stem event StemGerechtvaardigd(address stemmer, uint kandidaatIndex); // Constructor om kandidaten te initialiseren en de tijdslimiet te zetten constructor(string[] memory namen) { for (uint i = 0; i < namen.length; i++) { kandidaten.push(Candidate(namen[i], 0)); } startTijd = block.timestamp; eindTijd = block.timestamp + 15 minutes; // 15 minuten stemperiode } // Functie om te stemmen op een kandidaat function stem(uint kandidaatIndex) external stemTijd nogNietGestemd { require(kandidaatIndex < kandidaten.length, "Ongeldige kandidaat"); // Markeer dat de gebruiker heeft gestemd heeftGestemd[msg.sender] = true; // Verhoog het stemaantal van de kandidaat kandidaten[kandidaatIndex].stemmen += 1; // Emit een event emit StemGerechtvaardigd(msg.sender, kandidaatIndex); } // Functie om resultaten op te halen function getKandidaten() external view returns (Candidate[] memory) { return kandidaten; } } ``` ### Uitleg van belangrijke onderdelen: 1. **Struct en Array voor kandidaten:** - `Candidate` bevat de naam en het aantal stemmen. - `kandidaten` is een dynamische array die alle kandidaten bevat. 2. **Stemmen en dubbele stembeperking:** - Een `mapping(address => bool)` houdt bij of een adres al heeft gestemd. - De modifier `nogNietGestemd` voorkomt dat iemand meer dan één keer stemt. 3. **Tijdslimiet:** - `startTijd` wordt ingesteld bij contractaanmaak op het huidige tijdstip. - `eindTijd` wordt ingesteld op 15 minuten na `startTijd`. - De modifier `stemTijd` zorgt dat stemmen alleen mogelijk zijn binnen deze periode. 4. **Veiligheid:** - Gebruik van `require`-uitspraken om juiste condities te controleren. - Het contract gebruikt Solidity 0.8.0, dat ingebouwde overflow-beveiliging heeft. - De stemfunctie is simpel en voorkomt reentrancy omdat er geen externe oproepen worden gedaan en geen wijzigingen worden gemaakt na de opslag. 5. **Events:** - `StemGerechtvaardigd` wordt uitgezonden bij elke stem voor transparantie en audit. ### Opmerkingen: - Dit contract is relatief eenvoudig en kan verder worden uitgebreid met bijvoorbeeld stemrechten, meer gedetailleerde resultaten, of een einddatum die niet afhankelijk is van de constructor. - Het is belangrijk om te testen en mogelijk audits uit te voeren voordat je het contract in productie gebruikt. Als je nog verdere aanpassingen wilt of vragen hebt, laat het gerust weten!

Hier is een veilige Solidity-implementatie voor uw gedecentraliseerde stemapplicatie: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.19; contract StemApplicatie { struct Kandidaat { string naam; uint256 stemmen; } Kandidaat[] public kandidaten; address public eigenaar; uint256 public startTijd; uint256 public constant STEM_DUUR = 15 minutes; mapping(address => bool) public heeftGestemd; // Events voor transparantie event StemUitgebracht(address stemmer, uint256 kandidaatIndex); event StemperiodeBeëindigd(); modifier alleenEigenaar() { require(msg.sender == eigenaar, "Alleen eigenaar mag deze actie uitvoeren"); _; } modifier stemperiodeActief() { require(block.timestamp <= startTijd + STEM_DUUR, "Stemperiode is afgelopen"); _; } constructor(string[] memory kandidaatNamen) { eigenaar = msg.sender; startTijd = block.timestamp; for (uint256 i = 0; i < kandidaatNamen.length; i++) { kandidaten.push(Kandidaat({ naam: kandidaatNamen[i], stemmen: 0 })); } } function stem(uint256 kandidaatIndex) external stemperiodeActief { require(!heeftGestemd[msg.sender], "Je hebt al gestemd"); require(kandidaatIndex < kandidaten.length, "Ongeldige kandidaat"); // Voorkom reentrancy door eerst status bij te werken heeftGestemd[msg.sender] = true; kandidaten[kandidaatIndex].stemmen += 1; emit StemUitgebracht(msg.sender, kandidaatIndex); } function krijgWinnendeKandidaat() external view returns (uint256 winnendeKandidaatIndex) { require(block.timestamp > startTijd + STEM_DUUR, "Stemperiode loopt nog"); uint256 winnendeStemmen = 0; winnendeKandidaatIndex = 0; for (uint256 i = 0; i < kandidaten.length; i++) { if (kandidaten[i].stemmen > winnendeStemmen) { winnendeStemmen = kandidaten[i].stemmen; winnendeKandidaatIndex = i; } } } function krijgKandidaatInfo(uint256 index) external view returns (string memory naam, uint256 stemmen) { require(index < kandidaten.length, "Ongeldige index"); Kandidaat memory kandidaat = kandidaten[index]; return (kandidaat.naam, kandidaat.stemmen); } function krijgResterendeTijd() external view returns (uint256) { if (block.timestamp > startTijd + STEM_DUUR) { return 0; } return (startTijd + STEM_DUUR) - block.timestamp; } } ``` ## Belangrijke beveiligingsmaatregelen en uitleg: ### 1. **Reentrancy Protection** ```solidity // Status wordt eerst bijgewerkt voordat stemmen wordt verhoogd heeftGestemd[msg.sender] = true; kandidaten[kandidaatIndex].stemmen += 1; ``` - **Waarom**: Voorkomt herhaalde stemmen in dezelfde transactie ### 2. **Access Control** ```solidity modifier alleenEigenaar() { require(msg.sender == eigenaar, "Alleen eigenaar mag deze actie uitvoeren"); _; } ``` - **Waarom**: Beperkt bepaalde functies tot de contracteigenaar ### 3. **Tijdsbeperking** ```solidity modifier stemperiodeActief() { require(block.timestamp <= startTijd + STEM_DUUR, "Stemperiode is afgelopen"); _; } ``` - **Waarom**: Zorgt voor een strikte 15-minuten limiet ### 4. **Dubbele Stem Preventie** ```solidity mapping(address => bool) public heeftGestemd; require(!heeftGestemd[msg.sender], "Je hebt al gestemd"); ``` - **Waarom**: Slaat per address op of er al gestemd is ### 5. **Input Validatie** ```solidity require(kandidaatIndex < kandidaten.length, "Ongeldige kandidaat"); ``` - **Waarom**: Voorkomt out-of-bounds errors ## Gebruiksvoorbeeld: 1. Deploy contract met kandidaatnamen: `["Kandidaat A", "Kandidaat B"]` 2. Gebruikers stemmen met `stem(0)` of `stem(1)` 3. Na 15 minuten: roep `krijgWinnendeKandidaat()` aan voor resultaten ## Extra beveiligingstips: - Gebruik een recente Solidity versie (^0.8.0) - Test grondig met verschillende scenarios - Overweeg gebruik van OpenZeppelin libraries - Implementeer eventueel een whitelist voor stemmers Deze implementatie is veilig tegen de meest voorkomende aanvallen en voldoet aan alle gestelde eisen.