Skip to content
/ Nadai-StarknetEs-Guia-Cairo1 Public

Todo en 1 - Guía completa de recursos para instalar, compilar, desplegar y contratos de Cairo 1 en Español

4 stars 0 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

Nadai2010/Nadai-StarknetEs-Guia-Cairo1

1 Branch0 Tags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

Nadai2010Nadai2010
Guía Cairo 1 Test
Jun 27, 2023
621c230 · Jun 27, 2023

History

29 Commits
imagenes
imagenes
Jun 22, 2023
src
src
Jun 27, 2023
tests
tests
Jun 22, 2023
README.md
README.md
Jun 27, 2023
Tutorial_ERC721.md
Tutorial_ERC721.md
Jun 21, 2023

Repository files navigation

starknet logo

Guía Definitiva de Starknet-Es Cairo 1

Recursos oficiales

Temas

Configuración de su entorno de desarrollo de Starknet

Desde Starknet Español le guiamos a través de la configuración de su entorno de desarrollo para Cairo y Starknet. El objetivo es proporcionarle las herramientas necesarias para construir, implementar e interactuar con contratos inteligentes de Cairo en la red de Starknet. Instalaremos el compilador de Cairo, una herramienta fundamental para esta tarea, y la Interfaz de Línea de Comandos (CLI) de Starknet, una utilidad para interactuar con la red de Starknet.

  1. La CLI de Starknet es una interfaz de línea de comandos que le permite interactuar con Starknet. Esta es una de las herramientas que nos permiten interactuar con Starknet, sin embargo, no es la única. Cubriremos otras herramientas en capítulos posteriores (por ejemplo, el SDK de Starknet para JavaScript/Python/Rust o Protostar).

  2. El compilador de Cairo es una herramienta que compila código de Cairo a Sierra.

El proceso de configuración se puede realizar a través de dos métodos diferentes: configurar un entorno de desarrollo local o utilizar un contenedor de Docker.

Pre-requisitos

Antes de continuar, asegúrese de tener instalados los siguientes pre-requisitos en su sistema:

Git

Git: Será necesario tener Git instalado. A continuación, se muestra el comando para instalar Git en Ubuntu. Recuerda verificar las versiones disponibles para tu sistema operativo en el enlace proporcionado:

apt-get install git

Si se produce un error y te solicita entrar como administrador, agrega sudo al principio del comando. Se abrirá una ventana para ingresar tu contraseña (que será invisible) y luego puedes presionar Enter para continuar.

sudo apt-get install git

Python3.9

Python 3.9 - Primero revise la versión que se encuentra en siu sitema operativo, si ya de serie dispone una versión posterior en Linux por ejemplo, no hacer nada ya luego ajustamos con entornos virtuales, revise su versión:

python3 --version

Rust

Rust - Les recomendamos revisar el enlace proporcionado para obtener más información sobre la instalación de Rust. A continuación, se muestra el comando recomendado para la instalación de rustup en macOS y Linux. Si deseas utilizar otros métodos de instalación, te recomendamos consultar la documentación oficial.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Para revisar la instalación ha ido correctamente revise su versión:

rustc --version

En caso de dificultades anterirores también puede instalar una versión estable de Rust con los comandos:

rustup override set stable && rustup update

Instalación de la CLI de Starknet

Para instalar la CLI de Starknet, siga estos pasos:

Configure su entorno virtual:

Recomendamos trabajar dentro de un entorno virtual de Python. Esto aislará las dependencias de su proyecto de la instalación global de Python en su sistema. Para crear y activar un entorno virtual, puede usar venv o pyenv, para esta guía seguiremos pyenv aunque le dejaremos ambos ajustes:

Usando venv:

Cree un entorno virtual llamado cairo_venv

python3.9 -m venv ~/cairo_venv

Active el entorno virtual

source ~/cairo_venv/bin/activate

Usando pyenv:

Instale pyenv

curl https://pyenv.run | bash

Agregue las siguientes líneas a su .bashrc o .zshrc

export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

Reinicie su terminal y ejecute los siguientes comandos

pyenv install 3.9.0
pyenv virtualenv 3.9.0 cairo_venv
pyenv activate cairo_venv

Activar el entorno virtual

pyenv activate cairo_venv

Después de crear y activar el entorno virtual, debería ver (cairo_venv) en el indicador de línea de comando, lo que indica que el entorno virtual está activo, por ejemplo: (cairo_venv) nadai@nadai:

Ahora puede revisar que su vesión de python si es la que hemos requerido y necesita por ahora.

python --version

Instale las dependencias SO:

Antes de instalar la CLI de Starknet, debe instalar algunas dependencias específicas del sistema. Siga las instrucciones para su sistema operativo:

Ubuntu:

sudo apt install -y libgmp3-dev

Mac:

brew install gmp

Una vez que haya instalado las dependencias específicas del sistema, proceda a instalar los paquetes de Python requeridos para la CLI de Starknet:

pip install ecdsa fastecdsa sympy

Estos paquetes de Python proporcionan funcionalidad criptográfica y matemática necesaria para la CLI de Starknet.

Instale la CLI de Starknet:

Ahora que ha configurado el entorno e instalado las dependencias, puede instalar la CLI de Starknet. Siga estos pasos:

  1. Desinstale cualquier versión anterior de cairo-lang (cairo-lang es el nombre del paquete que contiene la CLI de Starknet):
pip uninstall cairo-lang

Instale la última versión de cairo-lang:

