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:

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:

// 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:

// 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:

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++:

// 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:

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:

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:

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:

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.

// Define a function
function addNumbers(int a, int b) returns (int) {
    return a + b;
}

Funksjonen kalles som vanlig:

// 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:

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.

// 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:

// 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:

// 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:

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:

// 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:

// Using `require()` function
if (!condition) revert("Error message");
// Equivalent to
require(condition, "Error message");