Blokkjede-smartkontrakter med Solidity · leksjon

Implementering av UUPS-proksymønsteret

Lær å implementere Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin for sikre oppgraderinger av kontrakter.

Leksjon 2 av 412 trinn

Implementering av UUPS-proksymønsteret er en gratis leksjon i Blokkjede-smartkontrakter med Solidity på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Blokkjede-smartkontrakter med Solidity, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Forstå UUPS

Universal Upgradeable Proxy Standard (UUPS) er et populært designmønster for å lage oppgraderbare smartkontrakter. Det gjør det mulig å endre logikken i en kontrakt uten å endre adressen dens på blokkjeden.

Dette er avgjørende for å rette feil, legge til nye funksjoner eller tilpasse seg endrede krav uten å miste brukerdata eller kontraktens tilstand.

Slik fungerer UUPS

UUPS bruker en proxykontrakt som inneholder kontraktens tilstand (data), og en separat implementasjonskontrakt som inneholder kontraktens logikk (funksjoner).

Proxykontrakt: En enkel, uforanderlig kontrakt som videresender kall til den gjeldende implementasjonen.
Implementasjonskontrakt: Inneholder den faktiske forretningslogikken. Det er denne kontrakten som oppgraderes.

Den viktigste forskjellen i UUPS er at oppgraderingslogikken ligger i implementasjonskontrakten, ikke i proxyen.

Bli kjent med OpenZeppelin

Det er komplekst og feilutsatt å implementere oppgraderbare kontrakter på riktig måte. Derfor stoler vi på velprøvde biblioteker som OpenZeppelin Contracts.

OpenZeppelin tilbyr sikre og reviderte implementasjoner av proxy-mønstre, inkludert UUPS, noe som gjør det langt tryggere og enklere å bygge oppgraderbare kontrakter.

Bygge UUPS-kontrakter

For at kontrakten skal være kompatibel med UUPS, må den arve fra OpenZeplins UUPSUpgradeable-kontrakt. Denne basiskontrakten tilbyr funksjonene og modifikatorene som kreves for oppgraderbarhet.

Husk at oppgraderbare kontrakter bruker en initializer-funksjon i stedet for en konstruktør, siden proxyen aldri kaller implementasjonens konstruktør direkte.

Vår første oppgraderbare kontrakt

Her er en grunnleggende kontrakt, MyContractV1, som er klar for UUPS-oppgraderinger. Legg merke til at den arver fra OpenZeplins UUPSUpgradeable. Vanligvis 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
}

Initialisere UUPS-kontrakter

I oppgraderbare kontrakter kan du ikke bruke en vanlig konstruktør. Proxy-kontrakten distribueres én gang, og konstruktøren dens blir kalt. Implementasjonskontraktens konstruktør blir aldri kalt når proxyen distribueres eller oppgraderes.

I stedet bruker du en initializer-funksjon. Denne funksjonen kalles én gang, vanligvis rett etter at proxyen er distribuert, for å sette opp den opprinnelige tilstanden til logikkontrakten.

Initialisere tilstand

La oss legge til en initializer i MyContractV1. Vi bruker __UUPSUpgradeable_init() og __Ownable_init() for å initialisere basiskontraktene riktig, og Reinitializer(1) for å 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 {}
}

Distribuere UUPS-kontrakten

Distribuering av UUPS-kontrakter innebærer bruk av en oppgraderingsplugin (for eksempel for Hardhat eller Truffle). Denne pluginen håndterer opprettelsen av proxyen og kobler den til den opprinnelige implementasjonskontrakten.

Den distribuerer implementasjonskontrakten.
Den distribuerer proxy-kontrakten, som peker på implementasjonen.
Den kaller initialize-funksjonen på proxyen.

Denne prosessen sørger for at kontrakten er riktig satt opp for fremtidige oppgraderinger.

Gjennomføre en oppgradering

Når du vil oppgradere kontrakten, distribuerer du en ny versjon av implementasjonskontrakten (for eksempel MyContractV2). Deretter kaller du en oppgraderingsfunksjon på den eksisterende proxy-kontrakten og ber den peke på den nye implementasjonen.

_authorizeUpgrade-funksjonen i implementasjonskontrakten styrer hvem som har tillatelse til å gjennomføre oppgraderingen, og er ofte begrenset til kontraktseieren.

Oppgradere logikken

La oss tenke oss at vi vil legge til en ny funksjon i MyContractV1. Vi oppretter MyContractV2, som arver fra MyContractV1 for å videreføre tilstanden og den eksisterende logikken. Deretter legger vi til den nye funksjonen.

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

Viktige UUPS-konsepter

Hvilke av følgende påstander er SANNE når det gjelder Universal Upgradeable Proxy Standard (UUPS) implementert med OpenZeppelin?

Besvar den i den interaktive leksjonen

UUPS: Sikre oppgraderinger

I denne leksjonen har du lært om Universal Upgradeable Proxy Standard (UUPS) og hvordan den implementeres ved hjelp av OpenZeppelin Contracts.

UUPS skiller tilstand (proxy) fra logikk (implementasjon).
Du bruker UUPSUpgradeable som basiskontrakt.
initialize-funksjoner erstatter konstruktører ved oppsett.
OpenZeplins oppgraderingsplugins forenkler distribuering og oppgraderinger.

UUPS er et kraftig mønster for å bygge fremtidssikre smartkontrakter!

Gratis å komme i gang

Lær deg Blokkjede-smartkontrakter med Solidity med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Implementering av UUPS-proksymønsteret» gratis?

Ja – hele teksten i «Implementering av UUPS-proksymønsteret» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Blokkjede-smartkontrakter med Solidity-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva lærer jeg i «Implementering av UUPS-proksymønsteret»?

Lær å implementere Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin for sikre oppgraderinger av kontrakter. Du øver på Blokkjede-smartkontrakter med Solidity med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Blokkjede-smartkontrakter med Solidity?

Ingen tidligere erfaring er nødvendig. Blokkjede-smartkontrakter med Solidity på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Implementering av UUPS-proksymønsteret»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Blokkjede-smartkontrakter med Solidity-leksjonen?

Ja. Alle Blokkjede-smartkontrakter med Solidity-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Hvorfor oppgraderbare kontrakter?
Implementering av UUPS-proksymønsteret
Diamond-standarden (proksyer med flere fasetter)
Transparent Proxy-mønsteret og lagringslayout

← Tilbake til Blokkjede-smartkontrakter med Solidity