pip install cairo-lang

Después de haber instalado la CLI de Starknet, verifique su instalación comprobando la versión, pero recuerde entrar en su entorno virtual

starknet --version

En este caso de comprobación de version puede usar -v o --version, si quiere acceder a la última version publicada revise Cairo-Lang Releases

Si recibes el siguiente error:

ImportError: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with LibreSSL 2.8.3. See: https://github.com/urllib3/urllib3/issues/2168

Intenta reducir la versión de urllib3:

pip install urllib3==1.26.6

Luego, verifica la versión nuevamente:

starknet --version

La salida debería mostrar la versión instalada de Starknet CLI. Asegúrate de que la versión coincida con la última versión publicada.

Para actualizar a la última versión de Starknet CLI, ejecuta el siguiente comando:

pip install cairo-lang --upgrade

Instalación del compilador Cairo

Para instalar el compilador Cairo, sigue estos pasos:

  1. Ahora procederemos a clonar y configurar nuestro compilador de Cairo. Primero, asegúrate de estar en la raíz de tu directorio $HOME.
cd ~/
  1. Clona el repositorio del compilador Cairo en una carpeta llamada .cairo en tu directorio principal:
git clone https://github.com/starkware-libs/cairo/ .cairo
  1. Cambia a la rama de trabajo y genera los binarios de la versión:
cd .cairo/
git checkout tags/v1.1.0
cargo build --all --release

Agrega los ejecutables de Cairo a tu variable de entorno PATH:

Actualiza tu archivo .bashrc o .zshrc para agregar los binarios de Cairo a tu variable de entorno PATH:

export PATH="$HOME/.cairo/target/release:$PATH"

Abre una nueva terminal y verifica que el siguiente comando devuelva un número de versión:

cairo-compile --version

Actualizar Compilador Cairo

Para actualizar el compilador Cairo, solo necesitamos cambiar a la etiqueta más reciente. Ejecuta los siguientes comandos:

  1. Ve al repositorio clonado de Cairo
cd ~/.cairo
  1. Obtén las etiquetas más recientes
git fetch
  1. Cambia a la etiqueta más reciente
git checkout tags/v2.0.0-rc4
cargo build --all --release
  1. Abre una nueva terminal y verifica que tengas la versión deseada:
cairo-compile --version

Ahora tenemos nuestro cairo-compile listo en la última versiíon disponible, no significa que sea la más estable, a día 21-06-2023 no se ha lanzado la 0.12, la cual será necesaria para poder compilar nuestro contratos y desplegar de la versión del cimpilador 2.X, en este caso vemos que es la v2.0.0-rc4

Así que ahora lo que tenemos que volver hacer es volver a la versión v1.1 con los comandos

git checkout tags/v1.1.0
cargo build --all --release

Ahora puedes volver a comprobar tu versión y ya tienes configurado tu entorno de desarrollo local para Starknet. Ahora puedes comenzar a construir, implementar e interactuar con contratos inteligentes en Cairo.

Configuración de Docker para el desarrollo de Starknet

El uso de un entorno Docker para el desarrollo de Starknet ofrece varias ventajas en comparación con la configuración del entorno de desarrollo de forma local. Estas ventajas incluyen:

  • Aislamiento: Los contenedores de Docker proporcionan un entorno aislado para el desarrollo de Starknet, asegurando que las dependencias y configuraciones no interfieran con otros proyectos o con la configuración global del sistema.

  • Portabilidad: Un contenedor de Docker puede ejecutarse en cualquier sistema con Docker instalado, lo que te permite compartir fácilmente tu entorno de desarrollo con otros o moverlo entre diferentes máquinas sin tener que volver a configurar el entorno desde cero.

  • Reproducibilidad: Las imágenes de Docker aseguran que tu entorno de desarrollo sea consistente en diferentes sistemas, lo que ayuda a eliminar problemas derivados de diferencias en las dependencias o configuraciones.

  • Versionado: Puedes utilizar diferentes imágenes o etiquetas de Docker para diferentes versiones de las herramientas de desarrollo de Starknet, lo que te permite cambiar fácilmente entre versiones según sea necesario.

  • Gestión más sencilla: Docker simplifica la gestión de entornos de desarrollo, permitiéndote iniciar, detener y reiniciar contenedores con facilidad. También facilita la limpieza de tu entorno eliminando contenedores e imágenes.

Teniendo en cuenta estas ventajas, las siguientes secciones te guiarán en la configuración de un entorno Docker para el desarrollo de Starknet. Este entorno te permitirá construir, implementar e interactuar fácilmente con contratos inteligentes en Cairo utilizando Docker.

Antes de continuar, asegúrate de tener los siguientes requisitos previos instalados en tu sistema:

Descargar la /imagenes/imagen de Docker

El primer paso es descargar la /imagenes/imagen de Docker que contiene las herramientas necesarias para el desarrollo de Starknet. Ejecuta el siguiente comando en tu terminal:

docker pull artudev19/cairo-env:latest

Este comando descarga la /imagenes/imagen de Docker de Starknet.

Ejecutar el contenedor de Docker

Para ejecutar un contenedor a partir de la /imagenes/imagen, ejecuta el comando docker run. Para mantener cierta información persistente, utiliza un volumen pasando la opción -v from_host_path:to_container_path. Esto reflejará el contenido de from_host_path dentro del contenedor. Si especificas una ruta en el contenedor que no existe, Docker la creará automáticamente.

