Cudos Network es una cadena de bloques de propósito especial diseñada para proporcionar computación en la nube de alto rendimiento, sin confianza y sin permisos para todos.

¿Quieres empezar a validar para CUDOS? ¡Entonces has venido al lugar correcto! La siguiente es una guía detallada paso a paso sobre cómo configurar su propio validador en CUDOS.

En este punto, vamos a desviarnos de la documentación oficial e ir con CentOS.

La configuración del entorno está destinada a realizarse en todas las máquinas host. Los requisitos de hardware se pueden encontrar aquí.

Una vez que haya activado una máquina host, siga los pasos a continuación.

Si acaba de comenzar con este tutorial, comience con la puesta en marcha de una máquina validadora.

Primero, necesitamos instalar un par de herramientas.

# Install Docker, Git and jQuery via the yum package manager.
$ sudo yum install docker git jq -y# Start the Docker daemon.
$ sudo service docker start# Install docker-compose by downloading the binary from the GitHub download archive.
$ curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose# Make docker-compose executable for the current user.
$ chmod +x /usr/local/bin/docker-compose

Ahora, vamos a crear un espacio de trabajo en el directorio $HOME y cd en él.

$ mkdir ~/cudos
$ cd ~/cudos

Next, necesitamos clonar CudosNode, CudosBuilders y CudosGravityBridge.

$ git clone --depth 1 --branch v0.2 https://github.com/CudoVentures/cudos-node.git CudosNode
$ git clone --depth 1 --branch v0.3  https://github.com/CudoVentures/cudos-builders.git CudosBuilders
$ git clone --depth 1 --branch v0.2 https://github.com/CudoVentures/cosmos-gravity-bridge.git CudosGravityBridge

Cree la imagen de Docker para CudosBuilders.

$ cd ~/cudos/docker/binary-builder
$ sudo docker-compose --env-file binary-builder.arg -f binary-builder.yml -p cudos-binary-builder up --build --detach

Muy bien, es hora de llegar al meollo del asunto. La configuración del validador implica la configuración de tres componentes:

  • El validador CUDOS, que participa en el consenso en cadena votando y proponiendo bloques, y que es utilizado por el orquestador para hacer su llamado contra la cadena CUDOS
  • El Gravity Bridge Orchestrator,que gestiona el flujo de tokens entre CUDOS y Ethereum
  • Un nodo completo de Ethereum,que es utilizado por el orquestador para hacer sus llamadas contra Ethereum

1.1) Configuración del nodo completo de Ethereum

Primero, encienda una nueva máquina host (consulte los requisitos de hardware del nodo Ethereum»).

Alternativamente, también puede usar su propio nodo completo de Ethereum, en cuyo caso puede saltar a 1.2). Solo asegúrate de no usar Infura.

Recordatorio:Complete la «0) Configuración del entorno» antes de continuar con los pasos a continuación.

Ejecutar un nodo Ethereum es bastante sencillo.

$ cd ~/cudos/CudosBuilders/docker/ethereum
$ sudo docker-compose -f ethereum-full.yml -p ethereum up --build --detach

Tenga en cuenta que la sincronización de la cadena de bloques de Rinkeby puede llevar horas / días. Puede ver los registros ejecutando el siguiente comando.

$ sudo docker logs -f ethereum

1.2) Configuración del nodo validador CUDOS

Primero, ponga en marcha una nueva máquina host (consulte Requisitos de hardware del «Nodo validador»). Vamos a inicializar un nodo completo CUDOS en él, que luego configuraremos para que se convierta en un validador.

Recordatorio:Complete la «0) Configuración del entorno» antes de continuar con los pasos a continuación.

# Navigate to the full-node directory of CudosBuilders.
$ cd ~/cudos/CudosBuilders/docker/full-node# Make a copy of the example full-node env file and open it with a text editor of your choice.
$ cp full-node.env.example full-node.client.testnet.public01.env
$ nano full-node.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
MONIKER=<Insert your validator moniker here>
SHOULD_USER_GLOBAL_PEERS=false# Initialize the full node.
$ sudo docker-compose --env-file full-node.client.testnet.public01.arg -f init-full-node.yml -p cudos-init-full-node-client-testnet-public-01 up --build

Si todo salió bien, debería haber un directorio ~/cudos/CudosData.

$ ls ~/cudos
CudosBuilders  CudosData  CudosGravityBridge  CudosNode
                   /\
                   ||
     This directory should be there.

También asegurémonos de que todos los archivos se generaron correctamente.

$ ls ~/cudos/CudosData/cudos-data-full-node-client-testnet-public-01
config  data  tendermint.nodeid

Copie y pegue el ID de nodo en un archivo de texto en el equipo local. Lo necesitarás en breve.

$ cat ~/cudos/CudosData/cudos-data-full-node-client-testnet-public-01/tendermint.nodeid

