Dominando Solidity: require y Errores Personalizados en los Contratos de Ethereum

Introducción

Solidity es un lenguaje de programación orientado al objeto y de alto nivel, para implementar contratos inteligentes. Los contratos inteligentes son programas que gobiernan el comportamiento de las cuentas en la red de Ethereum. Solidity es un lenguaje de corchetes, diseñado para que apunte a la Máquina Virtual de Ethereum (Ethereum Virtual Machine, EVM). Entre las herramientas esenciales en el arsenal de Solidity están las declaraciones require y la habilidad para crear errores personalizados.

En Solidity, la declaración require es usada para validar condiciones en los contratos inteligentes. La sintaxis básica de la declaración require envuelve revisar una condición y si la condición es false, se revierte la transacción.

Los errores personalizados son definidos usando la declaración error en Solidity. Pueden ser usados dentro y fuera de los contratos (incluyendo las interfaces y las bibliotecas). Ayudan a debuggear y comprender la razón de la reversión durante la ejecución del contrato.

¿Qué es la Declaración require en Solidity?

La declaración require es usada en Solidity para asegurar que se cumplan ciertas condiciones en los contratos inteligentes. Usualmente se usa para validar los pedidos de entrada o ejecución antes de ejecutar códigos adicionales. Si la condición proporcionada por require evalúa a false, revierte la transacción y cualquier cambio de estado será revertido.

El sintaxis general para usar la declaración require en Solidity es:

require(condition, errorMessage);

Aquí hay una explicación del código de arriba:

• condition: esta es la condición que necesita ser verdadera para que la función se ejecute exitosamente. Si la condición es falsa, la función se revertirá y cualquier cambio de estado se revertirá.
• errorMessage: este es un mensaje de error opcional que será mostrado si la condición require evalúa a false. Ayuda a proporcionar contexto sobre por qué la condición falló en nuestro código.

Aquí hay un ejemplo demostrando la sintaxis general de la declaración require:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract RequireStatement {
   function withdraw(uint amount) public {
   require(amount > 0, "Amount should be greater than zero");
   // Más código para la retirada
   // ...
   }
}

En el código de ejemplo de arriba, la declaración require asegura que la amount proporcionada es mayor que cero. Si la condición (amount > 0) no se cumple, la transacción se revertirá y el mensaje de error “Amount should be greater than zero” se mostrará.

Mejores Prácticas para usar la Declaración require en Solidity

Usar la declaración require en Solidity es esencial para asegurar la integridad y seguridad de tus contratos inteligentes. Aquí hay algunas de las mejores prácticas para usar la declaración require:

• Proporciona Mensajes de Error Informativos: incluye mensajes de error descriptivos para proporcionar más contexto cuando la condición require falla. A ayuda a los desarrolladores y a los usuarios a entender por qué la función de ejecución se revirtió, ayudando al debuggeo.
• Mantén las Condiciones Simples y Legibles: escribe condiciones claras y concisas que sean fáciles de entender. Las condiciones complejas puede que hagan que el código sea difícil de leer y mantener.
• Usa Moderadamente require: revertir una transacción puede ser costoso, así que es importante usar la declaración require sólo cuando sea necesario.

Beneficios de Usar la Declaración require en Solidity

Usar la declaración require en Solidity ofrece muchos beneficios que contribuyen a la seguridad, integridad y claridad del desarrollo del contrato inteligente. Algunos beneficios claves incluyen:

• Controles previos: la declaración require permite la verificación de los parámetros de entrada o las condiciones de estado antes de ejecutar partes críticas del código. Esto ayuda a asegurar que la función o el contrato se opere bajo las circunstancias esperadas.
• Mejoras de Seguridad: las declaraciones require son importantes para prevenir estados de cambio indeseados y asegurar que el estado del contrato se mantenga consistente. Apoyan en la protección contra los comportamientos inesperados o malignos que pueden comprometer la integridad de los contratos inteligentes.
• Legibilidad y Mantenimiento del Código: al usar las declaraciones require para los controles previos, el código se vuelve más legible e intuitivo. Mejora el mantenimiento y hace que el código sea fácil de entender para los desarrolladores, auditores y cualquiera que revise el código.

¿Qué son los Errores Personalizados en Solidity?

Solidity v0.8.4 trajo la introducción de los errores personalizados. Permite a los desarrolladores definir sus propios tipos de error y mensajes personalizados. Son usados para proporcionar información más descriptiva y específica cuando algo va mal durante la ejecución de una función en un contrato.

