M

MLOG

Dansk

Udforsk Solidity, det førende programmeringssprog til udvikling af smarte kontrakter på Ethereum-blockchainen. Denne guide dækker alt fra grundlæggende begreber til avancerede teknikker.

Solidity: En omfattende guide til smart kontraktprogrammering

Solidity er et højtniveau, kontraktorienteret programmeringssprog, der bruges til at implementere smarte kontrakter på forskellige blockchain-platforme, især Ethereum. Det er stærkt påvirket af C++, Python og JavaScript, designet til at målrette Ethereum Virtual Machine (EVM). Denne guide giver et detaljeret overblik over Solidity, der er egnet til både begyndere og erfarne programmører, der ønsker at dykke ned i verden af blockchain-udvikling.

Hvad er smarte kontrakter?

Før du dykker ned i Solidity, er det afgørende at forstå, hvad smarte kontrakter er. En smart kontrakt er en selveksekverende kontrakt, hvor vilkårene i aftalen er direkte skrevet ind i koden. Den er gemt på en blockchain og udføres automatisk, når forudbestemte betingelser er opfyldt. Smarte kontrakter muliggør automatisering, gennemsigtighed og sikkerhed i forskellige applikationer, herunder:

Hvorfor Solidity?

Solidity er det dominerende sprog til at skrive smarte kontrakter på Ethereum og andre EVM-kompatible blockchains på grund af flere faktorer:

Opsætning af dit udviklingsmiljø

For at begynde at udvikle med Solidity skal du opsætte et passende udviklingsmiljø. Her er nogle populære muligheder:

Remix IDE

Remix er en online, browserbaseret IDE, der er perfekt til at lære og eksperimentere med Solidity. Det kræver ingen lokal installation og giver funktioner som:

Få adgang til Remix IDE på https://remix.ethereum.org/

Truffle Suite

Truffle er et omfattende udviklingsframework, der forenkler processen med at bygge, teste og implementere smarte kontrakter. Det giver værktøjer som:

Sådan installeres Truffle:

npm install -g truffle

Hardhat

Hardhat er et andet populært Ethereum-udviklingsmiljø, kendt for sin fleksibilitet og udvidelsesmuligheder. Det giver dig mulighed for at kompilere, implementere, teste og debugge din Solidity-kode. Nøglefunktioner inkluderer:

Sådan installeres Hardhat:

npm install --save-dev hardhat

Solidity Basics: Syntaks og datatyper

Lad os udforske den grundlæggende syntaks og datatyper i Solidity.

Struktur af en Solidity-kontrakt

En Solidity-kontrakt svarer til en klasse i objektorienteret programmering. Den består af tilstandsvariabler, funktioner og begivenheder. Her er et simpelt eksempel:

pragma solidity ^0.8.0;

contract SimpleStorage {
 uint256 storedData;

 function set(uint256 x) public {
 storedData = x;
 }

 function get() public view returns (uint256) {
 return storedData;
 }
}

Forklaring:

Datatyper

Solidity understøtter en række datatyper:

Eksempel:

pragma solidity ^0.8.0;

contract DataTypes {
 uint256 public age = 30;
 bool public isAdult = true;
 address public owner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
 bytes32 public name = "JohnDoe";
 uint[] public numbers = [1, 2, 3, 4, 5];
 mapping(address => uint) public balances;

 constructor() {
 balances[msg.sender] = 100;
 }
}

Tilstandsvariabler vs. Lokale variabler

Tilstandsvariabler erklæres uden for funktioner og gemmes på blockchainen. De bevares på tværs af funktionskald og kontrakteksekveringer. I eksemplet ovenfor er storedData en tilstandsvariabel.

Lokale variabler erklæres inde i funktioner og eksisterer kun inden for omfanget af den pågældende funktion. De gemmes ikke på blockchainen og kasseres, når funktionen er fuldført.

Funktioner i Solidity

Funktioner er byggestenene i smarte kontrakter. De definerer den logik og de operationer, som kontrakten kan udføre. Funktioner kan:

Funktionssynlighed

Solidity-funktioner har fire synlighedsmodifikatorer:

Funktionsmodifikatorer

Funktionsmodifikatorer bruges til at ændre en funktions adfærd. De bruges ofte til at håndhæve sikkerhedsbegrænsninger eller udføre kontroller, før funktionens logik udføres.

