# Hvordan bruke Solidity-programmering Solidity brukes til å lage komplekse **smarte kontrakter som er designet for å fungere på Ethereum-blockchain**. Dette språket har unike strategier som skiller det fra andre programmeringsspråk. ## Hva er Solidity? Solidity er et høynivå programmeringsspråk for å lage smarte kontrakter på Ethereum-blockchain. Smarte kontrakter er **selvutførende kontrakter som automatiserer utvekslingen av eiendeler mellom parter**. Det spesielle med dem er at det ikke er behov for mellomledd for å sikre overholdelse av den smarte kontrakten. Solidity-kildekoden kompileres til bytecode og **distribueres** på Ethereum-blockchain som en smart kontrakt. Når dette er gjort, kan den smarte kontrakten utføres av hvilken som helst node i nettverket, og statusen lagres på blockchain. Vi viser et eksempel på en enkel kontrakt som modellerer en NFT-salgsautomat: ```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; } } ``` ## Hvilke applikasjoner er Solidity egnet for? Solidity er spesielt utviklet for **å lage distribuerte applikasjoner** eller DApps som kjører på Ethereum Virtual Machine (EVM). Smarte kontrakter er blant annet egnet for å administrere digitale eiendeler, opprette desentraliserte børser og implementere avstemningssystemer. ### Desentralisert finans (DeFi) Solidity brukes til å utvikle DeFi-applikasjoner som **desentraliserte børser, kreditt- og utlånsplattformer, prediksjonsmarkeder og kryptovalutaer**. DeFi har blitt en av de mest populære bruksområdene for blockchain-teknologi. I denne prosessen har Solidity blitt et uunnværlig verktøy for å bygge DeFi-applikasjoner på Ethereum-nettverket. ### Ikke-fungible tokens Non-fungible token (NFT) har vært svært populært siden 2020-tallet. NFT-er er unike digitale eiendeler som lagres på blockchain. De kan være **digitale kunstverk, sportsminner eller gjenstander fra spillindustrien**. Solidity brukes til å lage smarte kontrakter som driver NFT-er. ### Leveringskjedeadministrasjon Solidity kan brukes til å lage smarte kontrakter for **overvåking og styring av forsyningskjeder**. Kontraktene brukes til å automatisere ulike prosesser i forsyningskjeden. Dette inkluderer sporing av varers bevegelser, verifisering av produktenes ekthet og behandling av betalinger mellom parter. ### Avstemmingssystemer Solidity kan brukes til å lage smarte kontrakter som **implementerer sikre og transparente avstemningssystemer på blokkjeden**. Kontraktene kan brukes til å sikre at stemmer telles riktig og at avstemningsprosessen er rettferdig og transparent. ## Hva er fordelene og ulempene med Solidity? Selv om Solidity er et kraftig språk for å lage smarte kontrakter på Ethereum-blokkjeden, har det sine spesifikke fordeler og ulemper som utviklere bør ta hensyn til når de utvikler smarte kontrakter. Likevel krever utarbeidelse av sikre smarte kontrakter et visst nivå av **kompetanse og forsiktighet**. Som illustrasjon er det nedenfor en **smart kontrakt som fungerer som et svart hull**. All Ether som sendes til kontrakten blir permanent konsumert, uten mulighet for å hente tilbake Ether eller foreta en utbetaling: ```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); } } ``` ### Fordeler med Solidity - **Fleksibilitet**: Solidity er et allsidig språk. Det kan brukes til å utvikle forskjellige smarte kontrakter med en rekke bruksområder. - **Sikkerhet**: Solidity ble utviklet med fokus på sikkerhet, og inneholder funksjoner som tilgangskontroll, unntakshåndtering og feilmekanismer for å hjelpe utviklere med å lage sikre kontrakter. - **Ethereum-kompatibilitet**: For øyeblikket er Solidity det foretrukne språket for å lage smarte kontrakter på Ethereum-blockchain. - **Distinkt fellesskap**: Et stort fellesskap av blokkjedeutviklere arbeider med Solidity, noe som resulterer i en mengde ressurser for læring og problemløsing. ### Ulemper ved Solidity - **Læringskurve**: For utviklere som er nye innen blockchain og utvikling av smarte kontrakter, har Solidity en relativt bratt læringskurve. - **Uforanderlighet**: Når en smart kontrakt er implementert på blockchain, kan den ikke endres videre. Det betyr at utviklere må være ekstremt forsiktige når de skriver og tester. - **Mangel på formell verifisering**: Solidity mangler innebygde verktøy for formell kodegjennomgang. Dette gjør det nødvendig for utviklere å bruke eksterne verktøy for å garantere nøyaktigheten av kontraktene sine. - **Begrenset verktøyutvalg**: Soliditys verktøyøkosystem er fortsatt i sin spede begynnelse, noe som kan føre til problemer med integrerte utviklingsmiljøer (IDE), testrammeverk og andre utviklingsverktøy. ## Hva er den grunnleggende syntaksen i Solidity? Solidity er et **objektorientert programmeringsspråk utviklet for smarte kontrakter**. Det er inspirert av JavaScript, Python og C++. Språkets syntaks ligner på JavaScript, men har noen interessante særegenheter. ### Variabler i Solidity Ved første øyekast kan Soliditys variabelhåndtering virke lik andre programmeringsspråk. Imidlertid oppstår det en viktig forskjell fra det faktum at Ethereum Virtual Machine (EVM) fungerer som kjøringsmiljø. Alle **operasjoner på EVM, inkludert datalagring, medfører en viss mengde «gass»-kostnader**. Følgelig må man under programmeringen vurdere effektiviteten av en operasjon og bestemme hvordan den kan implementeres så effektivt som mulig. I tillegg til vanlige variabler har Solidity **konstanter, som må defineres** under kompilering. Konstanter krever mindre gass for lagring: ```solidity // Regular variable can be declared without defining int a; // Constant needs to be defined at declaration int constant b = 51; ``` Det samme gjelder for `immutable` variabler, i og med at de krever mindre gass og **ikke kan endres etter tildeling**. I motsetning til `constant` variabler kan tildelingen av uforanderlige variabler gjøres under kjøring. ### Kontrollsetninger i Solidity Som et imperativt programmeringsspråk støtter Solidity kjente kontrollsetninger, som **forgreninger og sløyfer**. Vi viser koden for å velge det største av to tall, `a` og `b`: ```solidity int largerNumber = 0; // If-else statement if (a > b) { largerNumber = a; } else { largerNumber = b; } ``` **`for` -sløyfen i Solidity** tilsvarer syntaksen som er kjent fra JavaScript eller C++: ```solidity // Loop 10 times for (int i = 0; i < 10; i++) { // … } ``` **23-sløyfen fungerer også som vanlig**. Vi kombinerer en avslutningsbetingelse med en numerisk tellervariabel: ```solidity bool continueLoop = true; int counter = 0; // Loop at most 10 times while (continueLoop && counter < 10) { // … counter++; } ``` ### Enkle typer i Solidity Solidity er et **statisk typet språk** og støtter typene som vanligvis finnes i programmeringsspråk. Enkle typer som representerer enkeltverdier inkluderer boolske verdier, tall og strenger. Booleanske verdier i Solidity tilordner verdiene `true` og `false`. De kan kobles sammen ved hjelp av **kjente boolske operatorer** og brukes i `if` setninger: ```solidity bool paymentReceived = true; bool itemsStocked = true; bool continueTransaction = paymentReceived && itemsStocked; if (continueTransaction) { // ... } ``` Solidity støtter et **bredt spekter av numeriske typer**. Heltall kan skilles mellom tall med fortegn (`int`) og tall uten fortegn (`uint`), hvor sistnevnte kun kan være positive. Videre kan tallets omfang spesifiseres i trinn på 8 bit, fra `int8` via `int16` opp til `int265`: ```solidity uint8 smallNumber = 120; int8 negativeNumber = -125; int8 result = smallNumber + negativeNumber; assert(result == -5) ``` Strenger brukes i Solidity hovedsakelig til å generere statusmeldinger. Språket støtter **enkelt og dobbelt anførselstegn** samt Unicode-tegn: ```Solidity string message = 'Hello World'; string success = unicode"Transfer sent"; ``` ### Funksjoner i Solidity **Funksjoner er et grunnleggende aspekt** av Solidity, som i de fleste programmeringsspråk. Definisjonen av en funksjon er lik JavaScript, hvor argumenttypene må spesifiseres eksplisitt. I tillegg brukes nøkkelordet returns for å indikere de `return` verditypene. ```solidity // Define a function function addNumbers(int a, int b) returns (int) { return a + b; } ``` **Funksjonen kalles** som vanlig: ```solidity // Call the function int result = addNumbers(2, 3); ``` Interessant nok **kan returverdier i Solidity også navngis, på samme måte som navngitte argumenter**. I denne situasjonen er det tilstrekkelig å tilordne de tilsvarende variablene i funksjonskroppen **,** og en eksplisitt retur via `return` er unødvendig: ```solidity function divideNumbers(int dividend, int divisor) returns (int quotient) { quotient = dividend / divisor; // No `return` necessary } ``` I likhet med `constant` eller `immutable` variabler **kan funksjoner** i Solidity **merkes som ikke-tilstandsendrende**. Nøkkelordene `view` og `pure` brukes til dette formålet. En `view` funksjon endrer ikke tilstanden, mens en `pure` -funksjon i tillegg garanterer at tilstandsvariabler ikke leses. ### Smarte kontrakter i Solidity I tillegg til standardtyper kjenner Solidity til en håndfull **spesialiserte typer** for **smarte kontrakter**. Den grunnleggende typen er `address` og kartlegger Ethereum-adresser. Adresser som er `payable` kan motta overføringer i Ether. For dette formålet tilbyr `payable` adresser `balance()` og `transfer()` metoder. ```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); } ``` Basert på type `address`, eksisterer type `contract` som en sentral språkkonstruksjon. **Kontrakter tilsvarer omtrent klasser i objektorienterte programmeringsspråk**. Kontrakter samler dermed tilstandsdata og funksjoner og beskytter dem mot omverdenen. Kontrakter støtter multiarv, som kjent fra Python eller C++. **`pragma`** ontrakter **begynner vanligvis med en linje** som angir den tillatte Solidity-versjonen, etterfulgt av den faktiske definisjonen: ```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; } } ``` Smarte kontrakter kan definere **tilstandsdata og funksjoner**. Som kjent fra C++ og Java, kan ett av tre tilgangsnivåer defineres i hvert tilfelle: - `public`: Variabelen kan nås **ved å lese og skrive fra kontrakten**. I tillegg genereres en `view` funksjon automatisk som en getter for ekstern lesetilgang. - `internal`: Variabelen er **skjermet** fra ekstern tilgang. Lese- og skrivetilgang er mulig fra kontrakten, samt fra arvekontrakter. - `private`: Som `internal`, men det er **ingen tilgang fra arvekontrakter.** Funksjoner kan videre karakteriseres som `external`. En `external` **fungerer som en del av kontraktgrensesnittet** og brukes for ekstern tilgang. `receive` for mottak av ether er et velkjent eksempel: ```solidity // Define without `function` keyword receive() external payable { // Handle Ether } ``` ### Modifikatorer i Solidity Solidity har en interessant språklig konstruksjon i form av modifikatorer, som ligner på Pythons dekoratorer. I likhet med Python brukes modifikatorer i Solidity til **å endre påkallingen av en funksjon**. De brukes ofte for å sikre at en bestemt betingelse er oppfylt før en funksjon utføres: ```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; } } ``` ### Transaksjonshåndtering med Solidity Solidity har en innebygd transaksjonshåndtering. Denne kan brukes til å sikre at en **ether-overføring enten blir fullstendig gjennomført** eller ikke gjennomført i det hele tatt. Språket forstår nøkkelordet `revert`, som utløser en «roll-back» av en transaksjon. Med nøkkelordet `error` kan du definere dine egne feilkoder: ```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 } } ``` **Et** annet **mønster som ofte forekommer**, er bruken av funksjonen `require()`. Denne kan brukes på samme måte som `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/nb-no/digitalguide/nettsteder/webutvikling/soliditet-programmering/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/soliditet-programmering/) for AI/LLM consumption.