Een smart contract is een zelfuitvoerend contract waarbij de voorwaarden van de overeenkomst zijn vastgelegd in computercode. Zodra aan bepaalde voorwaarden is voldaan, voert het contract zichzelf uit zonder dat er een tussenpersoon nodig is. Smart contracts draaien meestal op EVM-blockchain-netwerken zoals Ethereum.

Geschiedenis en evolutie van smart contracts

Het concept van smart contracts werd al in de jaren '90 bedacht door Nick Szabo, een pionier op het gebied van digitale contracten. Szabo stelde zich een toekomst voor waarin contracten automatisch en zonder tussenpersonen uitgevoerd zouden worden. Met de opkomst van blockchain-technologie, en in het bijzonder Ethereum, is dit concept werkelijkheid geworden. Deze evolutie heeft geleid tot tal van innovaties binnen de financiële sector, supply chain management en nog veel meer.

Hoe werkt een smart contract?

Een smart contract is als een automatische verkoopmachine (bijvoorbeeld een frisdrankautomaat):

1. Je stopt geld in de frisdrankautomaat (cryptocurrency in de blockchain).
2. De automaat controleert automatisch of het voldoende geld is ingestopt (de smart contract-code checkt de voorwaarden).
3. Als je genoeg hebt betaald, geeft de automaat het product (de smart contract voltooit de transactie).
4. Als je te weinig betaalt, krijg je niets en blijft je geld vaststaan of wordt het teruggegeven (de transactie wordt niet uitgevoerd).

De vending machine voert de overeenkomst uit zonder dat er een mens aan te pas komt. Er is geen kassier nodig om te beslissen of je het product krijgt. Op dezelfde manier voert een smart contract een digitale overeenkomst uit zonder dat een tussenpersoon, zoals een bank of een notaris, nodig is.

Stap voor stap vergelijking

1. Invoer (geld of crypto)

   • Frisdrankautomaat → Je stopt €2 in de automaat.
   • Smart contract → Je stuurt 0.01 ETH naar het smart contract.

2. Controle van de voorwaarden

   • Frisdrankautomaat → De machine controleert of je genoeg geld hebt ingevoerd.
   • Smart contract → De code checkt of je aan de voorwaarden voldoet (bijvoorbeeld: heb je genoeg crypto gestuurd?).

3. Automatische uitvoering

   • Frisdrankautomaat → Als je genoeg hebt betaald, wordt de frisdrank automatisch uitgeleverd.
   • Smart contract → Als de voorwaarden zijn voldaan, wordt de transactie automatisch uitgevoerd (bijvoorbeeld: NFT overgedragen, geld vrijgegeven, toegang verleend).

4. Geen tussenpersoon nodig

   • Frisdrankautomaat → Er is geen verkoper nodig om je de frisdrank te geven.
   • Smart contract → Er is geen notaris, bank of bemiddelaar nodig om de transactie goed te keuren.

5. Uitkomst is gegarandeerd

   • Frisdrankautomaat → Als de machine correct werkt en je genoeg hebt betaald, krijg je altijd je frisdrank.
   • Smart contract → Als de code correct is geprogrammeerd, wordt het contract altijd uitgevoerd zoals afgesproken.

Kenmerken van smart contracts

Autonoom
Zodra een smart contract is geïmplementeerd en gedeployed op een blockchain, kan niemand het zomaar wijzigen. De regels zijn vastgelegd in de code, waardoor het contract zelfstandig opereert.
Voorbeeld: Stel dat een smart contract wordt gebruikt voor een crowdfundingcampagne. In dat contract staat vastgelegd dat de ingezamelde fondsen slechts worden vrijgegeven wanneer een bepaald doelbedrag is bereikt. Zelfs als de organisator achteraf van gedachten verandert, kan de code niet aangepast worden om de fondsen op een andere manier te benutten.

Automatisch
De uitvoering van een smart contract gebeurt volledig automatisch wanneer aan de vooraf gedefinieerde voorwaarden is voldaan. Er is geen menselijke tussenkomst nodig om de actie uit te voeren.
Voorbeeld: Bij een escrow-systeem voor een online aankoop stort de koper het geld in een smart contract. Zodra de verkoper bevestigt dat het product is geleverd, voert het contract direct de betaling uit naar de verkoper, zonder dat een bank of notaris betrokken is.

Transparant
De werking van smart contracts is volledig zichtbaar voor iedereen op de blockchain, inclusief de broncode en de transacties. Dit zorgt voor controle en vertrouwen voor alle betrokken partijen.
Voorbeeld: In de DeFi (gedecentraliseerde financiën) sector kunnen gebruikers de code van een smart contract inspecteren om er zeker van te zijn dat er geen verborgen regels of achterdeurtjes in zitten, en tegelijkertijd alle transacties verifiëren die via het contract verlopen.

