Polimorfismo en contratos inteligentes

Contenido del curso

Por qué debes aprender Solidity

Introducción a la programación con Solidity

Programación de Funciones en Solidity

Gestionando costos de gas y comisiones

Conceptos avanzados de Solidity

Cómo continuar mi camino desarrollando en Blockchain

21
Cómo continuar mi camino con Solidity
01:58 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:05

Polimorfismo en contratos inteligentes

Curso de Introducción a Solidity

Clase 18 de 21

Clase 18 / 21

Comentarios (13)13 comentarios

Jimmy Buriticá Londoño

Hace 5 años

Polimorfismo

Capacidad de poder utilizar contratos derivados en estructuras superiores.

Pepe Sosa

Hace 5 años

Polimorfismo es una propiedad de la POO que permite (a nivel general digamos) enviar mensajes iguales a objetos de diferentes tipos.

En limpio: tus objetos deben de "saber" responder al mensaje que les estás enviando, esta es la propiedad polimórfica.

No tiene nada qué ver con contratos ni nada por el estilo, es puramente un tema de objetos.

Elías Muñiz

Hace 4 años

Polimorfismo, hablando de una forma más abstracta y en POO, _es la capacidad que tiene un objeto o función de tener distintos comportamientos de acuerdo al contexto. _ Por ejemplo: un método que se puede redefinir dependiendo de la cantidad de parámetros o tipos de datos que reciba.

Felix Manuel Figueroa Araujo

Hace 5 años

Esta clase le falta herramientas graficas para mejorar su entendimiento, el mismo instructor se marea con un juego de palabras y términos de su localidad.

Adolfo Sebastián Jara Gavilanes

Hace 5 años

Aquí podemos ver un ejemplo gráfico de como funciona el polimorfismo

Jorge Guzman Suir

Hace 5 años

Muchas gracias. Esta genial el ejemplo.

Jorge Guzman Suir

Hace 5 años

Encontre esta definicion en un libro de programacion que puede ser de ayuda. Polimorfismo: Habilidad de los objetos de diferentes clases relacionadas por la herencia de responder de manera diferente al mismo mensaje(es decir, una llamada de una funcion miembro). El mismo mensaje enviado a diferentes tipos de objetos toma "muchas formas "; de aqui el termino polimorfismo. Por ejemplo: si la clase "rectangulo" se deriva de "forma", entonces un objeto "rectangulo" es una version mas especifica de un objeto "forma". Una operacion (Por ejemplo: calcular el area) que puede realizarse sobre un objeto "forma" tambien puede realizarse sobre un objeto "rectangulo".

Luis Alejandro Vera Hernandez

Hace 5 años

Una convencion en las ´interfaces´ es llevar una i delante del nombre.

Interfaces solo definen encabezados pero no pueden tener una implementacion en la red. No podemos hacer el deploy pero si podemos usar un contrato que lo implemente.

Polimorfismo

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {
    
    function sumarDesdeContrato(uint numero1, uint numero2, address direccionContrato)
        public returns(uint) {  
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    } 
    
}

ImplementacionSuma.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplementacionSuma is Suma {
    
    function sumar(uint numero1, uint numero2) public override pure returns (uint) {
        return numero1 + numero2;
    }
    
}

Interface.sol

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

Con el polimorfismo pudimos usar la suma que esta en otro contrato porque no llamamos directamente a la implementación de Suma sino que hicimos la llamada a la Interface, a pesar de que las interfaces no pueden ser implementadas en la red, pero con Polimorfismo pudimos hacerlo.

Dany R

Hace 4 años

El polimorfismo de contrato, es el uso de CONTRATOS EXTERNOS a partir del contrato que estamos desarrollando.
Si estamos usando un contrato externo mediante polimorfismo, y el CONTRATO EXTERNO tiene "Padres", entonces también podremos acceder a las FUNCIONES y VARIABLE de los contratos Padres.
Si el CONTRATO EXTERNO que deseamos llamar ya esta desplegado en la red (P.E. Uniswap), entonces para poder usar sus FUNCIONES o VARIABLES deben estar declaradas como externas, además se debemos hacer uso de una INTERFACE.
El principal uso de las INTERFACES es ser un medio para poder interactuar con CONTRATOS EXTERNOS..
Si se desea hacer uso de una función de un CONTRATO EXTERNO, entonces la INTERFACE debe tener una función con el mismo nombre y mismo tipo de parámetros.

