No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Smart Contracts con Cairo en Starknet

8/10
Recursos

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.

Aportes 3

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Desarrollar un blockchain con un lenguaje poco tradicional como lo es Cairo, pienso que se pone en riesgo la adopción de ese ecosistema. No creo que muchas personas esten interesadas en aprender una alternativa a Solidity. Le ocurre lo mismo a Cardano con su lenguaje Plutus, basado en Haskell.

Cairo es el lenguaje con el que se programa en StarkNet. El juego de letras va así CAIRo == “CpuAIRo” (Algebraic Intermediate Representation)

Primero en comentar 😎😋