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.
Top comments (0)