Solidity

Solidity
Date de première version	2014
Dernière version	0.8.28 (9 octobre 2024)
Licence	Licence publique générale GNU version 3
Site web	soliditylang.org

Solidity est un langage de programmation orienté objet dédié à l'écriture de contrats intelligents. Il est utilisé pour implémenter des smartcontrat sur diverses blockchains, notamment Ethereum. Il a été développé par Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai et plusieurs anciens contributeurs principaux d'Ethereum pour permettre l'écriture de contrats intelligents sur des plateformes de blockchain telles qu'Ethereum.

Historique

Solidity a été initialement proposée en août 2014 par Gavin Wood ; le langage a ensuite été développé par l'équipe Solidity du projet Ethereum, dirigée par Christian Reitwiessner.

À l'heure actuelle, Solidity est le principal langage sur Ethereum ainsi que sur d'autres blockchains privées fonctionnant sur des plateformes en concurrence avec Ethereum, telles que Monax et sa blockchain Hyperledger Burrow, qui utilise Tendermint pour le consensus. SWIFT a déployé une preuve de concept à l'aide de Solidity exécuté sur Burrow. Un chercheur de l'université Cornell a déclaré que Solidity était en partie responsable du piratage de The DAO en 2016. Il a déclaré : « ce n'était en fait pas une faille ou un exploit dans le contrat DAO lui-même : techniquement, la machine virtuelle Ethereum (EVM) fonctionnait comme prévu, mais Solidity introduisait des failles de sécurité dans les contrats qui avaient échappé à la communauté, mais aussi aux concepteurs du langage eux-mêmes. » En effet, des contraintes propres à l'EVM, telles que l'impossibilité de mettre à jour un contrat intelligent (à moins d'en déployer un nouveau), ou l'absence de virgule flottante intégrée peuvent rendre certaines failles très difficiles à trouver et à corriger.

Description

Solidity est un langage de programmation de type statique conçu pour développer des contrats intelligents qui s'exécutent sur l'EVM (Ethereum Virtual Machine). Solidity est compilé en bytecode lui-même exécutable sur l'EVM. Grâce à Solidity, les développeurs sont en mesure d'écrire des applications implémentant une logique commerciale s’exécutant de manière autonome au travers des contrats intelligents, laissant une trace de transactions non répudiables et faisant autorité. Écrire des contrats intelligents dans des langages spécifiques aux contrats intelligents tels que Solidity est considéré comme facile (en apparence pour ceux qui ont déjà des compétences en programmation).

Exemple de programme Solidity :

pragma solidity >=0.5.0 <0.7.0;

contract Coin {
    // Le mot-clé "public" rend les variables
    // accessibles depuis d'autres contrats
    address public minter;
    mapping (address => uint) public balances;
    mapping (address => mapping (address => uint256)) public allowed;

    // Les événements permettent aux clients de réagir à des
    // changements spécifiques du contrat que vous déclarez
    event Transfer (address from, address to, uint amount);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event MintingRightTransferred(address indexed oldMinter, address indexed newMinter);

    string public symbol = "WIKI";
    string public name = "WikiArticleToken";
    uint256 public totalSupply;

    // Le code du constructeur est uniquement exécuté
    // lorsque le contrat est créé
    constructor() public {
        minter = msg.sender;
    }

    // Envoie un montant de pièces nouvellement créées à une adresse
    // Peut uniquement être appelé par le créateur du contrat
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount <= 2**256-1); // soyez conscient des montants élevés car il existe des débordements
        balances[receiver] += amount;
        totalSupply += amount;
        emit Transfer(address(0), receiver, amount);
    }

    // Envoie un montant de pièces existantes
    // de tout appelant à une adresse
    function transfer(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Solde insuffisant.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Transfer(msg.sender, receiver, amount);
    }

    function transferFrom(address from, address to, uint256 amount) public returns (bool success) {
        require((allowed[from][msg.sender]||(from == msg.sender)) >= amount, "Vous n'êtes pas autorisé à dépenser ce montant");
        require(amount <= balances[from], "Solde insuffisant");
        allowed[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }

    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
		return allowed[tokenOwner][spender];
    }

    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }

    function balanceOf(address guy) public view returns (uint256 balance) {
        return balances[guy];
    }

    function transferMinterRight(address _newMinter) public {
        require(msg.sender == minter);
        emit MintingRightTransferred(minter, _newMinter);
        minter = _newMinter;
    }
}

Disponibilité de la plateforme de développement

• Microsoft Visual Studio^{[réf. nécessaire]}
• Code Microsoft Visual Studio
• ConsenSys Enterprise
• Tendermint sur Microsoft Azure^{[réf. nécessaire]}
• ErisDB sur AWS^{[réf. nécessaire]}
• Environnement web Remix

Plateformes Blockchain

Solidity est disponible sur:

• Ethereum
• Ethereum Classic
• Tendermint et ErisDB (une version de Tendermint)^{[réf. nécessaire]}
• Contrepartie (qui fonctionne sur Bitcoin )^{[réf. nécessaire]}
• Tron
• Binance Smart Chain

Voir aussi

Vyper, un autre langage destiné à la creation de smartcontrat sur la machine virtuelle Ethereum.