- Starknet Doc - Documentos oficiales de Starknet
- Starknet Book - Libro de Starknet
- Cairo Doc - Documentos oficiales de de Cairo
- Libro Cairo - Libro de Cairo
- Sintaxis Cairo by Nethermind | Sintaxis Cairo by LambdaClass
- Configuración de su entorno de desarrollo de Starknet
- Instalación de la CLI de Starknet
- Instale las dependencias SO
- Instale la CLI de Starknet
- Instalación del compilador Cairo
- Configuración de Docker para el desarrollo de Starknet
- Instalación de Cairo con un script (Instalador por Fran)
- VS Code
- Despliegue de contratos Starknet
- Contratos Cairo 1
- Test
- Starknet CLI
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.
-
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).
-
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.
Antes de continuar, asegúrese de tener instalados los siguientes pre-requisitos en su sistema:
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
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 - 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
Para instalar la CLI de Starknet, siga estos pasos:
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:
Cree un entorno virtual llamado cairo_venv
python3.9 -m venv ~/cairo_venv
Active el entorno virtual
source ~/cairo_venv/bin/activate
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
Antes de instalar la CLI de Starknet, debe instalar algunas dependencias específicas del sistema. Siga las instrucciones para su sistema operativo:
sudo apt install -y libgmp3-dev
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.
Ahora que ha configurado el entorno e instalado las dependencias, puede instalar la CLI de Starknet. Siga estos pasos:
- 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
Para instalar el compilador Cairo, sigue estos pasos:
- Ahora procederemos a clonar y configurar nuestro compilador de Cairo. Primero, asegúrate de estar en la raíz de tu directorio
$HOME
.
cd ~/
- Clona el repositorio del compilador Cairo en una carpeta llamada
.cairo
en tu directorio principal:
git clone https://github.com/starkware-libs/cairo/ .cairo
- 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
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
Para actualizar el compilador Cairo, solo necesitamos cambiar a la etiqueta más reciente. Ejecuta los siguientes comandos:
- Ve al repositorio clonado de Cairo
cd ~/.cairo
- Obtén las etiquetas más recientes
git fetch
- Cambia a la etiqueta más reciente
git checkout tags/v2.0.0-rc4
cargo build --all --release
- 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.
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:
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.
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
.
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
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.
- 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 tuPATH
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.
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
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).
Para que los cambios en el PATH surtan efecto.
exec "$SHELL"
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
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
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
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
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.
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
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:
-
Generar localmente la dirección de tu cuenta
-
Financiarla
-
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.
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
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
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
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
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
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
.
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:
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.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.
starknet-compile ENS.cairo ENS.json
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
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.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.
starknet-compile Votar.cairo Votar.json
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
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.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.
starknet-compile ERC20.cairo ERC20.json
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
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.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.
starknet-compile ERC721.cairo ERC721.json
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
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
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.
starknet-compile PriceFeed.cairo PriceFeed.json
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
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
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í
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 Ignorados
En este contrato de Operaciones_Ignorar.cairo hemos añadido
#[ignore]
a la oeperación que vamos a ignorar.
#[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
yz == 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 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