Solidity uvod

Dodatni materijali

• Solidity by example
• CryptoZombies

Osnovni tipovi podataka

• address default 0x0...0
• int256 default 0
• uint256 default 0
• boolean default false
• string ""

  contract tipovi{
      bool public boolean; // false
      uint256 public neoznaceni_broj; // 0
      int256 public oznaceni_broj; // 0
      address public adresa; // 0x0000000000000000000000000000000000000000
  
      //public znaci da imam podrazumevani getter
      //ne znaci da bilo ko moze da promeni promenljivu
  }
  

Promenljive

• lokalne (promenljive definisane u funkcijama - ne cuvaju se na blockchainu)
• stanja (promenljive definisane u ugovoru - cuvaju se na blockchainu)
• env promenljive (globalne - cuvaju se na blockchainu- promenljive poput ko je pozvao funkciju, koji je redni broj bloka...)

contract promenljive{
    //promenljive stanja(cuvaju se na blockchainu, placamo gas za njih):
    bool proba; 
    address nesto;
    function proba() public view{
        //lokalne promenljive(postoje samo dok se funkcija izvrsava, ne placamo gas za njihovo cuvanje):
        uint broj;
        address neko;

        //globalne promenljive(ne deklarisu se, imaju podatke o blockchainu, svakako postoje):
        msg.sender
        msg.value
        block.blockhash 
        ...
    }

}

Kontrola toka

• grananje if/else if...
• petlje for, while

contract kontrola_toka{
    function proba() public pure{
        for(uint i = 0; i < 10; i++){
            if(i % 3 == 1) continue;
            else if(i == 7) break;
        }
    }

}

Napradniji tipovi podataka

• mapping
• struct
• array

contract stuktura{
    struct student{
        string ime;
        uint polozenoESPB;
    }
    uint[] public niz; // niz dinamicke duzine
    uint[3] public niz2; // niz od 3 elementa
    mapping (uint => uint) public transformacija; // kljuc -> vrednost, nije iterablian
    student[] private studenti;
    mapping (address => student) public nesto; //mapping ne dozvoljava strukturu kao kljuc 

    function dodaj(uint _a) public {
        transformacija[_a] = (_a + 7)* 57 % 23;
        niz.push(_a);
    } 
    function suma() public view returns(uint){
        uint s = 0;
        uint i;
        for(i = 0; i < niz.length;i++){
            s += niz[i];
        }
        return s;
    }
}

Funkcije

• public/private
• view/pure
• constructor
• modifier
• payable

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

contract PetStore {
    struct Pet{
        string ime;
        uint id;
        uint cena;
        address vlasnik;
        bool naprodaju;
    }
    uint broj;
    uint id;
    address public vlasnik;
    mapping (uint => Pet) public ljubimci;
    event AddedPet(string _ime, uint cena);
    event PetBought(uint _id);
    constructor(){
        broj = 0;
        id = 0;
        vlasnik = msg.sender;
    }
    modifier samoVlasnik(){
        require(vlasnik == msg.sender,"samo vlasnik sme da radi ovo");
        _;
    }
    function addPet(string memory _ime, uint _cena) public samoVlasnik{
        _dodaj(_me,_cena);
        emit AddedPet(_ime,_cena);
    }
    function _dodaj(string memory _ime, uint _cena) private{
        address _a;
        _cena = _cena ;
        Pet memory _pet = Pet(_ime,id,_cena,_a,true);
        ljubimci[id]= _pet;
        id += 1;
        broj += 1;
    }
    function buyPet(uint _id) public payable returns(bool){
        require(ljubimci[_id].naprodaju,"Nije na prodaju");
        require(msg.value == ljubimci[_id].cena, "nisi poslao tacno koliko treba" );
        ljubimci[_id].vlasnik = msg.sender;
        ljubimci[_id].naprodaju = false;
        broj -=1;
        emit PetBought(_id);
        return true;
    }
    function getPet(uint _id) public view returns(Pet memory){
       return ljubimci[_id]; 
    }

}