docker run -it --name stark-env -v /Desktop/stark-apps/contracts:/contracts artudev19/cairo-env:latest

Este comando ejecuta un contenedor llamado stark-env (asegúrate de que tu demonio de Docker esté en ejecución) y abre una terminal donde puedes ejecutar comandos de Starknet y Cairo. En el ejemplo anterior, los contratos de Cairo de tu máquina local estarán en el directorio stark-app/contracts, mientras que en el contenedor estarán en la ruta contracts.

Verificar la instalación

Verifica las versiones instaladas de Starknet CLI y el compilador Cairo:

starknet --version
cairo-compile --version

La salida debería mostrar la versión instalada de Starknet CLI y el compilador Cairo. Asegúrate de que las versiones coincidan con la última versión

Instalación de Cairo con un script (Instalador por Fran)

Como último metodo de instalación seguiremos el script de Fran. Si deseas instalar una versión específica de Cairo en lugar de la última versión, establece la variable de entorno CAIRO_GIT_TAG (por ejemplo, exporta CAIRO_GIT_TAG=v1.1.0), corra el siguiente comando:

curl -L https://github.com/franalgaba/cairo-installer/raw/main/bin/cairo-installer | bash

Después de la instalación, sigue estas instrucciones para configurar tu entorno de shell.

Configuración de tu entorno de shell para Cairo

  • Define la variable de entorno CAIRO_ROOT para que apunte a la ruta donde Cairo almacenará sus datos. Por defecto, es $HOME/.cairo. Si instalaste Cairo mediante la clonación de Git, te recomendamos que lo establezcas en la misma ubicación donde lo clonaste.
  • Agrega los ejecutables cairo-* a tu PATH si aún no están allí.

La siguiente configuración debería funcionar para la gran mayoría de los usuarios en casos de uso comunes.

Para bash

Los archivos de inicio predeterminados de Bash varían ampliamente entre distribuciones en cuanto a cuál de ellos carga qué, en qué circunstancias, en qué orden y qué configuración adicional realizan. Por lo tanto, la forma más confiable de tener Cairo en todos los entornos es agregar los comandos de configuración de Cairo tanto a .bashrc (para shells interactivos) como al archivo de perfil que Bash utilizaría (para shells de inicio de sesión).

Primero, agrega los comandos a ~/.bashrc ejecutando lo siguiente en tu terminal:

echo 'export CAIRO_ROOT="$HOME/.cairo"' >> ~/.bashrc
echo 'command -v cairo-compile >/dev/null || export PATH="$CAIRO_ROOT/target/release:$PATH"' >> ~/.bashrc

Luego, si tienes ~/.profile, ~/.bash_profile o ~/.bash_login, agrega los comandos también allí. Si no tienes ninguno de estos, agrégalos a ~/.profile.

  • Para agregar a ~/.profile:
echo 'export CAIRO_ROOT="$HOME/.cairo"' >> ~/.profile
echo 'command -v cairo-compile >/dev/null || export PATH="$CAIRO_ROOT/target/release:$PATH"' >> ~/.profile
  • Para agregar a ~/.bash_profile:
echo 'export CAIRO_ROOT="$HOME/.cairo"' >> ~/.bash_profile
echo 'command -v cairo-compile >/dev/null || export PATH="$CAIRO_ROOT/target/release:$PATH"' >> ~/.bash_profile

Para Zsh

echo 'export CAIRO_ROOT="$HOME/.cairo"' >> ~/.zshrc
echo 'command -v cairo-compile >/dev/null || export PATH="$CAIRO_ROOT/target/release:$PATH"' >> ~/.zshrc

Si deseas tener Cairo en shells de inicio de sesión no interactivos, también agrega los comandos a ~/.zprofile o ~/.zlogin.

Para el shell Fish:

Si tienes Fish 3.2.0 o una versión más reciente, ejecuta lo siguiente de forma interactiva:

set -Ux CAIRO_ROOT $HOME/.cairo
fish_add_path $CAIRO_ROOT/target/release

De lo contrario, ejecuta el fragmento de código a continuación:

set -Ux CAIRO_ROOT $HOME/.cairo
set -U fish_user_paths $CAIRO_ROOT/target/release $fish_user_paths

En MacOS, es posible que también desees instalar Fig, que proporciona completaciones de shell alternativas para muchas herramientas de línea de comandos con una interfaz emergente similar a un IDE en la ventana del terminal. (Ten en cuenta que sus completaciones son independientes de la base de código de Cairo, por lo que pueden estar ligeramente desactualizadas para cambios de interfaz muy recientes).

Reinicia tu shell

Para que los cambios en el PATH surtan efecto.

exec "$SHELL"

Actualización

En caso de querer actualizar correr el comando

rm -fr ~/.cairo
curl -L https://github.com/franalgaba/cairo-installer/raw/main/bin/cairo-installer | bash

Desinstalación

Cairo se instala en $CAIRO_ROOT (por defecto: ~/.cairo). Para desinstalarlo, simplemente elimínalo:

rm -fr ~/.cairo

Luego, elimina estas tres líneas de su .bashrc:

export PATH="$HOME/.cairo/target/release:$PATH"

Y por último, reinicia tu shell:

exec $SHELL

Versiones

Una vez tenga todo configurado puede comprobar sus versiones instaladas con los siguientes comadnos por independiente o conjunto como hemos visto a lo largo de la instalación

starknet --version
cairo-compile --version
starknet-compile --version

