Kurs Blockchain i Web3 · Moduł 6: Solidity Basics

Solidity - Język automatycznych mechanizmów

3 min czytania ·
W tej lekcji6

Witaj w Hali Mechanizmów! Atlas tutaj. Dziś poznasz Solidity - język, w którym pisze się automatyczne mechanizmy (smart contracts) działające w tunelach Krypty.

Czym jest Solidity?

Solidity to język programowania stworzony specjalnie dla Ethereum. Pozwala pisać smart contracts - programy działające na blockchain.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloKrypta {
    string public message = "Witaj w Krypcie!";

    function setMessage(string memory newMessage) public {
        message = newMessage;
    }
}

Struktura kontraktu

// 1. Licencja (wymagana od Solidity 0.6.8)
// SPDX-License-Identifier: MIT

// 2. Wersja kompilatora
pragma solidity ^0.8.20;

// 3. Importy (opcjonalne)
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// 4. Definicja kontraktu
contract MyContract {
    // 5. Zmienne stanu
    uint256 public myNumber;
    address public owner;

    // 6. Eventy
    event NumberChanged(uint256 newNumber);

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

    // 8. Konstruktor
    constructor() {
        owner = msg.sender;
    }

    // 9. Funkcje
    function setNumber(uint256 _number) public onlyOwner {
        myNumber = _number;
        emit NumberChanged(_number);
    }
}

Typy danych

// Typy wartości
bool isActive = true;
uint256 amount = 1000;        // unsigned integer (0 do 2^256-1)
int256 temperature = -10;      // signed integer
address wallet = 0x123...;     // adres Ethereum (20 bytes)
bytes32 hash = keccak256(...); // fixed-size bytes

// Typy referencyjne
string name = "Atlas";
bytes data = hex"001122";
uint256[] numbers;             // dynamic array
uint256[10] fixedArray;        // fixed array
mapping(address => uint256) balances;

// Struct
struct User {
    string name;
    uint256 balance;
    bool isActive;
}

Visibility (Widoczność)

contract Visibility {
    uint256 public publicVar;     // Dostępne wszędzie, auto-getter
    uint256 private privateVar;   // Tylko w tym kontrakcie
    uint256 internal internalVar; // Ten kontrakt + dziedziczące
    uint256 external externalVar; // Nie dla zmiennych!

    function publicFunc() public {}    // Dostępne wszędzie
    function privateFunc() private {}  // Tylko wewnętrznie
    function internalFunc() internal {} // + dziedziczące
    function externalFunc() external {} // Tylko z zewnątrz
}

Funkcje - view, pure, payable

contract Functions {
    uint256 public value;

    // view - czyta stan, nie modyfikuje
    function getValue() public view returns (uint256) {
        return value;
    }

    // pure - nie czyta ani nie modyfikuje stanu
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    // payable - może otrzymywać ETH
    function deposit() public payable {
        // msg.value zawiera wysłane ETH
    }

    // zwykła - może modyfikować stan
    function setValue(uint256 _value) public {
        value = _value;
    }
}

Podsumowanie

  • Solidity - język smart contracts
  • Struktura kontraktu
  • Typy danych (value, reference)
  • Visibility (public, private, internal, external)
  • Funkcje (view, pure, payable)
Kod do tej lekcji: index.js
// Solidity - podstawy składni
// (symulacja w JavaScript - prawdziwy Solidity wymaga kompilatora)

class SolidityContract {
  // Typy danych w Solidity
  static TYPES = {
    // Integers
    uint8: { min: 0, max: 255 },
    uint256: { min: 0, max: BigInt("2") ** BigInt("256") - BigInt("1") },
    int256: { min: -(BigInt("2") ** BigInt("255")), max: BigInt("2") ** BigInt("255") - BigInt("1") },

    // Boolean
    bool: [true, false],

    // Address (20 bytes)
    address: "0x" + "0".repeat(40),

    // Bytes
    bytes32: "0x" + "0".repeat(64)
  };

  constructor() {
    // State variables (przechowywane w storage)
    this.owner = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
    this.balance = BigInt(0);
    this.name = "MyToken";
    this.isActive = true;
  }
}

console.log("=== TYPY DANYCH W SOLIDITY ===\n");

console.log("INTEGER TYPES:");
console.log("  uint8:   0 to 255");
console.log("  uint256: 0 to 2^256-1 (domyślny)");
console.log("  int256:  -2^255 to 2^255-1");

console.log("\nINNE TYPY:");
console.log("  bool:    true/false");
console.log("  address: 20 bajtów (adres Ethereum)");
console.log("  bytes32: 32 bajty (hash)");
console.log("  string:  dynamiczny tekst");

console.log("\n=== PRZYKŁAD KONTRAKTU ===");
console.log(`
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleStorage {
    // State variables
    uint256 public storedNumber;
    address public owner;
    string public name;
    bool public isActive;

    // Constructor
    constructor(string memory _name) {
        owner = msg.sender;
        name = _name;
        isActive = true;
    }

    // Function to store a number
    function store(uint256 _number) public {
        storedNumber = _number;
    }

    // View function (read-only)
    function retrieve() public view returns (uint256) {
        return storedNumber;
    }
}
`);

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Która linia kodu poprawnie deklaruje wersję Solidity w smart kontrakcie?

  2. 2. Jaki typ danych w Solidity reprezentuje liczby całkowite nieujemne?

