Inicializa una dapp usando scripts

Al configurar un ejemplo de Dapp Soroban, la inicialización correcta es crucial. Este proceso implica varios pasos, incluyendo desplegar Docker, clonar y desplegar contratos inteligentes, e invocar funciones para configurarlos. En esta guía completa, te guiaré a través de los pasos necesarios para crear y desplegar estos contratos inteligentes, asegurando un proceso fluido para tu Dapp Soroban.

Desarrollar el Contrato Inteligente Soroban Token

En dapps como el Ejemplo de Dapp de Pago, los contratos inteligentes Token Soroban se utilizan para representar el activo tokenizado que los usuarios pueden enviar y recibir. Aquí hay un ejemplo de cómo crear y desplegar los contratos inteligentes Token Soroban:

Comienza clonando el repositorio de ejemplos de Soroban:

git clone https://github.com/stellar/soroban-examples.git

Luego, navega al directorio token:

cd soroban-examples/token

En este punto, puedes construir el contrato inteligente:

make

Esta acción compilará los contratos inteligentes y los colocará en el directorio token/target/wasm32v1-none/release. Después de desarrollarlo, estás listo para desplegar los contratos inteligentes en Testnet.

Desplegar e Inicializar el Contrato Inteligente Soroban Token

El contrato inteligente puede inicializarse en el momento del despliegue utilizando la función __constructor. Esta función se llamará en el momento del despliegue y puede declararse con parámetros que puedes pasar a la función con el comando de despliegue.

La función __constructor se añade al punto de entrada del contrato; en este contrato inteligente token se encuentra en el archivo contract.rs.

contract.rs

#[contractimpl]
impl Token {
  pub fn __constructor(e: Env, admin: Address, decimal: u32, name: String, symbol: String) {
      if decimal > 18 {
          panic!("Decimal must not be greater than 18");
      }
      write_administrator(&e, &admin);
      write_metadata(
          &e,
          TokenMetadata {
              decimal,
              name,
              symbol,
          },
      )
  }
  ...
}

La función __constructor en este proyecto de ejemplo recibe los siguientes parámetros:

• Cuenta del administrador: Esta es la clave pública de la cuenta del administrador. El administrador tiene control y autoridad sobre el contrato del token, lo que permite gestionar diversas funcionalidades del contrato. Aprende más sobre el rol del administrador en la Interfaz del Soroban Token.

• Precisión decimal: La precisión decimal especifica el número máximo de decimales que el token puede admitir en las transacciones. Este nivel de precisión permite flexibilidad al transferir cantidades del token.

• Nombre del token: El nombre del token.

• Símbolo del token: Este es el símbolo del token.

Para desplegar el contrato inteligente en este ejemplo, abre una terminal en el directorio soroban-examples/token y ejecuta lo siguiente:

stellar contract deploy \
 --wasm target/wasm32v1-none/release/soroban_token_contract.wasm \
 --source-account alice \
 --rpc-url https://soroban-testnet.stellar.org \
 --network-passphrase 'Test SDF Network ; September 2015'
 -- \
 --admin alice \
 --decimal 10 \
 --name 'Demo Token' \
 --symbol 'DT'

Este comando despliega los contratos inteligentes en Testnet utilizando la función stellar contract deploy. El contrato inteligente se desplegará con los parámetros obligatorios y se inicializará con estos valores.

Crear Tokens

Por último, necesitas crear algunos tokens para la cuenta del remitente:

stellar contract invoke \
 --id <TOKEN_CONTRACT_ID> \
 --source-account alice \
 --rpc-url https://soroban-testnet.stellar.org \
 --network-passphrase 'Test SDF Network ; September 2015'
 -- mint \
 --to bob \
 --amount 1000000000

Este comando acuñará 100 tokens en la cuenta del usuario designado, en este caso bob.

Al seguir estos pasos, aseguras que los contratos inteligentes Token Soroban estén correctamente desplegados e inicializados, preparando el escenario para que la Dapp interactúe efectivamente con el token.

Para profundizar en los comandos CLI de Stellar, consulta el repositorio CLI de Stellar.

Automatizando la Inicialización con Scripts

Para optimizar el proceso de inicialización, puedes usar un script. Este script debería automatizar varias tareas como configurar la red, generar identidades admin-token, financiar la cuenta admin-token, construir y desplegar los contratos, e inicializarlos con los parámetros necesarios.