CONTRATO EXTERNO

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Operaciones {

         function suma(uint numero1, uint numero2) external pure returns (uint){
             return numero1 + numero2;
         }

        function multiplicacion(uint numero1, uint numero2) external pure returns (uint){
             return numero1 + numero2;
         }
}

CONTRATO que hace uso de una INTERFACE para usar una función del contrato anterior

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

interface IOperaciones {

        function suma(uint numero1, uint numero2) external pure returns (uint);
        function multiplicacion(uint numero1, uint numero2) external pure returns (uint);

}

contract OperacionesAvanzadas {

    function Promedio(uint numero1, uint numero2, address _contrato) public pure returns (uint) {
         
            IOperaciones operacionesBasicas = IOperaciones(_contrato);

            uint prom;
            
            prom=operacionesBasicas.suma(numero1, numero2)/2;

            return prom;

    }
    
}

Notar que no se importo nada, solo se uso una INTERFACE

Joan Sebastian Fuertes Garcia

Hace 4 años

Excelente resumen!

Nicolas Felipe Diaz Rodriguez

Hace 5 años

Me surgio una duda platzinautas, para hacer polimorfismo siempre debo tener una interface, un contrato de implementacion y el contrato donde ejecutamos el polimorfismo?

Federico Mollea

Hace 5 años

Hola @nicodev27, en este caso para que sea polimorfismo si es necesario. Pero es solo a fines de que podamos ver y entender el concepto de Polimorfismo.

Es decir, podemos ejecutar una función de un contrato deployado en la red siempre y cuando conozcamos su tipo y su dirección. Si lo hacemos así sin usar una interfaz e implementación es válido, pero no seria polimorfismo.

Espero se entienda! Sino consultame!

slds

Sebastian Perez

Profesor

Hace 5 años

Me sumo al comentario, siempre que sea necesario (que es lo primero que deberías analizar) ahí si necesitas todo lo que indicas. El mayor provecho es cuando tenés distintos contratos o implementaciones que responden a una misma interface, por lo tanto corregiría "un contrato de implementación" a "más de un contrato de implementación", pero claro que con uno alcanzaría para un ejemplo mínimo.

Abidan Triguero Calle

Hace 4 años

RESUMEN CLASE 18: POLIMORFISMO

I.- INSTANCIAR UN CONTRATO EN OTRO CONTRATO

Dentro de un contrato podemos hacer referencia a otro contrato ya implementado en la red a través de su dirección.
Para esto podemos utilizar el tipo de contrato al que referenciamos o bien alguna de sus clases superiores.

II.- POLIMORFISMO

Capacidad de poder utilizar contratos derivados en estructuras superiores.

REMIX:

Polimorfismo.sol

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {

    function sumaDesdeContrato(uint numero1, uint numero2, address direccionContrato) 
        public returns(uint) {
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    }
}