VS Code

Ahora, si creamos un contrato de prueba, veremos que la sintaxis no es reconocida por nuestro programa de VS Code.

Pero ya tenemos disponible la extensión de Cairo 1 para VS Code. Para configurarla, primero debemos descargarla e instalarla buscando Cairo1 de StarkWare y haciendo clic en install.

También es posible que necesite reconstruir su cairo-language-server. Para hacerlo, vaya a la ubicación de instalación de Cairo y ejecute:

cd .cairo
cargo build --bin cairo-language-server --release

Una vez instalada, iremos a los ajustes para agregar la ruta de nuestro cairo-language-server, que se encuentra dentro de la ruta /home/nadai/.cairo/target/release/cairo-language-server. Deberá buscar su ruta exacta y reemplazar esta.

Luego, deberá pegar la ruta en los ajustes de su Extensión instalada del Cairo-languague-server que encontró en /path/cairo/target/release/cairo-language-server (sustituir usuario y revisar ruta de instalación). Una vez copiado y establecido, deberá recargar con F5 su Visual Studio y ya debería estar activo. Si no es así, cierre y abra para volver a visualizarlo.

Ahora su contrato de Cairo 1 debería ser reconocido con la sintaxis de la versión que haya configurado.

Puede seguir nuevas actualizaciones y configuraciones desde el link oifcial de StarkWare VS-Code

Despliegue de contratos Starknet

Ahora veremos como crear una contrato de cuenta, como se controlan estas cuentas, compilar, declarar, desplegar e interactuar con los Contracts que tenemos en Cairo 1.

Configuración de variables de entorno

Los siguientes comandos deben ejecutarse cada vez que abras un nuevo terminal para interactuar con Starknet. Configurarlos te ahorrará tiempo cuando utilices la CLI dentro de la misma sesión del terminal.

  • Utilizar la red de prueba de Starknet
export STARKNET_NETWORK=alpha-goerli
  • Establecer la implementación predeterminada de la billetera que se utilizará en la CLI
export STARKNET_WALLET=starkware.starknet.wallets.open_zeppelin.OpenZeppelinAccount

Establecer la ruta al compilador binario de Cairo 1. Ajusta esta ruta según tu instalación si es necesario

export CAIRO_COMPILER_DIR=~/.cairo/target/release/
  • Argumentos del compilador
export CAIRO_COMPILER_ARGS=--add-pythonic-hints

Inicialemnte se puede pasar todo junto de la siguiente manera

# Use Starknet testnet
export STARKNET_NETWORK=alpha-goerli
# Set the default wallet implementation to be used by the CLI
export STARKNET_WALLET=starkware.starknet.wallets.open_zeppelin.OpenZeppelinAccount
# Set the path to the cairo 1 compiler binary. Adapt this path to fit your installation if needed
export CAIRO_COMPILER_DIR=~/.cairo/target/release/
# Compiler arguments
export CAIRO_COMPILER_ARGS=--add-pythonic-hints

Aunque normalmente los errores comunes en estos casos son al volver a iniciar sesión así que si tiene algunos de estos dos errores, pase los EXPORT correspondientes

Error: AssertionError: A wallet must be specified (using --wallet or the STARKNET_WALLET environment variable), unless specifically using --no_wallet.
The network is unknown. The default list of allowed libfuncs will be used. To specify the network, pass '--network' or set the STARKNET_NETWORK environment variable.
Error: Exception: feeder_gateway_url must be specified with the "declare" subcommand.
Consider passing --network or setting the STARKNET_NETWORK environment variable.

Ambos se deben a la falta de exportar STARKNET_NETWORK y STARKNET_WALLET se soluciona pasando de nuevo los comandos:

export STARKNET_NETWORK=alpha-goerli
export STARKNET_WALLET=starkware.starknet.wallets.open_zeppelin.OpenZeppelinAccount

Configuración de una cuenta

Debes configurar tu CLI con un contrato de cuenta y financiarlo.

Las cuentas de Starknet son contratos inteligentes. Como tal, crear una implica enviar una transacción y lleva un poco más de tiempo que crear una EOA en otras redes.

Este proceso consta de tres pasos:

  1. Generar localmente la dirección de tu cuenta

  2. Financiarla

  3. Desplegarla

Las cuentas de Starknet declaradas a través de la CLI se almacenan en tu máquina en la carpeta ~/.starknet_accounts/ en la que podremos revisar su estado o ver los nombres y redes de las cuentas que tenemos.

Para poder visualizar estas carpeta ocultas en los SO, en ubuntu bastará con tocar Crtl+H y os aparecerán estas carpetas, como .cairo, es decir todas con . estás ocultas.

Crear una nueva cuenta

En este paso emepzaremos a crear nuestra nueva cuenta que inicialmente solo será calculada veamos, de hecho, podemos hacerlo sin concción a internet ya que sólo será el procedimiento de generar nuesta Private y Public Key:

starknet new_account --account NadaiTest

Tu terminal devolverá la dirección de tu cuenta.

Y podremos comprobar en nuestro archivo starknet_open_zeppelin_accounts.json que nuestra nueva ya aparece con un estado de false (aun no ha sido desplegado)

Pero si nos detecta aunque estemos sin conección a la red la cuenta creada, por lo que si pasamos el mismo comando nos daría el siguiente error

