DEV Community: Sergio Martinez Marin

get set Hola mundo en Soroban😀

Sergio Martinez Marin — Tue, 11 Mar 2025 20:58:57 +0000

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)

Nota 18 de Marzo de 2025
okashi lo van a dar de baja. Ojalá haya un sucesor, porque son herramientas muy útiles.

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:

Como puedes ver, hasta con emojis los mensajes 😉.

Más adelante empezaremos a analizar a fondo la soroban_sdk y hacer ejercicios con las estructuras y tipos de datos que ofrece.

Segundos pasos con el cliente de Stellar

Sergio Martinez Marin — Thu, 27 Feb 2025 15:50:42 +0000

Hola a todos 😀

En el pasado tutorial vimos lo básico del cliente de Stellar, ahora vamos a entrar un poco más en profundidad.
Temario:

Creación de un contrato.
Compilación del contrato.
Despliegue.
Ejecución del contrato.

🚨En este tutorial no vamos a entrar en los detalles del contrato como tal, únicamente en cómo se usa el cliente de Stellar.
En posteriores tutoriales, si se entrará al detalle de los contratos.

Creación de un contrato
Syntaxis:
stellar contract init "nombre_contrato"

stellar contract init hola_mundo

Estructura y archivos creados

Dentro de lib.rs está el contrato por defecto

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

#[contract]
pub struct Contract;

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

mod test;

Compilación del contrato
Se ejecuta el siguiente comando:
stellar contract build

Podemos ver que se creo una carpeta llamada release, más internamente vemos que está creado el archivo hello_world.wasm

💡el nombre del archivos en web assembly es el que automáticamente se pone dentro del archivo Cargo.toml

Despliegue del contrato
Mac/linux
stellar contract deploy \
--wasm target/wasm32-unknown-unknown/release/hello_world.wasm \
--source developer \
--network testnet \
--alias hello_world

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

Felicidades, ya tienes el contratro deplegado en testnet 🥳

https://stellar.expert/explorer/testnet/contract/CDCIWIAOWCDIORMZWV53VY5DVLOGB5PWG4ETSAEKKHX43RZVSPYUSLRS?filter=history

Interactuando con los contratos
Sintaxis
stellar contract invoke --id "contrato" --source "identidad" --network testnet -- "función" --"parametro" "dato del parámetro"

Linux y MAC
stellar contract invoke \
--id CDCIWIAOWCDIORMZWV53VY5DVLOGB5PWG4ETSAEKKHX43RZVSPYUSLRS \
--source developer \
--network testnet \
-- \
hello \
--to Pascual

Windows
stellar contract invoke --id CDCIWIAOWCDIORMZWV53VY5DVLOGB5PWG4ETSAEKKHX43RZVSPYUSLRS
--source developer --network testnet
-- hello
--to Manolo

El resultado es:

Como has podido ver las interacciones básicas con el cliente de stellar son sumamente sencillas 🙂.

Más adelante entraremos en terrenos más interesantes, como es la sintaxis, tipos de datos, estructuras y control de flujo en Soroban. Que por fortuna como se maneja, son un conjunto de liberias en Rust. Entonces el enfasis está en Rust como tal, más algunas consideraciones propias de la cadena.

Hasta la próxima 🤓

Primeros pasos con el cliente de Stellar

Sergio Martinez Marin — Wed, 26 Feb 2025 22:18:36 +0000

🚀 Tutorial: Stellar CLI
¿Qué es Stellar CLI?
El Stellar CLI (Command Line Interface) es una herramienta oficial de la Fundación Stellar para interactuar con la red Stellar y su ecosistema de contratos inteligentes (Soroban). Es una aplicación de línea de comandos que permite a desarrolladores y usuarios avanzados realizar operaciones como:

Crear y gestionar cuentas.
Enviar y recibir pagos.
Desplegar e interactuar con contratos inteligentes.
Simular y probar transacciones en un entorno local.
Conectar con redes como Testnet y Mainnet.

Para instalarlo seguir los pasos aquí

Ver las redes disponibles
stellar network ls

Por defecto están las redes que necesitamos.
Si necesita adicionar una red , hacer click aquí

Generación de una nueva identidad
La identidad es un alias , que nos sirve para manejar la cuenta generada de una forma mucho más sencilla.

Para este caso por ejemplo vamos a generar una identidad llamada developer , ya dejemos descanzar a Bob y Alice 😅

stellar keys generate --global developer --network testnet

Para este caso generamos una identidad global llamada developer en la red de testnet.

Al abrir el archivo generado vemos que es un contenedor de una frase semilla

más info del comando

LLave publica de la identidad:
Para saber cual es la llave pública de una identidad corremos el siguiente comando:
stellar keys address developer

Saldo de la cuenta
hay 2 formas por web o por comandos

El modo sencillo, explorador web
ingresamos la dirección en esta dirección https://stellar.expert/explorer/testnet

Acá vemos que la cuenta viene con 10.000 lumens, lo suficiente para seguir con los ejercicios

Para los amantes de la consola. 😉

Averiguamos en testnet cual es el id de XLM stellar contract id asset --asset native --network testnet
obtenemos esta respuesta: CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC
Obtenemos la llave pública de la identidad developer
stellar keys address developer
obtenemos:
GD45T2VRMYBSGRHLMVTS4QQZVXAM7WD6IYWKYRS7DFURRR2EKWCNGOAN
Ejecutamos los siguiente:
Sintaxis:
stellar contract invoke --id "dirección XLM" --network testnet --source-account developer -- balance --id "llave pública developer"

Escribimos lo siguiente:
stellar contract invoke --id CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC --network testnet --source-account developer -- balance --id GD45T2VRMYBSGRHLMVTS4QQZVXAM7WD6IYWKYRS7DFURRR2EKWCNGOAN

La respuesta es:

Pasar fondos de una billetera a otra

Vamos a pasar 100 XLM de la cuenta developer a developer1.

Sintaxis:

stellar contract invoke --id <asset_contract_ID> --networdk testnet --source-account developer -- transfer --to <developer1_ID> --from developer --amount 100

