StarkNet y los rollups de conocimiento cero están ganando popularidad últimamente debido a su eficiencia, por lo que es hora de aprender a desarrollar en StarkNet. Este tutorial te mostrará cómo crear un contrato inteligente simple en Cairo para guardar y recuperar una variable y, luego, desplegarlo en la red de prueba de StarkNet utilizando el framework (estructura) ProtoStar.
Puedes encontrar el proyecto con el contrato inteligente y los archivos compilados en la carpeta "protostar-project" del repositorio de GitHub.
Si deseas aprender algunos conceptos fundamentales de StarkNet, te recomiendo leer este artículo sobre la arquitectura y el entorno de StarkNet.
Un Contrato Inteligente de Cairo
Cairo es un lenguaje relativamente nuevo que permite contratos inteligentes en StarkNet; ¡vale la pena aprender más sobre ello! El contrato inteligente que vas a implementar hoy es muy similar a un contrato de almacenamiento simple con el que probablemente estés familiarizado en Solidity.
En este tutorial, escribiremos un contrato inteligente directo, pero te enseñará cómo declarar una variable, escribir una función getter y escribir una función para establecer la variable.
El Contrato Inteligente Principal
Lo primero que necesitamos, es declararlo como un contrato StarkNet e importar el paquete 'HashBuiltin'.
%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
Como puedes notar, estamos importando un paquete, HashBuiltin es una estructura que especifica el hash de la estructura de la memoria interna. Puedes aprender más sobre este paquete en StarkNet y Cairo Docs.
En este punto, podemos continuar declarando la variable.
Declara una Variable
Al igual que en Solidity, necesitamos declarar una variable para poder utilizarla. En este ejemplo, la variable es un 'felt' llamado 'my_value_storage' donde, básicamente, podemos almacenar un número.
@storage_var
func my_value_storage() -> (my_value_storage: felt) {
}
Las variables de almacenamiento, de forma predeterminada, no son visibles en la ABI. Son similares a las variables "private" en Solidity.
Una variable de almacenamiento puede ser leída con 'var_name.read()' o escrita con 'var_name.write()'.
Función Getter
Cuando utilizamos variables, es una buena práctica declarar una función 'getter'. Entonces, ¡también podemos agregarlo!
Un getter es una función "view" que podemos llamar para ver la variable almacenada.
@view
func get_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
my_stored_value: felt
) {
let (my_stored_value) = my_value_storage.read();
return (my_stored_value,);
}
Por ejemplo, esta función puede ser llamada desde el explorador de StarkNet y mostrar el valor almacenado.
Función para Definir la Variable
Ahora que tenemos la variable declarada, ¿cómo la modificamos?
Podríamos configurarla automáticamente, cuando el contrato se despliegue usando un 'constructor' pero, para este tutorial, quiero crear una función para ella.
Esta es una función 'external' que puede ser llamada por otro contrato inteligente (o cartera), lo que nos permite modificar esa variable.
@external
func set_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
my_value: felt,
) {
my_value_storage.write(my_value);
return ();
}
Como mencionamos, en la función para establecer un valor almacenado, usamos my_value_storage.write(my_value), donde my_value es el argumento pasado a la función.
Contrato Inteligente Completo
Ahora que tenemos todas las partes separadas, podemos juntarlas. Aquí encontrarás el contrato inteligente completo, con algunos comentarios:
%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
// Almacenar una variable
// De forma predeterminada, las variables de almacenamiento no son visibles a través de la ABI. Son similares a las variables "privadas" de Solidity
// Esta variable es un felt y se llama my_value_storage
// En un contrato inteligente, se puede leer con my_value_storage.read() o escribir con my_value_storage.write()
@storage_var
func my_value_storage() -> (my_value_storage: felt) {
}
// Declarando getters
// Las variables públicas deben ser declaradas explícitamente con un getter
// Función para devolver el valor de la variable
@view
func get_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
my_stored_value: felt
) {
let (my_stored_value) = my_value_storage.read();
return (my_stored_value,);
}
// Establezca el valor de la variable
@external
func set_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
my_value: felt,
) {
my_value_storage.write(my_value);
return ();
}
Un Proyecto Protostar
Para este ejemplo, usaremos Protostar, uno de los frameworks de Starknet.
Lo primero, instala Protostar.
Toma en cuenta que Protostar solo es compatible con Linux y macOS.
Inicializar un Proyecto Protostar
Después de instalar Protostar, crearemos un proyecto usando el siguiente comando:
protostar init store-variable
Donde store-variable es el nombre del proyecto.
El resultado de ejecutar protostar init es un archivo de configuración llamado protostar.toml, archivos de ejemplo y los siguientes 3 directorios:
- src: Un directorio para tu código.
- lib: Un directorio estándar para dependencias externas.
- tests: Un directorio que almacena pruebas.
El archivo protostar.toml es el archivo de configuración donde especificamos la ruta para nuestros contratos. En este caso, ya tendrás un ejemplo de archivo cairo.main.
En este caso, generaremos un contrato llamado "main" a partir de nuestra carpeta "src".
["protostar.contracts"]
main = [
"src/main.cairo",
]
Simplemente elimina el código de ejemplo y pega el código de nuestro contrato inteligente.
Compila el contrato inteligente de Cairo
Hemos inicializado un proyecto Protostar y hay un contrato inteligente de Cairo en la carpeta src; estamos listos para compilar.
En el directorio principal del proyecto, ejecuta el siguiente comando para compilar.
protostar build
Recibirás un mensaje de éxito si el contrato se compila correctamente.
16:23:13 [INFO] Built the project successfully
16:23:14 [INFO] Execution time: 2.96 s
Después de compilar el contrato, notarás que hay un directorio "build" en el proyecto, donde podrás encontrar la ABI del contrato y el contrato compilado como "main.json".
Despliega el Contrato Inteligente en la Red de Pruebas de StarkNet
Después que el contrato inteligente haya sido compilado, finalmente podemos usar Protostar para desplegarlo en la red de pruebas de StarkNet.
Utiliza el siguiente comando para desplegar el contrato compilado.
protostar deploy ./build/main.json --network testnet
El resultado mostrará el hash de la transacción y la dirección del contrato, además proporcionará un enlace al contrato inteligente en el explorador Voyager.
[INFO] Deploy transaction was sent.
Contract address: 0x06a5ea9e42c921bd58e24b8da9d1fc91a488df0700b173f1c6bb0e453f68afec
Transaction hash: 0x1cbba90ba0d1fbfba09b1f7a0f987134dd9a02a845ca89244b3272374d37ede
https://goerli.voyager.online/contract/0x06a5ea9e42c921bd58e24b8da9d1fc91a488df0700b173f1c6bb0e453f68afec
Interactuar con el Contrato Desplegado
Ahora que el contrato inteligente ha sido desplegado en la red de pruebas de StarkNet, puedes utilizar el explorador Voyager para interactuar con él.
Si aún necesitas desplegar tu propio contrato, puedes utilizar el contrato inteligente que hemos desplegado.
Utiliza la pestaña "Read Contract" para llamar a la función "view" y ver el valor almacenado.
A continuación, puedes utilizar la pestaña "Write Contract" para llamar a la función "external" y modificar el valor.
Al escribir en un contrato, lo cual cambia el estado de la red, deberás autorizar la transacción. Recuerda conectar tu cartera al explorador Voyager y tener algo de ETH de prueba.
Puedes obtener algo de ETH Goerli en la L2 del grifo de StarkNet.
Conclusión
¡Felicitaciones por completar este tutorial! Hoy has aprendido a escribir y desplegar un contrato inteligente simple en Cairo.
No dudes en revisar nuestra serie "StarkNet Odyssey" para obtener más información sobre Cairo y otras herramientas de desarrollo disponibles.
- StarkNet - descripción general de las herramientas para desarrolladores y zk-rollups
- StarkNet Odyssey: escapando del infierno de Cairo
- Descubre cómo puedes ahorrar miles de dólares en costos de infraestructura cada mes con nuestros precios insuperables en la plataforma de desarrollo Web3 más completa.
- Ingresa tu carga de trabajo y comprueba cómo Chainstack es accesible en comparación con otros proveedores de RPC.
- Conéctate a Ethereum, Polygon, BNB Smart Chain, Avalanche, Arbitrum, Optimism, Oasis Sapphire, NEAR, Aurora, Solana, Polygon zkEVM, Aptos, Gnosis Chain, Cronos, Filecoin, Fantom, StarkNet, Harmony, Tezos y la red principal o red de pruebas de Fuse a través de la interfaz diseñada para ayudarte a realizar tu trabajo.
- Para obtener más información sobre Chainstack, visita nuestro Portal del Desarrollador o únete a nuestro servidor en Discord y al grupo de Telegram.
¿Has explorado lo que puedes lograr con Chainstack? Comienza hoy mismo de forma gratuita.
Artículo escrito por Davide Zambiasi. Traducido por Juliana Cabeza.
Discussion (0)