0Pricing
Blockchain Smart Contracts with Solidity · Pelajaran

Pola Kontrol Akses

Terapkan mekanisme kontrol akses yang tangguh menggunakan pola `Ownable`, `Pausable`, dan kontrol akses berbasis peran (RBAC).

Pola Kontrol Akses adalah pelajaran Blockchain Smart Contracts with Solidity gratis di CoddyKit. Ini adalah pelajaran 2 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 Blockchain Smart Contracts with Solidity, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Blockchain Smart Contracts with Solidity mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

What is Access Control?

In smart contracts, access control defines who can perform specific actions. It's like setting permissions on a file or folder.

Without proper access control, anyone could call sensitive functions, leading to vulnerabilities or unintended behavior.

Why It's Crucial

Imagine a contract that manages funds or critical system settings. You wouldn't want just anyone to be able to:

  • Withdraw all funds.
  • Change the contract's owner.
  • Pause essential operations.

Access control is a fundamental security measure.

The `onlyOwner` Modifier

A common pattern is to restrict certain functions to the contract's owner (the address that deployed it).

This is often achieved using a modifier, a special keyword in Solidity that can alter the behavior of a function.

Custom `onlyOwner` Example

Here's how you might manually implement an onlyOwner modifier and use it:

pragma solidity ^0.8.0;

contract MyBasicOwnable {
  address public owner;

  constructor() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    require(msg.sender == owner, "Not owner");
    _;
  }

  function setGreeting(string memory _text) public onlyOwner {
    // Only the owner can call this
    // ... (e.g., update a greeting message)
  }
}

OpenZeppelin's `Ownable`

While you can write your own, it's best practice to use battle-tested libraries. OpenZeppelin provides a secure and standardized Ownable contract.

By inheriting from Ownable, your contract gets the owner state variable and the onlyOwner modifier automatically.

Using OpenZeppelin `Ownable`

Simply import and inherit Ownable. The contract deployer automatically becomes the owner.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";

contract MyOzOwnable is Ownable {
  uint256 public value;

  function setValue(uint256 _newValue) public onlyOwner {
    value = _newValue;
  }

  function getValue() public view returns (uint256) {
    return value;
  }
}

The `Pausable` Pattern

The Pausable pattern allows a contract to be put into a 'paused' state, preventing certain functions from being called.

This is crucial for emergency situations, like discovering a critical bug or reacting to a hack, giving developers time to mitigate issues.

Using OpenZeppelin `Pausable`

OpenZeppelin's Pausable provides paused state, whenNotPaused and whenPaused modifiers, and _pause()/_unpause() functions.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyPausableContract is Pausable, Ownable {
  uint256 public counter;

  function increment() public whenNotPaused {
    counter++;
  }

  function pauseContract() public onlyOwner {
    _pause(); // Only owner can pause
  }

  function unpauseContract() public onlyOwner {
    _unpause(); // Only owner can unpause
  }
}

Role-Based Access Control (RBAC)

For more complex contracts, a single 'owner' might not be enough. Role-Based Access Control (RBAC) allows defining multiple roles (e.g., 'minter', 'admin', 'pauser').

OpenZeppelin's AccessControl contract helps manage these roles efficiently.

Using OpenZeppelin `AccessControl`

Define roles as bytes32 constants. The deployer automatically gets DEFAULT_ADMIN_ROLE, which can grant/revoke other roles.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract MyRBACContract is AccessControl {
  bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
  bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

  constructor() {
    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    _grantRole(MINTER_ROLE, msg.sender); // Deployer is also a minter
  }

  function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
    // Logic to mint tokens
  }

  function systemPause() public onlyRole(PAUSER_ROLE) {
    // Logic to pause critical system functions
  }
}

Access Control Check

Which of the following are benefits of implementing access control patterns like Ownable, Pausable, or AccessControl in smart contracts?

Recap: Access Control Patterns

You've learned about essential access control patterns in Solidity:

  • Ownable: Restricts functions to a single owner, often the contract deployer.
  • Pausable: Allows for emergency pausing/unpausing of contract functionality.
  • AccessControl (RBAC): Provides flexible, role-based permissions for more complex scenarios.

These patterns are critical for building robust and secure smart contracts, often leveraged from OpenZeppelin's battle-tested libraries.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Kontrol Akses” gratis?

Ya — teks lengkap “Pola Kontrol Akses” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Blockchain Smart Contracts with Solidity, upgrade ke CoddyKit PRO. Kursus Blockchain Smart Contracts with Solidity mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pola Kontrol Akses”?

Terapkan mekanisme kontrol akses yang tangguh menggunakan pola `Ownable`, `Pausable`, dan kontrol akses berbasis peran (RBAC). Kamu berlatih Blockchain Smart Contracts with Solidity 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 Blockchain Smart Contracts with Solidity?

Tidak diperlukan pengalaman sebelumnya. Blockchain Smart Contracts with Solidity 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 2 dari 4.

Berapa lama pelajaran “Pola Kontrol Akses” 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 Blockchain Smart Contracts with Solidity ini?

Ya. Setiap pelajaran Blockchain Smart Contracts with Solidity 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

  1. Kerentanan Umum (Reentrancy, dll.)
  2. Pola Kontrol Akses
  3. Pemrograman Aman dengan SafeMath
  4. Audit, Pengujian, dan Bounty Bug
← Kembali ke Blockchain Smart Contracts with Solidity