Pero ¿Qué pasaría si borramos nuestra cuenta que ha sido calculada pero no desplegada?¿Nos daría los mismo valores? Vamos a probar, borremos la cuetna que aún no ha sido desplegada

  • Account address: 0x03175cdd79fe7cc981a7876ee19fd9aadc5c36b12a1534fe730857b7d0d3a330

Y volvemos a correr el comando para desplegar nuestra cuenta que antes no s daba error como cuenta ya existente:

starknet new_account --account NadaiTest

Vemos como se ha generado una cuenta, una private key, public key completamente nueva asociado a nuestro nombre.

  • Account address: 0x053e688af06f4d763213a165bca6811cdd603e031922a13e10819c2be8d3fc1c

Financiar Cuenta

Primero aclaremos que estas cuentas son una versión modificada del contrato de cuenta de OpenZeppelin. La firma se calcula de manera diferente.

Ahora necesitamos tener fondos en esa cuenta que ha sido sólo calculda, moveremos la cantidad adecuada de fondos a la cuenta para luego desplegar nuestra cuenta invocando el comando starknet deploy_account.

  • Utiliza el faucet para obtener fondos y enviarlos a la cuenta.
  • Transfiere fondos utilizando Starkgate.
  • Transfiere fondos de otra cuenta.

En este caso usamos faucet

Sin importar cómo lo hagas, asegúrate de que la transacción de financiación alcance el estado PENDING antes de continuar. Puedes verificarlo en Starkscan, Voyager o como aprenderemos en este caso a directamente con la CLI, y comprobar como nuestro estado de despliegue pasa de false a true

El hash de la transacción del faucet) será el que usemos para ver el estado de nuestro envio de saldo para poder desplegar, también puede hacerlo desde los explodaroes mencionados

starknet get_transaction --hash 0x7438cc6d5a5cd40b64c6cc7684ad054ce682e236da48534c8411626378f4e3d
En este caso vemos que ya ha sido aceptada en L2 `ACCEPTED_ON_L2`, asi que procedamos a desplegar la cuenta

Desplegar Cuenta

Ahora ya podemos desplegar nuestra cuenta con el comando y el nombre de la cuenta, en este caso NadaiTest

starknet deploy_account --account NadaiTest

Tu resultado de muestra debería verse algo así:

Y ya podriamos comprobar que nuesto estado de cuenta ha cambiado true y ya definitivamente se encuentra desplegado.

Como ultima comprobación antes de empezar con nuestro Contratos de Cairo 1, veamos como nuestra cuenta ya se sitúa con una transación y por lo tanto el nonce 1 desde la CLI

starknet get_nonce --contract_address 0x053e688af06f4d763213a165bca6811cdd603e031922a13e10819c2be8d3fc1c

Compilar

Para compilar nuestros Contratos de Cairo 1, primero crearemos en nuestro proyecto una carpeta para añadir los contratos src así que si ha clonado este repo, primero ejecute:

cd src

Ahora se encotrará en la carpeta de Contratos, primero personalice el contrato que usaremos de prueba Hola.cairo y agregaremos un nuevo tipo de evento. Encuentre un nombre que sea único (esto es importante). Agregue el siguiente código:

#[event]
fn Escoga_Evento_Unico(from:ContractAddress, value:felt252) {}

Ahora procederemos a compilar nuestro contrato de prueba Hola.cairo, el cual nos generará si todo va bien el archivo .json necesario para los siguientes paso, primero añadimos el comando, seguido del nombre del contrato que queremos compilar y el nombre de salida a .json

starknet-compile Hola.cairo Hola.json

Declaración

Los contratos en Starknet tiene la ventaja de poder ser declarados en la red una vez y luego sólo desplegar, veremos posterior como no puede declararse dos contratos iguales. En Starknet, el proceso de implementación consta de dos pasos:

  • Declarar la clase de su contrato o enviar el código de su contrato a la red.
  • Implementar un contrato o crear una instancia del código que declaró anteriormente.

Comencemos con la declaración del código anterior.

starknet declare --contract Hola.json --account NadaiTest

Una vez su declaración haya sido aceptada ya su class hash aparecerá en el explorador, puede revisar el estado con el comando:

starknet get_transaction --hash 0x610a4a6c84d011ca0013b9df30014ef978b0c9307d23fea2821d13fe4c1035d

Desde el explorador podemos comprobar que aún no se ha desplegado ningún contrato usando esta declaración

Despliegue

El hash de transacción le permite rastrear cuándo la red habrá recibido el código de su contrato. Una vez que esta transacción pase a PENDING (pendiente), puede implementar una instancia de su contrato.

Utilizando el class hash generado anteriormente, implemente el contrato. Si encuentra algún problema relacionado con las tarifas, agregue el indicador --max_fee 100000000000000000 a sus comandos de CLI para establecer un límite de gas arbitrariamente alto para su transacción de implementación.

Así que para desplegar su primer contrato en Cairo 1, de una ejemplo sencillo sin inputs corra el comando:

starknet deploy --class_hash 0x225786c0dcc2d62487f3bab0df7685563f1a37e04562ea4d4b94c350f74002  --account NadaiTest

Si todo ha ido bien ya podra revisar su contrato, puede revisar esta implentación y dejar su mensaje de bienvenida, pero para ello primero deberá de usar un convertidor a felt, en esta caso usamos Stark-Utils y el mensaje que querenmos convertir.

  • Mensaje = Starknet La Mejor L2 😜
  • Felt = 523853089324632803106236192193517396970156379196793374498332

