Uso de la herencia en Solidity

Hola, para aclarar que Solidity sí es un lenguaje orientado a objetos, en la documentación oficial lo definen así:

Solidity is an object-oriented, high-level language for implementing smart contracts. Smart contracts are programs which govern the behaviour of accounts within the Ethereum state.

Fuente: Documentación oficial

17 - Herencia

“No hay que reinvetar la rueda”

Utilizamos la Herencia para reutilizar codigo en nuevos contratos. Solidity no es POO, pero se comporta similar. Solidity es orientado a contratos. Identificaremos con la sentencia is. Si un contrato tiene un constructor con parametros, debemos indicar que valores debe tomar ese constructor para poder derivarse.

Entonces, se busca generar una relacion entre contratos para reutilizar el codigo mediante la Herencia. Por lo que la capacidad de agregar/modificar una funcion ya escrita en el contrato anterior nos sera de mucha utilidad.

Las funciones virtuales son funciones definidas para que se puedan reescrbir por las funciones override. Para esto debemos establecer una relacion de Herencia. Si una funcion virtual no define implementacion, el contrato se convierte en un contrato abstracto. Tambien hay contratos abstractos que usamos como moldes vacios para usar en futuros contratos.

Las interfaces no van a tener codigo. su funcion es indicarnos un comportamiento que queremos que tenga un contrato. Solo tiene declaraciones (definiciones de funciones) sin codigo.

• super (sentencia) nos sirve para hacer referencia a una funcion de clase superior.

Ejemplo practico: Buscamos 2 funciones virtuales en Modificadores📗 e Interface📘 para colocar en nuestro archivo/contrato de Herencia 📕📘📗.

Vamos a tener que importar el directorio de los demas contratos, en este caso se encuentran en la misma carpeta los contratos. Coloco los emojis de libros para hacer referencia a un contrato, si hay varios libros es porque es una Herencia que contiene otros contratos.

• Herencia.sol 📕📘📗

// SPDX-Licence-Identifier: UNLICENSED

pragma solidity >=0.7.0 < 0.9.0;

import "./Interface.sol";
import "./Modificadores.sol";

contract Herencia is Suma, Modificadores {

    constructor(string memory nombreNuevo) Modificadores(nombreNuevo) {

    }

    function sumar(uint numero1, uint numero2) public override EsOwner() view returns(uint) {
        return numero1 + numero2;
    }
}

Es buena practica traer todo el encabezado de la funcion de “Interface”, por lo que es recomendable copiar y pegar “function sumar(uint numero1, uint numero2)”

• Interface.sol 📘

// SPDX-Licence-Identifier: UNLICENSED

pragma solidity >=0.7.0 < 0.9.0;

interface Suma {

    function sumar(uint numero1, uint numero2) external returns (uint);
}

• Modificadores.sol 📗

// SPDX-Licence-Identifier: UNLICENSED

pragma solidity >=0.4.0 < 0.9.0;