Onveranderlijk
Eenmaal gedeployed op de blockchain kan de code van een smart contract niet worden gewijzigd. Dit zorgt ervoor dat de regels en voorwaarden voor altijd vastliggen en niet achteraf aangepast kunnen worden.
Voorbeeld: Bij een verzekeringssmart contract dat automatisch schadeclaims afhandelt, is ervoor gezorgd dat de overeengekomen voorwaarden nooit kunnen worden gewijzigd nadat het contract is vastgelegd. Hierdoor is het onmogelijk om achteraf regels te manipuleren ten gunste van één van de partijen.

Vertrouwensvrij
Smart contracts elimineren de noodzaak van een derde partij (zoals een bank of notaris) om vertrouwen te waarborgen. Het systeem vertrouwt op de blockchain en de vooraf bepaalde code voor de uitvoering van transacties.
Voorbeeld: In een gedecentraliseerde beurshandel (DEX) hoeven handelspartijen elkaar niet persoonlijk te vertrouwen. Transacties worden door het smart contract automatisch en volgens vaststaande regels uitgevoerd, wat het risico op fraude of misbruik minimaliseert.

Technische diepgang: Hoe werkt een smart contract op Ethereum?

• Smart contracts worden geschreven in programmeertalen zoals Solidity voor Ethereum, Rust voor Solana, en Cairo voor Starknet.
• Ze worden gedeployed (geüpload) naar de blockchain, waar ze een uniek adres krijgen. Dit zijn als het ware rekeningenadressen op de blockchain. Deze kun je herkennen aan het begin van het adres, bijvoorbeeld: 0x1234A6627b34dA0B357D2fcc2Cbe6baC165EE4b4.
• Gebruikers kunnen functies aanroepen in het contract (bijvoorbeeld geld storten, een transactie voltooien).
• De Ethereum Virtual Machine (EVM) voert de code uit en zorgt ervoor dat de regels worden nageleefd.
• De uitkomsten van het contract worden opgeslagen op de blockchain, zodat ze niet kunnen worden veranderd.

Toepassingen van smart contracts

1. Financiën (DeFi) → Leningen, staking, automatische betalingen.
2. NFT's → Eigenaarschap van digitale kunst en verzamelobjecten.
3. Supply Chain → Automatische tracking van goederen.
4. Stemmen → Veilige en transparante digitale verkiezingen.
5. Kaartjes → Kaartjes voor evenementen, tickets voor concerten, etc.

Risico's en uitdagingen van smart contracts

Hoewel smart contracts veel voordelen bieden, brengen ze ook bepaalde risico's met zich mee:

• Onherroepelijkheid: Eenmaal gedeployed kunnen fouten in de code niet eenvoudig worden hersteld.
• Veiligheidslekken: Fouten in de code, zoals reentrancy-aanvallen, kunnen leiden tot grote verliezen. Met miljoenen euro's schade tot gevolg.
• Hoge transactiekosten (gas fees): Tijdens drukke netwerkperiodes kunnen transactiekosten aanzienlijk stijgen.
• Complexiteit van regelgeving: De juridische status van smart contracts is in veel landen nog in ontwikkeling.

Het is daarom essentieel om smart contracts grondig te testen en te laten auditen voordat ze in productie worden genomen. Neem contact op met ons voor een audit.

Voorbeeld van een smart contract voor een vending machine:

Niet gebruiken in productie, enkel als voorbeeld. Zelf proberen te compilen en te deployen? Klik hier voor een remix IDE.

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

contract VendingMachine {
    address public owner;
    mapping(uint => uint) public prices;    // productId => price in wei
    mapping(uint => uint) public inventory;   // productId => aantal beschikbaar

    event ProductPurchased(uint productId, address buyer);

    constructor() {
        owner = msg.sender;

        // Initiële prijzen instellen (1 ETH = 10^18 wei)
        prices[1] = 1e18; // Cola: 1 ETH
        prices[2] = 2e18; // Sinas: 2 ETH

        // Initiële voorraad instellen
        inventory[1] = 10; // 10 Cola's
        inventory[2] = 10; // 10 Sinas
    }

    function buyProduct(uint productId) public payable {
        require(prices[productId] > 0, "Product bestaat niet");
        require(inventory[productId] > 0, "Product is uitverkocht");
        require(msg.value >= prices[productId], "Onvoldoende betaald");

        inventory[productId]--;

        // Geef teveel betaald bedrag terug
        if (msg.value > prices[productId]) {
            payable(msg.sender).transfer(msg.value - prices[productId]);
        }

        emit ProductPurchased(productId, msg.sender);
    }

    function restockProduct(uint productId, uint amount) public {
        require(msg.sender == owner, "Alleen de eigenaar kan bijvullen");
        inventory[productId] += amount;
    }

    function withdrawFunds() public {
        require(msg.sender == owner, "Alleen de eigenaar kan geld opnemen");
        payable(owner).transfer(address(this).balance);
    }
}