UUPS-proxy-mallin toteuttaminen
Opettele toteuttamaan Universal Upgradeable Proxy Standard (UUPS) OpenZeppelinin avulla turvallisia sopimuspäivityksiä varten.
UUPS-proxy-mallin toteuttaminen on ilmainen Lohkoketjun älysopimukset Soliditylla-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Lohkoketjun älysopimukset Soliditylla-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lohkoketjun älysopimukset Soliditylla-kurssilla on yhteensä 4 oppituntia.
UUPS:n ymmärtäminen
Universal Upgradeable Proxy Standard (UUPS) on suosittu suunnittelumalli päivitettävien älysopimusten luomiseen. Sen avulla sopimuksen logiikkaa voidaan muuttaa ilman, että sen osoite lohkoketjussa muuttuu.
Tämä on tärkeää virheiden korjaamiseksi, uusien ominaisuuksien lisäämiseksi ja muuttuviin vaatimuksiin mukautumiseksi ilman käyttäjätietojen tai sopimuksen tilan menettämistä.
Miten UUPS toimii
UUPS käyttää proxy-sopimusta, joka säilyttää sopimuksen tilan (tiedot), sekä erillistä implementation-sopimusta, joka sisältää sopimuksen logiikan (funktiot).
- Proxy-sopimus: Yksinkertainen ja muuttumaton sopimus, joka välittää kutsut nykyiselle implementation-sopimukselle.
- Implementation-sopimus: Sisältää varsinaisen liiketoimintalogiikan. Tätä sopimusta päivitetään.
UUPS:n keskeinen ero on, että päivityslogiikka sijaitsee implementation-sopimuksessa, ei proxy-sopimuksessa.
OpenZeppeliniin luottaminen
Päivitettävien sopimusten oikeaoppinen toteuttaminen on monimutkaista ja altista virheille. Siksi luotamme taistelunkestäviin kirjastoihin, kuten OpenZeppelin Contracts -kirjastoon.
OpenZeppelin tarjoaa turvallisia ja auditoituja toteutuksia proxy-malleista, mukaan lukien UUPS, joten päivitettävien sopimusten rakentaminen on paljon turvallisempaa ja helpompaa.
UUPS-sopimusten rakentaminen
Jotta sopimuksesi olisi UUPS-yhteensopiva, sen on perittävä OpenZeppelinin UUPSUpgradeable-sopimus. Tämä perussopimus tarjoaa päivitettävyyteen tarvittavat funktiot ja muokkaimet.
Muista, että päivitettävissä sopimuksissa käytetään konstruktorin sijaan initializer-funktiota, koska proxy ei koskaan kutsu toteutussopimuksen konstruktoria suoraan.
Ensimmäinen päivitettävä sopimuksemme
Tässä on UUPS-päivityksiä varten valmis perussopimus MyContractV1. Huomaa, että se perii OpenZeppelinin UUPSUpgradeable-sopimuksen. Yleensä OpenZeppelin-sopimukset asennetaan npm:n kautta ja tuodaan projektiin.
// 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-sopimusten alustaminen
Päivitettävissä sopimuksissa ei voi käyttää tavallista konstruktoria. Proxy-sopimus otetaan käyttöön kerran, ja sen konstruktoria kutsutaan. Toteutussopimuksen konstruktoria ei koskaan kutsuta, kun proxy otetaan käyttöön tai päivitetään.
Sen sijaan käytetään initializer-funktiota. Funktiota kutsutaan kerran, yleensä heti proxyn käyttöönoton jälkeen, jotta logiikkasopimuksen alkutila voidaan määrittää.
Tilan alustaminen
Lisätään MyContractV1-sopimukseemme alustaja. Käytämme funktioita __UUPSUpgradeable_init() ja __Ownable_init() perussopimusten asianmukaiseen alustamiseen sekä funktiota Reinitializer(1) estämään useat alustukset.
// 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 {}
}UUPS-sopimuksen käyttöönotto
UUPS-sopimusten käyttöönotto edellyttää päivityslaajennuksen käyttöä (esimerkiksi Hardhatille tai Trufflelle). Laajennus huolehtii proxyn luomisesta ja sen yhdistämisestä alkuperäiseen toteutussopimukseen.
- Se ottaa käyttöön toteutussopimuksen.
- Se ottaa käyttöön proxysopimuksen, joka osoittaa toteutussopimukseen.
- Se kutsuu proxyn
initialize-funktiota.
Näin sopimus määritetään oikein tulevia päivityksiä varten.
Päivityksen suorittaminen
Kun haluat päivittää sopimuksesi, ota käyttöön uusi versio toteutussopimuksesta (esimerkiksi MyContractV2). Kutsu sitten päivitysfunktiota olemassa olevassa proxysopimuksessa ja määritä se osoittamaan uuteen toteutukseen.
Toteutussopimuksen _authorizeUpgrade-funktio määrittää, kenellä on oikeus suorittaa päivitys. Usein oikeus rajataan sopimuksen omistajalle.
Logiikan päivittäminen
Oletetaan, että haluamme lisätä uuden ominaisuuden sopimukseen MyContractV1. Luomme sopimuksen MyContractV2, joka perii sopimuksen MyContractV1 ja saa siten käyttöönsä sen tilan sekä olemassa olevan logiikan. Lisäämme sitten uuden 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.
}UUPSin keskeiset käsitteet
Mitkä seuraavista väitteistä PITÄVÄT PAIKKANSA OpenZeppelinilla toteutetusta Universal Upgradeable Proxy Standardista (UUPS)?
UUPS: turvalliset päivitykset
Tässä oppitunnissa opitte Universal Upgradeable Proxy Standardin (UUPS) ja sen toteuttamisen OpenZeppelin Contractsin avulla.
- UUPS erottaa tilan (proxyn) ja logiikan (toteutuksen).
- Perussopimuksena käytetään
UUPSUpgradeable-sopimusta. initialize-funktiot korvaavat konstruktorit alustuksessa.- OpenZeppelinin päivityslaajennukset yksinkertaistavat käyttöönottoa ja päivityksiä.
UUPS on tehokas malli tulevaisuudenkestävien älysopimusten rakentamiseen!
Opi Lohkoketjun älysopimukset Soliditylla tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 12
- Oppitunnit
- 48
Usein kysytyt kysymykset
Onko oppitunti ”UUPS-proxy-mallin toteuttaminen” ilmainen?
Kyllä – oppitunnin ”UUPS-proxy-mallin toteuttaminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Lohkoketjun älysopimukset Soliditylla-kurssin, päivitä CoddyKit PROhon. Lohkoketjun älysopimukset Soliditylla-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”UUPS-proxy-mallin toteuttaminen”?
Opettele toteuttamaan Universal Upgradeable Proxy Standard (UUPS) OpenZeppelinin avulla turvallisia sopimuspäivityksiä varten. Harjoittelet Lohkoketjun älysopimukset Soliditylla-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Lohkoketjun älysopimukset Soliditylla-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Lohkoketjun älysopimukset Soliditylla-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.
Kuinka kauan ”UUPS-proxy-mallin toteuttaminen”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Lohkoketjun älysopimukset Soliditylla-oppitunnilla?
Kyllä. Jokainen Lohkoketjun älysopimukset Soliditylla-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Miksi päivitettävät sopimukset?
- UUPS-proxy-mallin toteuttaminen
- Diamond-standardi (moniosaiset proxyt)
- Transparent Proxy -malli ja tallennusasettelu