Los errores personalizados pueden ser definidos usando la declaración error seguido por un nombre único para el error junto a los mensajes de error específicos o los códigos de error para proporcionar contexto adicional sobre el error. Los errores personalizados son más eficientes con el uso de gas que usar las cadenas en los mensajes de error, y también pueden ser usados para pasar parámetros a los mensajes de error.

En Solidity, puedes definir los errores personalizados usando la declaración error dentro del contrato. Aquí está la sintaxis para definir los errores personalizados en Solidity:

error MyCustomError(string message);

Aquí está la explicación del código de arriba:

• La declaración error en el código de ejemplo es un keyword usado para definir los errores personalizados en Solidity.
• MyCustomError es el nombre dado para el error personalizado. Puedes reemplazar el nombre MyCustomError con el nombre que tu quieras.
• string message especifica el tipo de parámetro a ser incluído con el error. Este parámetro puede ser usado para pasar información sobre el error.

Aquí hay un ejemplo que demuestra el sintaxis general en la declaración error:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract CustomErrorExample {
   error MyCustomError(uint value, string message);

   function checkValue(uint _value) public {
       if (_value < 10) {
           revert MyCustomError(_value, "Value is too low");
       }
       // Código adicional si el valor es aceptable
   }
}

En el código de ejemplo de arriba, la declaración del error MyCustomError es definida para manejar casos donde el valor es muy bajo. Dentro de la función checkValue, si la función _value proporcionada es menos de 10, se revertirá y mostrará el error MyCustomError, pasando el _value y el mensaje de error “Value is too low”. Esto permite por un mensaje de error más descriptivo e informativo cuando la condición no se cumple.

Definir los errores personalizados permite a los desarrolladores de Solidity crear tipos de error específicos con información adicional, ayudando al mejor manejo de errores y debuggeos dentro de los contratos inteligentes.

Mejores Prácticas para Usar los Errores Personalizados en Solidity

Cuando trabajamos con los errores personalizados en Solidity, es importante seguir estas mejores prácticas para asegurar la claridad, seguridad y el manejo adecuado de los errores en los contratos inteligentes. Aquí hay algunas mejores prácticas para usar los errores personalizados:

• Usa Nombres Descriptivos: nombra tus errores personalizados de forma descriptiva para indicar fácilmente qué sucedió. También deberías incluir explicaciones detalladas del error en el mensaje del error.
• Usa los Errores Personalizados para Representar los Diferentes Tipos de Errores: esto hará que tu código sea fácil de leer y mantener. Por ejemplo: puedes tener un error personalizado por fondos insuficientes, un error personalizado por accesos no autorizados y un error personalizado por una entrada inválida.

Siguiendo estas mejores prácticas, puedes usar los errores personalizados para escribir contratos de Solidity más seguros, confiables y eficientes.

Beneficios de Usar los Errores Personalizados en Solidity

Usar los errores personalizados en Solidity ofrece muchas ventajas y beneficios para el desarrollo de contratos inteligentes y el manejo de errores. Algunos de los beneficios clave incluyen:

• Costos de Gas Reducidos: los errores personalizados salvan más gas que usar las cadenas en los mensajes de errores. Esto es porque el mensaje de error está codificado dentro del bytecode del contrato, así que no necesita ser almacenado en la blockchain.
• Legibilidad y Mantenimiento Mejorado del Código: los errores personalizados pueden hacer que el código se mantenga más y sea más legible, indicando explícitamente las suposiciones que el código está haciendo.

Conclusión

La declaración require es usualmente utiliza para revisar los parámetros de entrada, verificar ciertas condiciones antes de ejecutar las partes críticas del código, o asegurar que el estado del contrato sea el esperado antes de proseguir con más operaciones. Esto ayuda a prevenir que acciones erróneas o malignas puedan resultar en estados indeseables o inconsistentes en la blockchain.

Los errores personalizados son útiles para proporcionar un feedback más significativo a los usuarios que interactúan con el contrato, permitiéndoles entender por qué una transacción falló y proporcionar más transparencia en el comportamiento del contrato inteligente.

Si encontraste útil este post del blog, por favor aplaude, compártelo y sígueme para aprender más sobre la red blockchain, la Máquina Virtual de Ethereum, Solidity y mucho más. Gracias por quedarte hasta el final y te veo en la próxima.

Este artículo fue escrito por Wasiu Akindoyin y traducido por Delia Viloria T. Su original se puede leer aquí.

Sería genial escucharte en nuestro Discord, puedes contarnos tus ideas, comentarios, sugerencias y dejarnos saber lo que necesitas.
Si prefieres puedes escribirnos a @web3dev_eshttps://twitter.com/web3dev_es en Twitter.