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?

o inicia sesi贸n.

Cairo es el lenguaje con el que se programa en StarkNet. El juego de letras va as铆 CAIRo == 鈥淐puAIRo鈥 (Algebraic Intermediate Representation)

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.

Primero en comentar 馃槑馃構