Estructura de un Contrato

Los contratos en Solidity son similares a las clases en los lenguajes orientados a objetos. Cada contrato puede contener declaraciones de variables de estado, funciones, modificadores de funciones, eventos, errores, tipos struct y enum. Además, los contratos pueden heredar de otros contratos.

También hay tipos de contratos especiales llamados libraries e interfaces.

La sección sobre contratos contiene más detalles que esta sección, el cual sirve para proveer un rápido resumen.

Variables de Estado

Las variables de estado son variables cuyos valores se almacenan permanentemente en el almacenamiento del contrato.

open in Remix

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

contract SimpleStorage {
    uint storedData; // Variable de estado
    // ...
}

Véase la sección de tipos para tipos válidos de variables de estado y la sección visibilidad-y-getters para posibles opciones de visibilidad. See the Tipos section for valid state variable types and Visibility and Getters for possible choices for visibility.

Funciones

Las funciones son las unidades de código ejecutables. Las funciones están definidas usualmente dentro de los contratos, pero tambíen pueden ser definidas fuera de los contratos.

open in Remix

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

contract SimpleAuction {
    function bid() public payable { // Función
        // ...
    }
}

// Función auxiliar definida fuera de un contrato
function helper(uint x) pure returns (uint) {
    return x * 2;
}

Las-llamadas-a-funciones pueden suceder interna o externamente y tienen diferentes niveles de visibilidad hacia otros contratos. Las funciones aceptan parámetros y retornan variables para pasar parámetros y valores entre ellos.

Modificadores de Funciones

Los modificadores de funciones se pueden usar para modificar la semántica de las funciones de una forma declarativa (véase modificadores en la sección de contratos).

La sobrecarga, es decir, tener el mismo nombre del modificador con diferentes parámetros, no es posible.

Como las funciones, los modificadores se pueden anular.

open in Remix

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

contract Purchase {
    address public seller;

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

    function abort() public view onlySeller { // Uso del modificador
        // ...
    }
}

Eventos

Los eventos son interfaces convenientes con las facilidades de registro de la 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); // Evento

    function bid() public payable {
        // ...
        emit HighestBidIncreased(msg.sender, msg.value); // Desencadenando un evento
    }
}

Véase eventos en la sección de contratos para información sobre cómo los eventos se declaran y pueden ser usados desde dentro de una dapp.

Errores

Los errores le permiten definir nombres y datos descriptivos para situaciones de falla. Los errores se pueden usar en sentencias revert. En comparaciñon a las descripciones de caradenas de caracteres, los errores son mucho más baratos y le permiten codificar datos adicionales. Puede usar NatSpec para describir el error al usuario.

open in Remix

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

/// Sin suficientes fondos para transferir.  Solicitado `requested`,
/// pero solo disponible `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;
        // ...
    }
}

Véase errores en la sección de contratos para más información.

Tipos de Structs

Los structs son tipos personalizados que pueden agrupar varias variables (véase Structs en la sección tipos).

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;
    }
}

Tipos Enum

Los enums pueden ser usados para crear tipos personalizados con un conjunto finito de “valores constantes” (véase Enums en la sección de tipos).

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
}