Podríamos directamente al explorador y contrato que hemos desplegado, conectar nuestra cuenta de ArgentX o Braavos que queramos y dejar nuestro mensaje a Hola_Starknianos_Dice.

Intercatuar

Esta vez vamos hacer un invoke de la transacción desde la CLI. La sintaxis para invocar una función en su contrato es la siguiente:

starknet invoke --function <nombre de la función> --address <dirección del contrato implementado> --account <nombre_de_cuenta>

En nuestro caso añadimos la dirección del contrato que acabamos de desplegar 0x06383a164125316277fb4ce86bd20d61a82d74ab73d695cf1f8d4c1ac3d40ecb las input, que han sido el saludo convertido a felt 523853089324632803106236192193517396970156379196793374498332 y nuestra cuenta de test NadaiTest

starknet invoke --function Hola_Starknianos_Dice --address 0x06383a164125316277fb4ce86bd20d61a82d74ab73d695cf1f8d4c1ac3d40ecb --input 523853089324632803106236192193517396970156379196793374498332 --account NadaiTest

Ahora podrá revisar en el explorador el evento y el mensaje que hemos dejado, en este caso:

Contratos Cairo 1

En esta sección iremos añadiendo algunos contratos de interés, pruebas y recursos mínimo para un despliego más rápido.

ENS

Ens.cairo es una implementación sencilla de un servicio de espacios de nombres en Cairo. Contiene una única función externa llamada NomreAlmacenado y una única función de vista llamada obtener_nombre. También se utiliza una variable de almacenamiento llamada names, que es un mapeo de dirección a nombre, para almacenar los nombres asignados a cada dirección. Además, se emite un evento llamado almacenar_nombre cada vez que se almacena un nombre.

Compile

starknet-compile ENS.cairo ENS.json

Declare

starknet declare --contract ENS.json --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha declarado.

Sending the transaction with max_fee: 0.000001 ETH (1378300052376 WEI).
Declare transaction was sent.
Contract class hash: 0x6fddb1d03560a9f027e05c161cd391e4ecd840666809f223502bcb9e27fa215
Transaction hash: 0x525a2bdc1f57b9c03a620221dd5aa60e9a80124fafaf2e01c384126d03b4abf

Desplegar

Aquí deberemos pasar los argumentos del constructor, en este caso pasamos Nadai que es igual en felt 336641417577, puede usar el Stark-Util

starknet deploy --class_hash 0x6fddb1d03560a9f027e05c161cd391e4ecd840666809f223502bcb9e27fa215 --inputs 336641417577 --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha desplagado.

Sending the transaction with max_fee: 0.000005 ETH (4776200186272 WEI).
Invoke transaction for contract deployment was sent.
Contract address: 0x033aa7e37649cf51b4541a1b576f99abb6137401ca9aa04523b7a506b0192f21
Transaction hash: 0x7f638882abfc06cf8b95de2a192b3089ce7bef00e6d5aa7276059394b776bcb

Votar

Votar.cairo es una implementación de un servicio de votos en Cairo. Podrá votar con si o no, solo aquellos que hayan sido añadidos, para ello tenemos la función del constructor que registrará _register_voters en este caso hasta 3 votantes. Podrá leer el estado de votos, votar y ver quien ha votado.

Compile

starknet-compile Votar.cairo Votar.json

Declare

starknet declare --contract Votar.json --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha declarado.

Sending the transaction with max_fee: 0.000001 ETH (1378300314253 WEI).
Declare transaction was sent.
Contract class hash: 0x2ce8d6a94592d2b47da3902f8b00bd4cd5c575ffd8d0aa33cebd5dbf0eae906
Transaction hash: 0x4d6bce29802a855a95c76595efe03681765f3bc0593c988191594240b2226d8

Desplegar

Aquí deberemos pasar los argumentos del constructor, en este caso pasamos las cuentas que van a ser registradas para votar, las pasamos a felt con el Stark-Util

starknet deploy --class_hash 0x02ce8d6a94592d2b47da3902f8b00bd4cd5c575ffd8d0aa33cebd5dbf0eae906 --inputs 1795950254530259382270168937734171348535331377400385313842303804539016002736 2576485153152103101814659868666844275075629902050884189831195075733091688326 1129738685687880537468674905681849347313318001773551180695869634292384364582 --account Nadai

Si todo ha ido bien deberá salir la transacción con la diección del contrato que ha desplagado.

Sending the transaction with max_fee: 0.000012 ETH (11515903420223 WEI).
Invoke transaction for contract deployment was sent.
Contract address: 0x07cfd595045ddbe08ce5b562f46c0d105af80794380878728634a9e8a84a7942
Transaction hash: 0x5262b3dc24b511f1506a04fd4ef17cf0b120668bccaa282a7805022eb005320

Ahora podrá añadir su voto si su cuenta ha sido registrada.

ERC20

ERC20.cairo es una implementación de un token ERC-20 en Cairo. Podrá crear su propio token, establecer un name , symbol, los decimals, mint, aprobar o transferir tus ERC-20.

Compile

starknet-compile ERC20.cairo ERC20.json

Declare

starknet declare --contract ERC20.json --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha declarado.

Sending the transaction with max_fee: 0.000001 ETH (1387470794710 WEI).
Declare transaction was sent.
Contract class hash: 0x7db653c91959fd5674c1bb5b8a3938b4b14ac9ecdda9da195ac35fe65cae183
Transaction hash: 0x48b5bb7fa8358c16cc2162fa8441b493f0bc883b146fe199a83fbf3653b6c7d

