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: 26.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.

--> AUTOINSTALL SCRIPT <--

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 con:

Dirección del contrato de staking: 0x93d176dd54FF38b08f33b4Fc62573ec80F1da185
Límite de tokens a aprobar

Paso 2: Hacer Stake de Tokens

Ve al contrato de staking: 0x93d176dd54FF38b08f33b4Fc62573ec80F1da185
Conecta tu billetera

Ejecuta stake con mínimo 100 SXT (o 100000000000000000000 unidades)

Solo para Validadores

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()).

Convertir Dirección EVM a Formato SS58

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)

Solo puedes nominar validadores activos.

Convierte la dirección SS58 del validador a 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:

[0x1234, 0x3456, 0x5678]

❌ No usar formato SS58 ✅ Usar formato Hexadecimal

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

PreviousStaking de SXT NextAutoinstall Script

Last updated 0 minutes ago