Implementazione del pattern proxy UUPS
Impari a implementare il Universal Upgradeable Proxy Standard (UUPS) utilizzando OpenZeppelin per aggiornare i contratti in modo sicuro.
Implementazione del pattern proxy UUPS è una lezione Blockchain Smart Contracts with Solidity gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Blockchain Smart Contracts with Solidity, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Understanding UUPS
The Universal Upgradeable Proxy Standard (UUPS) is a popular design pattern for creating upgradeable smart contracts. It allows you to change a contract's logic without changing its address on the blockchain.
This is crucial for fixing bugs, adding new features, or adapting to changing requirements without losing user data or contract state.
How UUPS Works
UUPS uses a proxy contract that holds the contract's state (data) and a separate implementation contract that holds the contract's logic (functions).
- Proxy Contract: A simple, unchanging contract that forwards calls to the current implementation.
- Implementation Contract: Contains the actual business logic. This is the contract that gets upgraded.
The key difference in UUPS is that the upgrade logic resides within the implementation contract, not the proxy.
Trusting OpenZeppelin
Implementing upgradeable contracts correctly is complex and prone to errors. That's why we rely on battle-tested libraries like OpenZeppelin Contracts.
OpenZeppelin provides secure and audited implementations of proxy patterns, including UUPS, making it much safer and easier to build upgradeable contracts.
Building UUPS Contracts
To make your contract UUPS-compatible, it needs to inherit from OpenZeppelin's UUPSUpgradeable contract. This base contract provides the necessary functions and modifiers for upgradeability.
Remember, upgradeable contracts use an initializer function instead of a constructor, as the proxy never calls the implementation's constructor directly.
Our First Upgradeable Contract
Here's a basic contract, MyContractV1, ready for UUPS upgrades. Notice it inherits from OpenZeppelin's UUPSUpgradeable. You'll typically install OpenZeppelin contracts via npm and import them.
// 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
}Initializing UUPS Contracts
In upgradeable contracts, you cannot use a regular constructor. The proxy contract is deployed once, and its constructor is called. The implementation contract's constructor is never called when the proxy is deployed or upgraded.
Instead, you use an initializer function. This function is called once, typically right after the proxy is deployed, to set up the initial state of your logic contract.
Initializing State
Let's add an initializer to our MyContractV1. We use __UUPSUpgradeable_init() and __Ownable_init() to properly initialize base contracts, and Reinitializer(1) to prevent multiple initializations.
// 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 {}
}Deploying Your UUPS Contract
Deploying UUPS contracts involves using an upgrades plugin (e.g., for Hardhat or Truffle). This plugin handles creating the proxy and linking it to your initial implementation contract.
- It deploys your implementation contract.
- It deploys the proxy contract, pointing to your implementation.
- It calls the
initializefunction on the proxy.
This process ensures your contract is correctly set up for future upgrades.
Performing an Upgrade
When you want to upgrade your contract, you deploy a new version of your implementation contract (e.g., MyContractV2). Then, you call an upgrade function on the existing proxy contract, telling it to point to the new implementation.
The _authorizeUpgrade function in your implementation contract controls who has permission to perform this upgrade, often restricted to the contract owner.
Upgrading Your Logic
Let's imagine we want to add a new feature to MyContractV1. We create MyContractV2, inheriting from MyContractV1 to carry over its state and existing logic. We then add our new function.
// 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.
}UUPS Key Concepts
Which of the following statements are TRUE regarding the Universal Upgradeable Proxy Standard (UUPS) implemented with OpenZeppelin?
UUPS: Secure Upgrades
In this lesson, you learned about the Universal Upgradeable Proxy Standard (UUPS) and how to implement it using OpenZeppelin Contracts.
- UUPS separates state (proxy) from logic (implementation).
- You use
UUPSUpgradeableas a base contract. initializefunctions replace constructors for setup.- OpenZeppelin's upgrade plugins simplify deployment and upgrades.
UUPS is a powerful pattern for building future-proof smart contracts!
Impara Blockchain Smart Contracts with Solidity con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Implementazione del pattern proxy UUPS» è gratuita?
Sì — il testo completo di «Implementazione del pattern proxy UUPS» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Blockchain Smart Contracts with Solidity, passa a CoddyKit PRO. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.
Cosa imparerò in «Implementazione del pattern proxy UUPS»?
Impari a implementare il Universal Upgradeable Proxy Standard (UUPS) utilizzando OpenZeppelin per aggiornare i contratti in modo sicuro. Eserciti Blockchain Smart Contracts with Solidity con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Blockchain Smart Contracts with Solidity?
Non è richiesta alcuna esperienza precedente. Blockchain Smart Contracts with Solidity su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Implementazione del pattern proxy UUPS»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Blockchain Smart Contracts with Solidity?
Sì. Ogni lezione Blockchain Smart Contracts with Solidity include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché utilizzare contratti aggiornabili?
- Implementazione del pattern proxy UUPS
- Diamond Standard (proxy multifacet)
- Pattern Transparent Proxy e layout dello storage