> For the complete documentation index, see [llms.txt](https://seednodes.gitbook.io/club-de-nodos/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://seednodes.gitbook.io/club-de-nodos/guias/celestia.md).
# Celestia
{% hint style="info" %}
[Celestia](https://celestia.org/build/) es una red de disponibilidad de datos que optimiza la escalabilidad de Ethereum separando la disponibilidad de datos del consenso y la ejecución. Introduce técnicas innovadoras como el muestreo de disponibilidad de datos y los árboles de Merkle con espacios de nombres, que permiten una verificación eficiente de los datos. Aprender a montar un nodo en Celestia desde cero te proporcionará una comprensión profunda de estas técnicas y te permitirá contribuir activamente a la seguridad y la escalabilidad de la red Ethereum.
{% endhint %}
#### Preparación e instalación del nodo.
### Introducción
> #### **¿Qué es Celestia?**
>
> Celestia es una [data availability network](https://blog.celestia.org/celestia-a-scalable-general-purpose-data-availability-layer-for-decentralized-apps-and-trust-minimized-sidechains) que se adapta de manera segura al crecimiento de usuarios, posibilitando que cualquier individuo lance su propia cadena de bloques.
>
> En la vanguardia de las arquitecturas blockchain escalables, Celestia introduce el concepto de "[modular blockchains](https://celestia.org/learn)". En este enfoque, la escalabilidad se logra [desvinculando la ejecución del consenso](https://arxiv.org/abs/1905.09274) y presentando una novedosa técnica llamada "[data availability sampling](https://arxiv.org/abs/1809.09044)".
>
> En el primer aspecto, Celestia asume la responsabilidad exclusiva de ordenar las transacciones y garantizar la disponibilidad de los datos, equiparable a [reducir el consenso a una transmisión atómica](https://en.wikipedia.org/wiki/Atomic_broadcast#Equivalent_to_Consensus). Por otro lado, el "[data availability sampling](https://coinmarketcap.com/alexandria/article/what-is-data-availability)" ofrece una solución eficiente al desafío de la disponibilidad de datos al exigir que solo los nodos ligeros, con recursos limitados, realicen muestreos en fragmentos aleatorios de cada bloque para verificar dicha disponibilidad.
>
> La participación de más nodos ligeros en este proceso de muestreo aumenta la capacidad segura de la red para manejar datos, posibilitando un incremento en el tamaño del bloque sin un correspondiente aumento en el costo de la verificación de la cadena.
***
#### **Tipos de Nodo:**
Hay muchas formas en las que podes participar en las [redes](https://docs.celestia.org/nodes/participate) de Celestia. Los operadores de nodos de Celestia pueden ejecutar varias opciones en la red.
**Consensus:**
* [Nodo validador](https://docs.celestia.org/nodes/consensus-node#optional-setting-up-a-validator) : este tipo de nodo participa en el consenso produciendo y votando bloques.
* [Nodo de consenso completo](https://docs.celestia.org/nodes/consensus-node) : un nodo completo de la aplicación celestia para sincronizar el historial de blockchain.
**Data Availability:**
* [Bridge node](https://docs.celestia.org/nodes/bridge-node): este nodo sirve de puente entre la red de disponibilidad de datos y la red de consenso.
* [Full storage node](https://docs.celestia.org/nodes/full-storage-node): este nodo almacena todos los datos pero no se conecta a Consensus.
* [Light Node:](https://docs.celestia.org/nodes/light-node) los clientes ligeros realizan muestreos de disponibilidad de datos en la red de disponibilidad de datos.
## Parte 1: Preparación
*\*NOTA: La versión de Ubuntu que se utiliza es la Ubuntu 22.04.4 LTS*
**Cómo instalar los componentes esenciales:**
```
sudo apt update && sudo apt -y upgrade
```
Este comando se encarga de actualizar la lista de paquetes disponibles en los repositorios, y si eso se realiza correctamente, procede a actualizar todos los paquetes instalados en el sistema.
Instalamos paquetes esenciales:
```
sudo apt install curl tar wget aria2 clang pkg-config libssl-dev jq build-essential \
git make ncdu -y
```
#### **Instalando Golang:**
Celestia-Node está escrito en Golang, por lo que primero debemos instalar Golang para construir y ejecutar nuestro nodo.
Configuramos la versión:
```
ver="1.21.1"
```
Descargamos e instalamos Golang:
```
cd $HOME
wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz"
rm "go$ver.linux-amd64.tar.gz"
```
Agregas /usr/local/go/bin en el directorio a $PATH si aún no lo hiciste:
```
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile
source $HOME/.bash_profile
```
Verificamos que se instalo correctamente la versión de Go:
```
go version
```
***
## Parte 2: Instalación
Eliminamos cualquier copia existente de celestia-node, clonamos el repositorio y cambie al directorio:
```
cd $HOME
rm -rf celestia-node
git clone https://github.com/celestiaorg/celestia-node.git
cd celestia-node/
```
Chequeamos la versión deseada, según la red que vamos a usar:
```
git checkout tags/v0.12.4
```
*Construimos el Celestia binary. Existen 2 maneras: Standar y Experimental.*
* *Standar*
```
make build
```
* *Experimental*
Si sos un operador de nodo que se siente cómodo con las funciones experimentales y buscas un rendimiento óptimo con un uso mínimo de RAM, se recomienda esta opción.
```
make build-jemalloc
```
Instalamos el binary:
```
make install
```
Construimos la utilidad de cel-key:
```
make cel-key
```
Verificamos que el binary esté funcionando y verificamos también la versión:
```
celestia version
```
El comando mostrará la versión de celestia-node, el hash de confirmación, la fecha de compilación, la versión del sistema y la versión de Golang.
\*NOTA: Ahora que hemos instalado el nodo, es hora de elegir el tipo y ejecutarlo.
#### Iniciando un Light Node:
Lo primero es crear una instancia (o inicializar) el nodo, que significa configurar un almacén en nuestra máquina, que es donde se almacenarán los datos y nuestras claves.
* **Mainnet:** `celestia light init`
* **Arabica:** `celestia light init --p2p.network mocha`
* **Mocha:** `celestia light init --p2p.network arabica`
Esto mostrará la ubicación de su almacén de nodos y su configuración. También mostrará la confirmación de que el almacén de nodos se ha inicializado.
\*NOTA: En este paso se crea una frase nemotécnica (resguardarla).
**Conectando a un public core endpoint:**
Conexión al Punto Final gRPC del Nodo Validador, por defecto puerto 9090, es esencial para acceder a la capacidad de obtener y enviar información relacionada con el estado. Esto incluye la facultad de enviar transacciones PayForBlob o consultar el saldo de la cuenta del nodo.
```
celestia light start --core.ip
```
\*NOTA: No es necesario declarar una red para Mainnet Beta.
*Ejemplo Mainnet:*
```
celestia light start --core.ip consensus.lunaroasis.net
```
*Usando un RPC propio, o uno de la* [*lista en la página de prueba de Mocha*](https://docs.celestia.org/nodes/mocha-testnet#rpc-endpoints) *o* [*la lista en la página de devnet de Arábica*](https://docs.celestia.org/nodes/arabica-devnet#rpc-endpoints) *, iniciamos el nodo:*
*Ejemplo en Mocha:*
```
celestia light start --core.ip rpc-mocha.pops.one --p2p.network mocha
```
*Ejemplo en Arabica:*
```
celestia light start --core.ip validator-1.celestia-arabica-11.com \
--p2p.network arabica
```
#### **Keys y wallets:**
Podemos crear una clave para el nodo ejecutando el siguiente comando con la utilidad cel-key en el directorio celestia-node:
```
./cel-key add --keyring-backend test \
--node.type light --p2p.network
```
Podemos iniciar nuestro light node con la clave creada anteriormente ejecutando el siguiente comando:
```
celestia light start --keyring.accname my_celes_key \
--core.ip consensus.lunaroasis.net
```
Una vez que iniciamos el light node, se generará una clave para nuestra wallet. Deberemos fondearla esa dirección con tokens de testnet para pagar las transacciones de PayForBlob.
Podemos encontrar la dirección utilizando la CLI de RPC o ejecutando el siguiente comando en el directorio celestia-node:
```
./cel-key list --node.type light --keyring-backend test \
--p2p.network
```
#### **Testnet tokens**
Existen dos redes para obtener tokens de testnet:
* [Arábica Devnet](https://docs.celestia.org/nodes/arabica-devnet#arabica-devnet-faucet)
* [Mocha Testnet](https://docs.celestia.org/nodes/mocha-testnet#mocha-testnet-faucet)
También se accede a ellos ingresando al [Discord](https://discord.gg/ajuUUrRU) de Celestia y solicitándolos de la siguiente manera:
*$request*
*Donde es la dirección celestia1\*\*\*\*\*\* generada cuando creaste la billetera.*
#### **Full storage node:**
Iniciamos con el siguiente comando:
* **Mainnet:** `celestia full init`
* **Arabica:** `celestia full init --p2p.network arabica`
* **Mocha:** `celestia full init --p2p.network mocha`
**Conectando a un public core endpoint:**
Conexión al Punto Final gRPC del Nodo Validador, por defecto puerto 9090, es esencial para acceder a la capacidad de obtener y enviar información relacionada con el estado. Esto incluye la facultad de enviar transacciones PayForBlob o consultar el saldo de la cuenta del nodo.
```
celestia full start --core.ip
```
\*NOTA: No es necesario declarar una red para Mainnet Beta.
*Ejemplo en Mocha:*
```
celestia full start --core.ip rpc-mocha.pops.one --p2p.network mocha
```
*Ejemplo en Arabica:*
```
celestia full start --core.ip validator-1.celestia-arabica-11.com \
--p2p.network arabica
```
#### **Bridge Node:**
Iniciamos con el siguiente comando:
* **Mainnet:** `celestia bridge init`
* **Arabica:** `celestia bridge init --p2p.network arabica`
* **Mocha:** `celestia bridge init --p2p.network mocha`
**Conectando a un public core endpoint:**
Conexión al Punto Final gRPC del Nodo Validador, por defecto puerto 9090, es esencial para acceder a la capacidad de obtener y enviar información relacionada con el estado. Esto incluye la facultad de enviar transacciones PayForBlob o consultar el saldo de la cuenta del nodo.
```
celestia bridge start --core.ip
```
\*NOTA: No es necesario declarar una red en Mainnet Beta.
*Ejemplo en Mocha:*
```
celestia bridge start --core.ip rpc-mocha.pops.one:26657 --p2p.network mocha
```
*Ejemplo en Arabica:*
```
celestia bridge start --core.ip validator-1.celestia-arabica-11.com \
--p2p.network arabica
```
***
Todo el material que se presenta aquí es de acceso público. Para obtener información detallada y seguir los pasos en inglés, se puede visitar la [web oficial](https://docs.celestia.org/nodes/overview).
\
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://seednodes.gitbook.io/club-de-nodos/guias/celestia.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
