Sergio Martinez Marin

Posted on Mar 11

get set Hola mundo en Soroban😀

Hola a todos, el mundo es una caja de chocolates, no sabemos que sorpresas nos vamos a llevar . Pensaba hacer un tutorial de un okashi ( un editor online de contratos en Stellar), pero no funciona 🤷‍♂️, cuando vuelva a funcionar se hará un tutorial (marzo 7 de 2025 al momento de empezar este manual)

Dada esta eventualidad, vamos a empezar directo en el editor de facto que es Visual studio code.

Plugins en el editor vscode
1)

2)

let´s Code 🤠

Nos vamos a una ruta donde queramos crear nuestro proyecto y ponemos el siguiente comando:

stellar contract init get_set_helloworld --name get_set_message

obtenemos lo siguiente:

Como podemos observar el proyecto como tal se llama get_set_helloworld y en la carpeta contracts se creó una carpeta llamada get_set_message

Análisis del código generado

1 Declaración de No-Standard Library

#![no_std]

Esta directiva le indica al compilador que el contrato se compilará sin la biblioteca estándar de Rust. Esto con el fin de hacer lo más liviano posible.

2 Importación de Elementos del SDK

use soroban_sdk::{contract, contractimpl, vec, Env, String, Vec};

contract
Es un macro atributo que se aplica a una estructura para marcarla como el contenedor del contrato. Esto permite que el entorno de Soroban reconozca el contrato y genere la metadata necesaria.
contractimpl
Es otro macro atributo que se utiliza en el bloque impl para indicar que las funciones definidas en ese bloque serán exportadas y podrán ser invocadas desde el entorno de ejecución del contrato.
vec
Es un macro propio de Soroban que crea un vector (colección
dinámica) adaptado al entorno de contratos. Permite inicializar vectores de forma similar a vec! de Rust, pero considerando las particularidades del entorno.
Env
Es una estructura que representa el entorno en el que se ejecuta el contrato. A través de ella se accede a funciones esenciales como el almacenamiento, emisión de eventos, logs, etc.
String
Es una implementación propia del tipo cadena optimizada para entornos sin estándar (no_std) y adaptada a las limitaciones de ejecución de los contratos inteligentes en Soroban.
Vec
Es el tipo vector (colección dinámica) proporcionado por Soroban, similar al Vec estándar de Rust pero diseñado para trabajar de forma segura y eficiente en contratos inteligentes.

Definición del Contrato
#[contract]
pub struct Contract;

Implementación de las Funciones del Contrato
#[contractimpl]

impl Contract { pub fn hello(env: Env, to: String) -> Vec<String> { vec![&env, String::from_str(&env, "Hello"), to] } }

La anotación #[contractimpl]
sobre el bloque impl Contract indica que las funciones definidas serán expuestas para que puedan ser llamadas por el entorno de Soroban.
Función hello:

Firma:

pub fn hello(env: Env, to: String) -> Vec<String>
Recibe dos argumentos:
env: Env: El entorno de ejecución, que se usa para acceder a funcionalidades propias del runtime de Soroban.

to: String: Una cadena que se pasa como parámetro.
Retorna un Vec, es decir, un vector de cadenas.

Cuerpo de la función:

vec![&env, String::from_str(&env, "Hello"), to]

Se usa el macro vec! propio de Soroban para crear un vector.
Elementos del vector:

&env: Se pasa el entorno para que el macro pueda asignar memoria o gestionar la colección en el contexto de Soroban.
String::from_str(&env, "Hello"): Convierte el literal "Hello" en un objeto de tipo String propio de Soroban, usando el entorno env para la conversión.
to: Se agrega la cadena que se recibió como argumento.

Resultado: La función construye y retorna un vector que contiene
dos cadenas: la cadena literal "Hello" y la cadena proporcionada en el parámetro to.

Vamos modificar este código

Consideraciones

¿Para que necesitamos una estructura vector?: En lo ¡absoluto!, vamos a guardar un valor , con opciones de leer y escribir, no una disposición de varios valores.
pub fn hello: hasta luego función.

En conclusión borrón y cuenta nueva 🫠

#![no_std]
use soroban_sdk::{contract, contractimpl, Env, Symbol, symbol_short, String};

const MESSAGE: Symbol = symbol_short!("Message");

