Fe o Solidity, ¿cuál es es mejor?

La diversidad de lenguajes es tan crucial como la diversidad de clientes, ya que puede ayudar a hacer que una chain de contratos inteligentes sea más segura y resistente a errores a nivel de compiladores o librerías. Además, puede estimular nuevas ideas que surgen de código desarrollado desde cero. Fe es un nuevo lenguaje de la EVM, al igual que Solidity y Vyper. Sin embargo, Fe aporta nuevas opiniones en términos de legibilidad, decidibilidad y estimaciones de gas.

En esta guía, lanzaremos un token ERC20 utilizando Fe. Ten en cuenta que, si bien Fe está listo para su uso en producción, las herramientas de desarrollo aún están atrás en comparación con otros lenguajes de la EVM. Esta guía está dirigida tanto a los pioneros como a los curiosos.

Antes de iniciar

Para este tutorial necesitarás Metamask, o cualquier otra wallet de tu preferencia, con fondos en Scroll Sepolia que puedes obtener desde la Sepolia faucet y luego los puedes bridgear a L2 usando el Scroll Sepolia bridge. También puedes usar una Scroll Sepolia Faucet para recibir fondos directamente en L2.

En esta guía lanzaremos en Scroll Sepolia. También explicaré los cambios exactos que debes realizar para lanzar en cualquier otra chain EVM.

1. Instalación

En Linux:

wget https://github.com/ethereum/fe/releases/download/v0.26.0/fe_amd64
mv fe_amd64 fe
chmod +x fe

En Mac:

wget https://github.com/ethereum/fe/releases/download/v0.26.0/fe_mac
mv fe_mac fe
chmod +x fe

También vas a necesitar foundry en ambos Linux o Mac (necesaria para lanzar los contratos)

curl -L https://foundry.paradigm.xyz | bash
# ahora refresca tus variables de entorno, simplemente cierra y vuelve a abrir tu terminal
foundryup

Para más información dirígete a la documentación oficial de la intalación de Fe y foundry.

2. Crea un contrato ERC20

Crea el siguiente archivo llamado erc20_token.fe:

erc20_token.fe

struct Approval {
    #indexed
    pub owner: address
    #indexed
    pub spender: address
    pub value: u256
}

struct Transfer {
    #indexed
    pub from: address
    #indexed
    pub to: address
    pub value: u256
}