To 2 z 16 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż elementy podstawowego smart kontraktu w poprawnej kolejności:

  • Edytor kodu

    Utwórz obiekt reprezentujący prosty kontrakt z polem 'myNumber' o wartości 42

  • Klikanie w kolejności

    Ułóż elementy w poprawnej kolejności, aby utworzyć deklarację funkcji zwracającej wartość uint

  • Edytor kodu

    Napisz funkcję setValue, która przyjmuje parametr 'value' i ustawia pole this.storedValue

  • Układanie w poziomie

    Ułóż widoczności funkcji od najbardziej restrykcyjnej do najbardziej otwartej:

  • Edytor kodu

    Napisz funkcję add, która dodaje dwie liczby bez używania pól obiektu

  • Układanie w pionie

    Ułóż poprawnie kod pokazujący różnicę między zmienną stanu a lokalną:

  • Klikanie w kolejności

    Ułóż elementy w poprawnej kolejności, aby utworzyć mapping przechowujący salda adresów

  • Edytor kodu

    Utwórz obiekt 'balances' i dodaj saldo dla adresu '0x123' o wartości 100

  • Układanie w poziomie

    Ułóż kroki dodawania elementu do tablicy w Solidity:

  • Edytor kodu

    Utwórz tablicę 'numbers', dodaj do niej liczby 1, 2, 3 i zwróć długość tablicy

  • Układanie w pionie

    Ułóż poprawnie deklarację struktury Person:

  • Edytor kodu

    Utwórz obiekt person z polami name: 'Alice' i age: 25

  • Klikanie w kolejności

    Ułóż elementy w poprawnej kolejności, aby utworzyć deklarację eventu Transfer

  • Edytor kodu

    Napisz funkcję transfer, która 'emituje' event poprzez console.log z informacją o transferze

  • Układanie w pionie

    Ułóż poprawnie deklarację własnego modyfikatora onlyOwner:

  • Edytor kodu

    Napisz funkcję onlyOwner, która sprawdza czy caller === owner i rzuca błąd jeśli nie

  • Klikanie w kolejności

    Ułóż elementy w poprawnej kolejności, aby utworzyć walidację salda

  • Edytor kodu

    Napisz funkcję withdraw, która sprawdza czy balance >= amount i rzuca błąd jeśli nie

  • Układanie w poziomie

    Ułóż kroki definiowania i używania własnego błędu w Solidity:

  • Edytor kodu

    Utwórz klasę InsufficientBalanceError rozszerzającą Error i użyj jej w funkcji

  • Układanie w pionie

    Ułóż poprawnie przykład dziedziczenia kontraktów:

  • Klikanie w kolejności

    Ułóż elementy w poprawnej kolejności, aby utworzyć constructor ustawiający właściciela

  • Układanie w poziomie

    Co reprezentuje msg.sender w transakcji?

  • Edytor kodu

    Utwórz klasę SimpleStorage z konstruktorem, zmienną stanu, funkcją set i get oraz eventem

  1. PytanieWersja Solidity
  2. Ułóż w kolejnościStruktura kontraktu
  3. PytanieTypy całkowitoliczbowe
  4. Zadanie z kodemPierwszy smart kontrakt
  5. PytanieTyp address
  6. Kliknij w kolejnościDeklaracja funkcji
  7. PytanieWidoczność funkcji
  8. Zadanie z kodemFunkcja z parametrami
  9. PytanieModyfikator view
  10. Ułóż w kolejnościPoziomy widoczności
  11. PytanieModyfikator pure
  12. Zadanie z kodemFunkcja pure
  13. Ułóż w kolejnościZmienne stanu vs lokalne
  14. PytanieTyp bool
  15. Kliknij w kolejnościMapping - podstawy
  16. Zadanie z kodemMapping w praktyce
  17. PytanieTablice w Solidity
  18. Ułóż w kolejnościOperacje na tablicach
  19. Zadanie z kodemPraca z tablicami
  20. PytanieStruktury (Structs)
  21. Ułóż w kolejnościDeklaracja struct
  22. Zadanie z kodemTworzenie struct
  23. PytanieEventy w Solidity
  24. Kliknij w kolejnościDeklaracja eventu
  25. Zadanie z kodemEmitowanie eventu
  26. PytanieModyfikator payable
  27. Ułóż w kolejnościWłasne modyfikatory
  28. Zadanie z kodemImplementacja modyfikatora
  29. PytanieRequire vs Assert
  30. Kliknij w kolejnościUżycie require
  31. Zadanie z kodemObsługa błędów
  32. PytanieRevert
  33. Ułóż w kolejnościWłasne błędy
  34. Zadanie z kodemCustom error
  35. PytanieDziedziczenie kontraktów
  36. Ułóż w kolejnościStruktura dziedziczenia
  37. PytanieConstructor
  38. Kliknij w kolejnościImplementacja constructora
  39. PytanieString vs bytes
  40. Ułóż w kolejnościMsg.sender
  41. Zadanie z kodemKompletny smart contract
  42. Projekt do wysłaniaProjekt - Zaawansowany kontrakt
  43. RozmowaPodsumowanie modułu