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.

Creación y Despliegue del Contrato Inteligente Token Soroban

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/wasm32-unknown-unknown/release.

Después de crear, estás listo para desplegar los contratos inteligentes en Futurenet. Para hacer esto, abre una terminal en el directorio soroban-examples/token y ejecuta lo siguiente:

stellar contract deploy \
 --wasm target/wasm32-unknown-unknown/release/soroban_token_contract.wasm \
 --source <ADMIN_ACCOUNT_SECRET_KEY> \
 --rpc-url https://rpc-futurenet.stellar.org:443 \
 --network-passphrase 'Test SDF Future Network ; October 2022'

Este comando despliega los contratos inteligentes en Futurenet usando la función stellar contract deploy.

Inicializando un Contrato Token

Con los contratos desplegados, es hora de inicializar el contrato token:

stellar contract invoke \
 --id <TOKEN_CONTRACT_ID> \
 --source-account <ADMIN_ACCOUNT_SECRET_KEY> \
 --rpc-url https://rpc-futurenet.stellar.org:443 \
 --network-passphrase 'Test SDF Future Network ; October 2022' \
 -- initialize \
 --admin <ADMIN_PUBLIC_KEY> \
 --decimal 7 \
 --name '44656d6f20546f6b656e' \
 --symbol '"4454"'

Este comando requiere ciertos inputs:

• Cuenta Administradora: Esta es la clave pública de la cuenta administradora. La administradora tiene control y autoridad sobre el contrato token, lo que permite la gestión de varias funcionalidades del contrato. Aprende más sobre el papel del administrador en la Interfaz de Token Soroban. El administrador tiene control y autoridad sobre el contrato token, lo que permite la gestión de varias funcionalidades del contrato. Aprende más sobre el papel del administrador en la Interfaz de Token Soroban.

• Precisión Decimal: El valor de precisión decimal de 7 especifica que el token puede soportar transacciones de hasta 7 lugares decimales. Este nivel de precisión permite flexibilidad al transferir montos de tokens.

• Nombre del Token: El nombre del token, representado como una cadena hexadecimales. En este caso, '44656d6f20546f6b656e' corresponde a "Demo Token".

• Símbolo del Token: Este es el símbolo del token, también representado como una cadena hexadecimal. '4454' se traduce en el símbolo "DT".

Crear Tokens

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

stellar contract invoke \
 --id <TOKEN_CONTRACT_ID> \
 --source-account <ADMIN_ACCOUNT_SECRET_KEY> \
 --rpc-url https://rpc-futurenet.stellar.org:443 \
 --network-passphrase 'Test SDF Future Network ; October 2022' \
 -- mint \
 --to <USER_PUBLIC_KEY> \
 --amount 1000000000

Este comando creará 100 tokens para la cuenta del usuario designado.

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, envolver los activos de Stellar, generar identidades de administrador de token, financiar la cuenta del administrador de 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)"

# TODO: Remove this once we can use `stellar keys` from webpack.
mkdir -p .soroban-example-dapp
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

ARGS="--network $NETWORK --source token-admin"

echo Deploy the Stellar asset contract
TOKEN_ID=$(stellar contract asset deploy $ARGS --asset "EXT:$TOKEN_ADMIN_ADDRESS")
echo "Token deployed successfully with TOKEN_ID: $TOKEN_ID"

# TODO - remove this workaround when
# https://github.com/stellar/soroban-tools/issues/661 is resolved.
TOKEN_ADDRESS="$(node ./address_workaround.js $TOKEN_ID)"
echo "Token Address converted to StrKey contract address format:" $TOKEN_ADDRESS

echo -n "$TOKEN_ID" > .soroban-example-dapp/token_id

echo Build the crowdfund contract
make build

echo Deploy the crowdfund contract
CROWDFUND_ID="$(
  stellar contract deploy $ARGS \
    --wasm target/wasm32-unknown-unknown/release/soroban_crowdfund_contract.wasm
)"
echo "Contract deployed successfully with ID: $CROWDFUND_ID"
echo "$CROWDFUND_ID" > .soroban-example-dapp/crowdfund_id

echo "Initialize the crowdfund contract"
deadline="$(($(date +"%s") + 86400))"
stellar contract invoke \
  $ARGS \
  --id "$CROWDFUND_ID" \
  -- \
  initialize \
  --recipient "$TOKEN_ADMIN_ADDRESS" \
  --deadline "$deadline" \
  --target_amount "1000000000" \
  --token "$TOKEN_ADDRESS"

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
• Despliega el contrato de activo de Stellar con stellar contract asset deploy y almacena el TOKEN_ID resultante
• Construye el contrato de crowdfunding con make build y lo despliega usando stellar contract deploy, almacenando el CROWDFUND_ID devuelto
• Inicializa el contrato de crowdfunding invocando la función de inicialización con los parámetros necesarios
• 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.