Smarta blockkedjekontrakt med Solidity · Lektion

Implementera UUPS-proxymönstret

Lär er att implementera Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin för säkra uppgraderingar av kontrakt.

Lektion 2 av 412 steg

Implementera UUPS-proxymönstret är en gratis lektion i Smarta blockkedjekontrakt med Solidity på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Smarta blockkedjekontrakt med Solidity, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Förstå UUPS

Universal Upgradeable Proxy Standard (UUPS) är ett populärt designmönster för att skapa uppgraderingsbara smartkontrakt. Det gör det möjligt att ändra ett kontrakts logik utan att ändra dess adress på blockkedjan.

Detta är avgörande för att åtgärda fel, lägga till nya funktioner eller anpassa sig till förändrade krav utan att förlora användardata eller kontraktets tillstånd.

Så fungerar UUPS

UUPS använder ett proxykontrakt som lagrar kontraktets tillstånd (data) och ett separat implementeringskontrakt som innehåller kontraktets logik (funktioner).

Proxykontrakt: Ett enkelt, oföränderligt kontrakt som vidarebefordrar anrop till den aktuella implementeringen.
Implementeringskontrakt: Innehåller den faktiska affärslogiken. Det är detta kontrakt som uppgraderas.

Den viktiga skillnaden med UUPS är att uppgraderingslogiken finns i implementeringskontraktet, inte i proxykontraktet.

Att lita på OpenZeppelin

Att implementera uppgraderbara kontrakt korrekt är komplext och felbenäget. Därför förlitar vi oss på väl beprövade bibliotek som OpenZeppelin Contracts.

OpenZeppelin tillhandahåller säkra och granskade implementationer av proxymönster, inklusive UUPS, vilket gör det betydligt säkrare och enklare att bygga uppgraderbara kontrakt.

Bygga UUPS-kontrakt

För att göra ditt kontrakt kompatibelt med UUPS måste det ärva från OpenZeppelins UUPSUpgradeable-kontrakt. Detta baskontrakt tillhandahåller de funktioner och modifierare som krävs för uppgraderbarhet.

Kom ihåg att uppgraderbara kontrakt använder en initializer-funktion i stället för en konstruktor, eftersom proxyn aldrig anropar implementationens konstruktor direkt.

Vårt första uppgraderbara kontrakt

Här är ett grundläggande kontrakt, MyContractV1, som är förberett för UUPS-uppgraderingar. Observera att det ärver från OpenZeppelins UUPSUpgradeable. Vanligtvis installerar du OpenZeppelin-kontrakt via npm och importerar 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
}

Initiera UUPS-kontrakt

I uppgraderbara kontrakt kan du inte använda en vanlig konstruktor. Proxykontraktet distribueras en gång och dess konstruktor anropas. Implementationens konstruktor anropas aldrig när proxyn distribueras eller uppgraderas.

I stället använder du en initializer-funktion. Denna funktion anropas en gång, vanligtvis direkt efter att proxyn har distribuerats, för att konfigurera det initiala tillståndet i ditt logikkontrakt.

Initiera tillstånd

Vi lägger till en initializer i vår MyContractV1. Vi använder __UUPSUpgradeable_init() och __Ownable_init() för att initiera baskontrakten korrekt, samt Reinitializer(1) för att förhindra flera initieringar.

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

Distribuera ditt UUPS-kontrakt

För att distribuera UUPS-kontrakt använder du ett uppgraderingsplugin, till exempel för Hardhat eller Truffle. Detta plugin hanterar skapandet av proxyn och kopplar den till ditt ursprungliga implementationkontrakt.

Det distribuerar ditt implementationkontrakt.
Det distribuerar proxykontraktet, som pekar på din implementation.
Det anropar funktionen initialize på proxyn.

Denna process säkerställer att kontraktet är korrekt konfigurerat för framtida uppgraderingar.

Genomföra en uppgradering

När du vill uppgradera ditt kontrakt distribuerar du en ny version av implementationkontraktet, till exempel MyContractV2. Sedan anropar du en uppgraderingsfunktion på det befintliga proxykontraktet och anger att det ska peka på den nya implementationen.

Funktionen _authorizeUpgrade i ditt implementationkontrakt styr vem som har behörighet att genomföra uppgraderingen. Behörigheten begränsas ofta till kontraktets ägare.

Uppgradera din logik

Anta att vi vill lägga till en ny funktion i MyContractV1. Vi skapar MyContractV2, som ärver från MyContractV1 för att behålla dess tillstånd och befintliga logik. Sedan lägger vi till vår nya 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.
}

Viktiga UUPS-begrepp

Vilka av följande påståenden är SANNA när det gäller Universal Upgradeable Proxy Standard (UUPS), implementerad med OpenZeppelin?

Besvara frågan i den interaktiva lektionen

UUPS: Säkra uppgraderingar

I den här lektionen har du lärt dig om Universal Upgradeable Proxy Standard (UUPS) och hur den implementeras med OpenZeppelin Contracts.

UUPS separerar tillståndet (proxyn) från logiken (implementationen).
Du använder UUPSUpgradeable som baskontrakt.
initialize-funktioner ersätter konstruktorer vid konfigurering.
OpenZeppelins uppgraderingsplugins förenklar distribution och uppgraderingar.

UUPS är ett kraftfullt mönster för att bygga framtidssäkra smarta kontrakt!

Gratis att börja

Lär dig Smarta blockkedjekontrakt med Solidity med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implementera UUPS-proxymönstret” gratis?

Ja – hela texten till ”Implementera UUPS-proxymönstret” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Smarta blockkedjekontrakt med Solidity, kan Ni uppgradera till CoddyKit PRO. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera UUPS-proxymönstret”?

Lär er att implementera Universal Upgradeable Proxy Standard (UUPS) med OpenZeppelin för säkra uppgraderingar av kontrakt. Ni övar på Smarta blockkedjekontrakt med Solidity med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Smarta blockkedjekontrakt med Solidity?

Du behöver inga förkunskaper. Utbildningen i Smarta blockkedjekontrakt med Solidity på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Implementera UUPS-proxymönstret”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Smarta blockkedjekontrakt med Solidity-lektionen?

Ja. Varje Smarta blockkedjekontrakt med Solidity-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Varför uppgraderingsbara kontrakt?
Implementera UUPS-proxymönstret
Diamond Standard (proxies med flera facets)
Mönstret Transparent Proxy och lagringslayout

← Tillbaka till Smarta blockkedjekontrakt med Solidity