Como es de observar no hemos creado la identidad developer1 por lo tanto ejecutamos:
stellar keys generate --global developer1 --network testnet
stellar keys address developer1
obtenemos la siguiente llave pública :
GCETVOMJKZ5OPTBIWBADL2PT6DTL7VPZMS5P4MIAYSINZYH5IIZRE27U

Ahora que tenemos todos los datos ejecutamos:
stellar contract invoke --id CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC --network testnet --source-account developer -- transfer --to GCETVOMJKZ5OPTBIWBADL2PT6DTL7VPZMS5P4MIAYSINZYH5IIZRE27U --from developer --amount 1000000000

Obtenemos lo siguiente:

En un próximo tutorial usaremos el cliente de Stellar para crear un contrato, desplegarlo y ejecutarlo, todo con el cliente de estellar, como podrán sospechar el famoso "hola mundo" 🤗.

Instalación entorno desarrollo Stellar 😎

Sergio Martinez Marin — Wed, 26 Feb 2025 14:34:27 +0000

Stellar es una veterana cadena de bloques que sigue evolucionando.

Como siempre fiel a su filosofía, ahora viene con contratos inteligentes en el lenguaje Soroban 🤓.

Para el desarrollo de contratos y dapps, debemos pensar en 2 partes.
Primero la parte web (nodejs) y luego la parte de contratos ( lenguaje Rust 🦀)

Instalación de parte web (nodejs)

NVM Node version manager:
Para una instalación más cómoda, instalamos este programa que nos permite una instalación y desistaación de las versionas de nodejs de una manera simple

Respositorio e instrucciones para Mac y Linux
https://github.com/nvm-sh/nvm

Repositorio e instrcciones para Windows
https://github.com/coreybutler/nvm-windows/releases

Una vez instalado, abrimos la consola y ejecutamos el comando:
nvm

Si vemos la lista de comandos de este programa, ya estamos listos para instalar nodejs

Instalación de NodeJS
Se abre la terminal y ejecutamos:
nvm install 22.14.0
Favir consultar la última versión LTS de NodeJS acá

Listo, ya tenemos la parte web con nodejs

Instalación soporte contratos (rust y estellar client)

Para la instalación de rust, dirigirse a este enlace:
https://www.rust-lang.org/es/tools/install

Sistemas linux:
Abrir la consola y seguir los siguientes pasos:

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

Allí elegimos la opción 1 ( instalación estandar)

Para las compilaciones, tener todo instalado algunas librerias importantes adicionales. sudo apt install build-essential

Sistemas Windows

Descargar el ejecutable, se 32 o 64 bits, según la necesidad requerida
Descargar los pre requisitos (Rust Visual C++ prerequisites), elegir la opción 1.

Elegir la opción 1

🚨 Para todos los sistemas ejecutamos lo siguiente:

rustup toolchain install stable-x86_64-pc-windows-gnu
rustup default stable-x86_64-pc-windows-gnu
rustup target add wasm32-unknown-unknown

Finalmene en la consola ponemos rustc -V para ver la versión que hemos instalado de Rust

Cliente de Stellar
Para mac y linux ( en la terminal):
brew install stellar-cli
Para Windows ( en la terminal)
winget install --id Stellar.StellarCLI --version 22.2.0

Una vez instalado en la terminal ejecutamos el comando stellar
( en la terminal)

Felicidades, ya tienes casi todo lo indispensable para empezar a desarrodar en Stellar 🤠

Analizando el "Hola mundo" en NEAR Contrato y Frontend 🤠

Sergio Martinez Marin — Mon, 01 Jul 2024 03:54:31 +0000

Primeros pasos contratos inteligentes con NEAR
Hola a todos, anteriormente habíamos analizado los pasos básicos del cliente de NEAR basado en RUST. Cliente rust. El día de hoy vamos dar los primeros pasos en los contratos inteligentes en NEAR.

Los contratos en NEAR tradicionalmente se han hecho en el lenguaje RUST, afortunadamente han tenido la buena idea de optar por usar librerías de RUST y no han creado ningún lenguaje único y propietario de NEAR, por lo tanto las personas que manejan RUST escribir contratos inteligentes va a ser algo poco complejo.

Lamentablemente RUST a pesar de ser el lenguaje más “amado 😍” su sintaxis no es en lo absoluto similar a lenguajes como C. C++, C#, JAVA, Javascript, Python, etc…lo cual requiere ponerle amor y dedicación a este lenguaje, ya que es un lenguaje que definitivamente es el presente y futuro en soluciones blockchain.

Por fortuna al generar los contratos inteligentes en NEAR, se genera un WebAssembly, y es por ello que el equipo de NEAR también ha pensado en lenguajes más populares para generar este mismo WebAssembly como lo es JavaScript, el cual es muy conocido, popular y ampliamente usado. Este artículo mostrará como se basará en generación de contratos mediante JavaScript.

Su majestad Webassembly al rescate!

Prerequisitos:

Para los usuarios de Windows , si o si, por el momento hay que usar WSL, en el cliente NEAR y la instalación de NodeJS

1) Instalación del cliente de NEAR ( mejor el de RUST)
2) Instalación de NodeJS

Para el paso 2, es más práctico usar NVM : Node Version Manager
Para instalar el nvm vamos al link oficial de este proyecto
https://github.com/nvm-sh/nvm

Una ves instalado el NVM vamos a https://nodejs.org/en y vemos la última versión LTS ( al día de este artículo es la versión 20.14.0), procedemos a instalarla de la siguiente manera:
nvm install 20.14.0

Ahora vamos a empezar con el clásico Hola mundo

En la terminal escribimos

npx create-near-app@latest

Seleccionamos A Smart Contract

Seleccionamos sobre que lenguaje deseamos trabajar, para este caso en JS/TS

Le damos un nombre al proyecto:

Ponemos la opción “Y” para instalar el sdk de NEAR

Listo , ya tenemos creado el ambiente para crear contratos en NEAR 😊

Ingresamos al directorio hola mundo con el comando :

 cd hola-mundo

y allí escribimos: code .

Análisis del contrato hola mundo

import { NearBindgen, near, call, view } from 'near-sdk-js';

NearBindgen Es el decorador de facto que se usa al empezar todos los contratos en NEAR.
Near: tiene las primitivas de envío de fondos, altura del bloque, y logs, entre otros
call: Llamado a métodos del contrato que cambian estados del contrato ( escritura) y poseen un coste asociado a la operación
view: Llamado a métodos del contrato de sólo lectura.

