# Kako uporabljati programiranje Solidity Solidity se uporablja za oblikovanje kompleksnih **pametnih pogodb, zasnovanih za delovanje na blok verigi Ethereum**. Ta jezik predstavlja edinstvene strategije, ki ga ločujejo od drugih programskih jezikov. ## Kaj je Solidity? Solidity je visokoravni programski jezik za ustvarjanje pametnih pogodb na blok verigi Ethereum. Pametne pogodbe so **samodejno izvršljive pogodbe, ki avtomatizirajo izmenjavo sredstev med strankami**. Posebnost teh pogodb je, da za zagotovitev skladnosti s pametno pogodbo niso potrebni posredniki. Izvorna koda Solidity se prevede v bajtno kodo in **se** kot pametna pogodba **razporedi** na blok verigi Ethereum. Ko je to storjeno, lahko pametno pogodbo izvede kateri koli vozlišče v omrežju, stanje pa se shrani na blok verigi. Prikazujemo primer preproste pogodbe, ki modelira avtomat za prodajo NFT: ```solidity pragma Solidity 0.8.7; contract NFTVendingMachine { // Declare state variables address public owner; mapping (address => uint) public nftBalance; // Run on deployment constructor() { owner = msg.sender; nftBalance[address(this)] = 100; } // Allow the owner to restock the NFT balance function restock(uint amount) public { require(msg.sender == owner, "Only the owner can restock."); nftBalance[address(this)] += amount; } // Allow anyone to purchase NFTs function purchase(uint amount) public payable { require(msg.value >= amount * 1 ether, "You must pay at least 1 ETH per NFT"); require(nftBalance[address(this)] >= amount, "Not enough NFTs in stock to complete this purchase"); nftBalance[address(this)] -= amount; nftBalance[msg.sender] += amount; } } ``` ## Za katere aplikacije je Solidity primeren? Solidity je posebej zasnovan za **ustvarjanje razpršenih aplikacij** ali DApps, ki delujejo na virtualnem stroju Ethereum (EVM). Pametne pogodbe so primerne za upravljanje digitalnih sredstev, ustvarjanje decentraliziranih borz in izvajanje glasovalnih sistemov, med drugim. ### Decentralizirane finance (DeFi) Solidity se uporablja za razvoj aplikacij DeFi, kot so **decentralizirane borze, platforme za kredite in posojila, trgi napovedi in kriptovalute**. DeFi je postal eden najbolj priljubljenih primerov uporabe tehnologije blockchain. V tem procesu je Solidity postal nepogrešljivo orodje za razvoj aplikacij DeFi v omrežju Ethereum. ### Nezamenljivi žetoni Nezamenljivi žetoni (NFT) so od leta 2020 zelo priljubljeni. NFT-ji so edinstvena digitalna sredstva, shranjena v verigi blokov. Lahko so **digitalna umetniška dela, športni spominki ali artefakti iz igralniške industrije**. Solidity se uporablja za ustvarjanje pametnih pogodb, ki poganjajo NFT-je. ### Upravljanje dobavne verige Solidity se lahko uporablja za ustvarjanje pametnih pogodb za **spremljanje in upravljanje dobavnih verig**. Pogodbe se uporabljajo za avtomatizacijo različnih procesov v dobavni verigi. Ti vključujejo sledenje gibanja blaga, preverjanje pristnosti izdelkov in obdelavo plačil med strankami. ### Sistemi usklajevanja Solidity se lahko uporabi za ustvarjanje pametnih pogodb, ki **izvajajo varne in pregledne sisteme glasovanja na blok verigi**. Pogodbe se lahko uporabijo za zagotovitev, da se glasovi pravilno preštejejo in da je glasovalni postopek pošten in pregleden. ## Kakšne so prednosti in slabosti Solidity? Solidity je sicer zmogljiv jezik za ustvarjanje pametnih pogodb na blok verigi Ethereum, vendar ima svoje specifične prednosti in slabosti, ki jih morajo razvijalci upoštevati pri razvoju pametnih pogodb. Kljub temu pa ustvarjanje varnih pametnih pogodb zahteva določeno raven **usposobljenosti in previdnosti**. Za ponazoritev je spodaj prikazan **pametni pogodbeni dokument, ki deluje kot črna luknja**. Vsak Ether, poslan v pogodbeni dokument, se trajno porabi, brez možnosti za ponovno pridobitev Etherja ali izplačilo: ```solidity // SPDX-License-Identifier: GPL-3.0 pragma solidity >= 0.9.0; // This contract swallows all Ether sent to it contract Blackhole { event Received(address, uint); receive() external payable { emit Received(msg.sender, msg.value); } } ``` ### Prednosti trdnosti - **Prilagodljivost**: Solidity je vsestranski jezik. Uporablja se lahko za razvoj različnih pametnih pogodb z različnimi primeri uporabe. - **Varnost**: Solidity je bil ustvarjen z osredotočenostjo na varnost, vključuje značilnosti, kot so nadzor dostopa, obravnavanje izjem in mehanizmi za odpoved, ki razvijalcem pomagajo pri oblikovanju varnih pogodb. - **Združljivost z Ethereumom**: Trenutno je Solidity najbolj priljubljen jezik za ustvarjanje pametnih pogodb na blok verigi Ethereum. - **Izrazita skupnost**: Velika skupnost razvijalcev blokovnih verig dela s Solidity, kar omogoča številne vire za učenje in reševanje problemov. ### Pomanjkljivosti Solidity - **Učna krivulja**: Za razvijalce, ki so novi na področju razvoja blokovnih verig in pametnih pogodb, je Solidity relativno zahteven za učenje. - **Nespremenljivost**: Ko je pametna pogodba enkrat razporejena v blockchainu, je ni mogoče več spreminjati. Iz tega sledi, da morajo razvijalci biti pri pisanju in testiranju izredno previdni. - **Pomanjkanje formalne verifikacije**: Solidity nima vgrajenih orodij za formalno pregledovanje kode. Zaradi tega morajo razvijalci uporabljati zunanja orodja, da zagotovijo točnost svojih pogodb. - **Omejena orodja**: Ekosistem orodij Solidity je še v začetni fazi, kar lahko povzroči težave z integriranimi razvojnimi okolji (IDE), okviri za testiranje in drugimi razvojnimi orodji. ## Kakšna je osnovna sintaksa Solidity? Solidity je **objektno usmerjen programski jezik, zasnovan za pametne pogodbe**. Navdih črpa iz JavaScript, Python in C++. Sintaksa jezika je podobna JavaScript, čeprav z nekaterimi zanimivimi posebnostmi. ### Spremenljivke v Solidity Na prvi pogled se obdelava spremenljivk v Solidity zdi podobna obdelavi v drugih programskih jezikih. Vendar pa obstaja pomembna razlika, ki izhaja iz dejstva, da kot izvedbeno okolje služi Ethereum Virtual Machine (EVM). Vse **operacije na EVM, vključno s shranjevanjem podatkov, povzročajo določene stroške „plina**“. Zato je med programiranjem treba pretehtati učinkovitost operacije in določiti, kako jo je mogoče izvesti čim bolj učinkovito. Poleg rednih spremenljivk ima Solidity tudi **konstante, ki jih je treba definirati** med kompiliranjem. Konstante zahtevajo manj plina za shranjevanje: ```solidity // Regular variable can be declared without defining int a; // Constant needs to be defined at declaration int constant b = 51; ``` Enako velja za `immutable` spremenljivk, saj zahtevajo manj plina in jih **po dodelitvi ni mogoče spremeniti**. Za razliko od `constant` spremenljivk je dodelitev nespremenljivih spremenljivk mogoča med izvajanjem. ### Kontrolne izjave v Solidity Kot imperativni programski jezik Solidity podpira znane kontrolne izjave, kot so **veje in zanke**. Prikazujemo kodo za izbiro večjega od dveh številk, `a` in `b`: ```solidity int largerNumber = 0; // If-else statement if (a > b) { largerNumber = a; } else { largerNumber = b; } ``` **Zanka`for` v Solidity** ustreza sintaksi, znani iz JavaScript ali C++: ```solidity // Loop 10 times for (int i = 0; i < 10; i++) { // … } ``` **Tudi zanka** `while` **deluje kot običajno**. Kombiniramo pogoj za zaključek s številčno spremenljivko števca: ```solidity bool continueLoop = true; int counter = 0; // Loop at most 10 times while (continueLoop && counter < 10) { // … counter++; } ``` ### Preprosti tipi v Solidity Solidity je **statično tipiziran jezik** in podpira tipe, ki so pogosti v programskih jezikih. Preprosti tipi, ki predstavljajo posamezne vrednosti, vključujejo logične vrednosti, številke in nize. Booleani v Solidityju preslikujejo vrednosti `true` in `false`. Lahko se povežejo z **znanimi booleanskimi operacijami** in uporabijo v `if` izjavah: ```solidity bool paymentReceived = true; bool itemsStocked = true; bool continueTransaction = paymentReceived && itemsStocked; if (continueTransaction) { // ... } ``` Solidity podpira **široko paleto numeričnih tipov**. Celoštevilska števila se lahko razlikujejo med števili s predznakom (`int`) in števili brez predznaka (`uint`), pri čemer so slednja lahko samo pozitivna. Poleg tega se lahko obseg števila določi v korakih po 8 bitov, od `int8` prek `int16` do `int265`: ```solidity uint8 smallNumber = 120; int8 negativeNumber = -125; int8 result = smallNumber + negativeNumber; assert(result == -5) ``` Nize se v Solidity uporabljajo predvsem za ustvarjanje statusnih sporočil. Jezik podpira **enojne in dvojne narekovaje** ter Unicode znake: ```Solidity string message = 'Hello World'; string success = unicode"Transfer sent"; ``` ### Funkcije v Solidity **Funkcije so temeljni vidik** Solidity, kot v večini programskih jezikov. Opredelitev funkcije je podobna JavaScriptu, kjer morajo biti tipi argumentov izrecno navedeni. Poleg tega se za označevanje `return` tipov vrednosti uporablja ključna beseda returns. ```solidity // Define a function function addNumbers(int a, int b) returns (int) { return a + b; } ``` **Klic funkcije** se izvede kot običajno: ```solidity // Call the function int result = addNumbers(2, 3); ``` Zanimivo je **, da se podobno kot imenovani argumenti lahko imenujejo tudi vrnjene vrednosti v Solidity.** V tem primeru zadostuje dodelitev ustreznih spremenljivk v telesu funkcije, eksplicitna vrnitev prek `return` pa ni potrebna: ```solidity function divideNumbers(int dividend, int divisor) returns (int quotient) { quotient = dividend / divisor; // No `return` necessary } ``` Podobno kot pri spremenljivkah `constant` ali `immutable` **se lahko funkcije** v Solidity **označijo kot funkcije, ki ne spreminjajo stanja**. Za ta namen se uporabljata ključni besedi `view` in `pure`. Funkcija `view` ne spreminja stanja, medtem ko funkcija `pure` dodatno zagotavlja, da ne bere spremenljivk stanja. ### Pametne pogodbe v Solidity Poleg standardnih tipov Solidity pozna tudi nekaj **tipov, specializiranih za pametne pogodbe**. Osnovni tip je `address` in mapira naslove Ethereum. Naslovi, ki so `payable`, lahko prejemajo prenose v Etherju. Za ta namen naslovi `payable` zagotavljajo metode `balance()` in `transfer()`. ```solidity // Get address of this contract address mine = address(this); // Get payable external address address payable other = payable(0x123); // Transfer if balances fulfill conditions if (other.balance < 10 && mine.balance >= 100) { other.transfer(10); } ``` Na podlagi tipa `address` obstaja tip `contract` kot osrednji jezikovni konstrukt. **Pogodbe približno ustrezajo razredom v objektno usmerjenih programskih jezikih**. Pogodbe tako združujejo podatke o stanju in funkcije ter jih ščitijo pred zunanjim svetom. Pogodbe podpirajo večkratno dedovanje, kot je znano iz Python ali C++. Pogodbe **se običajno začnejo s `pragma` vrstico, ki** določa dovoljeno različico Solidity, ki ji sledi dejanska definicija: ```solidity // Make sure Solidity version matches pragma Solidity >=0.7.1 <0.9.0; // Contract definition contract Purchase { // Public state variables address seller; address buyer; // View-function function getSeller() external view returns (address) { return seller; } } ``` Pametne pogodbe lahko opredeljujejo **stanje podatkov in funkcije**. Kot je znano iz C++ in Java, je v vsakem primeru mogoče opredeliti eno od treh ravni dostopa: - `public`: Do spremenljivke je mogoče dostopati **z branjem in pisanjem iz pogodbe**. Poleg tega se samodejno generira funkcija `view` kot getter za zunanji dostop za branje. - `internal`: Spremenljivka je **zaščitena** pred zunanjim dostopom. Dostop za branje in pisanje je mogoč iz pogodbe kot tudi iz pogodb, ki jo podedujejo. - `private`: kot `internal`, vendar **ni dostopa iz naslednjih pogodb** Funkcije lahko nadalje opišemo kot `external`. Funkcija `external` **deluje kot del pogodbenega vmesnika** in se uporablja za zunanji dostop. Funkcija `receive` za sprejemanje etra je dobro znan primer: ```solidity // Define without `function` keyword receive() external payable { // Handle Ether } ``` ### Modifikatorji v Solidity Solidity ima zanimivo jezikovno konstrukcijo v obliki modifikatorjev, ki so podobni dekoratorjem v Pythonu. Podobno kot v Pythonu se modifikatorji v Solidity uporabljajo za **spreminjanje klicanja funkcije**. Pogosto se uporabljajo za zagotovitev, da je pred izvedbo funkcije izpolnjen določen pogoj: ```solidity contract Sale { uint price; address payable owner; modifier onlyOwner { // Will throw error if called by anyone other than the owner require( msg.sender == owner, "Only owner can call this function." ); // The wrapped function's body is inserted here _; } // `onlyOwner` wraps `changePrice` function changePrice(uint newPrice) public onlyOwner { // We'll only get here if the owner called this function price = newPrice; } } ``` ### Upravljanje transakcij s Solidity Solidity ima vgrajeno upravljanje transakcij. To se lahko uporabi za zagotovitev, da **je prenos etherja bodisi popolnoma poravnan** bodisi sploh ni poravnan. Jezik razume ključno besedo `revert`, ki sproži »roll-back« transakcije. S ključno besedo `error` lahko opredelite svoje lastne kodekse napak: ```solidity // Custom error definition error InsufficientPayment(uint256 paid, uint256 required); // Contract representing a sale contract Sale { uint price; // Purchase if enough ether transferred function purchase() public payable { if (msg.value < price) { revert InsufficientPayment(msg.value, price); } // Complete purchase } } ``` Drugi **pogosto srečani vzorec** je uporaba funkcije `require()`. To se lahko uporabi analogno kot `revert`: ```solidity // Using `require()` function if (!condition) revert("Error message"); // Equivalent to require(condition, "Error message"); ``` This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/programiranje-solidity/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/programiranje-solidity/) for AI/LLM consumption.