# Kā lietot Solidity programmēšanu Solidity tiek izmantots sarežģītu **viedo līgumu** izstrādei, **kas paredzēti darbībai Ethereum blokķēdē**. Šī valoda piedāvā unikālas stratēģijas, kas to atšķir no citām programmēšanas valodām. ## Kas ir Solidity? Solidity ir augsta līmeņa programmēšanas valoda, kas paredzēta viedo līgumu izveidei Ethereum blokķēdē. Viedie līgumi ir **pašizpildāmi līgumi, kas automatizē aktīvu apmaiņu starp pusēm**. To īpaša iezīme ir tā, ka viedo līgumu izpildes nodrošināšanai nav nepieciešami starpnieki. Solidity avota kods tiek kompilēts bytecode un **izvietots** Ethereum blokķēdē kā viedais līgums. Pēc tam viedais līgums var tikt izpildīts jebkurā tīkla mezglā, un stāvoklis tiek saglabāts blokķēdē. Mēs parādām vienkārša līguma piemēru, kas modelē NFT tirdzniecības automātu: ```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; } } ``` ## Kādām lietojumprogrammām Solidity ir piemērots? Solidity ir īpaši izstrādāts, lai **radītu izkliedētas lietojumprogrammas** jeb DApps, kas darbojas uz Ethereum Virtual Machine (EVM). Viedie līgumi ir piemēroti, lai pārvaldītu digitālos aktīvus, radītu decentralizētas biržas un ieviestu balsošanas sistēmas, kā arī citām lietām. ### Decentralizētās finanses (DeFi) Solidity tiek izmantots, lai izstrādātu DeFi lietojumprogrammas, piemēram, **decentralizētas biržas, kredītu un aizdevumu platformas, prognozēšanas tirgus un kriptovalūtas**. DeFi ir kļuvis par vienu no populārākajiem blokķēdes tehnoloģijas lietojumiem. Šajā procesā Solidity ir kļuvis par neaizstājamu rīku DeFi lietojumprogrammu izstrādei Ethereum tīklā. ### Neaizvietojami žetoni Neaizvietojamais žetons (NFT) kopš 2020. gada ir guvis lielu popularitāti. NFT ir unikāli digitāli aktīvi, kas tiek glabāti blokķēdē. Tie var būt **digitāli mākslas darbi, sporta suvenīri vai artefakti no spēļu industrijas**. Solidity tiek izmantots, lai izveidotu viedos līgumus, kas nodrošina NFT darbību. ### Piegādes ķēdes pārvaldība Solidity var izmantot, lai izveidotu viedos līgumus **piegādes ķēžu uzraudzībai un pārvaldībai**. Līgumi tiek izmantoti, lai automatizētu dažādus piegādes ķēdes procesus. Tie ietver preču kustības izsekošanu, produktu autentiskuma pārbaudi un maksājumu apstrādi starp pusēm. ### Saskaņošanas sistēmas Solidity var izmantot, lai izveidotu viedos līgumus, kas **īsteno drošas un pārredzamas balsošanas sistēmas blokķēdē**. Līgumus var izmantot, lai nodrošinātu, ka balsis tiek skaitītas pareizi un balsošanas process ir godīgs un pārredzams. ## Kādi ir Solidity priekšrocības un trūkumi? Lai gan Solidity ir spēcīga valoda viedo līgumu izstrādei Ethereum blokķēdē, tai ir savas specifiskas priekšrocības un trūkumi, kurus izstrādātājiem jāņem vērā, izstrādājot viedos līgumus. Tomēr drošu viedo līgumu izstrāde prasa noteiktu **prasmju** līmeni **un piesardzību**. Kā ilustrācija zemāk ir redzams **vieds līgums, kas darbojas kā melnais caurums**. Jebkurš uz līgumu nosūtītais Ether tiek neatgriezeniski patērēts, un nav iespējams atgūt Ether vai veikt izmaksu: ```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 priekšrocības - **Elastība**: Solidity ir daudzpusīga valoda. To var izmantot, lai izstrādātu dažādus viedos līgumus ar dažādiem lietošanas gadījumiem. - **Drošība**: Solidity tika izveidota, pievēršot uzmanību drošībai, iekļaujot tādas funkcijas kā piekļuves kontrole, izņēmumu apstrāde un kļūdu mehānismi, lai palīdzētu izstrādātājiem izveidot drošus līgumus. - **Saderība ar Ethereum**: pašlaik Solidity ir vēlamā valoda viedo līgumu izstrādei Ethereum blokķēdē. - **Atšķirīga kopiena**: Liela blokķēdes izstrādātāju kopiena strādā ar Solidity, kā rezultātā ir pieejams daudz resursu mācībām un problēmu risināšanai. ### Solidity trūkumi - **Mācību process**: attīstītājiem, kuriem blokķēde un viedo līgumu izstrāde ir jauna joma, Solidity ir salīdzinoši sarežģīts mācību process. - **Nemainīgums**: Kad viedais līgums ir ieviests blokķēdē, to vairs nevar mainīt. Tāpēc izstrādātājiem ir jābūt ārkārtīgi uzmanīgiem, rakstot un testējot. - **Formālās verifikācijas trūkums**: Solidity trūkst iebūvētu rīku formālai koda pārskatīšanai. Tāpēc izstrādātājiem ir jāizmanto ārējie rīki, lai garantētu līgumu precizitāti. - **Ierobežoti rīki**: Solidity rīku ekosistēma joprojām atrodas sākuma stadijā, kas var radīt problēmas ar integrētajām attīstības vidēm (IDE), testēšanas sistēmām un citiem attīstības rīkiem. ## Kāda ir Solidity pamata sintakse? Solidity ir **objektorientēta programmēšanas valoda, kas izstrādāta viediem līgumiem**. Tā ir iedvesmojusies no JavaScript, Python un C++. Valodas sintakse ir līdzīga JavaScript, lai gan ar dažām interesantām īpatnībām. ### Mainīgie Solidity No pirmā acu uzmetiena Solidity mainīgo apstrāde var šķist līdzīga citām programmēšanas valodām. Tomēr būtiska atšķirība rodas no tā, ka Ethereum Virtual Machine (EVM) kalpo kā izpildes vide. Visas **darbības EVM, ieskaitot datu uzglabāšanu, rada noteiktas “gāzes” izmaksas**. Tāpēc programmēšanas laikā ir jāapsver darbības efektivitāte un jānosaka, kā to var īstenot pēc iespējas efektīvāk. Papildus parastajām mainīgajām lielumiem Solidity ir **konstantes, kas jādefinē** kompilācijas laikā. Konstantes prasa mazāk gāzes uzglabāšanai: ```solidity // Regular variable can be declared without defining int a; // Constant needs to be defined at declaration int constant b = 51; ``` Tas pats attiecas uz `immutable` mainīgajiem, jo tiem ir nepieciešams mazāk gāzes un **tos nevar mainīt pēc piešķiršanas**. Atšķirībā no `constant` mainīgajiem, nemainīgo mainīgo piešķiršana var tikt veikta darbības laikā. ### Kontrolizteikumi Solidity Kā imperatīva programmēšanas valoda Solidity atbalsta pazīstamas kontroles instrukcijas, piemēram, **atzarojumus un cilpas**. Parādām kodu, kas izvēlas lielāko no diviem skaitļiem, `a` un `b`: ```solidity int largerNumber = 0; // If-else statement if (a > b) { largerNumber = a; } else { largerNumber = b; } ``` **`for` cilpa Solidity** atbilst sintaksei, kas pazīstama no JavaScript vai C++: ```solidity // Loop 10 times for (int i = 0; i < 10; i++) { // … } ``` `while` **cilpa arī darbojas kā parasti**. Mēs apvienojam pārtraukšanas nosacījumu ar skaitlisko skaitītāja mainīgo: ```solidity bool continueLoop = true; int counter = 0; // Loop at most 10 times while (continueLoop && counter < 10) { // … counter++; } ``` ### Vienkāršie tipi Solidity Solidity ir **statiski tipizēta valoda**, kas atbalsta programmēšanas valodās bieži sastopamos tipus. Vienkāršie tipi, kas pārstāv atsevišķas vērtības, ietver Boole’a tipus, skaitļus un virknes. Booleani Solidity kartē ataino vērtības `true` un `false`. Tos var savienot, izmantojot **pazīstamos Booleanu operatorus**, un izmantot `if` izteikumos: ```solidity bool paymentReceived = true; bool itemsStocked = true; bool continueTransaction = paymentReceived && itemsStocked; if (continueTransaction) { // ... } ``` Solidity atbalsta **plašu skaitlisko tipu klāstu**. Veselos skaitļus var iedalīt parakstītos (`int`) un neparakstītos (`uint`) skaitļos, kur pēdējie var būt tikai pozitīvi. Turklāt skaitļa diapazonu var norādīt 8 bitu soļos, sākot no `int8`, caur `int16` līdz `int265`: ```solidity uint8 smallNumber = 120; int8 negativeNumber = -125; int8 result = smallNumber + negativeNumber; assert(result == -5) ``` Stingas Solidity tiek izmantotas galvenokārt statusa ziņojumu ģenerēšanai. Valoda atbalsta **vienkāršās un dubultās pēdiņas**, kā arī Unicode rakstzīmes: ```Solidity string message = 'Hello World'; string success = unicode"Transfer sent"; ``` ### Funkcijas Solidity **Funkcijas ir** Solidity**pamatelements**, tāpat kā lielākajā daļā programmēšanas valodu. Funkcijas definīcija ir līdzīga JavaScript, kur argumentu tipi ir jānorāda skaidri. Turklāt, lai norādītu `return` vērtību tipus, tiek izmantots atslēgvārds returns. ```solidity // Define a function function addNumbers(int a, int b) returns (int) { return a + b; } ``` **Funkcijas izsaukšana** tiek veikta kā parasti: ```solidity // Call the function int result = addNumbers(2, 3); ``` Interesanti, **ka līdzīgi kā nosauktiem argumentiem, arī Solidity atgriešanas vērtības var nosaukt**. Šajā situācijā pietiek ar atbilstošo mainīgo piešķiršanu funkcijas ķermenī, un nav nepieciešama eksplicīta atgriešana ar `return`: ```solidity function divideNumbers(int dividend, int divisor) returns (int quotient) { quotient = dividend / divisor; // No `return` necessary } ``` Līdzīgi kā `constant` vai `immutable` mainīgajiem, Solidity **funkcijas var atzīmēt kā nemainīgas**. Šim nolūkam izmanto atslēgvārdus `view` un `pure`. `view` funkcija nemaina stāvokli, bet `pure` funkcija papildus garantē, ka netiks lasīti stāvokļa mainīgie. ### Viedie līgumi Solidity Papildus standarta tipiem Solidity pazīst arī dažus **viedlīgumu specializētos tipus**. Pamata tips ir `address` un tas kartē Ethereum adreses. Adreses, kas ir `payable`, var saņemt pārskaitījumus Ether. Šim nolūkam `payable` adreses nodrošina `balance()` un `transfer()` metodes. ```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); } ``` Pamatojoties uz `address` tipu, `contract` tips pastāv kā centrāla valodas konstrukcija. **Līgumi aptuveni atbilst klasēm objektorientētās programmēšanas valodās**. Tādējādi līgumi apvieno stāvokļa datus un funkcijas un aizsargā tos no ārpasaules. Līgumi atbalsta daudzkārtēju pārmantošanu, kā tas ir zināms no Python vai C++. Līgumi **parasti sākas ar `pragma` rindu, kurā** norādīta atļautā Solidity versija, kam seko faktiskā definīcija: ```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; } } ``` Viedie līgumi var definēt **stāvokļa datus un funkcijas**. Kā zināms no C++ un Java, katrā gadījumā var definēt vienu no trim piekļuves līmeņiem: - `public`: Mainīgajam var piekļūt **, lasot un rakstot no līguma**. Turklāt `view` funkcija tiek automātiski ģenerēta kā getter ārējai lasīšanas piekļuvei. - `internal`: Mainīgais ir **aizsargāts** no ārējās piekļuves. Lasīšanas un rakstīšanas piekļuve ir iespējama no līguma, kā arī no mantotajiem līgumiem. - `private`: tāpat kā `internal`, bet **nav piekļuves no mantotajiem līgumiem** Funkcijas var tālāk raksturot kā `external`. `external` funkcija **darbojas kā daļa no līguma saskarnes** un tiek izmantota ārējai piekļuvei. `receive` funkcija ētera saņemšanai ir labi zināms piemērs: ```solidity // Define without `function` keyword receive() external payable { // Handle Ether } ``` ### Modifikatori Solidity Solidity ir interesanta valodas konstrukcija modifikatoru veidā, kas līdzinās Python dekoratoriem. Līdzīgi kā Python, Solidity modifikatori tiek izmantoti, lai **mainītu funkcijas izsaukšanu**. Tie bieži tiek izmantoti, lai nodrošinātu, ka pirms funkcijas izpildes tiek izpildīts konkrēts nosacījums: ```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; } } ``` ### Darījumu pārvaldība ar Solidity Solidity ir iebūvēta darījumu pārvaldība. To var izmantot, lai nodrošinātu, ka **ētera pārskaitījums tiek pilnībā nokārtots vai** vispār netiek nokārtots. Valoda saprot `revert` atslēgvārdu, kas izraisa darījuma “atgriešanu”. Ar `error` atslēgvārdu varat definēt savus kļūdu 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 } } ``` Vēl viens **bieži sastopams modelis** ir `require()` funkcijas izmantošana. To var izmantot analogi `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/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/soliditates-programmesana/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/soliditates-programmesana/) for AI/LLM consumption.