Blockchain-smart contracts med Solidity · Lektion

Implementering af UUPS-proxymønsteret

Lær at implementere Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin for sikre kontraktopgraderinger.

Lektion 2 af 412 trin

Implementering af UUPS-proxymønsteret er en gratis Blockchain-smart contracts med Solidity-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Blockchain-smart contracts med Solidity, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.

Forstå UUPS

Universal Upgradeable Proxy Standard (UUPS) er et populært designmønster til oprettelse af opgraderbare smartkontrakter. Det giver dig mulighed for at ændre en kontrakts logik uden at ændre dens adresse på blockchainen.

Det er afgørende for at rette fejl, tilføje nye funktioner eller tilpasse sig ændrede krav uden at miste brugerdata eller kontraktens tilstand.

Sådan fungerer UUPS

UUPS bruger en proxykontrakt, der indeholder kontraktens tilstand (data), og en separat implementeringskontrakt, der indeholder kontraktens logik (funktioner).

Proxykontrakt: En enkel, uforanderlig kontrakt, der videresender kald til den aktuelle implementering.
Implementeringskontrakt: Indeholder den faktiske forretningslogik. Det er denne kontrakt, der opgraderes.

Den afgørende forskel ved UUPS er, at opgraderingslogikken ligger i implementeringskontrakten og ikke i proxyen.

At have tillid til OpenZeppelin

Det er komplekst og fejlbehæftet at implementere opgraderbare kontrakter korrekt. Derfor benytter vi gennemprøvede biblioteker som OpenZeppelin Contracts.

OpenZeppelin leverer sikre og auditerede implementeringer af proxymønstre, herunder UUPS, hvilket gør det langt sikrere og nemmere at bygge opgraderbare kontrakter.

Opbygning af UUPS-kontrakter

For at gøre din kontrakt kompatibel med UUPS skal den nedarve fra OpenZeppelins UUPSUpgradeable-kontrakt. Denne basiskontrakt leverer de nødvendige funktioner og modifikatorer til opgraderbarhed.

Husk, at opgraderbare kontrakter bruger en initializer-funktion i stedet for en konstruktør, fordi proxyen aldrig kalder implementeringens konstruktør direkte.

Vores første opgraderbare kontrakt

Her er en grundlæggende kontrakt, MyContractV1, der er klar til UUPS-opgraderinger. Bemærk, at den nedarver fra OpenZeppelins UUPSUpgradeable. Normalt installerer du OpenZeppelin-kontrakter via npm og importerer dem.

// 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
}

Initialisering af UUPS-kontrakter

I opgraderbare kontrakter kan du ikke bruge en almindelig konstruktør. Proxykontrakten implementeres én gang, og dens konstruktør kaldes. Implementeringskontraktens konstruktør kaldes aldrig, når proxyen implementeres eller opgraderes.

I stedet bruger du en initializer-funktion. Denne funktion kaldes én gang, normalt lige efter at proxyen er implementeret, for at konfigurere den indledende tilstand for din logikkontrakt.

Initialisering af tilstand

Lad os tilføje en initialisering til vores MyContractV1. Vi bruger __UUPSUpgradeable_init() og __Ownable_init() til at initialisere basiskontrakter korrekt, og Reinitializer(1) til at forhindre flere initialiseringer.

// 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 {}
}

Implementering af din UUPS-kontrakt

Implementering af UUPS-kontrakter indebærer brug af et opgraderingsplugin, f.eks. til Hardhat eller Truffle. Dette plugin håndterer oprettelsen af proxyen og forbinder den med din oprindelige implementeringskontrakt.

Det implementerer din implementeringskontrakt.
Det implementerer proxykontrakten, som peger på din implementering.
Det kalder funktionen initialize på proxyen.

Denne proces sikrer, at din kontrakt er konfigureret korrekt til fremtidige opgraderinger.

Gennemførelse af en opgradering

Når du vil opgradere din kontrakt, implementerer du en ny version af din implementeringskontrakt, f.eks. MyContractV2. Derefter kalder du en opgraderingsfunktion på den eksisterende proxykontrakt og angiver, at den skal pege på den nye implementering.

Funktionen _authorizeUpgrade i din implementeringskontrakt styrer, hvem der har tilladelse til at gennemføre denne opgradering. Tilladelsen er ofte begrænset til kontraktens ejer.

Opgradering af din logik

Lad os forestille os, at vi vil tilføje en ny funktion til MyContractV1. Vi opretter MyContractV2, som nedarver fra MyContractV1 for at videreføre dens tilstand og eksisterende logik. Derefter tilføjer vi vores nye funktion.

// 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.
}

Vigtige UUPS-begreber

Hvilke af følgende udsagn er SANDE om Universal Upgradeable Proxy Standard (UUPS), der er implementeret med OpenZeppelin?

Besvar den i den interaktive lektion

UUPS: Sikker opgradering

I denne lektion har du lært om Universal Upgradeable Proxy Standard (UUPS) og om, hvordan den implementeres ved hjælp af OpenZeppelin Contracts.

UUPS adskiller tilstand (proxy) fra logik (implementering).
Du bruger UUPSUpgradeable som basiskontrakt.
initialize-funktioner erstatter konstruktører ved opsætning.
OpenZeppelins opgraderingsplugins forenkler implementering og opgraderinger.

UUPS er et effektivt mønster til at bygge fremtidssikrede smarte kontrakter!

Gratis at komme i gang

Lær Blockchain-smart contracts med Solidity med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Implementering af UUPS-proxymønsteret” gratis?

Ja — hele teksten til “Implementering af UUPS-proxymønsteret” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Blockchain-smart contracts med Solidity-kurset, skal du opgradere til CoddyKit PRO. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Implementering af UUPS-proxymønsteret”?

Lær at implementere Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin for sikre kontraktopgraderinger. Du øver dig i Blockchain-smart contracts med Solidity med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Blockchain-smart contracts med Solidity?

Der kræves ingen tidligere erfaring. Blockchain-smart contracts med Solidity på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Implementering af UUPS-proxymønsteret”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Blockchain-smart contracts med Solidity-lektion?

Ja. Alle Blockchain-smart contracts med Solidity-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Hvorfor opgraderbare kontrakter?
Implementering af UUPS-proxymønsteret
Diamond-standarden (multifacet-proxies)
Mønsteret Transparent Proxy og storage-layout

← Tilbage til Blockchain-smart contracts med Solidity