Structure d’un contrat

Les contrats Solidity sont similaires à des classes dans des langages orientés objet. Chaque contrat peut contenir des déclarations de Variables d’état, Fonctions, Modificateurs de fonction, Évènements, Errors, Types Structure et Types Enum. De plus, les contrats peuvent hériter d’autres contrats.

Il existe également des types de contrats spéciaux appelés libraries et interfaces.

La section sur les contrats contient plus de détails que cette section, qui permet d’avoir une vue d’ensemble rapide.

Variables d’état

Les variables d’état sont des variables dont les valeurs sont stockées en permanence dans le storage du contrat. .. code-block:: solidity

// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.0 <0.9.0;

contract SimpleStorage {

uint storedData; // State variable // …

}

Voir la section Types pour les types de variables d’état valides et Visibilité et Getters pour les choix possibles de visibilité.

Fonctions

Les fonctions sont les unités exécutables du code d’un contrat. Functions are usually defined inside a contract, but they can also be defined outside of contracts.

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.1 <0.9.0;

contract SimpleAuction {
    function bid() public payable { // Function
        // ...
    }
}

// Helper function defined outside of a contract
function helper(uint x) pure returns (uint) {
    return x * 2;
}

Les Appels de fonction peuvent se faire en interne ou en externe et ont différents niveaux de visibilité pour d’autres contrats. Functions accept parameters and return variables to pass parameters and values between them.

Modificateurs de fonction

Les modificateurs de fonction peuvent être utilisés pour modifier la sémantique des fonctions d’une manière déclarative (voir Modificateurs de fonctions dans la section contrats).

Overloading, that is, having the same modifier name with different parameters, is not possible.

Like functions, modifiers can be overridden.

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;

contract Purchase {
    address public seller;

    modifier onlySeller() { // Modifier
        require(
            msg.sender == seller,
            "Only seller can call this."
        );
        _;
    }

    function abort() public view onlySeller { // Modifier usage
        // ...
    }
}

Évènements

Les évènements (event) sont une interface d’accès aux fonctionnalités de journalisation (logs) de l’EVM.

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.21 <0.9.0;

contract SimpleAuction {
    event HighestBidIncreased(address bidder, uint amount); // Event

    function bid() public payable {
        // ...
        emit HighestBidIncreased(msg.sender, msg.value); // Triggering event
    }
}

Voir Événements dans la section contrats pour plus d’informations sur la façon dont les événements sont déclarés et peuvent être utilisés à partir d’une dapp.

Errors

Errors allow you to define descriptive names and data for failure situations. Errors can be used in revert statements. In comparison to string descriptions, errors are much cheaper and allow you to encode additional data. You can use NatSpec to describe the error to the user.

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

/// Not enough funds for transfer. Requested `requested`,
/// but only `available` available.
error NotEnoughFunds(uint requested, uint available);

contract Token {
    mapping(address => uint) balances;
    function transfer(address to, uint amount) public {
        uint balance = balances[msg.sender];
        if (balance < amount)
            revert NotEnoughFunds(amount, balance);
        balances[msg.sender] -= amount;
        balances[to] += amount;
        // ...
    }
}

See Errors and the Revert Statement in the contracts section for more information.

Types Structure

Les structures sont des types personnalisés qui peuvent regrouper plusieurs variables (voir Structs dans la section types).

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract Ballot {
    struct Voter { // Struct
        uint weight;
        bool voted;
        address delegate;
        uint vote;
    }
}

Types Enum

Les Enumérateurs (enum) peuvent être utilisés pour créer des types personnalisés avec un ensemble fini de “valeurs constantes” (voir Énumérateurs dans la section Types).

open in Remix

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract Purchase {
    enum State { Created, Locked, Inactive } // Enum
}