Solidity 101: Aprendiendo a Crear Contratos Inteligentes en Ethereum - parte 2

¡Bienvenidos a la serie de posteos para aprender Solidity!

Como ya vimos en el post anterior, Solidity se destaca como el lenguaje mas popular para desarrollar contratos inteligentes, especialmente para la red de Ethereum. Solidity nos permite desarrollar aplicaciones descentralizadas (dApps) con funcionalidades complejas y automatizadas.

En este posteo exploraremos la sintaxis, desde los conceptos básicos hasta los aspectos más avanzados, brindándote una base sólida para comenzar a programar en este lenguaje.

Estructura básica:

Para empezar, familiaricémonos con la estructura básica de Solidity. Todo contrato en Solidity se define especificando la licencia del contrato y la versión de Solidity a utilizar en el inicio. Luego utilizando la palabra clave contract. A continuación, se presenta un ejemplo simple de un contrato básico:

pragma solidity ^0.8.0; // Indica la versión de Solidity que se utilizará

// Declaración de la licencia del contrato
// Puedes seleccionar la licencia que mejor se adapte a tus necesidades
// Por ejemplo:
// SPDX-License-Identifier: MIT

contract MiContrato {
    // Declaraciones de variables y funciones aquí
}

La línea pragma solidity ^0.8.0; especifica la versión mínima de Solidity que se requiere para compilar el contrato. Es importante indicar la versión correcta para asegurarte de que el contrato funcione correctamente y aproveche las características más recientes del lenguaje.

En cuanto a la licencia, puedes seleccionar la adecuada para tu proyecto. La línea // SPDX-License-Identifier: MIT es un ejemplo de cómo se puede indicar la licencia MIT. Sin embargo, existen otras licencias como GPL, Apache, entre otras, que puedes utilizar según tus preferencias y requisitos legales.

Recuerda que incluir la versión de Solidity y la licencia en tu contrato es una buena práctica para brindar transparencia y claridad sobre los términos de uso del código fuente.

Tipos de datos y variables:

Solidity admite una amplia gama de tipos de datos, incluyendo enteros, cadenas de texto, booleanos, direcciones y más. Aquí hay algunos ejemplos de declaración de variables:

uint256 miNumero;       // Entero sin signo de 256 bits
string miTexto;         // Cadena de texto
bool miBooleano;        // Valor booleano (verdadero/falso)
address miDireccion;    // Dirección de Ethereum

Funciones:

Las funciones en Solidity permiten definir el comportamiento de un contrato. Pueden recibir parámetros, devolver valores y realizar acciones en la cadena de bloques. A continuación, se muestra un ejemplo de declaración de función en Solidity:

function saludar(string memory _nombre) public pure returns (string memory) {
    return "¡Hola, " + nombre + "!";
}

En este ejemplo, la función saludar toma un parámetro de tipo string llamado nombre y devuelve un saludo personalizado.

Modificadores de acceso:

Solidity proporciona modificadores de acceso para controlar la visibilidad y accesibilidad de las variables y funciones en un contrato. Los principales modificadores de acceso son: public, private, internal y external. Estos modificadores determinan quién puede acceder a las variables o funciones. A continuación, se muestra un ejemplo de uso de modificadores de acceso:

contract MiContrato {
    uint256 miNumero;   // Solo accesible dentro del contrato

    function obtenerNumero() public view returns (uint256) {
        return miNumero;
    }
}

En este caso, la variable miNumero solo puede ser accedida dentro del contrato, mientras que la función obtenerNumero es de acceso público y permite leer el valor de miNumero desde fuera del contrato.

Estructuras y herencia:

Solidity también admite estructuras y herencia, lo que permite organizar y reutilizar el código de manera eficiente. Las estructuras permiten definir tipos de datos personalizados, mientras que la herencia permite a un contrato heredar propiedades y funciones de otro contrato. Aquí hay un ejemplo que combina ambas características:

contract Animal {
    string internal animalName;
    uint256 internal age;

    constructor(string memory _name, uint256 _age) {
        animalName = _name;
        age = _age;
    }

    function getAnimalDetails() public view returns (string memory, uint256) {
        return (animalName, age);
    }
}

contract Dog is Animal {
    string internal breed;

    constructor(string memory _name, uint256 _age, string memory _breed)
        Animal(_name, _age)
    {
        breed = _breed;
    }

    function getDogDetails() public view returns (string memory, uint256, string memory) {
        return (animalName, age, breed);
    }
}

En este ejemplo, tenemos dos contratos: Animal y Dog. El contrato Animal es la clase base, que contiene variables animalName y age, junto con una función getAnimalDetails() para obtener los detalles del animal.

El contrato Dog hereda de Animal utilizando la palabra clave is. Además de las variables y función heredadas, Dog también tiene su propia variable breed y una función adicional getDogDetails() que devuelve los detalles específicos de un perro.

Al crear un contrato Dog, primero se llama al constructor del contrato base Animal utilizando Animal(_name, _age). Esto permite establecer el nombre y la edad del animal al crear una instancia de Dog.

Con esta estructura y herencia, puedes crear contratos que representen diferentes tipos de animales y aprovechar las propiedades y funciones comunes heredadas de la clase base Animal. Esto promueve la reutilización del código y facilita la organización de la lógica de tu contrato en jerarquías lógicas.

Al principio parece complicado y más si no haz trabajado con algun otro lenguaje que este orientado a clases, pero con el tiempo y la práctica se vuelve algo más sencillo.

Más adelante explicaremos cada uno de estos tópicos a detalle, igualmente si quieres seguir avanzando puedes leer la documentación en la pagina oficial de Solidity o mirar mas ejemplos de código en esta pagina espectacular de Solidity by example