Hier is een voorbeeld van een Solidity smart contract voor een gedecentraliseerde escrow dienst die voldoet aan jouw specificaties. Het contract bevat de volgende functionaliteiten: - Partijen: Alice (koper), Bob (verkoper), Carol (arbiter) - Escrow bedrag: 1 ETH - Voorwaarden voor vrijgave: Goedgekeurde levering van goederen - Geschillenafhandeling: Arbiter beslist over vrijgave of terugbetaling - Beveiligingsmaatregelen: Voorkomen van dubbele uitbetalingen en reentrancy attacks ### Uitleg van de escrow-logica: 1. **Initialisatie:** De escrow wordt gestart door Alice en Bob, waarbij Alice het bedrag van 1 ETH naar het contract stuurt. 2. **Goedgekeurde levering:** Als Alice de goederen ontvangt en tevreden is, geeft zij een goedkeuringssignaal. Het contract geeft dan de betaling vrij aan Bob. 3. **Geschillen:** Als er een geschil is, kan de arbiter Carol ingrijpen en beslissen over vrijgave of terugbetaling. 4. **Veiligheid:** Het contract gebruikt `ReentrancyGuard` (van OpenZeppelin) om reentrancy te voorkomen en zorgt dat betalingen slechts één keer plaatsvinden. Hier is de code: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; contract EscrowDienst is ReentrancyGuard { address public alice; // Koper address public bob; // Verkoper address public carol; // Arbiter uint public escrowAmount = 1 ether; enum State { Created, Funded, Released, Refunded, Disputed, Resolved } State public currentState; bool public goodsDelivered; bool public buyerApproved; event EscrowCreated(address indexed buyer, address indexed seller, address indexed arbiter); event FundsDeposited(address indexed buyer); event GoodsDelivered(); event BuyerApproved(); event DisputeRaised(); event DisputeResolved(bool releaseFunds); event FundsReleased(); event FundsRefunded(); modifier onlyBuyer() { require(msg.sender == alice, "Alleen koper (Alice) kan deze actie uitvoeren"); _; } modifier onlySeller() { require(msg.sender == bob, "Alleen verkoper (Bob) kan deze actie uitvoeren"); _; } modifier onlyArbiter() { require(msg.sender == carol, "Alleen arbiter (Carol) kan deze actie uitvoeren"); _; } modifier inState(State expectedState) { require(currentState == expectedState, "Ongepaste staat"); _; } constructor(address _bob, address _carol) { alice = msg.sender; bob = _bob; carol = _carol; currentState = State.Created; emit EscrowCreated(alice, bob, carol); } // Alice stort het geld in het contract function depositFunds() external payable onlyBuyer inState(State.Created) { require(msg.value == escrowAmount, "Minimaal 1 ETH vereist"); currentState = State.Funded; emit FundsDeposited(msg.sender); } // Verkoper bevestigt dat goederen verzonden zijn function confirmGoodsDelivered() external onlySeller inState(State.Funded) { goodsDelivered = true; emit GoodsDelivered(); } // Koper geeft aan dat hij tevreden is en goedkeurt vrijgave function approveRelease() external onlyBuyer inState(State.Funded) { require(goodsDelivered, "Goederen nog niet geleverd"); buyerApproved = true; // Vrijgave van fondsen aan verkoper _releaseFunds(); currentState = State.Released; emit BuyerApproved(); } // Arbiter kan een geschil openen function raiseDispute() external onlyBuyer inState(State.Funded) { currentState = State.Disputed; emit DisputeRaised(); } // Arbiter beslist over het geschil // _release = true => vrijgave aan verkoper, anders terugbetaling koper function resolveDispute(bool _release) external onlyArbiter inState(State.Disputed) { if (_release) { _releaseFunds(); currentState = State.Resolved; emit DisputeResolved(true); } else { _refundFunds(); currentState = State.Resolved; emit DisputeResolved(false); } } // Vrijgave van fondsen aan verkoper function _releaseFunds() internal nonReentrant { require(currentState == State.Funded || currentState == State.Released, "Niet in juiste staat voor vrijgave"); require(address(this).balance >= escrowAmount, "Onvoldoende saldo"); payable(bob).transfer(escrowAmount); emit FundsReleased(); } // Terugbetaling aan koper function _refundFunds() internal nonReentrant { require(currentState == State.Funded || currentState == State.Disputed, "Niet in juiste staat voor terugbetaling"); require(address(this).balance >= escrowAmount, "Onvoldoende saldo"); payable(alice).transfer(escrowAmount); emit FundsRefunded(); } } ``` ### Belangrijke punten: - Het contract gebruikt `ReentrancyGuard` van OpenZeppelin om reentrancy-aanvallen te voorkomen. - Betalingen worden slechts één keer gedaan, door gebruik te maken van interne functies `_releaseFunds()` en `_refundFunds()`. - De staat van het contract wordt bijgehouden via een enum `State` om de logica te beheersen en beveiliging te bieden. - Partijen kunnen alleen acties uitvoeren die passen bij de huidige status, dankzij de modifiers. ### Hoe te gebruiken: 1. Alice start het contract en stuurt 1 ETH naar het contract via `depositFunds`. 2. Bob bevestigt verzending via `confirmGoodsDelivered`. 3. Alice geeft haar goedkeuring via `approveRelease`. 4. Als er een geschil is, kunnen Alice of Bob een geschil openen met `raiseDispute`. 5. De arbiter beslist via `resolveDispute` en bepaalt of de betaling wordt vrijgegeven of teruggestort. Dit contract is een basisvoorbeeld en kan verder uitgebreid worden met functies zoals tijdslimieten, event logging, en meer uitgebreide beveiliging afhankelijk van de eisen.