Luciendo bien hasta ahora. Ahora, para obtener pares, es una buena práctica activar un nodo centinela en otra máquina host.

  • Repita el paso «0) Configuración del entorno» en el nodo centinela.
  • Siga la guía oficial de configuración de Sentry.
    Para el paso 6, necesitará el ID de nodo del validador del archivo de texto mencionado anteriormente y la dirección IP pública del validador. Asegúrese de que el puerto 26656 esté abierto para conexiones entrantes y salientes. Por ahora, no tiene que ingresar ninguna otra dirección del par que no sea la del validador.
  • Obtenga el ID de nodo del centinela, cópielo y péguelo en un archivo de texto en su computadora local. Lo necesitarás en breve.
$ cat ~/cudos/CudosData/cudos-data-sentry-node-client-testnet-public-01/tendermint.nodeid
  • Idealmente, querrá configurar al menos dos nodos centinelas para una protección DDoS efectiva. Simplemente repita los tres pasos anteriores en otra máquina host.

Opcional:Configurar un nodo semilla. Sin embargo, omitiremos este paso en esta guía.

Ahora que hemos configurado nuestros centinelas, necesitamos agregarlos como pares a nuestro nodo validador.

$ cd ~/cudos/CudosBuilders/docker/full-node
$ nano full-node.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
PERSISTENT_PEERS=<sentry1-node-id>@<sentry1-public.ip>:26656,<sentry2-node-id>@<sentry2-public.ip>:26656

Muy bien, es hora de iniciar el nodo completo.

# Set the configuration.
$ sudo docker-compose --env-file full-node.client.testnet.public01.arg -f config-full-node.yml -p cudos-config-full-node-client-testnet-public-01 up --build# Start the full node.
sudo docker-compose --env-file full-node.client.testnet.public01.arg -f start-full-node.yml -p cudos-start-full-node-client-testnet-public-01 up --build --detach# Logs can be viewed by running the following command.
$ sudo docker logs -f cudos-start-full-node-client-testnet-public-01

En este punto, dado que solo hemos comenzado el nodo completo hace unos momentos, todavía va a sincronizar la cadena de bloques. Dependiendo de su hardware y el tamaño de la cadena de bloques, esto puede tomar horas / días. Puede comprobar el estado de sincronización mediante los siguientes comandos.

# Wait for the output of this command to be 'false'.
$ sudo docker exec -ti cudos-start-full-node-client-testnet-public-01 cudos-noded status | jq '.SyncInfo.catching_up'# Check the progress by comparing the block height from the output of this command with the latest block height from the official block explorer.
$ sudo docker exec -ti cudos-start-full-node-client-testnet-public-01 cudos-noded status | jq '.SyncInfo.latest_block_height'

Mientras tanto, podemos crear una cuenta, que es necesaria para interactuar con la cadena de bloques. Vamos a crear uno usando la extensión web Keplr. Por favor, siga esta guía.

¡No olvides hacer una copia de seguridad de la frase mnemotécnica y almacenarla en un lugar seguro!

Una vez que el nodo se ha puesto al día, podemos importar nuestra cuenta de validador que acabamos de crear en Keplr. Para eso, necesitaremos acceder a la shell del contenedor del validador.

$ sudo docker exec -it cudos-start-full-node-client-testnet-public-01 bash

Luego, ejecute el siguiente comando, que le pedirá que ingrese la frase mnemotécnica.

$ cudos-noded keys add validator --recover --keyring-backend file

Para comprobar si la clave se agregó correctamente, utilice el siguiente comando, que debe enumerar una clave «validadora».

$ cudos-noded keys list --keyring-backend file

Antes de que podamos crear nuestro validador en la cadena, necesita algunos tokens que pueda auto-apostar, por lo que realmente puede convertirse en un validador y participar en el consenso.

Una vez que tenga algunos tokens, ahora podemos crear el validador en cadena utilizando el siguiente comando.

$ cudos-noded tx staking create-validator \
  --amount <STAKE> \
  --from validator \
  --pubkey $(cudos-noded tendermint show-validator) \
  --moniker <YOUR_MONIKER> \
  --chain-id <CHAIN_ID> \
  --commission-rate <COM_RATE> \
  --commission-max-rate <COM_MAX_RATE> \
  --commission-max-change-rate <COM_MAX_CHANGE_RATE> \
  --min-self-delegation 1 \
  --gas auto \
  --gas-prices 0.025acudos \
  --gas-adjustment 1.80 \
  --keyring-backend file \
  -y
  • <Stake > debe ser de al menos 1000000000000000000000acudos (=1 CUDOS)
  • <YOUR_MONIKER > debe ser el mismo apodo que proporcionó en ~/cudos/CudosBuilders/docker/full-node/full-node.client.testnet.public01.env
  • <CHAIN_ID debe > ser cudos-testnet-public para testnet (TBD para mainnet)
  • <COM_RATE es > el porcentaje de comisión que desea tomar de todas las recompensas, es decir, 0.10 significa que tomará el 10% de todas las recompensas generadas.
  • <COM_MAX_RATE es > la tasa de comisión máxima a la que se está comprometiendo, es decir, 0.40 significa que nunca tomará más del 40% de todas las recompensas generadas.
  • <COM_MAX_CHANGE_RATE es > la tasa máxima en porcentaje, que puede cambiar su tasa de comisión por día, es decir, 0.20 significa que por día, puede aumentar o disminuir su comisión en un 20% más.