Eksempel:

pragma solidity ^0.8.0;

contract Ownership {
 address public owner;

 constructor() {
 owner = msg.sender;
 }

 modifier onlyOwner() {
 require(msg.sender == owner, "Kun ejeren kan kalde denne funktion");
 _;
 }

 function transferOwnership(address newOwner) public onlyOwner {
 owner = newOwner;
 }
}

I dette eksempel kontrollerer onlyOwner-modifikatoren, om den, der kalder, er ejeren af kontrakten. Hvis ikke, tilbagefører den transaktionen. Pladsholderen _ repræsenterer resten af funktionens kode.

Funktionstilstands mutabilitet

Solidity-funktioner kan også have tilstands mutabilitetsmodifikatorer:

Eksempel:

pragma solidity ^0.8.0;

contract Example {
 uint256 public value;

 function getValue() public view returns (uint256) {
 return value;
 }

 function add(uint256 x) public pure returns (uint256) {
 return x + 5;
 }

 function deposit() public payable {
 value += msg.value;
 }
}

Kontrolstrukturer

Solidity understøtter standardkontrolstrukturer som if, else, for, while og do-while loops.

Eksempel:

pragma solidity ^0.8.0;

contract ControlStructures {
 function checkValue(uint256 x) public pure returns (string memory) {
 if (x > 10) {
 return "Værdien er større end 10";
 } else if (x < 10) {
 return "Værdien er mindre end 10";
 } else {
 return "Værdien er lig med 10";
 }
 }

 function sumArray(uint[] memory arr) public pure returns (uint256) {
 uint256 sum = 0;
 for (uint256 i = 0; i < arr.length; i++) {
 sum += arr[i];
 }
 return sum;
 }
}

Begivenheder og logføring

Begivenheder giver smarte kontrakter mulighed for at kommunikere med omverdenen. Når en begivenhed udsendes, gemmes den i blockchainens transaktionslogger. Disse logfiler kan overvåges af eksterne applikationer for at spore kontraktens aktivitet.

Eksempel:

pragma solidity ^0.8.0;

contract EventExample {
 event ValueChanged(address indexed caller, uint256 newValue);

 uint256 public value;

 function setValue(uint256 newValue) public {
 value = newValue;
 emit ValueChanged(msg.sender, newValue);
 }
}

I dette eksempel udsendes begivenheden ValueChanged, når funktionen setValue kaldes. Nøgleordet indexed på parameteren caller giver eksterne applikationer mulighed for at filtrere begivenheder baseret på den, der kalder, adresse.

Arv

Solidity understøtter arv, hvilket giver dig mulighed for at oprette nye kontrakter baseret på eksisterende. Dette fremmer genbrug af kode og modularitet.

Eksempel:

pragma solidity ^0.8.0;

contract BaseContract {
 uint256 public value;

 function setValue(uint256 newValue) public {
 value = newValue;
 }
}

contract DerivedContract is BaseContract {
 function incrementValue() public {
 value++;
 }
}

I dette eksempel arver DerivedContract fra BaseContract. Den arver tilstandsvariablen value og funktionen setValue. Den definerer også sin egen funktion, incrementValue.

Biblioteker

Biblioteker svarer til kontrakter, men de kan ikke gemme data. De bruges til at implementere genanvendelig kode, der kan kaldes af flere kontrakter. Biblioteker implementeres kun én gang, hvilket reducerer gasomkostningerne.

Eksempel:

pragma solidity ^0.8.0;

library Math {
 function add(uint256 a, uint256 b) internal pure returns (uint256) {
 return a + b;
 }
}

contract Example {
 using Math for uint256;
 uint256 public result;

 function calculateSum(uint256 x, uint256 y) public {
 result = x.add(y);
 }
}

I dette eksempel definerer biblioteket Math en add-funktion. Erklæringen using Math for uint256; giver dig mulighed for at kalde add-funktionen på uint256-variabler ved hjælp af punktnotationen.

Almindelige sårbarheder i smarte kontrakter

Smarte kontrakter er modtagelige for forskellige sårbarheder, der kan føre til tab af midler eller uventet adfærd. Det er afgørende at være opmærksom på disse sårbarheder og tage skridt til at afbøde dem.

Reentrancy