Aquí hay un ejemplo de script de inicialización:

initialize.sh

#!/bin/bash

set -e

NETWORK="$1"

# If stellar-cli is called inside the soroban-preview docker container,
# it can call the stellar standalone container just using its name "stellar"
if [[ "$IS_USING_DOCKER" == "true" ]]; then
  SOROBAN_RPC_HOST="http://stellar:8000"
else
  SOROBAN_RPC_HOST="http://localhost:8000"
fi

case "$1" in
standalone)
  echo "Using standalone network"
  SOROBAN_NETWORK_PASSPHRASE="Standalone Network ; February 2017"
  FRIENDBOT_URL="$SOROBAN_RPC_HOST/friendbot"
  SOROBAN_RPC_URL="$SOROBAN_RPC_HOST/soroban/rpc"
  ;;
futurenet)
  echo "Using Futurenet network"
  SOROBAN_NETWORK_PASSPHRASE="Test SDF Future Network ; October 2022"
  FRIENDBOT_URL="https://friendbot-futurenet.stellar.org/"
  SOROBAN_RPC_URL="https://rpc-futurenet.stellar.org"
  ;;
testnet)
  echo "Using Testnet network"
  SOROBAN_NETWORK_PASSPHRASE="Test SDF Network ; September 2015"
  FRIENDBOT_URL="https://friendbot.stellar.org/"
  SOROBAN_RPC_URL="https://soroban-testnet.stellar.org"
  ;;
*)
  echo "Usage: $0 standalone|futurenet|testnet"
  exit 1
  ;;
esac

echo Add the $NETWORK network to cli client
stellar network add \
  --rpc-url "$SOROBAN_RPC_URL" \
  --network-passphrase "$SOROBAN_NETWORK_PASSPHRASE" "$NETWORK"

if !(stellar keys ls | grep token-admin 2>&1 >/dev/null); then
  echo Create the token-admin identity
  stellar keys generate token-admin
fi
TOKEN_ADMIN_SECRET="$(stellar keys show token-admin)"
TOKEN_ADMIN_ADDRESS="$(stellar keys address token-admin)"

echo "$TOKEN_ADMIN_SECRET" > .soroban-example-dapp/token_admin_secret
echo "$TOKEN_ADMIN_ADDRESS" > .soroban-example-dapp/token_admin_address

# This will fail if the account already exists, but it'll still be fine.
echo Fund token-admin account from friendbot
curl --silent -X POST "$FRIENDBOT_URL?addr=$TOKEN_ADMIN_ADDRESS" >/dev/null

echo Build the contract
make build

echo Deploy the contract
ARGS="--network $NETWORK --source-account token-admin -- --admin $2 --decimal $3 --name $4 --symbol $5"
CROWDFUND_ID="$(
  stellar contract deploy $ARGS \
    --wasm target/wasm32v1-none/release/soroban_token_contract.wasm
)"
echo "Contract deployed successfully with ID: $CROWDFUND_ID"
echo "$CROWDFUND_ID" > .soroban-example-dapp/crowdfund_id

echo "Done"

Aquí tienes un resumen de lo que hace el script initialize.sh:

• Identifica la red (standalone o futurenet) basado en la entrada del usuario
• Determina la URL del host RPC Stellar dependiendo de su entorno de ejecución (ya sea dentro del contenedor Docker de soroban-preview o localmente)
• Establece la URL RPC de Stellar basada en la URL del host previamente determinada
• Establece la frase de paso de la red Soroban y la URL de Friendbot dependiendo de la red elegida
• Agrega la configuración de red usando stellar network add
• Genera una identidad de administrador de token usando stellar keys generate
• Recoge el TOKEN_ADMIN_SECRET y el TOKEN_ADMIN_ADDRESS de la identidad recién generada
• Guarda el TOKEN_ADMIN_SECRET y el TOKEN_ADMIN_ADDRESS en el directorio .soroban
• Financia la cuenta del administrador de token usando Friendbot
• Desarrolla el contrato con make build y lo despliega usando stellar contract deploy, almacenando el CROWDFUND_ID devuelto
• Imprime "Hecho" para significar el final del proceso de inicialización

Al aprovechar la inicialización automatizada, puedes optimizar el proceso de configuración para tu Dapp Soroban, asegurando que esté correctamente desplegada e inicializada.