ImplementacionSuma.sol

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplememntacionSuma is Suma {

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

Leonardo Jose Jimenez Ortiz

Hace 4 años

no se puede tambien hacer polimorfismo colocando como contrato padre un contract, o tiene que ser a juro con interface para que el polimorfismo suceda???

Sebastian Perez

Profesor

Hace 4 años

Hola Leonardo, es correcto lo que dices, puede hacerse con un contrato el polimorfismo. Es más común encontrarlo con interfaces, pero es válido hacerlo con contratos.

Paul Rodas

Hace 3 años

Mi forma de explicar el polimorfismo: Una sola forma de llamar a una funcion (los mismos parametros) Varias formas de procesar esos parametros (codigo en cada implementacion) Me parece muy util este concepto en Solidity porque podemos definir una funcion por ejemplo una interface construirContrato, enviarle el nombre, identificacion personal y cada hacer implementaciones de esa interface ImplementacionCompraVenta, ImplementacionMatrimonio, etc.

Edgar Alfredo López Salero

Hace 4 años

El polimorfismo permite que diferentes contratos respondan de manera distinta al mismo mensaje. Entre las ventajas que este nos permite utilizar una interfaz en distintos contratos, a partir de una contrato derivado a través de la dirección. Es decir tenemos una interfaz llamada mascotas, estas tienen como propiedad nombre y fecha de nacimiento. El uso de esta interfaz, generara distintos resultados dependiendo del tipo de animal, perro, gato, hamster. Es decir la llamada de este contrato mascota generara distinta salida de acuerdo al tipo de animal. Es decir cada animal tiene distinta forma, de alli el concepto polimorfismo.

Bramucci Candela

Hace 4 años

Polimorfismo

Polimorfismo: Capacidad de poder utilizar contratos derivados en estructuras superiores.

Instanciar un contrato en otro contrato

Dentro de un contrato podemos hacer referencia a otro contrato ya implementado en la red a través de su dirección. Para esto podemos utilizar el tipo de contrato al que referenciamos o bien alguna de sus clases superiores. .

Ejemplo

Interface.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {
    
    function sumarDesdeContrato(uint numero1, uint numero2, address direccionContrato)
        public returns(uint) {  
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    } 
    
}

ImplementacionSuma.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplementacionSuma is Suma {
    
    function sumar(uint numero1, uint numero2) public override pure returns (uint) {
        return numero1 + numero2;
    }
    
}

Carlos Esteban León Pinilla

Hace 4 años

Es complejo de entender... pero basicamente como lo entendi, lo que paso aqui es:

Creas una implementacion de una interfaz.
Usas la dirección generada de la interfaz y la pasas como parametro dentro del contrato que la quieres implementar.
Dentro del contrato a implementarla, referencias la direccion a la interfaz a la que pertenece lo cual genera una instancia, posteriormente puedes usar sus métodos.

Mauro Volpe

Hace 4 años

Me parece que se puede mejorar la explicación y ejemplo sobre polimorfismo, instanciando varios contratos y mostrando como ante la ejecución del mismo método el comportamiento es diferente. Y quizás suma mencionar ligadura dinámica y estática de código, ya que si SOLIDITY es OO deberia contar con esta habilidad. Saludos

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {
    
    function sumarDesdeContrato(uint numero1, uint numero2, address direccionContrato)
        public returns(uint) {  
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    } 
    
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplementacionSuma is Suma {
    
    function sumar(uint numero1, uint numero2) public override pure returns (uint) {
        return numero1 + numero2;
    }
    
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Operaciones {

         function suma(uint numero1, uint numero2) external pure returns (uint){
             return numero1 + numero2;
         }

        function multiplicacion(uint numero1, uint numero2) external pure returns (uint){
             return numero1 + numero2;
         }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

interface IOperaciones {

        function suma(uint numero1, uint numero2) external pure returns (uint);
        function multiplicacion(uint numero1, uint numero2) external pure returns (uint);

}

contract OperacionesAvanzadas {

    function Promedio(uint numero1, uint numero2, address _contrato) public pure returns (uint) {
         
            IOperaciones operacionesBasicas = IOperaciones(_contrato);

            uint prom;
            
            prom=operacionesBasicas.suma(numero1, numero2)/2;

            return prom;

    }
    
}

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {

    function sumaDesdeContrato(uint numero1, uint numero2, address direccionContrato) 
        public returns(uint) {
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    }
}

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplememntacionSuma is Suma {

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

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract Polimorfismo {
    
    function sumarDesdeContrato(uint numero1, uint numero2, address direccionContrato)
        public returns(uint) {  
            Suma interfaceSuma = Suma(direccionContrato);
            return interfaceSuma.sumar(numero1,numero2);
    } 
    
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./Interface.sol";

contract ImplementacionSuma is Suma {
    
    function sumar(uint numero1, uint numero2) public override pure returns (uint) {
        return numero1 + numero2;
    }
    
}

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

Polimorfismo en contratos inteligentes

Progreso del curso

Por qué debes aprender Solidity

Introducción a la programación con Solidity

Programación de Funciones en Solidity

Gestionando costos de gas y comisiones

Conceptos avanzados de Solidity

Cómo continuar mi camino desarrollando en Blockchain