Desplegar

Aquí deberemos pasar los argumentos del constructor, en este caso pasamos names symbol total supply y el recipient, primeros pasamos todo a felt con el Stark-Util

starknet deploy --class_hash 0x0731affa00504b8311180a11585108f15296bf91b024c76a96057959c608d037 --inputs 336641417577 5128521 18 --account Nadai

Si todo ha ido bien deberá salir la transacción con la diección del contrato que ha desplagado.

Sending the transaction with max_fee: 0.000009 ETH (8865223076573 WEI).
Invoke transaction for contract deployment was sent.
Contract address: 0x05ecb0d7f6a32fa713c1568186dfb88392126c48332d04327e4cdea8061696d1
Transaction hash: 0x14081aa8b720286828ff2c9207d726e585e77e6c43af3bbadd90d13ffa3aee2

Ahora podrá ver su nuevo token con los valores que se han establecido en el constructor en el despliegue.

ERC721

ERC721.cairo es una implementación de un token no fungible ERC-721 en Cairo. Podrá crear su propio NFT, en este ejemplo sencillo basta con establecer un name y symbol para desplegar este contrato.

Compile

starknet-compile ERC721.cairo ERC721.json

Declare

starknet declare --contract ERC721.json --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha declarado.

Sending the transaction with max_fee: 0.000001 ETH (1487715674268 WEI).
Declare transaction was sent.
Contract class hash: 0x6b1dca7fb9e0166e639a08d5521d2ad854fd023a9d4b2bcbc3c79d510b87fe0
Transaction hash: 0x44d3b2321c8b2bc2c06ff0c11cebb4fad72cc0aba9f7fe603df3ee03658d328

Desplegar

Aquí deberemos pasar los argumentos del constructor, en este caso pasamos names y symbol como inputs, primero pasamos todo a felt con el Stark-Util

starknet deploy --class_hash 0x6b1dca7fb9e0166e639a08d5521d2ad854fd023a9d4b2bcbc3c79d510b87fe0 --inputs 336641417577 5129801 --account Nadai

Si todo ha ido bien deberá salir la transacción con la diección del contrato que ha desplagado.

Sending the transaction with max_fee: 0.000007 ETH (6609894432026 WEI).
Invoke transaction for contract deployment was sent.
Contract address: 0x041250c83391e1ba8701c39e8eca759525c4d34f87ccfdf5a4d6c35c5282fa5d
Transaction hash: 0x6d169a3a0ce233f7b46546dc995bc4d6cdc779a88d768e0e4a4dc2b4e2c94d1

Pragma

PriceFeed.cairo es una implementación para saber los precios de algunas token del Oracle de Pragma en Cairo.

Pragma es la red de oráculos descentralizada, transparente y composible, la funcionalidad de Pragma va mucho más allá de los precios.

Los contratos inteligentes de Pragma aprovechan el cálculo zk para agregar datos sin procesar con total transparencia y solidez. Debido a que el oráculo está completamente en cadena, cualquiera puede verificar cualquier punto de datos desde el origen a través de la transformación hasta el destino.

Compile

starknet-compile PriceFeed.cairo PriceFeed.json

Declare

starknet declare --contract PriceFeed.json --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha declarado, en nuestro caso cambiambos el nombre del view en PriceFeed.cairo

Siempre recordar que si ya ha sido declarado solo hace falta desplegar con el mismo class hash

BTC/USD

Contract class hash: 0x00f8cd5bb03e4feb41f3a7af81dcee6cbc0e617651ae47276292aede18619c5f
Transaction hash: 0x02570af0c51b0ce82c071284c2f2c4764ab39afd7a0018b56022baa84d3d0342

Desplegar

Aquí deberemos pasar los argumentos del constructor, en este caso pasamos el contract de pragma para el price feed 0x446812bac98c08190dee8967180f4e3cdcd1db9373ca269904acb17f67f7093 y el par que vamos a escoger, en este caso realizamos pruebas con BTC/USD como input, en este caso no hace falta pasar nada ya que pueden copiar estos valores desde los doc de Pragma, auqnue podrá comprobar que todo es felt, dejamos una vez más el convertidor de Stark-Util

Si quiere revisar todos los activos disponibles, los feed data o cualquier otra consulta de datos revise la documentación oficial

  • StarkNet Mainnet = 0x0346c57f094d641ad94e43468628d8 e9c574dcb2803ec372576ccc60a40be2c4
  • StarkNet Alpha-Goerli = 0x446812bac98c08190dee8967180f4e 3cdcd1db9373ca269904acb17f67f7093
  • StarkNet Alpha-Goerli 2 = 0xc28f8752abb9ed18f65fed730b8faa 69bdf6128bb730411efd916284701938
  • ETH/USD = 19514442401534788
  • BTC/USD = 18669995996566340

Prueba BTC/USD

Pasamos los comandos con las entradas de la testnet de Alpha-Goerli y en par BTC/USD que podemos revisar que es un string convertido a felt

starknet deploy --class_hash 0xf8cd5bb03e4feb41f3a7af81dcee6cbc0e617651ae47276292aede18619c5f --inputs 0x446812bac98c08190dee8967180f4e3cdcd1db9373ca269904acb17f67f7093 18669995996566340 --account Nadai

Si todo ha ido bien deberá salir la transacción con la dirección del contrato que ha desplagado.