greeting: string = 'Hello';

Atributo de clase tipo string , lo clásico de un hola mundo con clases.

@view({}) // This method is read-only and can be called for free
  get_greeting(): string {
    return this.greeting;
  }

Tenemos el decorador que es una función de sólo lectura y su implementación no tiene alguna particularidad diferente al estándar de typescript.

@call({}) // This method changes the state, for which it cost gas
  set_greeting({ greeting }: { greeting: string }): void {
    near.log(`Saving greeting ${greeting}`);
    this.greeting = greeting;
  }

Tenemos el decorador que es una operación de escritura.
Como particularidad en los parámetros, difiere un poco a como se usan los parámetros en una función normal donde sólo sería (greeting:string):void y en la parte izquierda se ponen los parámetros y en la derecha se especifican su tipo.
Algo muy interesante es que podemos guardar los logs en la blockchain, siempre y cuando sean muy relevantes, ya que tienen un costo asociado.

Compilación del contrato
Ejecutamos el comando:

npm run build

Si somos observadores, vemos que se ha creado una carpeta llamada build con un código en WebAssembly.

Creación de subcuentas

A diferencia de las EVM, donde un contrato es un ente autónomo donde una billetera (address) paga un fee por su despliegue y nada más, en NEAR los contratos se asocian a una dirección.
Por ello lo más común es crear algo llamado subcuentas, una subcuenta aplica lo mismo que los domnios y subdominios de internet.
EJ: neacolombiadev.testnet es la cuenta principal ( dominio)
Una subcuenta para este ejemplo seria holamundo.nearcolombiadev.testnet
No hay limite de subcuentas, entonces no tendríamos problema con el despliegue de contatos.
Para crear una subcuenta entramos al cliete de near y ponemos la opción de account

Ponemos la opción de create-account

Opción fund-myself

Ponemos el nombre de la subcuenta:

Ponemos la verificación que la subcuenta no exista

Indicamos la cantidad de near con que deseamos darle fondos a la cuenta:

Elegimos la opción de generar la llave automáticamente.

Ponemos la opción de grabar en el sistema legacy

Elegimos opción de testnet

Seleccionamos sign-with-key-chain

Finalmente la opción de de send

En el explorador de bloques vemos nuestra subcuenta creada exitosamente

En la cuenta de nearcolombiadev.testnet teníamos 10 NEAR, menos el conste de la creación de la subcuenta y fondeo , podemos ver el nuevo saldo:

Despliegue del contrato

Si por alguna razón nos quedamos sin fondos, podemos ir a la faucet de near:
https://near-faucet.io/

Por la terminal ingresamos al cliente de near y seleccionamos la opción de contrato.

Seleccionamos deploy

Elegimos la cuenta con la que queremos hacer el deploy, en este caso holamundo.colombiadev.testnet

Ponemos la ruta del contrato compilado: ./build/hello_near.wasm

Ponemos la opción without-init-call: el init call es el “constructor” de la clase y se pueden poner parámetros”

Elegimos que va para testnet

Opción sign-with-keychain

Finalmente en send

Si todo sale exitoso: vamos al nuevo explorador de bloques

https://testnet.nearblocks.io/
Allí ponemos la subcuenta que creamos anteriormente: holamundo.nearcolombiadev.testnet

En el explorador de bloques vemos la transacción de despliegue de contratos y podemos ver los métodos del contrato por la opción contract

Click en contract methods

Cómo interactuar con el contrato

Lo podemos hacer por el cliente de near o por la página https://testnet.nearblocks.io/
Empecemos de la forma fácil y visual, por nearblocks! 😉
Primero debemos ingresar por sign in

Seleccionamos la billetera:

En nuestro caso particular tenemos la cuenta asociada con meteorWallet

Super importante la pantalla siguiente: sólo autorizamos a saber billeteras y saldos, pero no a realizar transacciones o firmar transacciones a nombre de nosotros!

A continuación vamos a poner la dirección donde tenemos el contrato:
holamundodev.testnet

Entramos por la parte de contrato:

Seleccionamos contract methods

Verificamos que estemos conectados.

Llamado de lectura get_greeting

Desplegamos get_greeting y click en query

Acá observamos el contenido de la variable greeting del contato

Llamado de escritura: set_greeting
Ampliamos set_greeting, click en add en arguments, el parámetro se llama greeting y es tipo string, Ponemos el valor deseado y click en write

Damos click en confirmar

A continuación sale el fee que se va a gastar y le damos aprobar a la billetera

Para confirmar el nuevo valor podemos usar el método get_greeting

Ahora hagámoslo con el cliente de near , ( para los amantes de la consola 😎)
Llamado de lectura get_greeting
1) Por terminal ponemos near
2) Seleccionamos contract
3) Call-function
4) As-read-only
5) Seleccionamos la cuenta holamundo.nearcolombiadev.testnet
6) Ponemos que la función es: get_greeting
7) Seleccionamos que los parámetros son json-args
8) Como no hay parámetros escribimos {}
9) Seleccionamos que está en testnet
10) Finalmente ponemos que lo queremos realizar con la altura del bloque actual

Llamado de escritura: set_greeting
1) Llamamos a termnial el programa de near
2) Opción contract
3) Opción Call-function
4) Opción as-transaction
5) Opción holamundo.nearcolombiadev.testnet
6) La función es : set_greeting
7) Opción json-args
8) Escriibimos el parámetro en formato json {"greeting":"Hola desde la consola 😍"}
9) Dejamos por defecto el valor sugerido de la aplicación del gas a pagar
10) No hay desposito, entonces lo dejamos en 0NEAR
11) Seleccionamos desde que cuenta lo queremos firmar, para este caso desde nearcolombiadev.testnet
12) Opción testnet
13) Opción sign-with-keychain
14) Finalmente en send

Podemos repetir desde consola para ver el valor nuevo en la variable del contrato

Y donde dejamos a near.log del contato?

Esta opción se graba por cada transacción, en este caso al revisar la última transacción de escritura
https://testnet.nearblocks.io/en/txns/7HKTJGu5AVYoXL9ccWLx5SN8j6mNqXzrmzstCpm2Dxm7?tab=execution

