Los tokens de Ethereum son actives digitales natives de la propia blockchain. Sirven para brindar interactividad, usos y uniformidad. Por eso se introdujeron estándares de tokens, y el más utilizado es Ethereum Request for Comments 20 (ERC20). También existen otras variantes como ERC-20 y ER-777, que sirven para crear tokens fungibles que existen en la red Ethereum. Los estándares de token para contratos inteligentes están también muy extendidos. Pero ERC20 es el estándar, inmutable y muy utilizado alrededor del mundo para contratos inteligentes.
Como resultado, la adopción de un nuevo estándar para tokens Ethereum cuando el anterior, aún funciona, carece de sentido. Sin embargo, con el uso extendido y la adopción de finanzas descentralizadas, así como la liquidez atrapada al casi no existir regulaciones, el riesgo de los participantes deshonestos empieza a aflorar.
Eligiendo el estándar para tokens Ethereum: ERC20 vs ERC777
Ambos son los estándares más usados para el desarrollo de tokens fungibles. La elección de un token responde a los usos, su tasa de adopción, las características y seguridad que brinde al inversor.
El ERC20 tiene un alcance muy amplio, y también brinda seguridad, mientras que ERC777 mejora algunas funciones y añade compatibilidad con versiones previas. El EIP (por sus siglas en inglés, Propuesta de Mejora de Ethereum) ERC777 introduce funciones mejoradas para que la interacción con los tokens de Ethereum sea más dinámica.
Con las funciones de gancho, por ejemplo, los contratos inteligentes pueden reaccionar de manera específica ante eventos predeterminados. Esta ventaja permite evadir escenarios de pérdida de tokens por envíos a direcciones equivocadas.
A su vez, al usar operadores, el contrato inteligente tiene permisos para realizar tareas y enviar tokens en nombre de otro contrato inteligente o dirección regular. El ERC777 es un estándar con retrocompatibilidad con ERC20. La interacción con estos tokens es casi perfecta, permitiendo beneficiarse de las funciones mejoradas y un uso que no cambia respecto del protocolo ERC20.
¿Qué son los contratos inteligentes?
Un contrato inteligente es un tipo de código escrito para ejecutarse por sí mismo. Un desarrollador lo crea para reforzar los términos del acuerdo entre comprador y vendedor. El código y sus acuerdos se distribuyen de manera descentralizada y segura, además de inmutable por estar en una red blockchain.
Los contratos inteligentes no requiren de terceras partes, autoridades centrales o intermediarios. El código por si mismo, es la ley. Puede permitir transacciones confiables y acuerdos que se desarrollarán de esta manera, confiando en el rendimiento de cada persona según sus obligaciones.
¿Por qué los tokens Ethereum de ERC777 se usan para vulnerabilidades?
Los contratos inteligentes pueden generar vulnerabilidades, siendo en su mayoría bugs en el código sea ERC20 o ERC777. Los humanos los crean mediante la solidez de la programación del lengua, y todo humano puede fallar. Con el estándar ERC777 lo que se facilita son herramientas para detectar rápidamente los fallos del código.
Uniswap (un Exchange descentralizado) tuvo una vulnerabilidad en su pool de inversión de imBTC y Dforce. Mediante el vector de re-entrada los hackers atacaron, y ahora está considerada una de las vulnerabilidades a combatir. El famoso hack DAO de 2017 se realizó cuando el nuevo ERC777 todavía no tenía forma.
Es muy sencillo culpar al estándar de los tokens Ethereum por la vulnerabilidad, con desarrolladores y equipos de proyecto, y de esa forma no auditar los contratos inteligentes.
Ejemplos de uso de ERC777
- Se puede usar para armar una lista negra de inversores.
- Utilización de operarios automáticos para suscribirte o hacer pagos en tu nombre.
- La función de “Enviar” permite que el usuario transfiera datos de transacción y que los datos operativos permitieran una reconciliación más rápida.
- Permite redirigir tokens específicos a otro contrato.
Usando el ERC777 tokensReceived Hook
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import “https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.1/contracts/token/ERC777/ERC777.sol”;
contract my777Receiver is IERC777Recipient {
mapping (address=>uint) public balances;
ERC777 my_erc777;
IERC1820Registry private registry1820= IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
constructor (address my_erc777_address){
registry1820.setInterfaceImplementer(address(this),keccak256(“ERC777TokensRecipient”),address(this));
my_erc777 = ERC777(my_erc777_address);
}
//ERC777 Recipient Hook
function tokensReceived(address operator, address from, address to,uint256 amount, bytes calldata data,
bytes calldata operatorData) external {
//revert or require
}
function () external payable {}
}Usando el ERC777 tokensToSend Hook
// SPDX-License-Identifier: MIT
//Using https://remix.ethereum.org
pragma solidity >=0.8.4;
import “https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.1/contracts/token/ERC777/ERC777.sol”;
contract ERC777 is IERC777Recipient {
//calling the setInterfaceImplementer function on the ERC-1820 registry with the holder address as the address
IERC1820Registry private registry1820= IERC1820Registry (0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
registry1820.setInterfaceImplementer(address(this), keccak256(“ERC777TokensSender”), address(this));
mapping (address=>uint) public balances;
//ERC777 Sender Hook
function tokensToSend(address operator, address from,address to,uint256 amount,bytes calldata userData,
bytes calldata operatorData) external{
}
function () external payable {}
}Usando operadores de ERC777
// SPDX-License-Identifier: MIT
//Using https://remix.ethereum.org
pragma solidity >=0.8.4;
import “https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.1/contracts/token/ERC777/ERC777.sol”;
contract my777Receiver is IERC777Recipient {
mapping (address=>uint) public balances;
ERC777 my_erc777;
IERC1820Registry private registry1820= IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
constructor (address my_erc777_address){
registry1820.setInterfaceImplementer(address(this),keccak256(“ERC777TokensRecipient”),address(this));
my_erc777 = ERC777(my_erc777_address);
}
//ERC 777 HOOK
function tokensReceived(address operator,address from,address to,uint256 amount,
bytes calldata userData,bytes calldata operatorData) override external{
// revert();
}
//Authorised Operator deposit
function deposit(uint amount) public{
my_erc777.operatorSend(address(msg.sender), address(this), amount, “”, “”);
balances[msg.sender] += amount;
}
//authorised Operator withdrawal
function withdrawTokens() public{
my_erc777.operatorSend(address(this), address(msg.sender), balances[msg.sender], “”, “”);
balances[msg.sender] = 0;
}
}El proceso de tokens Ethereum para enviarlos con ERC777
Un remitente, a la vez que es dueño del token que desea transferor, tendrá que pedir un contrato ERC777 para usar la función de Enviar. Entonces, el contrato buscará el registro, y a través del ERC1820 (activado en la blockchain para leer el registro de usuarios confiables) avisará una dirección registrada para recibir tokens.
Si no hay dirección en el registro, la función tokensReceived del contrato del destinatario hará un llamado para la recepción de tokens. El contrato destinatario también puede rechazar los tokens mediante la función tokens Received. Con ERC777 el destinatario puede registrar tokens ERC20 en el registro ERC1820 y aprovechar los beneficios.
Reduciendo riesgos con los contratos inteligentes
El riesgo está presente de manera constante, y en los contratos inteligentes no hay excepción. Es la esencia de adoptar un riesgo en prácticas de gestión y así resguardar las entidades DeFi. Considerando que se mueven muchos fondos en el espacio, te contamos algunas medidas que pueden reducir el riesgo.
Auditorias. El aumento del valor ajustado en DeFi cada vez es mayor, así como la necesidad de auditorías más frecuentes. Hay numerosos bugs y otros riesgos en los contratos inteligentes por eso una auditoría manual o automatizada puede ayudar a evitar problemas. Los auditores de contratos inteligentes buscan vulnerabilidades y problemas de seguridad en los contratos. Así aseguran, en lo posible, el desarrollo de los proyectos. Certik, Chainsulting y Perkshield, entre otras, auditan sus contratos.
Compra de cobertura de seguros. Los seguros DeFi se compran para protegerse frente a pérdidas o riesgos que pueden ocurrir en el espacio DeFi. Las finanzas desentralizadas tienen una cobertura para que no haya pérdidas en las tarifas de Exchange. Pueden ser seguros centralizados o descentralizados. Esta medida redude las potenciales pérdidas. Algunas empresas de seguros DeFi incluyen Bridge mutual, Insure DeFi, insurAnce y nexus Mutual.
Experiencia de uso de desarrolladores. Los desarrolladores experimentados ayudan a reducir peligros en los contratos inteligentes. Suelen descubrir mayores riesgos de manera habitual porque tienen el ojo entranado.
Evita la copia de otros códigos. Copiar un código de otro protocolo es la manera rápida de desarrollarse, pero puede ocasionar más vulnerabilidades. Sobre todo por posibles incompatibilidades.
Limita el acceso de usuarios. Tanto el hardware como el software son puntos que los hackers utilizan para tratar de robar información. Con un contrato inteligente de multi-firmas puedes aumentar la seguridad.
Cierre de los tokens Ethereum y el ERC777
El código ERC777 introduce estupendas funciones para los contratos inteligentes. Por eso, los desarrolladores son animados a escribir códigos de software con la reducción de riesgos en mente. Así protegen el contenido de las vulnerabilidades, y lo desarrollan con perspectiva de que sean auditados y protegidos por un seguro, entre otras funcionalidades. Las estrategias de mitigación de riesgo no eliminan las pérdidas, pero pueden reducir el impacto de las mismas.