Sending the transaction with max_fee: 0.000006 ETH (6121500104066 WEI).
Invoke transaction for contract deployment was sent.
Contract address: 0x073d297ea88a3f3b2d0528a214bc897222b243872521ae02859f2d5bd3d23f86
Transaction hash: 0x623d8f42c2594e050f7ec92f76b3c3639e4cc62e0a6c90b7f264cf7c1824fc3

Aquí puede ver un montaje del día de la prueba, usted puede hacer las llamadas que quiera para estar actualizado en este par gracias a Pragma, sólo revise el view_price_btc_usd_ aquí

Test

Si queremos ver el potencial que trae Cairo incorporado, es la facilidad y capacidad de pasar test, para ello primero iremos a la carpeta tests que tenemos con algunos ejemplos, aunque también puede hacer desde la raíz del proyecto y se marcan para identificar que son pruebas con #[cfg(test)]

cairo-test suma.cairo

o

cairo-test ./tests/suma.cairo

Si el resultado es correcto:

Vemos el error que hemos definido en el contract suma.cairo al ejecutar mal la operación.

En caso de error en el resultado imprimirá el mensaje anterior

cairo-test resta.cairo

o

cairo-test ./tests/resta.cairo

Si el resultado es correcto:

cairo-test multiplicacion.cairo

o

cairo-test ./tests/multiplicacion.cairo

Si el resultado es correcto:

cairo-test operaciones.cairo

o

cairo-test ./tests/operaciones.cairo

Si el resultado es correcto mostrará todas las operaciones han pasado la prueba, en este caso suma, resta y mutliplicación:

Test Individuales En este caso haremos la prueba solo de la resta, omitiendo el resto de operaciones de nuestro contrato Operaciones.cairo

cairo-test operaciones.cairo -f resta

o

cairo-test ./tests/operaciones.cairo -f resta

Si todo ha ido bien, el resultado mostrará sólo la prueba de la resta, en este caso ha sido correcta.

    #[test]
    #[ignore]
    fn resta() {
        let result = 2 - 2;
        assert(result == 0, 'El resultado no es 0');
    }

Corremos nuestro test con el comando normal:

cairo-test operaciones_ignorar.cairo

o

cairo-test ./tests/operaciones_ignorar.cairo

Si todo ha ido bien, el resultado mostrará todas las pruebas restantes, en este caso la suma y multiplicación han pasado la prueba, mientras que la resta ha sido ignored

Saltar Test Ignorados Si ahora quiere pasar la prueba completa al mismo contrato Operaciones_Ignorar.cairo, no deberá de corregir su contrato, sólo añadir en su comando que incluya los ignorados --include-ignored

cairo-test operaciones_ignorar.cairo --include-ignored

o

cairo-test ./tests/operaciones_ignorar.cairo --include-ignored

Si todo ha ido bien, el resultado mostrará todas las pruebas, en este caso la suma, resta y multiplicación han pasado la prueba, saltándose la restricción del ignored

  • Test Tupla Primero veamos un test sencillo de una tupla en Cairo, en la que podremos pasar valores en booleanos o numéricos, pero necesitan que sea el valor correcto y == 5 en este caso como única comprobación.

Corremos los comandos:

cairo-test tupla.cairo

o

cairo-test ./tests/tupla.cairo

Si todo ha ido bien, el resultado mostrará como la prueba ha sido pasada con el valor 5

Ahora si cambiamos el valor de la y como la imágen a continuación nos saldrá un mensaje de panicked con la advertencia de El resultado no es 5

NOTA CURIOSA Todo es Felt, en este caso 396331670188477403133841500287902044638256767029 mensaje de error de panicked es El resultado no es 5

  • Test Tupla Multiple Ahora veremos un test de una tupla múltiple en Cairo, en la que podremos pasar valores en booleanos o numéricos, pero necesitan que sea el valor correcto, en este caso con x == 500 , y == 5 y z == true, primero pasaremos el test con los resultados correctos.

Corremos los comandos:

cairo-test tupla_multiple.cairo

o

cairo-test ./tests/tupla_multiple.cairo

Si todo ha ido bien, el resultado mostrará como la prueba ha sido pasada correctamente.

Ahora si cambiamos el valor de la y como la imágen a continuación nos saldrá un mensaje de panicked con la advertencia de El resultado no es 5, como el test anterior o podemos cambiar los 3 valores incorrectos y ver que pasa.

Vemos como se detiene en el primer error, probamos a corregir a x == 500

Vemos que ahora no ha pasado del segundo en este caso y == 5, así que podemos ver el gran poder de TEST EN CAIRO que nos encontramos, recuerden las notas y repasar resto de test.

NOTA CURIOSA Todo es Felt, en este caso 396331670188477403133841500287902044638256767029 mensaje de error de panicked es El resultado no es 5

Starknet CLI

starknet get_nonce --contract_address X
starknet get_transaction --hash X
starknet get_full_contract --contract_address X
starknet get_transaction --hash 0x44d3b2321c8b2bc2c06ff0c11cebb4fad72cc0aba9f7fe603df3ee03658d328
starknet get_full_contract --contract_address 0x041250c83391e1ba8701c39e8eca759525c4d34f87ccfdf5a4d6c35c5282fa5d

About

Todo en 1 - Guía completa de recursos para instalar, compilar, desplegar y contratos de Cairo 1 en Español

Topics

cairo cairo-lang starknet

Resources

Readme
Activity

Stars

4 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages