Uso de la herencia en Solidity

Clase 17 de 21 • Curso de Introducción a Solidity

Pepe Sosa

student•

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

Franklin Gil

student•

Cuando escuché eso de "Orientado a contratos" me parecio raro. Seria bueno poner en el Top este aporte para que no se haga eco de tecnicismo incorectos.

Carlos Rodríguez

student•

Yo antes ya había escuchado el concepto de "Orientado a contratos", no se sorprendan porque la verdad es que es muy utilizado.

Luis Dotto

student•

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();
        _;
    }
}

Luis Alejandro Vera Hernandez

student•

Gracias por los apuntes!

Pepe Sosa

student•

Hola, solo aclarar que Solidity sí es un lenguaje orientado a objetos, en tus notas veo que enfatizaste lo que dijo el profe pero está errado, la misma documentación oficial lo describe como orientado a objetos de alto nivel. No existe tal cosa como "orientado a contratos". Saludos.

Marcos Plata

student•

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.

Guillermo Leonardo Rossi

student•

Gran libro!

Carlos Rodríguez

student•

Grande tu aporte, ese libro es fenomenal.

Edgar Oswaldo Vargas Jara

student•

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

Pepe Sosa

student•

Eso es porque Solidity sí es un lenguaje orientado a objetos, su misma documentación oficial lo define literalmente así.

Jimmy Buriticá Londoño

student•

Solidity es un lenguaje orientado a "contratos".

Pepe Sosa

student•

No, no lo es. No existe tal cosa como "orientado a contratos".

Solidity is an object-oriented, high-level language for implementing smart contracts.

Fuente: Documentación oficial Solidity

Dany R

student•

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.

Andrés Muñoz

student•

Es posible cambiar a tipo private o internal la función heredada Suma en mi contracto para que no aparezca o pueda ser usada por fuera ?

Sebastian Perez

teacher•

Hola Andrés, se puede siempre y cuando la función del contrato superior sea virtual. En ese caso le haces override a la función y ahí le modificas la visibilidad.

Marco Antonio Olmos a.k.a. Marco Antonio Vazquez-O

student•

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

Abidan Triguero Calle

student•

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

}

Pro Code

student•

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") {

Dany R

student•

Dentro del Contrato Modificadores, no se uso “virtual” pero de todas maneras su funcion Suma, y el contructor, se pudieron usar en el Contrato Herencia, entonces ¿en que caso, si es necesario usar “virtual”?

Sebastian Perez

teacher•

"virtual" lo utilizaremos cuando deseamos que esa función pueda ser redefinida, o sea que otro usuario (o nosotros) en los contratos que hereden del nuestro puedan sobrescribir la lógica de esa función.

Si la función no es virtual, la pueden llamar y utilizar, pero no podrán redefinirla/reescribirla.

Gustavo Javier Flores

student•

extends = is?

Sebastian Perez

teacher•

Lo que en otros lenguajes es "extends" en Solidity es "is" :)

Carlos Rodríguez

student•

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

Jose Fernando Peréz

student•

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.

Bramucci Candela

student•

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();
        _;
    }
    
}

Marco Palmieri

student•

No me queda muy claro para qué sirven las interfaces, si lo unico que tienen es una función pero sin ninguna funcionalidad, por lo que pude ver en la clase

Dagoberto Porras Plata

student•

se utiliza para obligar un comportamiento en el contrato que vaya a heredar la interfaz. En otras palabras y como lo entiendo, es como una plantilla que sirve para que los programadores que quieran implementar la interfaz se le exija definir e implementar las funciones de la plantilla. Así que no se debe ver desde el aspecto funcional sino comportamental.

Rafael Mosquera

student•

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.

Josue Martin Chi Perera

student•

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🧐

Luis Alejandro Vera Hernandez

student•

Excelente clase, muy entendible todo

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

// 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();
        _;
    }
}

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

}

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

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();
        _;
    }
    
}

Uso de la herencia en Solidity

Por qué debes aprender Solidity

Curso de Solidity: Fundamentos y Desarrollo en Blockchain

Programación en Solidity para Contratos Inteligentes en Blockchain

Introducción a la programación con Solidity

Estructura Básica de Contratos en Solidity

Tipos de datos y variables en Solidity: enteros, booleanos y direcciones

Estructuras y Arrays en Contratos Inteligentes

Estructuras de datos en Solidity: Mappings y enums

Estructuras de control en Solidity

Manejo de Eventos con Solidity

Programación de Funciones en Solidity

Cómo implementar funciones en Solidity

Uso de Modificadores en Solidity

Manejo de errores

Gestionando costos de gas y comisiones

Tipos de almacenamiento

Manejo del gas y comisiones

Transferencias de ether desde un contrato

Recibir ether desde un contrato

Conceptos avanzados de Solidity

Manejo de dependencias y librerías

Uso de la herencia en Solidity

Polimorfismo en contratos inteligentes

Tokens

Application Binary Interface (ABI)

Cómo continuar mi camino desarrollando en Blockchain

Cómo continuar mi camino con Solidity