Kontrak yang Dapat Di-upgrade
Pola proxy
Kontrak yang Dapat Di-upgrade adalah pelajaran Web3 & DApp Development Fundamentals gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Web3 & DApp Development Fundamentals, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Web3 & DApp Development Fundamentals mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
The Immutability Problem
Deployed contract code cannot be changed. If you find a bug or need a new feature, the code is frozen at its address.
Upgradeable contracts work around this using a proxy pattern that lets you swap the logic while keeping the same address and data.
The Proxy Pattern
Upgradeability splits a contract into two parts:
- Proxy — holds the state and a pointer to the logic; users interact with it.
- Implementation — holds the code, no permanent state.
The proxy delegatecalls into the implementation, so logic runs against the proxy's storage.
How delegatecall Works
delegatecall executes another contract's code in the caller's storage context. So when the proxy delegatecalls the implementation:
- Code comes from the implementation.
- Storage read/written is the proxy's.
Upgrading just changes which implementation the proxy points to.
Initializers, Not Constructors
Constructors run at deploy time and do not affect proxy storage. Upgradeable contracts use an initialize function instead:
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract Box is Initializable {
uint256 public value;
function initialize(uint256 v) public initializer {
value = v;
}
}import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract Box is Initializable {
uint256 public value;
function initialize(uint256 v) public initializer {
value = v;
}
}The Upgradeable Library
OpenZeppelin ships a separate package for this. Its modules use initializers instead of constructors:
npm install @openzeppelin/contracts-upgradeablePair it with the Hardhat Upgrades plugin to deploy and manage proxies safely.
npm install @openzeppelin/contracts-upgradeable @openzeppelin/hardhat-upgradesDeploying a Proxy
The Hardhat Upgrades plugin deploys the implementation and proxy together, calling your initializer:
const { ethers, upgrades } = require("hardhat");
const Box = await ethers.getContractFactory("Box");
const box = await upgrades.deployProxy(Box, [42]);
await box.waitForDeployment();The array holds the initializer arguments.
const { ethers, upgrades } = require("hardhat");
const Box = await ethers.getContractFactory("Box");
const box = await upgrades.deployProxy(Box, [42]);
await box.waitForDeployment();Performing an Upgrade
To upgrade, deploy a new implementation and point the existing proxy at it:
const BoxV2 = await ethers.getContractFactory("BoxV2");
const upgraded = await upgrades.upgradeProxy(
await box.getAddress(),
BoxV2
);The address and stored state are preserved; only the logic changes.
const BoxV2 = await ethers.getContractFactory("BoxV2");
const upgraded = await upgrades.upgradeProxy(
await box.getAddress(),
BoxV2
);Storage Layout Rules
Because the proxy keeps its storage, new versions must preserve the storage layout:
- Never reorder or remove existing state variables.
- Only append new variables at the end.
- Reserve gaps in base contracts for future fields.
The plugin checks for unsafe changes and warns you.
Transparent vs UUPS
Two common proxy styles:
- Transparent — upgrade logic lives in the proxy; simple but slightly more gas.
- UUPS — upgrade logic lives in the implementation (via
UUPSUpgradeable); cheaper, but you must not forget to include it.
UUPS is now the generally recommended default.
Upgradeability Trade-offs
Upgradeability is powerful but adds risk:
- Whoever controls upgrades can change the rules — a centralization concern.
- Storage and initializer mistakes can brick the contract.
Guard the upgrade authority with a multisig or timelock, and test upgrades thoroughly.
Disabling Initializers in the Implementation
An implementation contract should never be initialized directly. Lock it in its constructor:
constructor() {
_disableInitializers();
}This prevents an attacker from taking over the standalone implementation while leaving the proxy's initializer usable.
constructor() {
_disableInitializers();
}Quick Check
Test your understanding of upgradeable contracts.
Recap
You learned how upgradeable contracts work.
- A proxy holds state and
delegatecalls a swappable implementation. - Use
initialize(guarded byinitializer) instead of a constructor. - The Hardhat Upgrades plugin deploys and upgrades proxies safely.
- Preserve storage layout: only append variables; use gaps.
- Choose Transparent or UUPS, and protect upgrade authority with a multisig or timelock.
Belajar Web3 & DApp Development Fundamentals dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 29
- Pelajaran
- 105
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Kontrak yang Dapat Di-upgrade” gratis?
Ya — teks lengkap “Kontrak yang Dapat Di-upgrade” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Web3 & DApp Development Fundamentals, upgrade ke CoddyKit PRO. Kursus Web3 & DApp Development Fundamentals mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Kontrak yang Dapat Di-upgrade”?
Pola proxy Kamu berlatih Web3 & DApp Development Fundamentals dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Web3 & DApp Development Fundamentals?
Tidak diperlukan pengalaman sebelumnya. Web3 & DApp Development Fundamentals di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Kontrak yang Dapat Di-upgrade” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Web3 & DApp Development Fundamentals ini?
Ya. Setiap pelajaran Web3 & DApp Development Fundamentals menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Mengapa OpenZeppelin
- Kontrol Akses
- Ekstensi Token
- Kontrak yang Dapat Di-upgrade