Desplegar tu Validador de Space and Time

Descubre paso a paso cómo empezar con tu propio validador de Space and Time. Requiere cierto nivel de conocimiento en infraestructura.

_{Fecha de Creación: 10.06.2025}

_{Fecha actualización: 30.06.2025}

Requisitos de Hardware del Nodo

Estos son los requisitos mínimos de hardware que necesitas para que tu validador funcione correctamente:

Núcleos de CPU

Arquitectura CPU

amd64, con soporte de virtualización

Memoria (GiB)

Almacenamiento (GiB)

512

Tipo de almacenamiento

SSD

Sistema Operativo

Linux

Velocidad de red

500Mbps subida/bajada

Dirección de red

IP estática

Despliegue

Docker y Docker Compose instalados

Staking

Tokens SXT

En Azure, esto equivale al SKU Standard_D8as_v5 con almacenamiento SKU PremiumV2_SSD.

Una vez configurado, tu validador:

Se sincronizará con la red SXT Chain
Comenzará a firmar compromisos
Recibirá trabajos de inserción y consulta en tiempo real
Comenzará a ganar recompensas de bloque e incentivos por delegación

Otros requisitos previos

Tokens en mainnet Necesitas al menos 100 SXT para poder registrar un nodo validador.
Validador activo Tu validador, una vez activo, quedará como "Waiting Validator" hasta que el equipo de Space and Time le de entrada al active set.
Conocimiento técnico para desplegar un validador necesitas tener un conocimiento mínimo sobre infraestructura.
Responsabilidad Al lanzar tu propio validador, tendrás que preocuparte de que el mismo se mantenga activo para generar rewards. Si no lo haces, tanto tú como tus delegadores ¡Pueden sufrir penalizaciones!

1. Descargas

1.1. Docker y Chainspecs

1.1.1. Imagen de Docker

Asumimos que tienes docker instalado en tu máquina. La imagen Docker del nodo SXT puede descargarse con el comando docker pull:

docker pull ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5
docker images --digests ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5

Cuando se libere una nueva imagen, también se compartirá el hash completo sha256. Confirma que el hash coincide usando el argumento --digests para asegurarte de que estás descargando la imagen correcta.

Si vas a usar docker puedes utilizar nuestro script de instalación del nodo de Space and Time. Esto te permite realizar una instalación mediante docker de manera automática.

 Si utilizas nuestro script de instalación del nodo puedes saltarte todas las instrucciones relacionadas con Docker y configuración manual (es decir, toda la sección 1 y la sección 2 de esta guía). Sin embargo, aún necesitas realizar la parte de staking y el registro de claves en la blockchain siguiendo las instrucciones a partir de la sección 3.

Ten en cuenta que el script NO realiza llamadas a contratos inteligentes, así que deberás completar estos pasos de forma manual.

1.1.2. Chainspecs de la Mainnet

Los chainspecs están incluidos en la imagen Docker. Para inspeccionarlos:

docker run -it --rm \
  --platform linux/amd64 \
  --entrypoint=bash ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5 \
  -c "cat /opt/chainspecs/mainnet-spec.json"

1.2. Bootnodes de la Mainnet

Los bootnodes son peers confiables con los cuales un nodo nuevo se conecta para obtener más peers. Los tres bootnodes hospedados por Space and Time son:

/dns/validator0.mainnet.sxt.network/tcp/30333/p2p/12D3KooWK4MUYTiz8H6gG98JwN3bT11keivvFLYjtwEv5sqhwkAt

/dns/validator1.mainnet.sxt.network/tcp/30333/p2p/12D3KooWF92asK6nd1DTo4Hng3ekGpV2UYW9mSXJaXqB9RKGtyFU

/dns/validator2.mainnet.sxt.network/tcp/30333/p2p/12D3KooWRdhvrmMziPGeLxB7jtbe7h5q54Qth8KWjoCPaLn9Hv4v

1.3. Claves del Nodo

Debido a que SXT Chain usa contratos EVM para staking, necesitarás una billetera Ethereum con al menos 0.05 ETH para cubrir las tarifas de transacción.

Las claves tradicionales de Substrate no se utilizan. Solo se usan claves Ethereum.

Genera tu clave del nodo:

docker run -it --rm \
  --platform linux/amd64 \
  -v sxt-node-key:/data \
  --entrypoint=/usr/local/bin/sxt-node \
  ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5 \
  key generate-node-key --chain /opt/chainspecs/mainnet-spec.json --file /data/subkey.key

El archivo generado será subkey.key en el volumen sxt-node-key.