Podemos ver claramente donde se guardan los logs. Estos deben ser bien pensados, que sea algo relevante con fines de auditoria, seguimiento o información relevante.

Ahora vamos a realizar la parte web. Near de por si crea toda la app por defecto del “hola mundo”, esto implica contrato y conexión a la billetera, pero obviamente otro contrato y no el de nosotros, así también apenas tiene conexiones por defecto a HereWallet y MyNear Wallet.

Primeros pasos:
En la terminal escribimos

npx create-near-app@latest

Elegimos que es una Web app
Esta para Next-JS, por convenciones más actualizadas, seleccionamos ( App-Router)

Seleccionamos que no queremos componentes BOS

Para este ejemplo ponemos de nombre del proyecto: hello-near-web

Finalmente ponemos en Y que deseamos instalar los módulos necesarios para poder ejecutar.

Puedes ejecutar el programa tal cual está, pero, hagámosle unas adaptaciones 👨‍🔧

Nos ubicamos en el directorio generado hello-near-web y abrimos el visual studio code o editor favorito.

En config.js vemos que tenemos las subcuentas donde tenemos alojado el contrato.
Cómo estamos ejecutando todo el tutorial en testnet, reemplazamos la subcuenta holamundo.nearcolombiadev.testnet

Abrimos la carpeta wallets y abrimos el archivo near.js

Como podemos observar sólo hay 2 billeteras instaladas, para que el usuario elija, estas son HereWallet y MyNearWallet

Para añadir más billeteras entramos al buscardor de paquetes Para añadir más billeteras entramos al buscardor de paquetes https://www.npmjs.com/

Allí ponemos en la búsqueda lo siguiente: _ @near-wallet-selector_.

Aparecen más billeteras, sólo es instalar las billeteras que deseamos incluir en la lista de billeteras que el usuario desee elegir.

Para nuestro caso vamos a incluir la billetera meteor

Ingresamos a este link: https://www.npmjs.com/package/@near-wallet-selector/meteor-wallet Y seguimos las instrucciones para su instalación.
npm install @near-wallet-selector/meteor-wallet

Luego incluimos el import del instructivo

import { setupMeteorWallet } from "@near-wallet-selector/meteor-wallet";

Finalmente incluimos setupMeteorWallet en la parte de modules

Si no eres análitico y no deseas ir a fondo eso es todo, ya puede ejecutar el front 😆

Y donde se invocan los métodos de lectura y escritura del contrato?

Dentro de la carpeta app/hello-near está el archivo page.js

Función de lectura:
Acá vemos que al empezar el user effect llamamos el llamado al método tipo de lectura “ViewMethod” con parámetos del contrato y su respectivo método

Si sómos analíticos, vemos que el objeto wallet está dentro del context.js

El objeto wallet no pertenece a la el sdk de near, es algo generardo localmente.

La clase Wallet nos crea una capa de abstracción para usarlo más facilmente los llamados al SDK de near en operaciones de lectura y escritura.

En el llamado vemos que si tenemos un RPC (proveedor de servicio), donde se va la cuenta , para este caso hola-mundo.nearcolombiadev.testnet, el método get_greeting y sin ningún parámeto {}

Función de escritura:
Volviendo a page.js dentro de la carpeta _hello-nea_r,se invoca la escritura y luego la parte de lectura para reflejar el cambio.

En near.js dentro del directorio wallet, vemos que no se interactúa con un RPC, se interactúa con la billetera que hayamos seleccionado al hacer login, y se hace la operación firmándola y enviando la transacción.

Ahora si, vamos a correr esta aplicación:

npm run dev

Le damos click en near integration

Ya podemos ver el método de lectura de contrato

Si damos click en login vemos que ya incorpora la billetera de Meteor

Y ya estamos en la capacidad de grabar un nuevo saludo.

Bueno, esperamos que haya quedado un poco claro cómo funcionan estos contratos y su parte web.

La base que deja NEAR con viewMethod y callMethod en near.js prácticamente los podemos usar para nuestros propios llamados a los métodos de cualquier contrato en la parte web.
Hasta la próxima 🤗.

Código fuente: github

Primeros pasos con cliente de NEAR escrito en RUST NEAR-CLI-RS 😎

Sergio Martinez Marin — Mon, 01 Jul 2024 00:25:28 +0000

En el mundo de las programación es muy importante contar con una herramienta que nos facilite en extremo operaciones del día como son:

Creación de cuentas: Mainnet y Testnet.
Creación de subcuentas; Mainnet y Testnet.
Transferencia de tokens: Fungibles y no fungibles.
Desplegar contratos: Mainnet y Testnet.
Ejecución de los métodos de los contratos: Métodos de lectura y métodos de escritura.

En NEAR tradicionalmente esto se hacía con el near-cli basado en Nodejs, pero NEAR pensando en hacer la vida más fácil a los dev ha sacado esta herramienta basada en RUST, lo cual la convierte en una herramienta más potente y eficiente 🤗.

Link de descarga: https://near.cli.rs/

Por ahora este link hace una redirección al respositorio de código de github: https://github.com/near/near-cli-rs

Descarga e instalación:

A la fecha del artículo relativamente hace poco salió una actualización del cliente con la versión 0.10.2, cuando lo vayan a bajar click en el último reléase para que bajen el cliente más actualizado.
La forma más sencilla es bajando los binarios precompilados:
Instalación en Linux y mac:
Ejecutar el comando:

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/download/v0.10.2/near-cli-rs-installer.sh | sh

Instalación en Windows:
Ejecutar el comando:

irm https://github.com/near/near-cli-rs/releases/download/v0.10.2/near-cli-rs-installer.ps1 | iex

A diferencia del cliente tradicional de near escrito en nodejs que por la dependencia de módulos puede ser muy grande este sólo ocupa 20 megas.

Manejo básico de cliente
Se escribe en consola el comando:

near

Como podemos observar a diferencia del cliente tradicional, este es mucho intuitivo y nos muestra que opciones tenemos, prácticamente es elegir que opción deseamos usar y seguir un paso a paso.

Creación de cuentas:

Seleccionamos la opción account y enter

Seleccionamos la opción create-account y enter