Zeker, hier is een veilig Solidity escrow-contract met uitleg: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.19; contract DecentralizedEscrow { // Partijen address public immutable koper; // Alice address public immutable verkoper; // Bob address public immutable arbiter; // Carol // Escrow bedrag uint256 public constant ESCROW_BEDRAG = 1 ether; // Contract status enum Status { Actief, Goedgekeurd, Geweigerd, Geschil } Status public status; // Beveiligingsvariabelen bool private locked; // Reentrancy guard // Events voor transparantie event EscrowGecreëerd(address koper, address verkoper, address arbiter); event Goedgekeurd(address door); event Geweigerd(address door); event GeschilAangemeld(address door); event Uitbetaling(address naar, uint256 bedrag); // Modifiers voor toegangscontrole modifier alleenPartijen() { require( msg.sender == koper || msg.sender == verkoper || msg.sender == arbiter, "Alleen contractpartijen" ); _; } modifier alleenArbiter() { require(msg.sender == arbiter, "Alleen arbiter"); _; } modifier alleenActief() { require(status == Status.Actief, "Escrow niet actief"); _; } // Reentrancy guard modifier nonReentrant() { require(!locked, "Geen reentrancy"); locked = true; _; locked = false; } constructor(address _verkoper, address _arbiter) payable { require(_verkoper != address(0), "Ongeldige verkoper"); require(_arbiter != address(0), "Ongeldige arbiter"); require(msg.value == ESCROW_BEDRAG, "Verkeerd escrow bedrag"); koper = msg.sender; verkoper = _verkoper; arbiter = _arbiter; status = Status.Actief; emit EscrowGecreëerd(koper, verkoper, arbiter); } // Koper keurt levering goed -> betaling naar verkoper function keurGoed() external alleenPartijen alleenActief nonReentrant { require(msg.sender == koper, "Alleen koper kan goedkeuren"); status = Status.Goedgekeurd; _betaal(verkoper, address(this).balance); emit Goedgekeurd(msg.sender); } // Koper weigert levering -> terugbetaling naar koper function weigerLevering() external alleenPartijen alleenActief nonReentrant { require(msg.sender == koper, "Alleen koper kan weigeren"); status = Status.Geweigerd; _betaal(koper, address(this).balance); emit Geweigerd(msg.sender); } // Partijen kunnen geschil starten (bij meningsverschil) function startGeschil() external alleenPartijen alleenActief { status = Status.Geschil; emit GeschilAangemeld(msg.sender); } // Arbiter beslist bij geschil function arbiterBeslissing(bool _goedkeuren) external alleenArbiter nonReentrant { require(status == Status.Geschil, "Geen actief geschil"); if (_goedkeuren) { status = Status.Goedgekeurd; _betaal(verkoper, address(this).balance); } else { status = Status.Geweigerd; _betaal(koper, address(this).balance); } } // Interne betalingsfunctie met beveiliging function _betaal(address _ontvanger, uint256 _bedrag) private { require(_bedrag > 0, "Geen saldo"); require(address(this).balance >= _bedrag, "Onvoldoende saldo"); // Status update voor dubbele uitbetalingen status = (_ontvanger == verkoper) ? Status.Goedgekeurd : Status.Geweigerd; (bool success, ) = _ontvanger.call{value: _bedrag}(""); require(success, "Betaling mislukt"); emit Uitbetaling(_ontvanger, _bedrag); } // Contract saldo opvragen function getSaldo() external view returns (uint256) { return address(this).balance; } // Fallback functie om ongewenste ETH stortingen te weigeren receive() external payable { revert("ETH stortingen niet toegestaan"); } fallback() external payable { revert("Ongeldige functie"); } } ``` ## Escrow Logica Uitleg: ### 1. **Initialisatie**: - Alice (koper) maakt het contract aan met 1 ETH - Bob (verkoper) en Carol (arbiter) adressen worden vastgelegd - Contract staat direct in "Actief" status ### 2. **Normale Stroom**: - **Goedgekeurd**: Alice roept `keurGoed()` aan → ETH gaat naar Bob - **Geweigerd**: Alice roept `weigerLevering()` aan → ETH terug naar Alice ### 3. **Geschilprocedure**: - Bij meningsverschil roept een partij `startGeschil()` aan - Carol (arbiter) beslist via `arbiterBeslissing()` - Arbiter kan kiezen voor uitbetaling aan verkoper of terugbetaling aan koper ## Beveiligingsmaatregelen: ### 1. **Reentrancy Protection**: - `nonReentrant` modifier gebruikt het "checks-effects-interactions" pattern - `locked` variabele voorkomt meerdere gelijktijdige aanroepen ### 2. **Dubbele Uitbetalingen**: - Status wordt direct geüpdatet voor betaling - Elke transactie vereist specifieke status (`alleenActief`) ### 3. **Toegangscontrole**: - `immutable` adressen voorkomen wijzigingen - Modifiers beperken functie-toegang tot geautoriseerde partijen ### 4. **Veilige Betalingen**: - `call()` met return value check - Saldo checks voorafgaand aan betaling ### 5. **Extra Beveiliging**: - Fallback functies blokkeren ongewenste ETH - Events voor transparantie en monitoring Dit contract biedt een robuuste escrow-dienst met duidelijke procedures en sterke beveiliging tegen veelvoorkomende smart contract kwetsbaarheden.