Haz una copia de seguridad del archivo subkey.key generado para poder realizar un backup en caso de emergencia.

Si pierdes esta subkey, dejarás de tener un backup de acceso al validador.
Si entregas esta subkey a un tercero, el tercero tendrá acceso a tu validador.

¡Es decir, guárdala con seguridad!

2. Docker Run

Ejecuta el siguiente comando reemplazando VALIDATOR_NAME:

docker run -d --restart always \
  --platform linux/amd64 \
  -v sxt-mainnet-data:/data \
  -v sxt-validator-key:/key \
  -v sxt-node-key:/node-key \
  -p 30333:30333/tcp \
  -p 9615:9615/tcp \
  -p 9944:9944/tcp \
  --env HYPER_KZG_PUBLIC_SETUP_DIRECTORY=/data \
  ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5 \
  --base-path /data \
  --prometheus-port 9615 \
  --prometheus-external \
  --pool-limit 10240 \
  --pool-kbytes 1024000 \
  --chain /opt/chainspecs/mainnet-spec.json \
  --keystore-path /key \
  --node-key-file /node-key/subkey.key \
  --bootnodes "/dns/validator0.mainnet.sxt.network/tcp/30333/p2p/12D3KooWK4MUYTiz8H6gG98JwN3bT11keivvFLYjtwEv5sqhwkAt" \
  --bootnodes "/dns/validator1.mainnet.sxt.network/tcp/30333/p2p/12D3KooWF92asK6nd1DTo4Hng3ekGpV2UYW9mSXJaXqB9RKGtyFU" \
  --bootnodes "/dns/validator2.mainnet.sxt.network/tcp/30333/p2p/12D3KooWRdhvrmMziPGeLxB7jtbe7h5q54Qth8KWjoCPaLn9Hv4v" \
  --validator \
  --port 30333 \
  --log info \
  --telemetry-url 'wss://telemetry.polkadot.io/submit/ 5' \
  --no-private-ipv4 \
  --name ${VALIDATOR_NAME?}

2.1 Docker Compose

Crea un archivo docker-compose.yaml:

---

name: 'sxt-mainnet-node'

services:
  sxt-mainnet:
    platform: linux/amd64
    restart: unless-stopped
    image: ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5
    ports:
      - '9615:9615'
      - '9944:9944'
      - '30333:30333'
    volumes:
      - sxt-mainnet-data:/data
      - sxt-validator-key:/key
      - sxt-node-key:/node-key
    pid: host
    environment:
      HYPER_KZG_PUBLIC_SETUP_DIRECTORY: /data
    command: >
      --base-path /data
      --prometheus-port 9615
      --prometheus-external
      --pool-limit 10240
      --pool-kbytes 1024000
      --chain /opt/chainspecs/mainnet-spec.json
      --keystore-path /key
      --node-key-file /node-key/subkey.key
      --bootnodes "/dns/validator0.mainnet.sxt.network/tcp/30333/p2p/12D3KooWK4MUYTiz8H6gG98JwN3bT11keivvFLYjtwEv5sqhwkAt"
      --bootnodes "/dns/validator1.mainnet.sxt.network/tcp/30333/p2p/12D3KooWF92asK6nd1DTo4Hng3ekGpV2UYW9mSXJaXqB9RKGtyFU"
      --bootnodes "/dns/validator2.mainnet.sxt.network/tcp/30333/p2p/12D3KooWRdhvrmMziPGeLxB7jtbe7h5q54Qth8KWjoCPaLn9Hv4v"
      --validator
      --port 30333
      --log info
      --telemetry-url 'wss://telemetry.polkadot.io/submit/ 5'
      --no-private-ipv4

volumes:
  sxt-mainnet-data:
    external: true
  sxt-validator-key:
    external: true
  sxt-node-key:
    external: true

Inicia el nodo:

docker compose -f ./docker-compose.yaml up -d

3. Instrucciones de Staking en la Mainnet de SXT Chain (NPoS)

Validadores

Son los que ejecutan el hardware para crear bloques y participar en el consenso. Tienen su propio stake y también el que les asignan los nominadores.

Nominadores

Asignan su stake a un validador ya existente para recibir parte de las recompensas sin necesidad de ejecutar un nodo. Si un validador es penalizado, también lo son sus nominadores. Se puede nominar a múltiples validadores.

Eras

Cada Era (24 horas) cambia el conjunto electo según la distribución del stake.

Épocas (Epochs)

Cada época asigna nuevos bloques al conjunto de validadores electo.

Elecciones