Se puede dar la opción de sponsor-by-faucert-service o fund-myself, esto con el fin de poder crear una cuenta con un nombre memotectnico como nearcolombia.testnet y no un código hexadecimal de muy difícil memorización.

Para este caso elegimos que nos de fondos de la faucet

Ponemos el nombre de la cuenta que deseamos crear, en este caso nearcolombiadev.testnet

Si no estamos seguros elegimos que nos verifique si esta cuenta no existe

Ponemos que las llaves las genere automáticamente

Elegimos la primera opción a no ser que se quiera guardar una compatibilidad con el cliente de Nodejs y se pone la segunda opción.

En este caso elegimos testnet

Aparece un resumen de lo que vamos a realizar y se procede con la opción créate.

Finalmente se crea la cuenta, aparece el link de la transacción y como se puede crear la cuenta con una instrucción completa y sin paso a paso.

Al entrar al link de la transacción verificamos que todo está creado correctamente.

Cómo ver el saldo de una cuenta

Entramos a near, opción de cuentas->view-account-summary-> ponemos la cuenta que queremos ver->si de es de testnet o mainnet->la altura del bloque o en el último bloque.

En conclusión el nuevo cliente cumple a cabalidad las necesidades que se necesitan día a día como desarrollador y es sumamente intuitivo.

Sólo es seguir las instrucciones paso a paso para hacer lo que necesitamos sin tener que memorizar ningún comando en especial.

Primeras aventuras en sway

Sergio Martinez Marin — Mon, 03 Apr 2023 22:12:15 +0000

Hola a todos:

Después de pasar por mi primera hackathon en modalidad física, me llevo muchas alegrías de ver una plataforma que promete mucho. Esta plataforma se llama Fuel.

Para no hechar una historia larga, se trata de una blockchain modular y está especializada en la capa de ejecución, esto quiere decir que esta capa de ejecución es una alternativa a todas las L2 que hay en sistemas etherum y puede estar en otras blockchain :)

Fuel network maneja su propia maquina virtual y lenguaje, y esto es algo positivo ya que solidity no ha podido dar avances más agresivos en su evolución como lenguaje por cuidar la retrocompatibilidad.

El lenguaje se llama sway, inspirado en Rust, diría que muy similar a rust, lo cual es tendencia ahora en las nuevas generaciones de soluciones de blockchain con todos sus beneficios y complejidades que esto implica.

A continuación vamos a realizar nuestro primer ejercicio paso a paso, desde un contrato básico, hasta llevarlo a interactuar con una interfaz web.

Antes que todo este tutorial se basa en este código
código fuente original:

https://github.com/FuelLabs/quickstart

La instalación:

funciona para cualquier solución linux compatible, Linux, mac y Windows( bajo wsl2)
Se baja y ejecuta esta instrucción

curl --proto '=https' --tlsv1.2 -sSf https://install.fuel.network/fuelup-init.sh | sh

Instrucciones completas acá:

https://install.fuel.network/master/installation/index.html

creamos un directorio, y dentro de este directorio ejecutamos la siguiente instrucción

forc new countersm

entramos al directorio countersm/src y cambiamos el código de main.sw por el siguiente código:

contract;

storage {
    counter: u64 = 0,
}

abi Counter {
    #[storage(read, write)]
    fn increment();

    #[storage(read)]
    fn count() -> u64;
}

impl Counter for Contract {
    #[storage(read)]
    fn count() -> u64 {
        storage.counter
    }

    #[storage(read, write)]
    fn increment() {
        storage.counter = storage.counter + 1;
    }
}

Storage
Estructuras "globales" y de acceso a todo el contrato.

abixxx
Definiciones genéricas de todas las funciones

impl xxx for Contract
Implementación del abi

Que nos obliguen a tener una estructura clara, nos da orden en el código :)

Nota: para el diario transcurrir, se recomienda editar el código con VS-code más la extensión de sway

En este caso,estoy corriendo el vs-code en windows y todo el sway en ubuntu 22.04 LTS desde WSL 🤓

Esta extensión nos advierte si tenemos algún error en nuestra codificación.

Una vez tenemos el código, en la consola de linux o mac compilamos el programa.

forc compile

Una vez tenemos listo nuestro código vamos a desplegarlo, pero........vamos a desplegarlo localmente, esto con el fin de tener una experiencia más agradable.

fuel-core run --ip 127.0.0.1 --port 4000

Acá tenemos billeteras generadas con fondos, entonces nos ahorramos crear la billetera y ponerle fondos, esto es muy útil cuando estamos haciendo desarrollos internos, luego si desplegamos en la testnet.

Como paso final de la parte de contratos vamos a deplegar el contrato en la red local ubicados dentro de la carpeta raiz de los contratos
forc deploy --unsigned

Creando la aplicación web
Como es una aplicación react, debemos tener instalado nodejs

https://nodejs.org/en

Nota:
Se intentó crear la aplicación web por NextJS, por Deno, o simplemente en consola, pero explota por un error en una libreria
https://www.npmjs.com/package/elliptic , la cual no permite hacer el uso de import o exports.

Para tener la interacción web-fuelnetwork, se usa la librería fuels, que es de typescript.

En este ejercicio vamos a usar vite, ya que no se recomienda usar create-react-app.

npm create vite@latest React Typescript+SWC

Ahora vamos al directorio web y ejecutamos npm install e instalamos la libería de fuels
npm install fuels

Después de instalar la libería fuels, vamos a mirar que al compilar con forc build se generó el abi en estructura json.

El código abi está generado en la siguiente carpeta

Si abrimos el archivo countersm-abi.json, vemos lo siguiente