contract ERC20 {
    _balances: Map<address, u256>
    _allowances: Map<address, Map<address, u256>>
    _total_supply: u256
    _name: String<100>
    _symbol: String<100>
    _decimals: u8

    pub fn __init__(mut self, mut ctx: Context) {
        self._name = "My Fe Token"
        self._symbol = "MFeT"
        self._decimals = u8(18)
        self._mint(ctx, account: ctx.msg_sender(), value: 1000_000_000_000_000_000_000_000)
    }

    pub fn name(self) -> String<100> {
        return self._name.to_mem()
    }

    pub fn symbol(self) -> String<100> {
        return self._symbol.to_mem()
    }

    pub fn decimals(self) -> u8 {
        return self._decimals
    }

    pub fn totalSupply(self) -> u256 {
        return self._total_supply
    }

    pub fn balanceOf(self, _ account: address) -> u256 {
        return self._balances[account]
    }

    pub fn transfer(mut self, mut ctx: Context, recipient: address, value: u256) -> bool {
        self._transfer(ctx, sender: ctx.msg_sender(), recipient, value)
        return true
    }

    pub fn allowance(self, owner: address, spender: address) -> u256 {
        return self._allowances[owner][spender]
    }

    pub fn approve(mut self, mut ctx: Context, spender: address, value: u256) -> bool {
        self._approve(ctx, owner: ctx.msg_sender(), spender, value)
        return true
    }

    pub fn transferFrom(mut self, mut ctx: Context, sender: address, recipient: address, value: u256) -> bool {
        assert self._allowances[sender][ctx.msg_sender()] >= value
        self._transfer(ctx, sender, recipient, value)
        self._approve(ctx, owner: sender, spender: ctx.msg_sender(), value: self._allowances[sender][ctx.msg_sender()] - value)
        return true
    }

    pub fn increaseAllowance(mut self, mut ctx: Context, spender: address, addedValue: u256) -> bool {
        self._approve(ctx, owner: ctx.msg_sender(), spender, value: self._allowances[ctx.msg_sender()][spender] + addedValue)
        return true
    }

    pub fn decreaseAllowance(mut self, mut ctx: Context, spender: address, subtractedValue: u256) -> bool {
        self._approve(ctx, owner: ctx.msg_sender(), spender, value: self._allowances[ctx.msg_sender()][spender] - subtractedValue)
        return true
    }

    fn _transfer(mut self, mut ctx: Context, sender: address, recipient: address, value: u256) {
        assert sender != 0
        assert recipient != 0
        _before_token_transfer(from: sender, to: recipient, value)
        self._balances[sender] = self._balances[sender] - value
        self._balances[recipient] = self._balances[recipient] + value
        ctx.emit(Transfer(from: sender, to: recipient, value))
    }

    fn _mint(mut self, mut ctx: Context, account: address, value: u256) {
        assert account != address(0)
        _before_token_transfer(from: address(0), to: account, value)
        self._total_supply = self._total_supply + value
        self._balances[account] = self._balances[account] + value
        ctx.emit(Transfer(from: address(0), to: account, value))
    }

    fn _burn(mut self, mut ctx: Context, account: address, value: u256) {
        assert account != address(0)
        _before_token_transfer(from: account, to: address(0), value)
        self._balances[account] = self._balances[account] - value
        self._total_supply = self._total_supply - value
        ctx.emit(Transfer(from: account, to: address(0), value))
    }

    fn _approve(mut self, mut ctx: Context, owner: address, spender: address, value: u256) {
        assert owner != address(0)
        assert spender != address(0)
        self._allowances[owner][spender] = value
        ctx.emit(Approval(owner, spender, value))
    }

    fn _setup_decimals(mut self, _ decimals_: u8) {
        self._decimals = decimals_
    }

    fn _before_token_transfer(from: address, to: address, _ value: u256) {}
}

Para más demos, dirígete hacia este repo.

3. Compila el contrato

Genera en ABI y el Bytecode corriendo el siguiente commando:

./fe build erc20_token.fe

Para más información sobre estos comandos, visita la documentación de Fe.

4. Lanzamiento

Para lanzar en Scroll Sepolia, simplemente coloca tu clave privada en YOURPRIVATEKEY y asegúrate de tu wallet tenga fondos.

Si deseas lanzar en otra chain, cambia la URL RPC https://sepolia-rpc.scroll.io/ por la URL RPC de la cadena que desees.

cast send --legacy --rpc-url https://sepolia-rpc.scroll.io/ --private-key YOURPRIVATEKEY --create $(cat output/ERC20/ERC20.bin)

El token debería estar ahora en tu cuenta. La dirección de la transacción y del token se mostrarán en la consola, o puedes encontrarla en Scroll Sepolia Etherscan o en el explorador de la cadena en la que desplegaste el contrato.

Fe recomienda el uso de Anvil de Foundry para desplegar e interactuar con contratos. Para obtener más información, consulta la documentación de foundry.

Conclusión

Todavía es muy temprano para decidir cuál usaré más en el futuro pues Fe está en una etapa muy temprana y seguro tendrá cambios. Pero me gusta mucho la idea de un nuevo lenguaje con nuevas ideas que ha aprendido de las lecciones de Solidity. Dudo que Solidity deje de ser el lenguaje dominante durante muchos años pero espero que las nuevas herramientas de análisis de errores y calculadoras de gas hagan que Fe tenga adopción significante y le permitan construir comunidad. A manera personal, me mantendré al tanto de nuevos cambios y lo estaré probando en proyectos futuros!

¿Ustedes cuál prefieren? ¿Seguirán usando Solidity o le darán una oportunidad a Fe?

¡Gracias por ver este tutorial!

Sígueme en dev.to y en Youtube para todo lo relacionado al desarrollo en Blockchain en Español.