# Kaip naudoti „Solidity“ programavimą Solidity naudojama sudėtingų **išmaniųjų sutarčių, skirtų veikti Ethereum blokų grandinėje,** kūrimui. Ši kalba pasižymi unikaliomis strategijomis, kurios ją išskiria iš kitų programavimo kalbų. ## Kas yra Solidity? Solidity yra aukšto lygio programavimo kalba, skirta kurti protingus kontraktus Ethereum blokų grandinėje. Protingi kontraktai yra **savaime vykdomi kontraktai, kurie automatizuoja turto mainus tarp šalių**. Jų ypatumas yra tai, kad nereikia jokių tarpininkų, siekiant užtikrinti protingo kontrakto laikymąsi. Solidity šaltinio kodas yra kompiliuojamas į baitkodą ir **diegiamas** Ethereum blokų grandinėje kaip išmanusis kontraktas. Tai atlikus, išmanusis kontraktas gali būti vykdomas bet kuriame tinklo mazge, o jo būsena saugoma blokų grandinėje. Pateikiame paprasto kontrakto, modeliuojančio NFT pardavimo automatą, pavyzdį: ```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; } } ``` ## Kokioms programoms tinka „Solidity“? Solidity yra specialiai sukurta **paskirstytoms programoms** arba DApps, veikiančioms Ethereum Virtual Machine (EVM) platformoje, **kurti**. Pažangios sutartys tinka skaitmeninių išteklių valdymui, decentralizuotų biržų kūrimui, balsavimo sistemų diegimui ir kt. ### Decentralizuotos finansinės paslaugos (DeFi) Solidity naudojama kuriant DeFi programas, pavyzdžiui, **decentralizuotas biržas, kredito ir skolinimo platformas, prognozavimo rinkas ir kriptovaliutas**. DeFi tapo viena iš populiariausių blokų grandinės technologijos naudojimo sričių. Šiame procese Solidity tapo nepakeičiamu įrankiu kuriant DeFi programas Ethereum tinkle. ### Nepakeičiami žetonai Neatsiejamas žetonas (NFT) nuo 2020-ųjų metų sulaukė didelio populiarumo. NFT yra unikalūs skaitmeniniai turtai, saugomi blokų grandinėje. Tai gali būti **skaitmeniniai meno kūriniai, sporto suvenyrai ar žaidimų pramonės artefaktai**. Solidity naudojama kuriant protingus kontraktus, kurie valdo NFT. ### Pristatymo grandinės valdymas Solidity gali būti naudojama kuriant išmaniuosius kontraktus **tiekimo grandinių stebėjimui ir valdymui**. Kontraktai naudojami įvairių tiekimo grandinės procesų automatizavimui. Tai apima prekių judėjimo stebėjimą, produktų autentiškumo tikrinimą ir mokėjimų tarp šalių apdorojimą. ### Sutikrinimo sistemos Solidity gali būti naudojama kuriant protingus kontraktus, kurie **įgyvendina saugias ir skaidrias balsavimo sistemas blokų grandinėje**. Kontraktai gali būti naudojami siekiant užtikrinti, kad balsai būtų skaičiuojami teisingai ir kad balsavimo procesas būtų sąžiningas ir skaidrus. ## Kokie yra „Solidity“ privalumai ir trūkumai? Nors „Solidity“ yra galinga kalba, skirta kurti išmaniuosius kontraktus „Ethereum“ blokų grandinėje, ji turi specifinių privalumų ir trūkumų, kuriuos kūrėjai turėtų atsižvelgti kurdami išmaniuosius kontraktus. Nepaisant to, saugių išmaniųjų kontraktų kūrimas reikalauja tam tikro lygio **kompetencijos ir atsargumo**. Pavyzdžiui, žemiau pateikiamas **protingas kontraktas, kuris veikia kaip juodoji skylė**. Bet koks į kontraktą siunčiamas eteris yra negrįžtamai sunaudojamas, be galimybės atgauti eterį ar atlikti išmokėjimą: ```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); } } ``` ### Solidity privalumai - **Lankstumas**: Solidity yra universali kalba. Ji gali būti naudojama įvairių protingų sutarčių, skirtų įvairiems naudojimo atvejams, kūrimui. - **Saugumas**: „Solidity“ buvo sukurta atsižvelgiant į saugumą, įtraukiant tokias savybes kaip prieigos kontrolė, išimčių tvarkymas ir gedimų mechanizmai, siekiant padėti kūrėjams kurti saugias sutartis. - **Suderinamumas su Ethereum**: šiuo metu Solidity yra pageidaujama kalba protingų sutarčių kūrimui Ethereum blokų grandinėje. - **Išskirtinė bendruomenė**: didelė blokų grandinės kūrėjų bendruomenė dirba su Solidity, todėl yra gausu išteklių mokymuisi ir problemų sprendimui. ### Solidity trūkumai - **Mokymosi kreivė**: Kūrėjams, kurie dar nėra susipažinę su blokų grandine ir protingų sutarčių kūrimu, „Solidity“ yra gana sudėtinga išmokti. - **Nekintamumas**: Kai protingas kontraktas yra įdiegtas blokų grandinėje, jo negalima toliau keisti. Todėl kūrėjai turi būti ypač atsargūs rašydami ir testuodami. - **Formalios patikros trūkumas**: „Solidity“ neturi įdiegtų įrankių formaliam kodo peržiūrėjimui. Dėl to kūrėjai turi naudoti išorinius įrankius, kad užtikrintų savo sutarčių tikslumą. - **Ribotos priemonės**: „Solidity“ priemonių ekosistema dar tik formuojasi, todėl gali kilti problemų su integruotomis programavimo aplinkomis (IDE), testavimo sistemomis ir kitomis programavimo priemonėmis. ## Kokia yra pagrindinė Solidity sintaksė? Solidity yra **objektinis programavimo kalba, sukurta protingiems kontraktams**. Ji yra įkvėpta JavaScript, Python ir C++ kalbų. Kalbos sintaksė yra panaši į JavaScript, nors turi keletą įdomių ypatumų. ### Kintamieji Solidity kalboje Iš pirmo žvilgsnio „Solidity“ kintamųjų tvarkymas gali atrodyti panašus į kitų programavimo kalbų. Tačiau esminis skirtumas kyla iš to, kad „Ethereum Virtual Machine“ (EVM) veikia kaip vykdymo aplinka. Visos **operacijos EVM, įskaitant duomenų saugojimą, reikalauja tam tikrų „dujų“ sąnaudų**. Todėl programavimo metu reikia įvertinti operacijos efektyvumą ir nuspręsti, kaip ją galima įgyvendinti kuo efektyviau. Be įprastų kintamųjų, Solidity turi **konstantas, kurios turi būti apibrėžtos** kompiliavimo metu. Konstantos reikalauja mažiau dujų saugojimui: ```solidity // Regular variable can be declared without defining int a; // Constant needs to be defined at declaration int constant b = 51; ``` Tas pats taikoma `immutable` kintamiesiems, nes jie reikalauja mažiau dujų ir **negali būti keičiami po priskyrimo**. Skirtingai nei `constant` kintamieji, nekintamųjų kintamųjų priskyrimas gali būti atliekamas vykdymo metu. ### Kontrolės teiginiai Solidity kalboje Kaip imperatyvinė programavimo kalba, Solidity palaiko įprastas valdymo instrukcijas, pavyzdžiui, **šakeles ir ciklus**. Pateikiame kodą, skirtą pasirinkti didesnį iš dviejų skaičių, `a` ir `b`: ```solidity int largerNumber = 0; // If-else statement if (a > b) { largerNumber = a; } else { largerNumber = b; } ``` **`for` kilpa Solidity** atitinka sintaksę, žinomą iš JavaScript arba C++: ```solidity // Loop 10 times for (int i = 0; i < 10; i++) { // … } ``` `while` **kilpa taip pat veikia kaip įprasta**. Mes sujungiame nutraukimo sąlygą su skaitmeniniu skaitiklio kintamuoju: ```solidity bool continueLoop = true; int counter = 0; // Loop at most 10 times while (continueLoop && counter < 10) { // … counter++; } ``` ### Paprasti tipai Solidity kalboje Solidity yra **statinio tipavimo kalba**, palaikanti tipus, paprastai naudojamus programavimo kalbose. Paprasti tipai, atspindintys vieną reikšmę, apima boolinius tipus, skaičius ir eilutes. Booleans Solidity atvaizduoja vertes `true` ir `false`. Jos gali būti susietos naudojant **žinomus Boolean operatorius** ir naudojamos `if` teiginiuose: ```solidity bool paymentReceived = true; bool itemsStocked = true; bool continueTransaction = paymentReceived && itemsStocked; if (continueTransaction) { // ... } ``` Solidity palaiko **platų skaitmeninių tipų spektrą**. Sveikieji skaičiai gali būti skirstomi į ženklinius (`int`) ir beženklinius (`uint`) skaičius, kur pastarieji gali būti tik teigiami. Be to, skaičiaus diapazonas gali būti nurodytas 8 bitų žingsniais, nuo `int8` per `int16` iki `int265`: ```solidity uint8 smallNumber = 120; int8 negativeNumber = -125; int8 result = smallNumber + negativeNumber; assert(result == -5) ``` Stringai Solidity kalboje naudojami daugiausia būsenos pranešimams generuoti. Kalba palaiko **viengubas ir dvigubas kabutes**, taip pat Unicode simbolius: ```Solidity string message = 'Hello World'; string success = unicode"Transfer sent"; ``` ### Funkcijos Solidity **Funkcijos yra pagrindinis** Solidity**aspektas**, kaip ir daugumoje programavimo kalbų. Funkcijos apibrėžimas yra panašus į JavaScript, kur argumentų tipai turi būti aiškiai nurodyti. Be to, raktinis žodis „returns“ naudojamas `return` vertės tipams nurodyti. ```solidity // Define a function function addNumbers(int a, int b) returns (int) { return a + b; } ``` **Funkcijos iškvietimas** atliekamas kaip įprasta: ```solidity // Call the function int result = addNumbers(2, 3); ``` Įdomu tai, **kad analogiškai kaip ir pavadinti argumentai, Solidity grąžinamosios reikšmės taip pat gali būti pavadintos**. Tokiu atveju pakanka priskirti atitinkamas kintamuosius funkcijos kūne, o aiškus grąžinimas per `return` nėra būtinas: ```solidity function divideNumbers(int dividend, int divisor) returns (int quotient) { quotient = dividend / divisor; // No `return` necessary } ``` Panašiai kaip `constant` ar `immutable` kintamieji, Solidity **funkcijos gali būti pažymėtos kaip nekeičiančios būsenos**. Šiam tikslui naudojami raktiniai žodžiai `view` ir `pure`. `view` funkcija nekeičia būsenos, o `pure` funkcija papildomai garantuoja, kad nebūtų skaitomi būsenos kintamieji. ### Išmanieji kontraktai „Solidity“ kalba Be standartinių tipų, Solidity žino keletą **specializuotų išmaniųjų sutarčių tipų**. Pagrindinis tipas yra `address` ir atitinka Ethereum adresus. Adresai, kurių tipas yra `payable`, gali priimti pervedimus Ether. Šiam tikslui `payable` adresai teikia `balance()` ir `transfer()` metodus. ```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); } ``` Remiantis `address` tipu, `contract` tipas egzistuoja kaip centrinė kalbos konstrukcija. **Sutartys atitinka objektų orientuotų programavimo kalbų klases**. Taigi, sutartys apjungia būsenos duomenis ir funkcijas bei apsaugo juos nuo išorinio pasaulio. Sutartys palaiko daugkartinį paveldėjimą, kaip žinoma iš Python ar C++. Sutartys **paprastai prasideda `pragma` eilute, kurioje** nurodyta leidžiama „Solidity“ versija, po kurios eina tikrasis apibrėžimas: ```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; } } ``` Išmanieji kontraktai gali apibrėžti **būsenos duomenis ir funkcijas**. Kaip žinoma iš C++ ir Java, kiekvienu atveju galima apibrėžti vieną iš trijų prieigos lygių: - `public`: **Prie** kintamojo galima prieiti **skaitant ir rašant iš sutarties**. Be to, `view` funkcija automatiškai generuojama kaip gavimo funkcija išorinei skaitymo prieigai. - `internal`: Kintamasis yra **apsaugotas** nuo išorinės prieigos. Skaityti ir rašyti galima iš sutarties vidaus, taip pat iš paveldėtų sutarčių. - `private`: kaip `internal`, bet **nėra prieigos iš paveldėtų sutarčių** Funkcijos taip pat gali būti apibūdinamos kaip `external`. `external` funkcija **veikia kaip sutarties sąsajos dalis** ir yra naudojama išorinei prieigai. `receive` funkcija, skirta eteriui priimti, yra gerai žinomas pavyzdys: ```solidity // Define without `function` keyword receive() external payable { // Handle Ether } ``` ### Modifikatoriai Solidity kalboje Solidity turi įdomią kalbos konstrukciją modifikatorių forma, kurie primena Python dekoratorius. Panašiai kaip Python, Solidity modifikatoriai naudojami **funkcijos iškvietimui pakeisti**. Jie dažnai naudojami siekiant užtikrinti, kad prieš vykdant funkciją būtų įvykdyta tam tikra sąlyga: ```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; } } ``` ### Sandorių valdymas naudojant „Solidity“ Solidity turi integruotą sandorių valdymą. Tai gali būti naudojama siekiant užtikrinti, kad **eterio pervedimas būtų visiškai įvykdytas arba** visiškai neįvykdytas. Kalba supranta `revert` raktinį žodį, kuris sukelia sandorio „atšaukimą“. Naudodami `error` raktinį žodį galite apibrėžti savo klaidų kodus: ```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 } } ``` Kitas **dažnai pasitaikantis modelis** yra `require()` funkcijos naudojimas. Ji gali būti naudojama analogiškai kaip `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/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/solidity-programavimas/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/solidity-programavimas/) for AI/LLM consumption.