contract Modificadores {


    address private owner;
    string private nombreOwner;

    constructor(string memory nombre {
        owner = msg.sender;
        nombreOwner = nombre;
    }

    function Suma(uint numero1, uint numero2) public view EsOwner() returns (uint) {
        return numero1 + numero2;
    }

    modifier EsOwner() {
        if (msg.sender != owner) revert();
        _;
    }
}

Es muy importante comprender los conceptos de POO para poder sacarle el maximo provecho a solidity, recomiendo tomar cualquier curso de programación orientada a objetos en platzi para poder entenderlos a profundidad, o si no, el libro “Análisis y Diseño Orientado a Objetos” de Graady Booch.

Muy parecido a los conceptos de Java. Quien sabe de POO puede entender esto facilmente

Solidity es un lenguaje orientado a “contratos”.

Entiendo que el profesor quiere decir que Solidity NO es un lenguaje de programacion orientado objetos “TRADICIONAL”, en otros lenguajes el manejo de clases y objetos es practicamente la misma, pero solidity tiene ciertas diferencias, incluso en alguna documentacion oficial de solidity lo definen como orientado a objetos y en otra como orientado a contratos.

Las FUNCIONES dentro de las INTERFACES por Defecto (Default) son EXTERTERNAL (EXTERNAS) & VIRTUAL (VIRTUALES) aunque NO le pongamos la palabra VIRTUAL.

Ejemplos de usar “virtual” en una función:

    function sumar(uint numero1, uint numero2) virtual public{}

    function utterance() public virtual returns (bytes32);

Esta última (utterance) exige anteponer “abstract” a la declaración del contrato y a esto es lo que se refiere el profe con Contrato Abstracto:

abstract contract Herencia is Suma, Modificadores("Abc") {

Buenísima clase, esto tiene un valor intrínseco muy grande ya que es sumamente utilizado en la creación de contratos.

RESUMEN CLASE 17:
HERENCIA

I.- HERENCIA

• El concepto es similar al de la programación orientada a objetos y la identificaremos con la sentencia “is”.

• Si un contrato tienen un constructor con parámetros debemos indicar qué valores debe tomar ese constructor para poder derivarse.

II.- OVERRIDE

• Podemos definir funciones de tipo “virtual” para indicar que pueden ser redefinidas en sus contratos derivados.

• Cuando se redefine una función se debe indicar el tipo “override” en su declaración.

• Si una función virtual no define implementación, el contrato se convierte en un contrato abstracto.

III.- INTERFACES

• Nos permiten definir el comportamiento que queremos que tenga un contrato.

• Se implementa igual que la herencia de contratos.

• Sus funciones no tienen implementación, solo encabezados.

IV.- SUPER

Podemos hacer referencia a algún elemento o función de la clase superior por medio de la sentencia “super”.

REMIX:

Herencia.sol

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";
import "./Modificadores.sol";

contract Herencia is Suma, Modificadores {

    constructor(string memory nombreNuevo) Modificadores(nombreNuevo) {
        
    }

    function sumar(uint numero1, uint numero2) public override esOwner() view returns(uint) {
        return numero1+numero2;
    }

}

Una Empresa es una serie de Contratos Comerciales de ahora en adelante y no se si para siempre, pero en futuro a corto y mediano plazo será una empresa su andamiaje central CORE o CPU una serie de Smartcontracts que SE HEREDAN por el esencial motivo de identidad, eficiencia, optimización y seguridad.

Solo me queda decir, los quiero mucho Platzi

Un agradecimiento al profe Uruguayo, voy a migrar a ese país, que es el mejor de LATAM, siempre agradecido master.

Herencia

Es la habilidad de usar la lógica escrita en otros contratos en nuestro propio contrato. Se hace por medio de la palabra is:

@import program/example

contract MyProgram is example{}

Si un contrato tiene un constructor con parámetros debemos indicar qué valores debe tomar ese constructor para poder derivarse.
.

Override

Podemos definir funciones del tipo virtual para indicar que pueden ser redefinidas en sus contratos derivados.

Cuando se redefine una función se debe indicar el tipo override en su declaración.

Si una función no define implementación (esto es si la función está vacía), el contrato se convierte en un contrato abstracto.
.

Interfaces

Nos permiten definir el comportamiento que queremos que tenga un contrato

Se implementa igual que la herencia de contratos.

Sus funciones no tienen implementación, solo encabezados.
.

Super

Podemos hacer referencia a algún elemento o función de la clase superior por medio de la sentencia super.
.

Ejemplo

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";
import "./Modificadores.sol";

contract Herencia is Suma, Modificadores {
    constructor(string memory nombreNuevo) Modificadores(nombreNuevo) 
    }
    
    function sumar(uint numero1, uint numero2) public override EsOwner() view returns(uint) {
        return numero1 + numero2;
    }
    
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

interface Suma {
    function sumar(uint numero1, uint numero2) external returns (uint);
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Modificadores {
    address private owner;
    string private nombreOwner;
    
    constructor(string memory nombre) {
        owner = msg.sender;
        nombreOwner = nombre;
    }
    
    function Resta(uint numero1, uint numero2) public view EsOwner() returns (uint) {
        return numero1 - numero2;
    }
    
    modifier EsOwner() {
        if (msg.sender != owner) revert();
        _;
    }
    
}

Solidity es un lenguaje de alto nivel orientado a objetos para implementar contratos inteligentes. Los contratos inteligentes son programas que rigen el comportamiento de las cuentas dentro del estado Ethereum.

Creo que para personas que conocen más del entorno esto les serviría mucho para optimizar sus tiempos y códigos ya que solo hay que realizar algunas modificaciones🧐

Excelente clase, muy entendible todo