Cuando hablamos de smart contracts en Ethereum, inmediatamente pensamos en Solidity. Solidity no es el único lenguaje de programación que permite compilar el contrato a un formato entendible por la EVM.
Existe otro lenguaje que también posee gran adopción por parte de la comunidad; como lo es Vyper, un lenguaje muy similar a Python. Pero existen uno más, mucho más desconocido en la industria y que viene ganando terreno gracias a un L2 que lo implementa. Su nombre es Cairo.
Interactuando con un zkRollup de uso general
StarkNet es un zkRollup de uso general que viene impulsando el desarrollo de smart contracts utilizando el compilador de Cairo. Se trata de un L2 con completa compatibilidad con Ethereum, sin importar el lenguaje que utilice.
Paso 1: Instalación de Cairo
Para instalar el compilador de Cairo, comienza instalando Python en tu computador y algunas dependencias necesarias.
Nota: A lo largo de esta clase, cada comando que se requiera ejecutar viene predecedido por un "$". Recuerda no copiar este caracter, dado que es una forma de delimitar un comando individual que se ejecuta en una terminal de comandos.
-
En Linux:
bash
$ sudo apt install -y python3.8-venv libgmp3-dev
-
En MacOS:
bash
$ brew install [email protected]
$ brew install gmp
-
En Windows debes instalar Python 3 desde el sitio web oficial y luego estas dependencias a través de pip
.
bash
$ pip3 install ecdsa fastecdsa sympy
Crea un ambiente virtual en Python para tener listo tu entorno de desarrollo:
bash
$ python3.8 -m venv ~/cairo_venv
$ source ~/cairo_venv/bin/activate
$ pip3 install cairo-lang
Paso 2: Primer contrato en Cairo
Los contratos en Cairo llevan la extensión .cairo
. Crea un simple archivo con el nombre contract.cairo
y el siguiente código fuente con la sintaxis de este nuevo lenguaje.
```cairo
// Declare this file as a StarkNet contract.
%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
// Define a storage variable.
@storage_var
func balance() -> (res: felt) {
}
// Increases the balance by the given amount.
@external
func increase_balance {
syscall_ptr: felt,
pedersen_ptr: HashBuiltin,
range_check_ptr,
} (amount: felt) {
let (res) = balance.read();
balance.write(res + amount);
return ();
}
// Returns the current balance.
@view
func get_balance {
syscall_ptr: felt,
pedersen_ptr: HashBuiltin,
range_check_ptr,
} () -> (res: felt) {
let (res) = balance.read();
return (res=res);
}
```
El contrato simplemente persiste un valor numérico ingresado a través del método increase_balance()
y podrás obtener el valor actual con get_balance()
. Es equivalente al siguiente contrato escrito en Solidity:
```c
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
contract MyContract {
uint balance;
function increase_balance(uint amount) public {
balance += amount;
}
function get_balance() returns(uint) public view {
return balance;
}
}
```
Paso 3: Creación de cuenta
Para desplegar un contrato, primero debemos crear una cuenta dentro del ecosistema de StarkNet nuestra wallet ejecutando los siguientes comandos.
```bash
Conectar a Goerli Testnet
$ export STARKNET_NETWORK=alpha-goerli
Usar las wallets de OpenZeppelin
$ export STARKNET_WALLET=starkware.starknet.wallets.open_zeppelin.OpenZeppelinAccount
Lanzar el smart contract de la cuenta de usuario
$ starknet deploy_account
```
Paso 4: Desplegar un contrato en StarkNet
Es momento de desplegar el contrato anteriormente creado, para esto puedes ejecutar los siguientes comandos:
```bash
Compilar el contrato
$ starknet-compile contract.cairo --output contract_compiled.json --abi contract_abi.json
Lanzar el contrato
$ starknet deploy --contract contract_compiled.json --no_wallet
```
Debemos esperar algunos minutos a que la transacción tenga el estado ACCEPTED_ON_L2
. Podemos verificarlo con ayuda del siguiente comando:
bash
$ starknet tx_status --hash HASH_DE_TRANSACCIÓN
Reemplaza HASH_DE_TRANSACCIÓN
por el hash de la transacción obtenido en el comando anterior al desplegar el contrato.
Paso 5: Interacción con el contrato
La interacción con al L2 de StarkNet se realiza de la misma manera que con otros protocolos de segunda capa. Con la particularidad de que requerirás de una wallet especial llamada Braavos Wallet que puedes instalar en tu navegador, resguardar las palabras de recuperación, y utilizarla como si de cualquier otra wallet se tratase.
Una vez tengas tu wallet, transfiere fondos desde Ethereum Goerli. Puedes hacerlo utilizando el bridge StarkGate o interactuando directamente con el contrato. Con enviar algo de ETH bastará para ejecutar el smart contract.
Si ya tienes fondos suficientes, ingresa al StarkScan y localiza tu contrato por medio de su dirección. Utilizaremos el explorador de StarkNet como front-end para ejecutar los métodos del contrato.
En las pestañas Read Contract
y Write Contract
, podrás encontrar los métodos de lectura y escritura sobre el contrato, respectivamente. El método get_balance()
te permitirá obtener el valor numérico guardado en el contrato, mientras que el método increase_balance()
te permitirá modificarlo.
Conecta tu wallet Braavos y podrás interactuar con tu primer zkRollup de uso general, StarkNet.
Conclusión
Sin duda es toda una innovación tecnológica desarrollar contratos inteligentes compatibles con EVM, en un lenguaje con una menor adopción que Solidity.
Como desarrolladores, debemos ser de mente abierta. No casarnos con un solo lenguaje y estar dispuestos a aprender uno nuevo, si las circunstancias o necesidades de un proyecto lo amerita. ¿Qué piensas de Cairo? ¿Le darías una oportunidad?
Contribución creada por: Kevin Fiorentino.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?