Hier is een basisvoorbeeld van een slim contract in Solidity dat een gedecentraliseerd stemproces implementeert, inclusief de genoemde specificaties: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract DecentralizedVoting { address public owner; uint public openTime; uint public closeTime; bool public votingClosed; struct Voter { bool registered; bool hasVoted; uint vote; // 0 = niet gestemd, 1 = ja, 2 = nee uint age; } mapping(address => Voter) public voters; address[] public voterAddresses; uint public yesCount; uint public noCount; // Events event VoterRegistered(address voter); event VoteCast(address voter, uint vote); event VotingStarted(uint startTime, uint endTime); event VotingClosed(); modifier onlyOwner() { require(msg.sender == owner, "Alleen eigenaar kan dit doen"); _; } modifier onlyDuringVoting() { require(block.timestamp >= openTime && block.timestamp <= closeTime, "Niet tijdens stemperiode"); require(!votingClosed, "Stemperiode is gesloten"); _; } modifier onlyRegistered() { require(voters[msg.sender].registered, "Ongekwalificeerde voter"); _; } constructor(uint _durationMinutes) { owner = msg.sender; openTime = block.timestamp; closeTime = block.timestamp + (_durationMinutes * 1 minutes); votingClosed = false; emit VotingStarted(openTime, closeTime); } // Registratie van stemmers function registerVoter(address _voter, uint _age) public onlyOwner { require(!voters[_voter].registered, "Voter al geregistreerd"); require(_age >= 18, "Voter moet ouder dan 18 zijn"); voters[_voter] = Voter({ registered: true, hasVoted: false, vote: 0, age: _age }); voterAddresses.push(_voter); emit VoterRegistered(_voter); } // Stemmen function vote(uint _vote) public onlyRegistered onlyDuringVoting { require(!voters[msg.sender].hasVoted, "Al gestemd"); require(_vote == 1 || _vote == 2, "Ongeldige stem"); voters[msg.sender].hasVoted = true; voters[msg.sender].vote = _vote; if (_vote == 1) { yesCount += 1; } else if (_vote == 2) { noCount += 1; } emit VoteCast(msg.sender, _vote); } // Sluiten van stemming (kan ook automatisch via tijd) function closeVoting() public onlyOwner { require(block.timestamp > closeTime, "Stemperiode nog niet afgelopen"); votingClosed = true; emit VotingClosed(); } // Resultaten bekijken function getResults() public view returns (string memory winnaar, uint stemmenVoor, uint stemmenTegen) { require(votingClosed, "Stemmen nog niet gesloten"); stemmenVoor = yesCount; stemmenTegen = noCount; if (yesCount > noCount) { winnaar = "Voorstanders winnen"; } else if (noCount > yesCount) { winnaar = "Tegenstanders winnen"; } else { winnaar = "Gelijkspel"; } } } ``` **Specificaties en mechanismen:** - **Open stemperiode:** Start bij contractaanmaak en loopt tot een ingestelde eindtijd (`closeTime`). - **Stemmen verzamelen:** Geregistreerde gebruikers kunnen stemmen tijdens de periode; stemmen worden vastgelegd zonder dat de identiteit zichtbaar is (stemgeheim). - **Registratie en geschiktheidscriteria:** Alleen de eigenaar kan gebruikers registreren, op voorwaarde dat ze ouder dan 18 zijn. - **Resultaten tellen:** Na sluiting wordt de winnaar bepaald op basis van meerderheid. - **Stemgeheim en manipulatiepreventie:** - Alleen geregistreerde gebruikers kunnen stemmen. - Elke gebruiker mag slechts één keer stemmen. - Tijdslimiet voorkomt stemmanipulatie na de sluiting. - Het contract kan verder worden uitgebreid met zero-knowledge proof mechanismen voor extra privacy, maar dat vereist complexere implementaties en externe tools. - **Automatische sluiting:** De eigenaar kan de stemming sluiten, of dit kan automatisch gebeuren na de eindtijd. Voor een volledig veilige en privacy-gevoelige implementatie kunnen aanvullende cryptografische technieken worden geïntegreerd, zoals zk-SNARKS, maar dat vereist meer geavanceerde smart contract-ontwikkelingen en off-chain componenten.

Zeker, hier is een voorbeeld van een slim contract voor een gedecentraliseerd stemsysteem in Solidity, met uitleg in het Nederlands. Dit contract bevat de basisprincipes die je hebt gespecificeerd, inclusief mechanismen voor geheimhouding en beveiliging. ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.19; contract DecentraalStemsysteem { struct Kandidaat { string naam; uint stemmen; } address public beheerder; bool public stemperiodeOpen; uint public eindTijdStemmen; // Registratie en leeftijdscontrole mapping(address => bool) public geregistreerdeStemmers; mapping(address => bool) public heeftGestemd; mapping(address => bytes32) public toegewezenSleutel; // Voor geheim stemmen Kandidaat[] public kandidaten; // Gebeurtenissen voor transparantie event StemmerGeregistreerd(address stemmer); event StemUitgebracht(address stemmer); event StemperiodeGesloten(); modifier alleenBeheerder() { require(msg.sender == beheerder, "Alleen beheerder mag deze actie uitvoeren"); _; } modifier stemperiodeActief() { require(stemperiodeOpen && block.timestamp < eindTijdStemmen, "Stemperiode is niet actief"); _; } constructor(string[] memory kandidaatNamen) { beheerder = msg.sender; for (uint i = 0; i < kandidaatNamen.length; i++) { kandidaten.push(Kandidaat({ naam: kandidaatNamen[i], stemmen: 0 })); } } // Registratiefunctie - in praktijk zou leeftijdsverificatie via orakel of KYC function registreerStemmer(bytes32 uniekeSleutel) external { require(!geregistreerdeStemmers[msg.sender], "Stemmer al geregistreerd"); require(uniekeSleutel != bytes32(0), "Ongeldige sleutel"); geregistreerdeStemmers[msg.sender] = true; toegewezenSleutel[msg.sender] = uniekeSleutel; emit StemmerGeregistreerd(msg.sender); } // Start stemperiode function openStemperiode(uint duurInMinuten) external alleenBeheerder { require(!stemperiodeOpen, "Stemperiode is al open"); stemperiodeOpen = true; eindTijdStemmen = block.timestamp + (duurInMinuten * 1 minutes); } // Geheime stemfunctie function brengStemUit(bytes32 versleuteldeStem, bytes32 sleutel) external stemperiodeActief { require(geregistreerdeStemmers[msg.sender], "Niet geregistreerd als stemmer"); require(!heeftGestemd[msg.sender], "Heeft al gestemd"); require(sleutel == toegewezenSleutel[msg.sender], "Ongeldige stemsleutel"); // Verifieer dat de versleutelde stem geldig is (in praktijk complexere cryptografie) require(versleuteldeStem != bytes32(0), "Ongeldige stem"); heeftGestemd[msg.sender] = true; // Stem wordt tijdelijk opgeslagen en later geteld // In productie: gebruik commit-reveal schema of zk-SNARKs emit StemUitgebracht(msg.sender); } // Sluit stemperiode en tel stemmen (vereenvoudigd) function sluitStemperiodeEnTelStemmen(bytes32[] memory ontsleuteldeStemmen) external alleenBeheerder { require(stemperiodeOpen, "Stemperiode is al gesloten"); require(block.timestamp >= eindTijdStemmen, "Stemperiode is nog niet afgelopen"); stemperiodeOpen = false; // Tel stemmen (vereenvoudigde implementatie) for (uint i = 0; i < ontsleuteldeStemmen.length; i++) { uint kandidaatIndex = uint(ontsleuteldeStemmen[i]) % kandidaten.length; kandidaten[kandidaatIndex].stemmen++; } emit StemperiodeGesloten(); } // Resultaat bepaling function bepaalWinnaar() external view returns (string memory) { require(!stemperiodeOpen, "Stemperiode is nog bezig"); uint winnendeStemmen = 0; uint winnaarIndex = 0; bool gelijkspel = false; for (uint i = 0; i < kandidaten.length; i++) { if (kandidaten[i].stemmen > winnendeStemmen) { winnendeStemmen = kandidaten[i].stemmen; winnaarIndex = i; gelijkspel = false; } else if (kandidaten[i].stemmen == winnendeStemmen && winnendeStemmen > 0) { gelijkspel = true; } } if (gelijkspel) { return "Gelijkspel - geen duidelijke winnaar"; } else if (winnendeStemmen == 0) { return "Geen stemmen uitgebracht"; } else { return kandidaten[winnaarIndex].naam; } } // Hulpfuncties function getAantalKandidaten() external view returns (uint) { return kandidaten.length; } function getTotaalUitgebrachteStemmen() external view returns (uint) { uint totaal = 0; for (uint i = 0; i < kandidaten.length; i++) { totaal += kandidaten[i].stemmen; } return totaal; } } ``` ## Belangrijke Beveiligingsmechanismen en Uitbreidingen: ### 1. **Stemgeheim Bescherming:** - **Commit-Reveal Schema**: In productie zou je een tweefasen stemproces implementeren - **Zero-Knowledge Proofs**: Gebruik zk-SNARKs voor verifieerbare privacy - **Versleutelde Stemmen**: Stemmen worden als gehashte waarden opgeslagen ### 2. **Manipulatie Preventie:** - **Eén stem per persoon**: Mapping controleert dubbele stemmen - **Tijdslot**: Stemperiode heeft vaste eindtijd - **Toegangscontrole**: Alleen geregistreerde stemmers kunnen deelnemen ### 3. **Aanvullende Veiligheidsmaatregelen:** ```solidity // Voor leeftijdsverificatie (vereist orakel) interface IOracle { function verifyAge(address user) external returns (bool); } // Tegen Sybil-aanvallen mapping(address => uint) public registratieTijd; uint public minimaleRegistratieTijd = 1 days; ``` ### 4. **Verbeterd Stemproces:** 1. **Registratie**: Gebruiker registreert met unieke sleutel 2. **Verificatie**: Leeftijd en identiteit geverifieerd (via orakel) 3. **Stemmen**: Versleutelde stem wordt ingediend 4. **Telllen**: Stemmen worden pas na sluiting geteld 5. **Resultaat**: Meerderheid bepaalt winnaar ### Praktische Implementatie Tips: - Gebruik IPFS voor off-chain stemopslag - Implementeer een orakel voor leeftijdsverificatie - Overweeg Layer 2 oplossing voor schaalbaarheid - Voeg event logging toe voor volledige transparantie Dit contract vormt een solide basis, maar voor productiegebruik zijn aanvullende audits en beveiligingsmaatregelen essentieel.