# Desplegar tu Validador de Space and Time

<sub>*Fecha de Creación: 10.06.2025*</sub>

<sub>*Fecha actualización: 30.06.2025*</sub>

## 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         | 16                                   |
| ---------------------- | ------------------------------------ |
| Arquitectura CPU       | amd64, con soporte de virtualización |
| Memoria (GiB)          | 64                                   |
| 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](https://azure.microsoft.com/en-us/pricing/#Pricing-by-product), 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! &#x20;

## 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** ](https://docs.ethernodes.io/guias-y-otros/space-and-time/desplegar-tu-validador-de-space-and-time/autoinstall-script)**de instalación del nodo de Space and Time. Esto te permite realizar una instalación mediante docker de manera automática.**&#x20;

{% hint style="danger" %}
 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.*
{% endhint %}

#### 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`<br>

### 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.

{% hint style="info" %}
**Las claves tradicionales de Substrate no se utilizan. Solo se usan claves Ethereum.**
{% endhint %}

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.

{% hint style="info" %}
**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!**
{% endhint %}

## 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](https://etherscan.io/address/0x93d176dd54FF38b08f33b4Fc62573ec80F1da185#writeContract)
* Contrato del Token SXT: [0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195](https://etherscan.io/token/0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195#writeContract)
* Contrato de Registro de SessionKey: [0x70106a3247542069a3ee1AF4D6988a5f34b31cE1](https://etherscan.io/address/0x70106a3247542069a3ee1AF4D6988a5f34b31cE1#writeContract)

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

1. Ve al contrato del token SXT: [0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195](https://etherscan.io/address/0xE6Bfd33F52d82Ccb5b37E16D3dD81f9FFDAbB195)
2. Conecta tu billetera Ethereum
3. Ejecuta approve (*write*) con:

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

<figure><img src="https://898315414-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0jBxWtQKEcPWOBbvzFp3%2Fuploads%2FB7Z7h9PpvxEjSNMSvjDO%2Fmainnet-approve.png?alt=media&#x26;token=eb114b3f-c043-4e9b-89a4-d2875a411745" alt=""><figcaption></figcaption></figure>

### Paso 2: Hacer Stake de Tokens

1. Ve al contrato de staking: [0x93d176dd54FF38b08f33b4Fc62573ec80F1da185](https://etherscan.io/address/0x93d176dd54FF38b08f33b4Fc62573ec80F1da185)
2. Conecta tu billetera
3. Ejecuta stake (*write*)con mínimo 100 SXT (o 100000000000000000000 unidades)

<figure><img src="https://898315414-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0jBxWtQKEcPWOBbvzFp3%2Fuploads%2F81DJ5yfO50YnU5vwhgF1%2Fmainnet-stake.png?alt=media&#x26;token=b044a7fc-8123-4265-86aa-e565571dd969" alt=""><figcaption></figcaption></figure>

### 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
  }'
```

{% hint style="info" %}
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()).
{% endhint %}

**¡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:

1. Conocer la identidad pública de nuestro validador. Así, podrás, por ejemplo, buscarlo a través de los exploradores
2. En caso que quieras nominar, [necesitarás convertir la dirección SS58 a formato HEX](#como-nominar-opcional).

### **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.&#x20;

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](https://docs.ethernodes.io/guias-y-otros/space-and-time/staking-de-sxt).

Requisitos para realizar la nominación:

1. Solo puedes nominar validadores activos o en la *waiting list*.
2. Necesitarás [convertir la dirección SS58](#convertir-direccion-evm-a-formato-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](https://etherscan.io/address/0x93d176dd54FF38b08f33b4Fc62573ec80F1da185#writeContract):

<figure><img src="https://898315414-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F0jBxWtQKEcPWOBbvzFp3%2Fuploads%2FmazoWnEvgOfJmtPPpYCs%2Fnominate.png?alt=media&#x26;token=ece2c24e-f48d-45c3-b012-7a1c40692e6f" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
❌ No usar formato SS58 para nominar.\
✅ Usar formato Hexadecimal para nominar.
{% endhint %}

## 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](https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fnew-rpc.mainnet.sxt.network%2F#/explorer)

#### ¿Dónde encuentro mi propio validador?

En el[ Explorador de Polk](https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fnew-rpc.mainnet.sxt.network%2F#/explorer), utilizando tu dirección SS58.