Ocurren en el último bloque de la penúltima época (Epoch 5). Las claves de los nuevos validadores entran en vigor al inicio de la siguiente Era.

Direcciones de Contratos en la Mainnet:

Contrato de Staking: 0x93d176dd54FF38b08f33b4Fc62573ec80F1da185
Contrato del Token SXT: 0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195
Contrato de Registro de SessionKey: 0x70106a3247542069a3ee1AF4D6988a5f34b31cE1

Requisitos Previos

Billetera Ethereum con ETH
Mínimo 0.05 ETH
Nodo validador sincronizado

Paso 1: Aprobar Gasto de Tokens

Autoriza al contrato de staking a gastar tus tokens:

Ve al contrato del token SXT: 0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195
Conecta tu billetera Ethereum
Ejecuta approve (write) con:

Dirección del contrato de staking (spender): 0x93d176dd54FF38b08f33b4Fc62573ec80F1da185
Límite de tokens a aprobar (18 decimales)

Paso 2: Hacer Stake de Tokens

Ve al contrato de staking: 0x93d176dd54FF38b08f33b4Fc62573ec80F1da185
Conecta tu billetera
Ejecuta stake (write)con mínimo 100 SXT (o 100000000000000000000 unidades)

Paso 3: Registrar tus Claves de Sesión

Ejecuta esta llamada RPC:

docker exec -ti $(docker ps -q -f volume=sxt-mainnet-data) \
curl -X POST http://localhost:9944 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "author_rotateKeys",
    "params": [],
    "id": 1
  }'

Copia el result hexadecimal recibido y pégalo en el campo body de la transacción en el contrato de mensaje. Esto también activa tu nodo (validate()).

¡Una vez registradas tes claves de sesión, tu validador ya estará registrado y listo para recibir delegaciones!

Convertir Dirección EVM a Formato SS58

Recuerda que hemos registrado nuestro validador con una address EVM (0x...). Ahora, necesitamos conocer nuestra wallet EVM en formato SS58. Existen dos motivos para realizar la conversión a formato SS58:

Conocer la identidad pública de nuestro validador. Así, podrás, por ejemplo, buscarlo a través de los exploradores
En caso que quieras nominar, necesitarás convertir la dirección SS58 a formato HEX.

Paso 1: Construye la Clave Pública

Precede tu dirección Ethereum con 24 bytes cero (0x000000000000000000000000) para completar los 32 bytes.

Ejemplo:

0x000000000000000000000000XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Paso 2: Inspecciona la Clave

docker exec -it $(docker ps -q -f volume=sxt-mainnet-data) /usr/local/bin/sxt-node key inspect --public 0x000000000000000000000000XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Obtendrás:

SS58 Address: 5FhXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Esta conversión es determinística y permite interoperabilidad entre claves Ethereum y SS58 en la red SXT.

Cómo Nominar (Opcional)

¿Qué es la nominación y por qué es opcional?

Nominar es el proceso de delegar tus tokens SXT a uno o varios validadores. Este validador puedes ser tu mismo u otros.

Cuando creamos un validador, hemos de asignar un stake mínimo de 100 SXT al mismo. Sobre esta cantidad, es redundante auto-nominarse. No obstante, si posteriormente queremos añadir nuevo Stake a nuestro validador desde la misma address (u otra), podemos realizar este proceso. Aquí tienes una guía para realizar staking de SXT.

Requisitos para realizar la nominación:

Solo puedes nominar validadores activos o en la waiting list.
Necesitarás convertir la dirección SS58 del validador a hexadecimal.

#Conversión de dirección SS58 a HEX (hexadecimal)
SS58_KEY=<Dirección SS58 del validador>
docker run -it --rm \
  --platform linux/amd64 \
  -v sxt-node-key:/data \
  --entrypoint=/usr/local/bin/sxt-node \
  ghcr.io/spaceandtimefdn/sxt-node:mainnet-v0.114.5 \
  key inspect $SS58_KEY

El valor hexadecimal se usará en la transacción de nominación. Aquí de dejamos un práctico sobre dónde poner la dirección obtenida en el Smart Contract para nominar:

❌ No usar formato SS58 para nominar. ✅ Usar formato Hexadecimal para nominar.

FAQ

¿Necesito nominar mi propio validador?

No. Si eres validador, ya tienes tu propio stake.

¿Dónde encuentro direcciones para nominar otros validadores?

En el Explorador de Polk

¿Dónde encuentro mi propio validador?

En el Explorador de Polk, utilizando tu dirección SS58.

PreviousStaking de SXT NextAutoinstall Script

Last updated 8 days ago