Blockchain-smart contracts met Solidity · Les

Implementatie van het UUPS-proxypatroon

Leer de Universal Upgradeable Proxy Standard (UUPS) te implementeren met OpenZeppelin voor veilige contractupgrades.

Les 2 van 412 stappen

Implementatie van het UUPS-proxypatroon is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Blockchain-smart contracts met Solidity. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

UUPS begrijpen

De Universal Upgradeable Proxy Standard (UUPS) is een populair ontwerppatroon voor het maken van opwaardeerbare smart contracts. Hiermee kun je de logica van een contract wijzigen zonder het adres op de blockchain te wijzigen.

Dit is cruciaal voor het oplossen van bugs, het toevoegen van nieuwe functies of het aanpassen aan veranderende vereisten, zonder gebruikersgegevens of de contractstatus te verliezen.

Hoe UUPS werkt

UUPS gebruikt een proxycontract dat de status (gegevens) van het contract bevat en een afzonderlijk implementatiecontract dat de logica (functies) van het contract bevat.

Proxycontract: Een eenvoudig, onveranderlijk contract dat aanroepen doorstuurt naar de huidige implementatie.
Implementatiecontract: Bevat de daadwerkelijke bedrijfslogica. Dit is het contract dat wordt opgewaardeerd.

Het belangrijkste verschil bij UUPS is dat de opwaardeerlogica in het implementatiecontract zit en niet in de proxy.

Vertrouwen op OpenZeppelin

Upgradeable contracten correct implementeren is complex en foutgevoelig. Daarom vertrouwen we op grondig geteste bibliotheken zoals OpenZeppelin Contracts.

OpenZeppelin biedt veilige en gecontroleerde implementaties van proxypatronen, waaronder UUPS. Daardoor wordt het veel veiliger en eenvoudiger om upgradeable contracten te bouwen.

UUPS-contracten bouwen

Om je contract compatibel te maken met UUPS, moet het overerven van het UUPSUpgradeable-contract van OpenZeppelin. Dit basiscontract biedt de benodigde functies en modifiers voor upgradebaarheid.

Houd er rekening mee dat upgradeable contracten een initializer-functie gebruiken in plaats van een constructor, omdat de proxy de constructor van de implementatie nooit rechtstreeks aanroept.

Ons eerste upgradeable contract

Hier is een eenvoudig contract, MyContractV1, dat klaar is voor UUPS-upgrades. Let erop dat het overerft van OpenZeppelins UUPSUpgradeable. Gewoonlijk installeer je OpenZeppelin-contracten via npm en importeer je ze.

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

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract MyContractV1 is UUPSUpgradeable {
    // This contract will contain our initial logic
    // We'll add an initializer in the next scene
}

UUPS-contracten initialiseren

In upgradeable contracten kun je geen gewone constructor gebruiken. Het proxycontract wordt één keer gedeployed en de constructor daarvan wordt aangeroepen. De constructor van het implementatiecontract wordt nooit aangeroepen wanneer de proxy wordt gedeployed of geüpgraded.

In plaats daarvan gebruik je een initializer-functie. Deze functie wordt één keer aangeroepen, meestal direct nadat de proxy is gedeployed, om de beginstatus van je logica-contract in te stellen.

Status initialiseren

Laten we een initializer toevoegen aan onze MyContractV1. We gebruiken __UUPSUpgradeable_init() en __Ownable_init() om basiscontracten correct te initialiseren, en Reinitializer(1) om meerdere initialisaties te voorkomen.

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

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract MyContractV1 is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    string public message;

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    function initialize(string memory initialMessage) public initializer {
        __UUPSUpgradeable_init();
        __Ownable_init(); // Initialize Ownable for access control
        message = initialMessage;
    }

    function setMessage(string memory newMessage) public onlyOwner {
        message = newMessage;
    }

    // Required for UUPS, defines who can upgrade
    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
}

Je UUPS-contract deployen

Bij het deployen van UUPS-contracten gebruik je een upgradeplug-in, bijvoorbeeld voor Hardhat of Truffle. Deze plug-in maakt de proxy aan en koppelt die aan je eerste implementatiecontract.

De plug-in deployt je implementatiecontract.
De plug-in deployt het proxycontract, dat naar je implementatie verwijst.
De plug-in roept de functie initialize aan op de proxy.

Dit proces zorgt ervoor dat je contract correct is ingesteld voor toekomstige upgrades.

Een upgrade uitvoeren

Wanneer je je contract wilt upgraden, deploy je een nieuwe versie van je implementatiecontract, bijvoorbeeld MyContractV2. Vervolgens roep je een upgradefunctie aan op het bestaande proxycontract en geef je aan dat dit naar de nieuwe implementatie moet verwijzen.

De functie _authorizeUpgrade in je implementatiecontract bepaalt wie toestemming heeft om deze upgrade uit te voeren. Vaak is dit beperkt tot de eigenaar van het contract.

Je logica upgraden

Laten we ons voorstellen dat we een nieuwe functie willen toevoegen aan MyContractV1. We maken MyContractV2, die overerft van MyContractV1 om de status en bestaande logica over te nemen. Vervolgens voegen we onze nieuwe functie toe.

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

import "./MyContractV1.sol"; // Assuming MyContractV1 is in the same directory

contract MyContractV2 is MyContractV1 {
    uint public counter; // New state variable

    // We don't need a new initializer unless we have new base contracts
    // to initialize, or specific V2 setup.

    function incrementCounter() public onlyOwner {
        counter++;
    }

    // Existing functions like setMessage and message getter are still available
    // via the proxy, using the logic from MyContractV2.
}

Belangrijke UUPS-concepten

Welke van de volgende uitspraken zijn WAAR over de Universal Upgradeable Proxy Standard (UUPS), geïmplementeerd met OpenZeppelin?

Beantwoord dit in de interactieve les

UUPS: veilige upgrades

In deze les heb je geleerd over de Universal Upgradeable Proxy Standard (UUPS) en hoe je deze implementeert met OpenZeppelin Contracts.

UUPS scheidt status (proxy) van logica (implementatie).
Je gebruikt UUPSUpgradeable als basiscontract.
Functies zoals initialize vervangen constructors voor het instellen van de beginstatus.
De upgradeplug-ins van OpenZeppelin vereenvoudigen het deployen en upgraden.

UUPS is een krachtig patroon voor het bouwen van toekomstbestendige slimme contracten!

Gratis beginnen

Leer Blockchain-smart contracts met Solidity met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Implementatie van het UUPS-proxypatroon” gratis?

Ja — de volledige tekst van “Implementatie van het UUPS-proxypatroon” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Blockchain-smart contracts met Solidity wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Wat leer ik in “Implementatie van het UUPS-proxypatroon”?

Leer de Universal Upgradeable Proxy Standard (UUPS) te implementeren met OpenZeppelin voor veilige contractupgrades. Je oefent met Blockchain-smart contracts met Solidity door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Blockchain-smart contracts met Solidity te beginnen?

Ervaring vooraf is niet nodig. Blockchain-smart contracts met Solidity op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Implementatie van het UUPS-proxypatroon”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Blockchain-smart contracts met Solidity?

Ja. Elke les over Blockchain-smart contracts met Solidity bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Waarom upgradebare contracten?
Implementatie van het UUPS-proxypatroon
Diamond Standard (proxies met meerdere facets)
Transparent Proxy-patroon en storage-layout

← Terug naar Blockchain-smart contracts met Solidity