Hier is een basisvoorbeeld van een Solidity smart contract dat voldoet aan jouw specificaties. Het bevat functies voor het beheren van polisgegevens, het indienen van claims via een mobiele app (met een eenvoudige foto-upload simulatie), het valideren en goedkeuren van claims, en het voorkomen van fraude door limieten te stellen. Daarnaast is het zo ontworpen dat het veilig is tegen veelvoorkomende kwetsbaarheden en probeert het gaskosten te minimaliseren. ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract Verzekeringspolis { // Struct voor polisgegevens struct Polis { address verzekerde; uint256 polisnummer; uint256 maandpremie; // in wei uint256 startDatum; uint256 eindeDatum; uint256 claimsBerekend; // aantal claims in het huidige jaar uint256 claimsTellerStart; // timestamp van begin van het jaar } // Struct voor claims struct Claim { uint256 claimId; address indiener; string fotoHash; // Simulatie van foto upload (bijvoorbeeld IPFS hash) uint256 datum; bool isGoedgekeurd; bool uitbetaald; } Polis public polis; uint256 public claimCount; mapping(uint256 => Claim) public claims; mapping(address => uint256) public claimsPerAdres; // optioneel, indien meerdere polissen uint256 public claimsPerJaarLimit = 5; // Modifier om te zorgen dat alleen de verzekerde toegang heeft modifier alleenVerzekerde() { require(msg.sender == polis.verzekerde, "Alleen verzekerde kan deze actie uitvoeren"); _; } // Constructor om polisgegevens te initialiseren constructor(address _verzekerde, uint256 _polisnummer, uint256 _maandpremie) { polis.verzekerde = _verzekerde; polis.polisnummer = _polisnummer; polis.maandpremie = _maandpremie; polis.startDatum = block.timestamp; // Einde datum kunnen we instellen op bijvoorbeeld 1 jaar later polis.eindeDatum = block.timestamp + 365 days; polis.claimsBerekend = 0; polis.claimsTellerStart = block.timestamp; claimCount = 0; } // Functie om een claim in te dienen via mobiele app function dienClaimIn(string memory _fotoHash) public onlyVerzekerde { // Controleer of binnen het jaar if (block.timestamp - polis.claimsTellerStart >= 365 days) { // Reset teller voor nieuwe jaar polis.claimsBerekend = 0; polis.claimsTellerStart = block.timestamp; } require(polis.claimsBerekend < claimsPerJaarLimit, "Max claims per jaar bereikt"); require(bytes(_fotoHash).length > 0, "Foto moet geüpload worden"); claimCount += 1; claims[claimCount] = Claim({ claimId: claimCount, indiener: msg.sender, fotoHash: _fotoHash, datum: block.timestamp, isGoedgekeurd: false, uitbetaald: false }); polis.claimsBerekend += 1; } // Functie om claims te bekijken function bekijkClaim(uint256 _claimId) public view returns (Claim memory) { require(_claimId > 0 && _claimId <= claimCount, "Claim niet gevonden"); return claims[_claimId]; } // Functie voor goedkeuring van claims (bijvoorbeeld door een administrator) // Voor eenvoud hier direct door de verzekerde, maar in praktijk via een geauthoriseerde partij function keurClaimGoed(uint256 _claimId) public alleenVerzekerde { Claim storage claim = claims[_claimId]; require(!claim.isGoedgekeurd, "Claim is al goedgekeurd"); claim.isGoedgekeurd = true; } // Uitbetaling vereist dat de claim is goedgekeurd en niet eerder uitbetaald function betaalClaim(uint256 _claimId) public onlyVerzekerde { Claim storage claim = claims[_claimId]; require(claim.isGoedgekeurd, "Claim is niet goedgekeurd"); require(!claim.uitbetaald, "Claim al uitbetaald"); // Volledige vergoeding uint256 vergoeding = polis.maandpremie * 12; // Jaarpremie als voorbeeld // In praktijk zou je hier een transfer of andere betaalmethode gebruiken // Bijvoorbeeld: payable(polis.verzekerde).transfer(vergoeding); // Maar aangezien dit een voorbeeld is, laten we het hier claim.uitbetaald = true; // Notitie: voor echte uitbetaling moet het contract ETH of tokens kunnen versturen } // (Optioneel) functie om de polis te bekijken function bekijkPolis() public view returns (Polis memory) { return polis; } } ``` **Belangrijke punten:** - Het contract bevat basisveiligheid, zoals `onlyVerzekerde` modifier om ongewenste toegang te voorkomen. - Claims kunnen slechts 5 keer per jaar worden ingediend, met automatische reset na 365 dagen. - Claims worden ingediend met een fotoHash, wat een simulatie is van een foto-upload (bijvoorbeeld IPFS hash). - De goedkeurings- en uitbetalingsfunctie is vereenvoudigd; in een echte situatie zou je een geautoriseerde partij nodig hebben om claims te keuren. - Uitbetalingen worden gesimuleerd; voor daadwerkelijke betalingen moet je het contract voorzien van de juiste ETH-tokens en `payable` functies. **Veiligheidstips:** - Voeg access control toe (bijvoorbeeld via OpenZeppelin's Ownable of Role-based access control) voor functies zoals goedkeuren en uitbetalen. - Voeg checks toe voor invoergegevens. - Overweeg het gebruik van oracles of off-chain verificatie voor claims. Bij verdere ontwikkeling kun je dit basiscontract uitbreiden met meer functies, uitgebreide fraudepreventie en integraties met backend-systemen.

Hier is een veilig en gas-efficiënt Solidity smart contract voor verzekeringsclaims: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.19; contract VerzekeringsClaim { address public eigenaar; address public verzekerde = 0xAbc123...; // Vul het volledige adres in uint256 public constant POLISNUMMER = 2002; uint256 public constante MAANDPREMIE = 30 ether; uint256 public constant MAX_CLAIMS_PER_JAAR = 5; struct Claim { uint256 claimId; uint256 indieningsDatum; string fotoHash; // IPFS hash van de foto bool goedgekeurd; bool uitgekeerd; uint256 uitkeringsBedrag; } mapping(uint256 => Claim) public claims; mapping(uint256 => uint256) public claimsPerJaar; // jaar -> aantal claims uint256 public claimCounter; event ClaimIngediend(uint256 claimId, address verzekerde, string fotoHash); ClaimGoedgekeurd(uint256 claimId, uint256 bedrag); event UitkeringBetaald(uint256 claimId, address ontvanger, uint256 bedrag); modifier alleenEigenaar() { require(msg.sender == eigenaar, "Alleen eigenaar"); _; } modifier alleenVerzekerde() { require(msg.sender == verzekerde, "Alleen verzekerde"); _; } constructor() { eigenaar = msg.sender; } function dienClaimIn(string memory _fotoHash) external alleenVerzekerde { uint256 huidigJaar = block.timestamp / 365 days; require(claimsPerJaar[huidigJaar] < MAX_CLAIMS_PER_JAAR, "Max claims bereikt"); claimCounter++; claimsPerJaar[huidigJaar]++; claims[claimCounter] = Claim({ claimId: claimCounter, indieningsDatum: block.timestamp, fotoHash: _fotoHash, goedgekeurd: false, uitgekeerd: false, uitkeringsBedrag: MAANDPREMIE // Volledige vergoeding }); emit ClaimIngediend(claimCounter, msg.sender, _fotoHash); } function keurClaimGoed(uint256 _claimId) external alleenEigenaar { Claim storage claim = claims[_claimId]; require(claim.claimId != 0, "Claim niet gevonden"); require(!claim.goedgekeurd, "Reeds goedgekeurd"); require(!claim.uitgekeerd, "Reeds uitgekeerd"); claim.goedgekeurd = true; emit ClaimGoedgekeurd(_claimId, claim.uitkeringsBedrag); } function betaalUitkering(uint256 _claimId) external alleenEigenaar { Claim storage claim = claims[_claimId]; require(claim.goedgekeurd, "Niet goedgekeurd"); require(!claim.uitgekeerd, "Reeds uitgekeerd"); require(address(this).balance >= claim.uitkeringsBedrag, "Onvoldoende saldo"); claim.uitgekeerd = true; (bool succes, ) = verzekerde.call{value: claim.uitkeringsBedrag}(""); require(succes, "Betaling mislukt"); emit UitkeringBetaald(_claimId, verzekerde, claim.uitkeringsBedrag); } function getAantalClaimsDitJaar() external view returns (uint256) { uint256 huidigJaar = block.timestamp / 365 days; return claimsPerJaar[huidigJaar]; } function getClaimDetails(uint256 _claimId) external view returns ( uint256, uint256, string memory, bool, bool, uint256 ) { Claim memory claim = claims[_claimId]; return ( claim.claimId, claim.indieningsDatum, claim.fotoHash, claim.goedgekeurd, claim.uitgekeerd, claim.uitkeringsBedrag ); } // Accepteer stortingen voor uitkeringen receive() external payable {} // Veiligheidsfunctie voor noodgevallen function emergencyWithdraw() external alleenEigenaar { payable(eigenaar).transfer(address(this).balance); } } ``` **Veiligheidsmaatregelen:** - Gebruikt Solidity 0.8.19 voor ingebouwde overflow protection - Access control modifiers voor eigenaar/verzekerde - Re-entrancy protection via Checks-Effects-Interactions pattern - Gebruikt `call()` voor betalingen i.p.v. `transfer()` **Gas-efficiëntie:** - Gebruikt `constant` variabelen waar mogelijk - Eenvoudige mappings voor snelle lookups - Geen complexe berekeningen in functies **Opmerkingen:** - Vervang `0xAbc123...` met het volledige 40-character adres - Foto's worden opgeslagen als IPFS hashes (off-chain) - Contract moet gefunded worden voor uitkeringen - Jaarberekening is gebaseerd op block timestamp Dit contract biedt een solide basis voor geautomatiseerde claimverwerking met fraudepreventie!