{
  "types": [
    {
      "typeId": 0,
      "type": "()",
      "components": [],
      "typeParameters": null
    },
    {
      "typeId": 1,
      "type": "u64",
      "components": null,
      "typeParameters": null
    }
  ],
  "functions": [
    {
      "inputs": [],
      "name": "count",
      "output": {
        "name": "",
        "type": 1,
        "typeArguments": null
      },
      "attributes": [
        {
          "name": "storage",
          "arguments": [
            "read"
          ]
        }
      ]
    },
    {
      "inputs": [],
      "name": "increment",
      "output": {
        "name": "",
        "type": 0,
        "typeArguments": null
      },
      "attributes": [
        {
          "name": "storage",
          "arguments": [
            "read",
            "write"
          ]
        }
      ]
    }
  ],
  "loggedTypes": [],
  "messagesTypes": [],
  "configurables": []

Nos ubicamos dentro de la carpeta web y ejecutamos el siguiente comando:

npx fuels typegen -i ../countersm/out/debug/*-abi.json -o ./src/types --contract

Con esto dejamos el abi listo para usar en web, pasamos el json a algo typescript!

En visual studio code, vamos modificar el archivo app.tsx y alteramos la funcionalidad del botón.

ponemos el siguiente código, lo que es contrato y llave secreta se cambia a sus datos respectivos.


import reactLogo from './assets/react.svg'
import viteLogo from '/vite.svg'
import './App.css'
import { useEffect, useState } from "react";
import "./App.css";
//Liberria para cargar la wallet
import { Wallet } from "fuels";
// Import the contract factory -- you can find the name in index.ts.
// You can also do command + space and the compiler will suggest the correct name.
//Generado npx fuels typegen -i ../countersm/out/debug/*-abi.json -o ./src/types --contract
import { CountersmAbi__factory } from "./types/factories/CountersmAbi__factory";

// The address of the contract deployed the Fuel testnet
//dato obtenido al desplegar el contrato localmente forc deploy --unsigned
const CONTRACT_ID =
  "0x3edb96c23766b8504caaff042994efa18460e7ba27f60191394a6bcf5be8d7d8";

//the private key from createWallet.js
//billetera generada al ejecutar el nodo localmente en memoria fuel-core run --ip 127.0.0.1 --port 4000
const WALLET_SECRET =
  "0x37fa81c84ccd547c30c176b118d5cb892bdb113e8e80141f266519422ef9eefd";

// Create a Wallet from given secretKey in this case
// The one we configured at the chainConfig.json
//el segundo parámetro es el provider, en este caso es local
const wallet = Wallet.fromPrivateKey(
  WALLET_SECRET, "http://127.0.01:4000/graphql"
);

// Connects out Contract instance to the deployed contract
// address using the given wallet.
const contract = CountersmAbi__factory.connect(CONTRACT_ID, wallet);


function App() {
  const [count, setCount] = useState(0)

  //función que hace incrementa en 1 y luego trae el valor de la blockchain local!! :)
  async function fuel_power(){
    await contract.functions.increment().txParams({ gasPrice: 1 }).call();
    const { value } = await contract.functions.count().get();
    setCount(Number(value));
  }

  return (
    <div className="App">
      <div>
        <a href="https://vitejs.dev" target="_blank">
          <img src={viteLogo} className="logo" alt="Vite logo" />
        </a>
        <a href="https://reactjs.org" target="_blank">
          <img src={reactLogo} className="logo react" alt="React logo" />
        </a>
      </div>
      <h1>Vite + React</h1>
      <div className="card">
        <button onClick={fuel_power}>
          count is {count}
        </button>
        <p>
          Edit <code>src/App.tsx</code> and save to test HMR
        </p>
      </div>
      <p className="read-the-docs">
        Click on the Vite and React logos to learn more
      </p>
    </div>
  )
}

export default App

Finalmente activamos el vite
npm run dev
y abrimos el navegador en el puerto 5173
http://localhost:5173

Cómo es local, la interacción blockchain es a la velocidad del rayo :)

Felicitaciones!!
Tu primera implementación real y con interacción web

Repositorio github:
https://github.com/sergiotechx/counterReactFuel

Actualización

Un miembro de Fuel me indicó donde está el foro de la comunidad y allí ya resolvieron el problema con NEXTJS y funciona!

En el archivo next.config.js se agrega lo siguiente:

 experimental: {
    esmExternals: false,
  }

https://forum.fuel.network/t/running-fuels-on-nextjs/1132

Invocando una función de un contrato inteligente de la BNBChain mediante una API REST🤯

Sergio Martinez Marin — Mon, 03 Oct 2022 23:18:35 +0000

Hola a todos, el día de hoy vamos a ver otra forma de invocar funciones de los contratos inteligentes, mediante la solución de TATUM (https://tatum.io/).
Con tatum la creación de NFT, y muchas funcionalidades que se necesitan a diario en una daap, vienen en forma de una simple llamada a una API REST, lo cual nos abre un mundo de posibilidades en nuestras aplicaciones ( cualquier cosa puede llamar una api rest 😁).

Otra ventaja es que tenemos acceso mediante API rest a 40 blockchains, lo cual nos ayuda muchisimo en nuestros desarrollos.

En esta ocación vamos invocar la función que creamos la primera vez en bnb studio (https://dev.to/sergiotechx/primeros-pasos-con-bnb-studio-525b).

Lo primero que debemos hacer es crear un usuario en TATUM, luego de esto, entramos en el dash board y damos click en api keys

Creamos una api key de testnet y otra de mainnet.
Nota: Según la api key que usamos en las invocaciones de las API rest el sistema sabe si nos dirigimos a operaciones de testnet o mainnet 🤓

Para ver toda la documentación, la podemos ver acá https://docs.tatum.io/

Ejemplo práctico
1) Vamos directos al siguiente link
https://apidoc.tatum.io/tag/BNB-Smart-Chain#operation/BscBlockchainSmartContractInvocation

podemos probar dentro del mismo documentador de tatum o en postman, para mayor comodidad vamos realizarlo en postman
2) elegimos que servidor queremos, si en europa o en USA en el URL de la api

En este caso lo dejamos en Europa y el link quedaría así
https://api-eu1.tatum.io/v3/bsc/smartcontract
Allí se evidencia que es versión 3 llamado a la BNB chain y el endpoint smartcontract

3) Es un request tipo Post, para poner que es una aplicación tipo JSON y las credenciales en la parte de headers en Post man

4)En el body ponemos que es tipo raw con tipo JSON

E incluimos el siguiente código

0 {
1  "contractAddress":"0x7BcAF331B2d33Fbdc17De5dD0C3DEadb360503bb",
2  "methodName": "getResult",
3  "methodABI":  
4            {
5              "inputs": [],
6              "name": "getResult",
7              "outputs": [
8               {
9                  "internalType": "string",
10                  "name": "",
11                  "type": "string"
12               }
13              ],
14              "stateMutability": "view",
15              "type": "function"
16            } ,
17   "params": []
18 }

Línea 1 el contrato a usar
Línea 2 el mètodo o función a invocar
Línea 3 el código abi

Al ver el ABI en el BNB Studio, vemos que el código está entre [], en tatum, quitamos esos []

Línea 17 los parámetros que vamos a usar

Ejecutamos el api rest, que es un llamado a una función de un contrato inteligente de la BNBChain y obtenemos lo siguiente

Consideraciones:
No es el santo grial para todas las aplicaciones, ya que en opciones que haya que pagar en BNB, hay que tener una billetera con fondos e indirectamente poner la privatekey con todas las medidas de seguridad, lo cual en ciertos escenarios no aplica.
Específicamente en una operación contra una metamask donde absolutamente todo lo paga el usuario, como lo sería un pancake swap por ejemplo. Pero......en airdrops, operaciones tipo backend, billeteras mobiles y un sin fin de aplicaciones es perfectamente viable.

Nos vemos más adelante en este maravilloso mundo blockchain 🤓😁🤠

Primeros pasos con Netherum en la BNB Chain

Sergio Martinez Marin — Sat, 01 Oct 2022 17:06:14 +0000

Hola a todos, en esta ocación vamos a ver algo super fundamental en el mundo C#, la mayoria de veces la web3 va ligado inherentemente a una página web y javascript, en cualquier variante ( navegador desktop, navegador de mobil o sus variantes).

Pero que pasa si queremos hacer una solución a nivel de Backend, escritorio o mobil directamente con C#, usamos una solución llamada Netherum 🤓
https://nethereum.com/
A continuación vamos a llamar la función que se créo en el artículo pasado (https://dev.to/sergiotechx/primeros-pasos-con-bnb-studio-525b), donde dimos los primeros pasos en el ide "BNB Studio" 🤠

Lo primero es crear un proyecto, tipo consola y por el packet manager de nugets, bajamos en Netherum.web3

Luego abrimos el bnbstudio para localizar el código abi y el contrato que desplegamos la vez pasada

Ahora escribimos lo siguiente ( maximiza el código para que sea más legible)

 static async Task Main(string[] args)
        {

            //Acá pones tu llave privada que no debes compartir con nadie!        
            string _privatekey = "tu llave privada";
            //un proveedor gratis de la testnet de BNB https://www.ankr.com/rpc/
            string _strconnection = "https://rpc.ankr.com/bsc_testnet_chapel";
            //chain ID de la BNBChain testnet 97
            //https://academy.binance.com/en/articles/connecting-metamask-to-binance-smart-chain
            Account account = new Account(_privatekey, new BigInteger(97));
            Web3 web3 = new Web3(account, _strconnection);
            string contractAdress = "0x7BcAF331B2d33Fbdc17De5dD0C3DEadb360503bb";
            //el abi lo sacamos del bnbstudio
            var abi = @"
                        [
                         {
                          ""inputs"": [],
                          ""name"": ""getResult"",
                          ""outputs"": [
                           {
                             ""internalType"": ""string"",
                             ""name"": """",
                             ""type"": ""string""
                           }
                          ],
              ""stateMutability"": ""view"",
              ""type"": ""function""
            }
          ]";
            Nethereum.Contracts.Contract contract = web3.Eth.GetContract(abi, contractAdress);
            //Invocación de la función del contrato inteligente
            var function = contract.GetFunction("getResult");
            //la función del smart contract retorna un datos tipo string
            var result = await function.CallAsync<string>();
            Console.WriteLine(result);
            Console.ReadLine();
        }

y este es el resultado

Cómo puedes ver, integrar tus contratos de la BNBChain al mundo C# es muy viable mediante este tipo de soluciones.

El código del proyecto lo puedes descargar acá
https://github.com/sergiotechx/NetherumCallAbi

Hasta la próxima.😁

Primeros pasos con BNB Studio

Sergio Martinez Marin — Sun, 18 Sep 2022 22:03:35 +0000

Hola a todos, mirando este link https://www.bnbchain.org/en/developers
Asumiendo que es el punto de entrada para todos los desarrolladores de la BNB chain, me encontré con esto

Está un poco desactualizado, porque es la BNB studio ahora por el rebranding que hubo, pero vale la pena mirarlo que tan util es a la hora de realizar nuestros proyectos bajo la bnb chain.

let`s go builders 😎!!!

El bnb studio en un ide para desarrollar nuestros smartcontracts de la BNB chain, está desarrollado https://www.obsidians.io/.
Actualmente el BNB Studio viene en 2 formatos:

WEB: https://bsc.intl.ide.black/
Desktop: en Linux, Mac y Windows

En el artículo vamos a instalar la versión de escritorio para Windows.
Antes de instalarlo, hay 2 alternativas de instalación.

Instalación de algunos elementos via docker, algo único que no he visto en otros ides , es la integración de containes para truffle y un nodo local de la bsc
Instalación de nodejs y eso es todo 👍

Nosotros para efectos prácticos lo vamos instalar con nodejs

1) Descargarmos e instalamos nodejs
https://nodejs.org/es/ descargamos la versión lts
hoy 16 de Agosto del 2022
https://nodejs.org/dist/v16.17.0/node-v16.17.0-x64.msi
2) Descargarmos e instalamos el Bnb Stucio
https://github.com/ObsidianLabs/BNB-Studio
La última versión fue lanzada en mayo 14 de 2022
https://github.com/ObsidianLabs/BNB-Studio/releases/tag/v0.10.6
https://github.com/ObsidianLabs/BNB-Studio/releases/download/v0.10.6/BNB-Studio-0.10.6.exe

Como vamos a trabajar en la modalidad que está instalado en nodejs, click en skip

Tenemos varios templates y su las respectivas versiones para estos templates

Además de esto podemos ver si nos vamos por truffle, hardhat, waffle con sus respectivas versiones o la versión docker

Para efectos prácticos, vamos a hacer un hola mundo por hardhat y lo vamos a lanzar por la testnet de la bsc

Nota: la ultima versión para bnb studio de hardhat es la 2.5.0 y la última versión de hardhat va por la 2.11.2

Automáticamente , se instala hardhat para el proyecto
Nos queda instalado lo siguiente:

{ "name": "helloworld", "version": "1.0.0", "description": "", "main": "hardhat.config.js", "scripts": { "build": "hardhat compile --config hardhat.config.js", "deploy": "hardhat run scripts/deploy.js" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@nomiclabs/hardhat-ethers": "^2.1.1", "@nomiclabs/hardhat-waffle": "^2.0.3", "chai": "^4.3.6", "ethereum-waffle": "^3.4.4", "ethers": "^5.7.1", "hardhat": "^2.5.0" } }

Vamos a borrar el contrato generado, crear nuetro propio contrato "helloworld.sol y ponerlo en la testnet de la BSC! 🤠

`
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.6;

contract Hello {
function getResult() public view returns(string memory){
return "Hola Mundo!";
}
}
`
Abrimos el archivo config.json y cambiamos lo siguiente:
Main File: ./contracts/hellworld.sol
Solc version: v0.8.6
EVM version: Berlin

y click en save all

Dentro de la carpeta "scripts" en deploy.js hacemos la siguiente modificación y grabamos el cambio, de esta forma hardhat sabe que el contrato a desplegar es el que estamos elaborando.
const Main = await ethers.getContractFactory('Main')
se cambia por : const Main = await ethers.getContractFactory('Hello')

Ahora vamos a compilar el contrato con danco click en el ícono del martillo

Si todo es exitoso abajo aparece lo siguiente

Ahora vamos a desplegar el contrato en la testnet de la BSC 😉

1) en la parte superior derecha seleccionamos que es la red de pruebas

2) Vamos al administrador de llaves privadas en la parte inferior derecha y click en el ícono de llave

Una ves ingresamos en esta opción click en import

En este paso, ponemos la llave privada de la metamask, mucho cuidado, la llave privada no la debejmos compartir con nadie!

Debe quedar algo así ydamos click en close

3) Click en el ícono de la ballenita, para desplegar el contrato en la testnet de la BNB chain.

Click en Estimate & Deploy ( esto hace el cálculo del gas y gas price por nosotros)

Finalmente click en Deploy

Felicitaciones!!! ya desplegamos un contrato en la testnet de la BSC!!!

Ahora vamos a interactuar con el contrato 🧐

Hacemos click en el contratro generado

En este caso no tenemos parámetros, pero esta habilitado para ello en BNB Studio!
Vamos a ejecutar el contrato!!

Conlusiones

Nos facilita mucho la vida este entorno, ya que podemos compilar y hacer despliegues totalmente automatizados con un sólo click.
Muy interesante ver que podemos usar truffle o hardhat. Aunque un poco desactualizado en sus versiones
No lo mostramos pero tiene un explorador de transacciones incluido.
Para las personas que les gusta tener todo bajo control, quizá sea más aconsejable usar otro ide como visual studio e incorporar hardhat, truffle u otras soluciones completamente a mano, ya que BNB Studio , nos hace todas estas labores de forma automática y perdemos un poco el control sobre esto.

Espero este tutorial haya sido de agrado y utilidad 😉

Llamado dinámico de una clase en C#

Sergio Martinez Marin — Tue, 06 Sep 2022 16:51:53 +0000

Hola a todos, espero que disfruten el siguiente mini tutorial 🦖

Aveces tenemos una configuración de un sistema, ya sea por base de datos o algún archivo de configuración.

Dependiendo de esta configuración el comportamiento del programa en su implementación puede cambiar mucho y como nosotros somos programadores elegantes 😎 no queremos hacer un switch case de implementación de interfaces, llamamos el objeto de nuestra configuración y voila 🤗.

Un ejemplo mundo real que estoy aplicando esto es para un bot de trading donde la configuración apunta a realizar operaciones en diferentes exchanges, cada exchange maneja diferentes apis, reglas de negocio e implementaciones, por lo cual esta técnica es sumamente útil.

Voy a plantear la siguiente situación hipotética, viajar, podemos viajar de muchas formas!

Desde un archivo json en nuestro ejemplo podemos, configurar el medio de transporte (avión, pie, carro y trén).

Para poner un poco de orden al caos de llamar objetos sin conexión, implementamos una interfaz la cual deben cumplir todos los objetos

Para facilitar la lectura de un objeto json, usaremos la librería newton soft.
El proyecto en su estructura quedaría así

Archivo de configuración Config.json

{
"Medio":  "Pie"
}

interface Iviajar

namespace LlamadoDinamico
{
    //Marco de referencia que deben cumplir los diferentes medios de viaje
    public interface Iviajar
    {
        bool ComienzoViaje(string destino);
    }
}

Programa principal

/***
 * Ejemplo de como invocar una clase dinámicamente por medio de una configuración almacenada en un archivo
 * de configuración
 ***/

using LlamadoDinamico;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;


string configPath = Directory.GetCurrentDirectory() + @"\Config.json";

if (File.Exists(configPath))
{
    //Obtención en bruto del archivo a texto
    string textConfiguration = File.ReadAllText(configPath);
    //de string a Jobject
    dynamic data = JObject.Parse((string)textConfiguration);
    string medio = data["Medio"];
    //se incluye la ruta del namespace completo más la clase
    string strclase = "LlamadoDinamico.FormasdeViaje." + medio;
    Iviajar viajar = (Iviajar)System.Reflection.Assembly.GetExecutingAssembly().CreateInstance(strclase);
    bool resultado = viajar.ComienzoViaje("FarFaraway!");
    Console.ReadLine();
}

Implementación de una de las forma de viaje
Pie.cs

namespace LlamadoDinamico.FormasdeViaje
{
    public class Pie : Iviajar
    {
        public bool ComienzoViaje(string destino)
        {
            bool respuesta = false;
            if (destino == "FarFaraway!")
            {
                Console.WriteLine("voya pie y está muy lejos, usa otro medio de transporte");
            }
            else 
            {
                Console.WriteLine("Andando ando!");
                respuesta = true;
            }
            return respuesta;
        }
    }
}

Baja el ejemplo completo acá
https://github.com/sergiotechx/LlamadoDinamico

Espero que te haya sido de utilidad 😁 y a seguir con toda la energía positiva en tu proyecto, que eso no se hace sólo 💪