Manejo de Eventos con Solidity

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

Ernesto García

teacher•

Eventos

Los eventos son un tipo de dato que sirve para emitir avisos de que ocurrió alguna acción en particular.

Puede ser utilizado por clientes para escuchar cambios importantes, y también pueden utilizarse para indexar información.

Protocolos como TheGraph utilizan indexación de eventos para agregación de información

Didier Zúñiga

student•

OJO! Los eventos consumen GAS

Rodrigo Ramos Xochiteotzin

student•

Prácticamente todo consume gas xd

Samir Jimenez Vivas

student•

Vaya es como Attack on Titan.

Marcos Kinam Diaz Rodriguez

student•

contract Eventos {
    
    uint[] public numeros;
    string public resultado;
    
    event NotificacionDeCondicion(bool condicion);
    
    constructor(bool condicion) {
        if (condicion) {
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }
        
        emit NotificacionDeCondicion(condicion);
        
        for (uint iterador = 0; iterador < 10; iterador++) {
            numeros.push(iterador);
        }
    }
    ```

Luis Alejandro Vera Hernandez

student•

Eventos

Permite conectar lo que pasa dentro de la Blockchain con el exterior porque a tráves de un protocolo otras aplicaciones se pueden suscribir a ellos y escuchar todo lo que está pasando en el Smart Contract.

Se usan para:

Registrar cambios que se hicieron
Feedback (Retroalimentación)

John Cogua

student•

Adicioné estas dos líneas de código para ver en los logs el array completo después del FOR.

event NotificacionDeNumeros(uint[] numeros);  

emit NotificacionDeNumeros(numeros);

Pepe Sosa

student•

Es importante comentar que en la declaración del evento, el parámetro se puede llamar como queramos, es decir, no es necesario que ese nombre coincida con lo que vamos a emitir salvo en el tipo.

Esto es, lo pudimos declarar como:

event NotificacionDeCondicion( bool nombreCualquiera );

Y ese "nombreCualquiera" es el que vamos a ver en el log como argumento.

Creí importante comentarlo para evitar confusiones con los nombres.

Abidan Triguero Calle

student•

RESUMEN CLASE 8: EVENTOS

Un evento es una acción que ocurre en el contrato la cual queremos que sea notificada fuera del mismo.
Los eventos no tienen una función en especial dentro de los contratos. Su objetivo es que sean integrados a componentes externos para poder ejecutar acciones externas como enviar una alerta a un usuario.
Debemos considerar que las llamadas a los eventos van a consumir gas y por lo tanto tienen un costo asociado. Se recomienda utilizarlos solo cuando sean necesarios.

REMIX:

Eventos.sol

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Eventos {

    uint[] public numeros;
    string public resultado;

    event NotificacionDeCondicion(bool condicion);

    constructor(bool condicion) {
        if (condicion) {
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }

        emit NotificacionDeCondicion(condicion);

        for (uint iterador = 0; iterador < 10; iterador++) {
            numeros.push(iterador);
        }
    } 

}

JAVIER SANTIAGO SALGADO

student•

Vamos bien, siempre es importante conocer las bases del lenguaje.

Adolfo Sebastián Jara Gavilanes

student•

Excelente comienzo para conocer lo más básico de Solidity! El profesor sabe impartir las clases con gran facilidad

Rafael Carpio

student•

Porque no me siento un experto hahaha siempre dicen eso cuando terminas un modulo y yo lo que quiero es volver a ver las clases otra vez porque un experto no me siento

Juan José Vargas Fletes

student•

Analizando esto, es muy parecido al concepto de corrutina, peeeero, sin la espera de respuesta que conlleva esta. :thin

Jeremy A Gomez P

student•

Saludos nuevamente, tengo 2 líneas que mercan como error y después de repasarla como por 15 min he podido notar que son las mismas que las que están en el video, si alguien sabe decirme que es lo que pasa se lo agradecería un millón de veces, porque estas cosas me están atrasando mucho en mi aprendizaje.!!

Sebastian Perez

teacher•

hola Jeremy, lo que no veo es donde esta declarada la variable resultado, puede ser eso ? Sera que es una referencia al array de strings de resultados ?

Erick Bonilla

student•

No entiendo la diferencia entre un emit y colocar public una variable

Sebastian Perez

teacher•

Hola Erick,

La diferencia es que el emit se hace sobre un evento y no sobre una variable. Una variable es un valor almacenado en un contrato y un evento es un registro de algo que aconteció y que queda guardado en los logs.

Guillermo Leonardo Rossi

student•

Si hago un evento y a continuación una tarea que no se ejecuta , por falta de gas o lo que sea....el evento se muestra? o ante un error por mas que el evento estaba antes del mismo se "rollbackea" y no lo muestra al evento?

Sebastian Perez

teacher•

Hola Guillermo, un evento no debería de emitirse cuando hay una interrupción ya que si bien no genera una transacción que cambie el estado de la red, escribe información en el nodo. En algunas redes locales lo escribe de todas formas, pero en Mainnet no lo hará

Jorge Fidel Zubieta Choque

student•

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Eventos {

uint[] public numeros;
string public resultado;

event NotificacionDeCondicion(bool condicion);
// vamos a notificar que condicion entro por el constructor -> recibimos un parametro del tipo boleano y debemos emitir el evento con emit!

constructor(bool condicion) {
    if (condicion) {
        resultado = "Condicion True";
    }
    else {
        resultado = "Condicion False";
    }
    
    emit NotificacionDeCondicion(condicion);
    // para llamar al evento con "emit" en este punto del codigo!
    // y le damos el Valor que queremos que quede registrado en este punto -> en este caso la condicion
    
    for (uint iterador = 0; iterador < 10; iterador++) {
        numeros.push(iterador);
    }
}

}

MIGUEL ANGEL DELGADO ARPITA

student•

// SPDX-License-Identifier: GLP-3.0

pragma solidity >= 0.7.0 < 0.9.0;

contract EstructuraDeControl {
    uint[] public numeros;
    string public resultado;
    event NotificacionDeCondicion(bool condicion);

    constructor(bool condicion) {
        if(condicion){
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }

        emit NotificacionDeCondicion(condicion);
        
        for (uint iterador =0; iterador < 100; iterador++){
            numeros.push(iterador);
        }

    }
}

contract Eventos {
    
    uint[] public numeros;
    string public resultado;
    
    event NotificacionDeCondicion(bool condicion);
    
    constructor(bool condicion) {
        if (condicion) {
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }
        
        emit NotificacionDeCondicion(condicion);
        
        for (uint iterador = 0; iterador < 10; iterador++) {
            numeros.push(iterador);
        }
    }
    ```

// SPDX-License-Identifier: GLP-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Eventos {

    uint[] public numeros;
    string public resultado;

    event NotificacionDeCondicion(bool condicion);

    constructor(bool condicion) {
        if (condicion) {
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }

        emit NotificacionDeCondicion(condicion);

        for (uint iterador = 0; iterador < 10; iterador++) {
            numeros.push(iterador);
        }
    } 

}

uint[] public numeros;
string public resultado;

event NotificacionDeCondicion(bool condicion);
// vamos a notificar que condicion entro por el constructor -> recibimos un parametro del tipo boleano y debemos emitir el evento con emit!

constructor(bool condicion) {
    if (condicion) {
        resultado = "Condicion True";
    }
    else {
        resultado = "Condicion False";
    }
    
    emit NotificacionDeCondicion(condicion);
    // para llamar al evento con "emit" en este punto del codigo!
    // y le damos el Valor que queremos que quede registrado en este punto -> en este caso la condicion
    
    for (uint iterador = 0; iterador < 10; iterador++) {
        numeros.push(iterador);
    }
}

// SPDX-License-Identifier: GLP-3.0

pragma solidity >= 0.7.0 < 0.9.0;

contract EstructuraDeControl {
    uint[] public numeros;
    string public resultado;
    event NotificacionDeCondicion(bool condicion);

    constructor(bool condicion) {
        if(condicion){
            resultado = "Condicion True";
        }
        else {
            resultado = "Condicion False";
        }

        emit NotificacionDeCondicion(condicion);
        
        for (uint iterador =0; iterador < 100; iterador++){
            numeros.push(iterador);
        }

    }
}

Manejo de Eventos con 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