Ejecute el comando y espere a que se procese. Si ve un hash de transacción sin obtener un error, ¡entonces ha creado con éxito una cuenta de validador! Puede copiar el hash de transacción y echarle un vistazo en el explorador de bloques.

Además, debería poder encontrar su validador en la lista impresa por el siguiente comando (busque su apodo).

$ cudos-noded q staking validators

Por favor, no salga de la sesión de shell de contenedor, ya que continuaremos trabajando en el validador en el siguiente paso.

1.3) Configuración del orquestador

Para el orquestador, necesitamos otra cuenta en la máquina validadora. Cree uno en Keplr, haga una copia de seguridad de la frase mnemotécnica y guárdela en un lugar seguro. A continuación, utilice el siguiente comando para importar la cuenta de orchestrator, que le pedirá que introduzca la frase mnemotécnica de la cuenta de orchestrator.

$ cudos-noded keys add orchestrator --recover --keyring-backend file

Para comprobar si la clave se agregó correctamente, utilice el siguiente comando, que debe enumerar una clave «validador» y la clave «orquestador» recién agregada.

$ cudos-noded keys list --keyring-backend file

Para los siguientes pasos, necesitará una cuenta de Ethereum. Siga esta guía sobre cómo instalar y configurar Metamask, y cree una cuenta. Una vez que tenga una dirección de Ethereum, podemos registrar el orquestador.

$ cudos-noded tx gravity set-orchestrator-address <VALIDATOR_ADDRESS> <ORCH_ADDRESS> <ETH_ADDRESS>
  • <VALIDATOR_ADDRESS es > la dirección del operador del validador (cudosvaloper…). Se puede recuperar con el siguiente comando.
$ cudos-noded keys show validator --bech val --keyring-backend file
  • <ORCH_ADDRESS es > la dirección de los orquestadores (cudos…). Se puede recuperar con el siguiente comando.
$ cudos-noded keys show orchestrator --keyring-backend file
  • <ETH_ADDRESS > es la dirección de Ethereum que creaste en Metamask (0x…).

Una vez que haya registrado el orquestador, debemos configurarlo.

$ cd ~/cudos/CudosBuilders/docker/orchestrator
$ cp orchestrator.env.example orchestrator.client.testnet.public01.env
$ nano orchestrator.client.testnet.public01.env# Add the following contents to the file. Once you're done, save the changes and close the file.
ADDRESS_PREFIX="cudos"
FEES="<FEES>"
GRPC="http://<CUDOS_NODE_IP>:9090"
ETHRPC="http://<ETH_NODE_IP>:8545"
CONTRACT_ADDR="0xb22F2A4c231e69703FC524Eb2E3eb7B83C316F42"
COSMOS_ORCH_MNEMONIC="<ORCH_MNEMONIC>"
ETH_PRIV_KEY_HEX="<HEX_PRIV_KEY>"
  • <Las TARIFAS > son las tarifas que tendrá que pagar por cada transacción puente, por ejemplo, 100 acudos.
  • <CUDOS_NODE_IP es > la dirección IP pública del nodo validador CUDOS.
  • <ETH_NODE_IP es > la dirección IP pública del nodo completo de Ethereum.
  • <ORCH_MNEMONIC es > la frase mnemotécnica de su cuenta de orquestador.
  • <ETH_PRIV_KEY_HEX es > la representación hexadecimal si la clave privada de la cuenta Ethereum, sin el «0x» inicial. Siga esta guía para exportar la clave privada desde Metamask.

Finalmente, ejecute el orquestador.

$ sudo docker-compose --env-file orchestrator.client.testnet.public01.arg -f orchestrator.release.yml -p cudos-orchestrator-client-testnet-public-01-release up --build --detach

Puede ver los registros con el siguiente comando.

$ sudo docker logs -f cudos-orchestrator-client-testnet-public-01-release

¡Y eso prácticamente lo envuelve! ¡Ahora está ejecutando un nodo validador en la cadena de bloques CUDOS y un orquestador para unir las transferencias de tokens entre Cosmos y Ethereum!

¡Esperamos que esta guía te haya sido útil y nos dejes con un aplauso!

¡Hasta la próxima!

Aprende más:

Sitio web, Twitter, Telegram, YouTube, Discord, Medium, Podcast