Reentrancy opstår, når en kontrakt kalder en ekstern kontrakt, og den eksterne kontrakt kalder tilbage til den originale kontrakt, før den originale kontrakts udførelse er fuldført. Dette kan føre til uventede tilstandsændringer.

Afbødning: Brug Checks-Effects-Interactions-mønsteret, og overvej at bruge funktionerne transfer eller send for at begrænse gas, der er tilgængelig for det eksterne kald.

Overflow og Underflow

Overflow opstår, når en aritmetisk operation overskrider den maksimale værdi af en datatype. Underflow opstår, når en aritmetisk operation resulterer i en værdi, der er mindre end minimumsværdien af en datatype.

Afbødning: Brug SafeMath-biblioteker (selvom overflow- og underflow-kontroller er indbygget som standard med Solidity 0.8.0 og nyere versioner) for at forhindre disse problemer.

Tidsstempelafhængighed

Hvis du stoler på bloktidsstemplet (block.timestamp), kan det gøre din kontrakt sårbar over for manipulation af minearbejdere, da de har en vis kontrol over tidsstemplet.

Afbødning: Undgå at bruge block.timestamp til kritisk logik. Overvej at bruge orakler eller andre mere pålidelige tidsressourcer.

Denial of Service (DoS)

DoS-angreb har til formål at gøre en kontrakt ubrugelig for legitime brugere. Dette kan opnås ved at forbruge al tilgængelig gas eller udnytte sårbarheder, der får kontrakten til at vende tilbage.

Afbødning: Implementer gasgrænser, undgå loops med ubegrænsede iterationer, og valider brugerinput omhyggeligt.

Front Running

Front running opstår, når nogen observerer en ventende transaktion og indsender deres egen transaktion med en højere gaspris for at få den udført før den originale transaktion.

Afbødning: Brug commit-reveal-ordninger eller andre teknikker til at skjule transaktionsdetaljer, indtil de er udført.

Bedste fremgangsmåder til at skrive sikre smarte kontrakter

Avancerede Solidity-koncepter

Når du har en solid forståelse af det grundlæggende, kan du udforske mere avancerede koncepter:

Assembly

Solidity giver dig mulighed for at skrive inline assembly-kode, hvilket giver dig mere kontrol over EVM. Det øger dog også risikoen for at introducere fejl og sårbarheder.

Proxies

Proxies giver dig mulighed for at opgradere dine smarte kontrakter uden at migrere data. Dette involverer implementering af en proxy-kontrakt, der videresender opkald til en implementeringskontrakt. Når du vil opgradere kontrakten, skal du blot implementere en ny implementeringskontrakt og opdatere proxyen til at pege på den nye implementering.

Meta-transaktioner

Meta-transaktioner giver brugerne mulighed for at interagere med din smarte kontrakt uden at betale gasgebyrer direkte. I stedet betaler en relayer gasgebyrerne på deres vegne. Dette kan forbedre brugeroplevelsen, især for brugere, der er nye inden for blockchain.

EIP-721 og EIP-1155 (NFT'er)

Solidity bruges almindeligvis til at oprette Non-Fungible Tokens (NFT'er) ved hjælp af standarder som EIP-721 og EIP-1155. Det er afgørende at forstå disse standarder for at bygge NFT-baserede applikationer.

Solidity og fremtiden for Blockchain

Solidity spiller en kritisk rolle i det hurtigt udviklende landskab af blockchain-teknologi. Efterhånden som blockchain-adoptionen fortsætter med at vokse, vil der være stor efterspørgsel efter Solidity-udviklere til at bygge innovative og sikre decentraliserede applikationer. Sproget opdateres og forbedres konstant, så det er vigtigt at holde sig ajour med den seneste udvikling for at få succes inden for dette område.

Konklusion

Solidity er et kraftfuldt og alsidigt sprog til at bygge smarte kontrakter på Ethereum-blockchainen. Denne guide har givet et omfattende overblik over Solidity, fra grundlæggende begreber til avancerede teknikker. Ved at mestre Solidity og følge bedste fremgangsmåder for sikker udvikling kan du bidrage til den spændende verden af decentraliserede applikationer og hjælpe med at forme fremtiden for blockchain-teknologi. Husk altid at prioritere sikkerhed, teste din kode grundigt og holde dig informeret om den seneste udvikling i Solidity-økosystemet. Potentialet i smarte kontrakter er enormt, og med Solidity kan du bringe dine innovative ideer til live.