Vous devez avoir entendu parler de termes tels que contrat intelligent, jetons, applications décentralisées, NFT, finance décentralisée, jetons et bien d’autres. Eh bien, Solidity est l’un des principaux langages de programmation pour construire les termes mentionnés ci-dessus.
Alors, qu’est-ce que la solidité?
Solidity est un langage de haut niveau orienté objet pour la mise en œuvre contrats intelligents.
Contrats intelligents sont des programmes qui régissent le comportement des comptes au sein de l’état Ethereum, ou de tout autre état blockchain avec lequel la solidité peut avoir une interaction.
La solidité est typée statiquement, prend en charge l’héritage, les bibliothèques et d’autres fonctionnalités.
Que peut-on construire avec solidité
Avec Solidity, vous pouvez créer des contrats pour des utilisations telles que le vote, le financement participatif, les enchères à l’aveugle, les jetons, les NFT et les portefeuilles multi-signatures.
Noter: vous devez avoir une bonne compréhension de la blockchain et de son fonctionnement, ainsi qu’une bonne compréhension de la blockchain Ethereum avant de vous plonger dans la programmation Solidity
Structure du code de solidité
Le code Solidity est un peu similaire à Javascript/Typescript, ce n’est pas exagéré puisque Javascript est l’une des influences de Solidity.
Solidity est conçu pour cibler la machine virtuelle Ethereum (EVM) et La solidité est Turing complète, contrairement au script de Bitcoin qui ne l’est pas.
Les fichiers de solidité sont identifiés avec l’extension .sol, par exemple Auction.sol
// Solidity contract structure//license
//SPDX-License-Identifier: MIT// compiler versioning
pragma solidity ^0.8.0;// import statements
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';// Contract declaration
contract NFT {
// Solidity variables
address public manager;
uint private _counter; // contract constructor
constructor() {
manager = msg.sender;
} // functions
function getNFT() external view returns(uint256) {
return _counter;
}}// Or //license
//SPDX-License-Identifier: MIT// compiler versioning
pragma solidity ^0.8.0;library Counters {
// Solidity struct
struct Counters {
uint256 _value;
} function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
}// Or//license
//SPDX-License-Identifier: MIT// compiler versioning
pragma solidity ^0.8.0;interface IERC721 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); function ownerOf(uint256 tokenId) external view returns (address owner);}
Les fichiers Solidity (.sol) ne peuvent contenir que des contrats (contract {}) abstraits ou non, des interfaces (interface {}) ou des bibliothèques (library {}).
Remarque : tous Les déclarations de solidité et les instructions doivent se terminer par un point-virgule (;), tandis que les accolades déterminent le début et la fin de nombres arbitraires d’instructions ou de déclarations : comme les fonctions, les modificateurs, les structures, les énumérations et le contrat lui-même.
Types de solidité
Booléen (bool), entiers (int/uint), nombres à virgule fixe (fixe/ufixé), enum, mappage, structure et adresse.
bool sold;
int num;
uint counter;
fixed dec;
ufixed dex;
address owner;
address payable manager;// Enum
enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
FreshJuiceSize choice;// mapping
mapping(string => string) names;// struct
struct MarketToken {
uint256 itemId;
address nftContract;
uint256 tokenId;
address payable seller;
address payable owner;
uint256 price;
bool sold;
}mapping(uint256 => MarketToken) idToMarketToken;idToMarketToken[itemId] = MarketToken(
itemId,
nftContract,
tokenId,
payable(msg.sender),
payable(address(0)),
price,
false
);
vous pouvez en savoir plus sur les types de solidité ici
Variables de solidité
Variables d’état — variables dont les valeurs sont stockées en permanence dans la mémoire contractuelle.
Variables locales — variables dont les valeurs sont présentes lors de l’exécution de la fonction.
Variables globales – Des variables spéciales existent dans l’espace de noms global utilisé pour obtenir des informations sur la blockchain.
Exemples de variables
// State Variables
contract SolidityState {
uint public stateData; // State variable
constructor() public {
stateData = 10; // Using State variable
}
}// Local Variables
contract SolidityLocal {
function getResult() public view returns(uint){
uint x = 1; // local variable
uint y = 2;
uint result = x + y;
return result; //access the local variable
}
}// Global Variables
contract SolidityGlobal {
address payable public manager; // State variable
constructor() public {
magager = payable(msg.sender);
/* msg.sender is a global variable, which holds the address of the address of the request sender */
}
}
Vous devriez avoir remarqué que le style de commentaire Solidity est le même que celui des commentaires Javascript // pour les commentaires sur une seule ligne et /**/ pour les commentaires sur plusieurs lignes.
De plus, lorsque vous déclarez des variables Solidity, vous devez commencer par un type, par exemple une unité, car Solidity est typé statiquement, contrairement à Javascript qui est vaguement typé
let name = "Raphael";
, ou Typescript qui ajoute le type de variable après le nom de la variable
const name: string = “Nene”;
après le type de variable, déclarez la visibilité de la variable (publique/privée), puis le nom de la variable.
Remarque : vLa visibilité variable doit être utilisée pour les variables d’état, pas pour les variables locales. lorsque vous rendez une variable publique, Solidity crée automatiquement une fonction getter pour la variable pour vous.
contract MyVariable {
string public fullName = "Raphael Eyerin"; function setName(string memory _fullName) public {
fullName = _fullName;
}
}
lorsque ce code est compilé, Solidity créera une fonction nommée fullName() pour accéder à la variable fullName, il n’est donc pas nécessaire de créer une fonction getter si vous déclarez la variable comme publique.
Énoncés conditionnels de solidité
Les instructions conditionnelles Solidity sont similaires à celles de Javascript et Typescript, mais Solidity n’a pas d’instruction switch.
Exemples if, if-else et if-else if
// If Condition
contract ConditionTest {
function test(uint a, uint b) external pure returns(string) {
string ans = "A is greater";
if(b > a) {
ans = "B is greater";
}
return ans;
}
}// If-Else Condition
contract ConditionTest {
function test(uint a, uint b) external pure returns(uint) {
if(b > a) {
return b;
} else {
return a;
}
}
}// If-Else If Condition
contract ConditionTest {
function test(uint a, uint b) external pure returns(string) {
string ans;
if(a > 500) {
ans = "I will give you 1000 wei";
} else if (a > 250) {
ans = "I will give you 500 wei";
} else if (b > a) {
ans = "I will give you 250 wei";
} else {
ans = "I will give you 100 wei";
}
return ans;
}
}
Boucles de solidité
Encore une fois Solidité pour la boucle, la boucle while et la boucle do-while est la même que celle de Javascript
Boucles
// for loop
contract SolidityTest {
function makeAll(uint maxNum) external pure returns(uint)
uint sum;
for (uint j = 0; j < maxNum; j++) { //for loop example
sum += j;
}
return sum;
}
}// While loop
contract SolidityTest {
function makeAll(uint maxNum) external pure returns(uint)
uint sum;
uint a = maxNum - 1; while(a > 0) { //while loop example
sum += j;
a--;
}
return sum;
}
}
Do while n’est pas souvent utilisé mais il est également similaire à celui de Javascript, vous pouvez également utiliser des instructions de contrôle de boucle dans Solidity (break/continue).
Fonctions de solidité
Voici comment définir une fonction dans Solidity
function function-name(parameter-list) scope returns() {
//statements
}function setName(string memory _name) public {
name = _name;
}function getName() external returns(string) {
return name;
}
Il commence par un mot-clé de fonction comme Javascript, puis le nom de la fonction. Le côté droit des fonctions Solidity est différent des fonctions Javascript, vous devez indiquer la portée de la fonction et le type de retour si la fonction renvoie une valeur. Typescript indique également le type de retour de la fonction sur le côté droit de la fonction, mais avec une syntaxe différente
let name: string = "";
public function getName(): string {
return name;
}
appeler une fonction dans Solidity est également similaire à la façon dont les fonctions sont appelées en Javascript
// Calling getName() function
string name = getName();
Types de visibilité des fonctions
Solidity a quatre types de visibilité de fonction : privé, public, externe et interne. La visibilité des fonctions nous permet de sécuriser facilement certaines parties d’un contrat sans avoir à écrire trop de logique personnalisée.
privé: Une fonction privée ne peut être appelée que par le contrat principal lui-même. Bien que ce ne soit pas la valeur par défaut, il est généralement recommandé de garder vos fonctions privées à moins qu’une étendue avec plus de visibilité ne soit nécessaire.
Publique: Une fonction publique peut être appelée par toutes les parties potentielles. Sauf indication contraire, toutes les fonctions sont rendues publiques par défaut
externe: Une fonction externe ne peut être appelée que par un tiers. Il ne peut pas être invoqué à partir du contrat principal lui-même ou de tout contrat dérivé de celui-ci.
Les fonctions externes ont l’avantage d’être plus performantes car leurs arguments n’ont pas besoin d’être copiés en mémoire. Ainsi, dans la mesure du possible, il est conseillé de conserver une logique qui n’a besoin d’être consultée que par une partie externe pour external une fonction.
interne: Une fonction interne peut être appelée par le contrat principal lui-même, ainsi que par les contrats dérivés. Comme avec private fonctions, c’est généralement une bonne idée de garder vos fonctions internal la mesure du possible.
Les fonctions de solidité peuvent avoir un vue, ou pur propriété, voir les fonctions sont des fonctions en lecture seule, ce qui garantit que les variables d’état ne peuvent pas être modifiées après les avoir appelées, tandis que fonctions pures ne lisez ni ne modifiez les variables d’état, qui renvoient les valeurs uniquement en utilisant les paramètres passés à la fonction ou les variables locales présentes dans celle-ci.
les fonctions peuvent également être surchargées dans Solidity.
Aperçu des fonctions
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
contract FunctionTest {
string private name;
uint age;
address manager; constructor() {
// call internal function
setOwner(msg.sender);
}// external view function
function getName() external view returns(string) {
return name;
}// external view function
// Public function
function setOwner(address _manager) intenal {
manager = _manager;
}
function setAge(uint _age) public (string) {
age = _age;
} // Pure function
function getResult() public pure returns(uint product, uint sum)
{
uint num1 = 2;
uint num2 = 4; product = num1 * num2;
sum = num1 + num2;
} // function overloading in Solidity
function getSum(uint a, uint b) public pure returns(uint){
return a + b;
} function getSum(uint a, uint b, uint c)
public pure returns(uint) {
return a + b + c;
}}
Modificateurs de fonction
Les modificateurs sont du code qui peut être exécuté avant et/ou après un appel de fonction.
Les modificateurs peuvent être utilisés pour :
- Accès restreint
- Valider les entrées
- Protégez-vous contre le piratage de réentrée
Exemple
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; contract FunctionMod {
// We will use these variables to demonstrate how to use
// modifiers.
address public owner;
uint public x = 10;
bool public locked; constructor() {
// Set the transaction sender as the owner of the contract.
owner = msg.sender;
}// Modifier to check that the caller is the owner of
// the contract.modifier onlyOwner() {
// Modifiers can take inputs. This modifier checks that the
require(msg.sender == owner, "Not owner");
// Underscore is a special character only used inside
// a function modifier and it tells Solidity to
// execute the rest of the code.
_;
}
// address passed in is not the zero address.modifier validAddress(address _addr) {
require(_addr != address(0), "Not valid address");
_;
}function changeOwner(address _newOwner)
}
public onlyOwner validAddress(_newOwner) {
owner = _newOwner;
}
vous devriez en savoir plus sur les fonctions Solidity et en savoir plus sur des choses que je n’ai pas abordées dans cet article.
Gestion des erreurs de solidité
La façon dont les erreurs sont gérées dans Solidity est différente de la façon dont les erreurs sont gérées dans Javascript, trois fonctions sont disponibles pour gérer les erreurs dans Solidity : exiger, affirmer et revenir en arrière. assert est utilisé pour les erreurs internes.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
contract Error {
uint num;
uint256 balance; // Assert
function testAssert(uint _num) public {
// Assert should only be used to test for internal errors
num = _num;
/* If the pass a function parameter other than zero in this function it will revert to its initial state
*/
assert(num == 0);
} // Revert
function testRevert(uint num) public {
// Revert is useful when the condition to check is complex. num = _num;
if (num <= 10) {
revert("Input must be greater than 10");
}
} // Require
function testRequire(uint256 _amount) public {
uint oldBalance = balance;
uint newBalance = balance + _amount;// balance + _amount does not overflow if balance + _amount >= balance
require(newBalance >= oldBalance, "Overflow");balance = newBalance;
// Custom error handling
assert(balance >= oldBalance);
}
error InsufficientBalance(uint balance, uint withdrawAmount); function testCustomError(uint _withdrawAmount) public view {
// address(this).balance is basically the contract balan
uint bal = address(this).balance;// if you try to witdraw more than the contract balance it will throw an error.
if (bal < _withdrawAmount) {
revert InsufficientBalance({balance: bal, withdrawAmount: _withdrawAmount});
}
}
}
Solidité Héritage
Vous devriez voir les contrats Solidity sous forme de classes Javascript
// A Soidity contract
contract Test {
// Variables
address private manager; // constructor funtion
constructor() {
manager = msg.sender;
} // contract functions
function getManager() external view returns(address) {
return manager;
}
}// Javascript class
class Test {
// constructor function
constructor(height, width) {
this.height = height;
this.width = width;
}// class methods
function getWidth() {
return this.width;
}
}
pour hériter d’un contrat dans Solidity il faut importer le contrat dans le contrat qui en héritera, puis utiliser le (est) mot-clé pour hériter du contrat ou de l’interface
// IERC721Storage.sol
interface IERC721Storage {
function name() external view returns (string memory _name);
function symbol() external view returns (string memory _symbol);
}// ERC721Storage.sol
import './IERC721.sol';contract ERC721Storage is IERC721 {
string private _name;
string private _symbol; constructor(string memory named, string memory symbolified) {
_name = named;
_symbol = symbolified;
} function name() external view returns(string memory) {
return _name;
}function symbol() external view returns(string memory) {
// you can also inherit a class or an abstract class
return _symbol;
}
}
Après avoir lu jusqu’ici, vous devez être d’accord avec moi sur le fait que le code Solidity et Javascript sont similaires, donc choisir la programmation Solidity en tant que développeur Javascript avec une bonne compréhension de la blockchain et de son fonctionnement ne devrait pas être un gros problème.
Ceci est juste une introduction de base à Solidity que vous devriez lire plus sur Solidity et ses outils de développement comme truffe, solcjs, web3js, métamasque, casque, ganache, fureur, et tant d’autres
Rejoignez Coinmonks Telegram Channel et Youtube Channel pour en savoir plus sur le trading et l’investissement crypto