#[contract]
pub struct MessageContract;

#[contractimpl]
impl MessageContract {

    pub fn set_message(env: Env, message: String) {
                env.storage().instance().set(&MESSAGE, &message)
    }

    pub fn get_message(env: Env) -> String {
        env.storage().instance().get(&MESSAGE)
            .unwrap_or(String::from_str(&env, "Default Message"))
    }

}

Análisis del código:

Importaciones del SDK de Soroban

use soroban_sdk::{contract, contractimpl, Env, Symbol, symbol_short, String};

Symbol y symbol_short:
Se usan para trabajar con identificadores cortos y
optimizados en el entorno de Soroban.
- Symbol Es un string de 32 caracteres, viene ocupa 64 bit (a-z A-Z 0-9)
- symbol_short! Es un string de 9 caracteres (a-z A-Z 0- 9)
String:

Es una versión adaptada del tipo cadena de texto para el entorno sin estándar (no_std) y específicamente optimizada para contratos inteligentes en Soroban.

Definición de una Constante
const MESSAGE: Symbol = symbol_short!("Message");

Función set_message
pub fn set_message(env: Env, message: String)
Recibe dos parámetros:

env: Env: Permite acceder a funcionalidades del entorno, en especial al almacenamiento.
message: String: La cadena que se desea almacenar.

env.storage().instance().set(&MESSAGE, &message)

usamos la constante MESSAGE como identificador único y el contenido de la variable message que viene como parámetro de la función para guardar en la cadena de bloques ese valor.

Función get_message

pub fn get_message(env: Env) -> String
Recibe el entorno (env) y retorna una cadena (String).

env.storage().instance().get(&MESSAGE) .unwrap_or(String::from_str(&env, "Default Message"))

Se intenta obtener el valor almacenado bajo la clave MESSAGE.
Si la clave no existe (es decir, no se ha establecido ningún mensaje), se utiliza unwrap_or para retornar un valor por defecto: se crea un String con el contenido "Default Message" usando String::from_str.

Compilación del contrato
la compilación y creación del webassembly es con el siguiente comando:
stellar contract build

cómo podemos ver dentro de la carpeta target, tenemos generado el archivo .wasm ( web assembly), listo para desplegar en la testnet 🙂

Despliegue en la testnet

Mac/Linux

stellar contract deploy \
  --wasm target/wasm32-unknown-unknown/release/get_set_message.wasm \
  --source developer \
  --network testnet \
  --alias get_set_message

Windows

stellar contract deploy `
  --wasm target/wasm32-unknown-unknown/release/get_set_message.wasm `
  --source developer `
  --network testnet `
  --alias get_set_message

Obtenemos lo siguiente:

Si vemos con atención en lo generado tenemos la ruta de la transacción y del contrato desplegado

Si pulsamos la techa mayuscula y click en la ruta del contrato desplegado se abre el explorador de bloques de stellar en nuestro contrato desplegado.

En la parte inferior accedemos a interfaces para ver las funciones públicas del contrato

Probando el contrato desplegado

Abrimos la consola y ejecutamos

Mac/Linux

stellar contract invoke \
  --id CAO3OLO2MZJNNTL2DP5ARDDDMLORXYA3BP4QIMKK3TFASGGSNG36S7F4 \
  --source developer \
  --network testnet \
  -- \
  set_message \
  --message "Hey master developer 😉"

Windows

stellar contract invoke `
  --id CAO3OLO2MZJNNTL2DP5ARDDDMLORXYA3BP4QIMKK3TFASGGSNG36S7F4 `
  --source developer `
  --network testnet `
  -- `
  set_message `
  --message "Hey master developer 😉"

Obtenemos lo siguiente:

Mac/Linux

stellar contract invoke \
  --id CAO3OLO2MZJNNTL2DP5ARDDDMLORXYA3BP4QIMKK3TFASGGSNG36S7F4 \
  --source developer \
  --network testnet \
  -- \
  get_message \

Windows

stellar contract invoke `
  --id CAO3OLO2MZJNNTL2DP5ARDDDMLORXYA3BP4QIMKK3TFASGGSNG36S7F4 `
  --source developer `
  --network testnet `
  -- `
  get_message `

Obtenemos lo siguiente: