Celestia-node RPC CLI tutorial

En este tutorial, cubriremos cómo usar la API RPC de celestia-node para enviar y recuperar datos (blobs) de la capa de disponibilidad de datos por su espacio de nombres.

Introducción

Blobs

Los datos se publican en la capa DA de Celestia utilizando MsgPayForBlobs transacciones a la red central. Leer más sobre MsgPayForBlobs.

Espacios de nombres

Celestia divide los datos de bloque en múltiples espacios de nombres, uno para cada aplicación. Esto permite que las aplicaciones solo descarguen sus datos, y no los datos de otras aplicaciones. Leer más sobre Namespaced Merkle trees (NMTs).

PUNTA

Si ya tiene un nodo en ejecución y financiado, puede saltar al sección de guía de RPC CLI.

ADVERTENCIA

Los puntos finales de la puerta de enlace se han desaprobado y se eliminarán en el futuro. Si desea usarlos de todos modos, puede encuentra más detalles sobre GitHub.

Requisitos de hardware

Se recomiendan los siguientes requisitos mínimos de hardware para ejecutar un nodo de luz:

Memoria: 500 MB RAM (mínimo)
CPU: Núcleo Único
Disco: 50 GB de almacenamiento SSD
Ancho de banda: 56 Kbps para Descargar/56 Kbps para Cargar

Configuración de dependencias

Esta parte del tutorial revisará la configuración de su entorno de desarrollo para ejecutar el software Celestia. Este entorno se puede utilizar para el desarrollo, la construcción de binarios y la ejecución de nodos.

En su terminal, configure las dependencias necesarias para instalar y construir celestia-node.

Si está en Ubuntu, primero actualice y actualice su sistema operativo:

APTO
sudo apt update && sudo apt upgrade -y

YUM
sudo yum update

Instale paquetes esenciales que son necesarios para ejecutar muchas tareas como descargar archivos, compilar y monitorear el nodo:

APTO
sudo apt install curl tar wget clang pkg-config libssl-dev jq \
build-essential git make ncdu -y

YUM
sudo yum install curl tar wget clang pkg-config libssl-dev jq \
build-essential git make ncdu -y

MAC
# these commands are for installing Homebrew, wget and jq
# follow the instructions from the output after running this command
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# then install wget & jq
brew install wget && brew install jq

Instalar Golang

celestia-node está escrito en Golang, por lo que debemos instalar Golang para construir y ejecutar nuestro nodo.

Establezca la versión para su red deseada:

Beta mainnet
ver="1.21.1"

Mocha
ver="1.21.1"

Arabica
ver="1.21.1"

Descargar e instalar Golang:

Ubuntu(AMD)
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"

Ubututu(ARM)
cd $HOME
wget "https://golang.org/dl/go$ver.linux-arm64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.linux-arm64.tar.gz"
rm "go$ver.linux-arm64.tar.gz"

MAC(APPLE)
cd $HOME
wget "https://golang.org/dl/go$ver.darwin-arm64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.darwin-arm64.tar.gz"
rm "go$ver.darwin-arm64.tar.gz"

MAC(INTEL)
cd $HOME
wget "https://golang.org/dl/go$ver.darwin-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go$ver.darwin-amd64.tar.gz"
rm "go$ver.darwin-amd64.tar.gz"

Añade tu /usr/local/go/bin directorio a tu $PATH si aún no lo has hecho:

Bash
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile
source $HOME/.bash_profile

zsh
echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.zshrc
source $HOME/.zshrc

Para verificar que la versión correcta de Go se instaló correctamente, ejecute:

bash

go version

La salida mostrará la versión instalada.

Celestia-nodo

Instalar celestia-node

Instalar celestia-node para Arábica devnet o Mocha testnet significa instalar una versión específica para que sea compatible con la red.

Instale el binario celestia-node ejecutando los siguientes comandos:

Elimine cualquier copia existente de celestia-node, clone el repositorio y cambie al directorio.

bash

cd $HOME
rm -rf celestia-node
git clone https://github.com/celestiaorg/celestia-node.git
cd celestia-node/

Consulte la versión deseada, según la red que utilizará:

Beta Mainnet
git checkout tags/v0.12.4

Mocha
git checkout tags/v0.13.1

Arábica
git checkout tags/v0.13.1

Construir el celestia binario:

a. Construcción estándar

bash

make build

b. Construcción experimental

OPCIONAL

Si usted es un operador de nodo cómodo con características experimentales y busca un rendimiento óptimo con un uso mínimo de RAM, esta opción se recomienda para usted.

bash

make build-jemalloc

Esta opción de compilación permite CGO, y descarga e instala jemalloc. Obtenga más información sobre el comando build.

Instalar el binario:

Ubuntu
make install

Mac
make go-install

Construir el cel-key utilidad:
bash
```
make cel-key
```
Verifique que el binario esté funcionando y verifique la versión:
bash
```
celestia version
```

La salida mostrará la versión semántica de celestia-node, hash de confirmación, fecha de compilación, versión del sistema y versión de Golang.

Instanciar un nodo de luz Celestia

Ahora, instanciemos un nodo Celestia Light:

PUNTA

Los puntos finales de RPC están expuestos en todos los tipos de nodos celestiales, como la luz, el puente y los nodos completos.

Beta Mainnet
celestia light init

Mocha
celestia light init --p2p.network mocha

Arábica
celestia light init --p2p.network arabica

Instanciar (o inicializar) el nodo significa configurar un almacén de nodos en su máquina. Aquí es donde se almacenarán los datos y sus claves.

Conéctese a un punto final central público

Ahora ejecutemos el nodo Celestia Light con una conexión gRPC a un punto final central público de ejemplo.

Nota: También se le recomienda encontrar un punto final de API administrado por la comunidad y hay varios en Discord. Este se utiliza con fines de demostración. Mira el Página de testnet de mocha, o Página arábica devnet.

Beta Mainnet
celestia light start --core.ip <URI>

Mocha
celestia light start --core.ip <URI> --p2p.network mocha

Arábica
celestia light start --core.ip <URI> --p2p.network arabica

PUNTA

El --core.ip el puerto GRPC es predeterminado en 9090, por lo que si no lo especifica en la línea de comandos, será predeterminado en ese puerto. Puede agregar el puerto después de la dirección IP o usar el --core.grpc.port marque para especificar otro puerto si lo prefiere.

Consulte la sección de puertos de la página de solución de problemas de celestia-node para obtener información sobre qué puertos deben estar abiertos en su máquina.

Por ejemplo, su comando junto con un punto final de RPC podría verse así:

Beta Mainnet
celestia light start --core.ip consensus.lunaroasis.net

Mocha
celestia light start --core.ip rpc-mocha.pops.one --p2p.network mocha

Arábica
celestia light start --core.ip validator-1.celestia-arabica-11.com \
  --p2p.network arabica

Llaves y billeteras

Puede crear su clave para su nodo ejecutando el siguiente comando desde el directorio celestia-node:

PUNTA

No necesita declarar una red para Mainnet Beta. Consulte la sección ID de cadena en la página de solución de problemas para obtener más información

bash

./cel-key add <key-name> --keyring-backend test --node.type light \
  --p2p.network <network>

Puede iniciar su nodo de luz con la clave creada ejecutando el siguiente comando:

Beta Mainnet
celestia light start --core.ip <URI> --keyring.accname <key-name>

Mocha
celestia light start --core.ip <URI> --keyring.accname <key-name> \
  --p2p.network mocha
  
Arábica
celestia light start --core.ip <URI> --keyring.accname <key-name> \
  --p2p.network arabica

Una vez que inicie el nodo de luz, se generará una clave de billetera para usted. Deberá financiar esa dirección con Mocha testnet o Arabica devnet tokens para pagar PayForBlobs transacciones.

Puede encontrar la dirección ejecutando el siguiente comando en el directorio celestia-node:

bash

./cel-key list --node.type light --keyring-backend test --p2p.network <network>

Si desea financiar su billetera con tokens de testnet, diríjase a cualquiera de los dos #mocha-faucet o #arabica-faucet canales en el Celestia Discord.

Puede solicitar fondos a la dirección de su billetera utilizando el siguiente comando en Discord:

texto

$request <CELESTIA-ADDRESS>

Donde <CELESTIA-ADDRESS> es el celestia1****** dirección generada cuando creó la billetera.

Con su billetera financiada, puede pasar al siguiente paso.

Guía RPC CLI

Esta sección del tutorial le enseñará cómo interactuar con un nodo de Celestia llamada de procedimiento remoto (RPC) API uso de la interfaz de línea de comandos (CLI).

Tendrás que hacerlo configurar dependencias, instalar y ejecutar celestia-node si aún no lo has hecho.

Formato de comandos

El formato para interactuar con los métodos RPC CLI es el siguiente:

bash

celestia <module> <method> [args...] [flags...]

Dónde:

celestiaes el comando principal para interactuar con el nodo.
<module> es el módulo específico en el nodo con el que desea interactuar, como blob, state, p2p, etc.
<method> es el método específico dentro del módulo que realiza la acción que desea, como blob.Submit, state.AccountAddress, p2p.Info, etc.
[args...]representa cualquier argumento adicional que el método pueda requerir.
[flags...] son parámetros que modifican el comportamiento del comando. Comienzan con -- (por ejemplo., --node.store, --token, o --url).

Por ejemplo, para enviar un blob a Celestia, puede usar este comando una vez que se establezca su almacén de nodos:

bash

celestia blob submit 0x42690c204d39600fddd3 'gm' --node.store $NODE_STORE

Alternativamente, podrías usar el --token bandera para establecer su token de autenticación:

bash

celestia blob submit 0x42690c204d39600fddd3 'gm' --token $AUTH_TOKEN

Antes de probar eso, repasemos las banderas básicas que deberá usar al interactuar con la CLI de RPC. También cubriremos cómo configurar su token de autenticación y cómo usar el almacén de nodos para configurarlo.

Banderas básicas

Todos los comandos RPC CLI tienen indicadores básicos que se pueden usar para interactuar con la API.

Estos incluyen:

--node.store string- la ruta al directorio raíz/hogar de su tienda celestia-node
--token string- token de autorización para realizar solicitudes
--url string- la dirección del RPC, por defecto es http://localhost:26658

Al ejecutar comandos RPC CLI, deberá configurar el token de autenticación o establecer el almacén de nodos, por lo que el token de autenticación se puede recuperar de la tienda.

El RPC CLI maneja estos indicadores en el siguiente orden:

Si el usuario pasa el token de autenticación, se utiliza el token de autenticación.
Si el usuario no pasa el token de autenticación, compruebe el indicador de almacén de nodos, cree el token desde el almacén de nodos y utilice el token de autenticación desde el almacén de nodos.

Token de la verdad 🔐

Para interactuar con la API utilizando RPC CLI, deberá establecer el token de autenticación.

El --token string flag establece el token de autenticación. Si no se encuentra un token, no se establecerá la autenticación. Y si no se establece la autenticación, la solicitud fallará.

Para configurar su token de autenticación, puede usar el siguiente comando. Asegúrese de reemplazar <node-type> con el tipo de nodo y <network> con la red en la que está ejecutando su nodo:

bash

export AUTH_TOKEN=$(celestia <node-type> auth admin --p2p.network <network>)

Aquí hay un ejemplo de cómo configurar su token de autenticación en un nodo de luz en Arábica:

bash

export AUTH_TOKEN=$(celestia light auth admin --p2p.network arabica)

Tienda de nodos

Para interactuar con la API utilizando RPC CLI, también puede usar su almacén de nodos para configurar su token de autenticación. Esto le permitirá interactuar con la API sin configurar un token de autenticación directamente.

Para configurar su almacén de nodos para un nodo de luz en mocha-4, puede usar el siguiente comando:

bash

export NODE_STORE=$HOME/.celestia-light-mocha-4

Luego, establece el --node.store bandera a la $NODE_STORE variable para establecer el token de autenticación desde su almacén de nodos:

bash

celestia <module> <method> [args...] --node.store $NODE_STORE

Token de autor en red personalizada o privada

Esta sección es para usuarios que están usando un CELESTIA_CUSTOM o red privada.

PUNTA

Si está utilizando una red privada y personalizada, lo hará necesita establecer la ubicación del almacén de nodos en su comando auth.

bash

--node.store $HOME/.celestia-light-private)

Lo anterior es un ejemplo de la siguiente red personalizada con:

bash

CELESTIA_CUSTOM=private celestia light init

bash

celestia light init --p2p.network private

Como ejemplo, así es como se vería una red completamente personalizada:

bash

# Initialize node store
CELESTIA_CUSTOM=robusta-22 celestia light init

# Set auth token
export AUTH_TOKEN=$(celestia light auth admin --p2p.network private \
  --node.store $HOME/.celestia-light-robusta-22)

Envío de datos

En este ejemplo, enviaremos una blob a la red con un blob.Enviar transacción con nuestro nodo de luz.

Algunas cosas a considerar:

El punto final entra namespace y data valores.
- El compromiso será generado por el nodo.
- La versión compartida es establecida por el nodo.
El espacio de nombres debe ser de 10 bytes, prefijado por 0x si es hex; de lo contrario, use base64
Los datos pueden codificarse hexadecimalmente (0x...), codificado en base64 ("..."), o una cadena de texto sin formato que se codificará en base64 ('Hello There!')
Opcionalmente, el usuario puede proporcionar una tarifa de gas y un límite de gas.

Utilizamos lo siguiente namespace de 0x42690c204d39600fddd3 y el data valor de 0x676d.

Aquí hay un ejemplo del formato de la blob.Submit transacción:

bash

celestia blob submit <hex-encoded namespace> <hex-encoded data> \
  [optional: fee] [optional: gasLimit] [node store | auth token]

Ejecutamos lo siguiente para enviar un blob a la red en formato hexadecimal:

bash

celestia blob submit 0x42690c204d39600fddd3 0x676d \
  --node.store $NODE_STORE

Obtenemos la siguiente salida:

json

{
  "result": {
    "height": 252607,
    "commitment": "0MFhYKQUi2BU+U1jxPzG7QY2BVV1lb3kiU+zAK7nUiY="
  }
}

También podemos usar una cadena de texto como valor de datos, que se convertirá a base64. Aquí hay un ejemplo del formato:

bash

celestia blob submit <hex-encoded namespace> <'data'> \
  [optional: fee] [optional: gasLimit] [node store | auth token]

Y un ejemplo para enviar "gm" como los datos de texto sin formato:

bash

celestia blob submit 0x42690c204d39600fddd3 'gm' --node.store $HOME/.celestia-light-mocha-4/

Salida:

json

{
  "result": {
    "height": 252614,
    "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
  }
}

Si observa desde la salida anterior, devuelve un result de 252614 que usaremos para el siguiente comando. El result corresponde a la altura del bloque en el que se incluyó la transacción.

Opcional: Enviar con rizo

Consulte el enviar una gota usando curl sección.

Recuperar datos

Después de enviar su transacción PFB, tras el éxito, el nodo devolverá la altura del bloque para el que se incluyó la transacción PFB. Luego puede usar esa altura de bloque y el ID de espacio de nombres con el que envió su transacción PFB para que le devuelvan sus recursos compartidos de mensajes (datos). En este ejemplo, la altura del bloque que obtuvimos fue 252614 que usaremos para el siguiente comando. Lea más sobre las acciones en el Especificaciones de Celestia.

Aquí está lo que un ejemplo del formato de la get el comando se ve como:

bash

celestia blob get <block height> <hex-encoded namespace> \
  <commitment from output above> <node store | auth>

Aquí hay un comando de ejemplo para recuperar los datos de arriba, en arabica-11:

bash

celestia blob get 252614 0x42690c204d39600fddd3 IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E= \
  --node.store $NODE_STORE

Generará la siguiente salida:

json

{
  "result": {
    "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAEJpDCBNOWAP3dM=",
    "data": "gm",
    "share_version": 0,
    "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
  }
}

La salida aquí es base64 decodificada a texto sin formato.

Para ver la respuesta base64, use el --base64 bandera establecida en TRUE (--base64=TRUE):

bash

celestia blob get 252614 0x42690c204d39600fddd3 IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E= \
  --base64=TRUE --node.store $NODE_STORE

La respuesta se verá similar a esto:

json

{
  "result": {
    "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAEJpDCBNOWAP3dM=",
    "data": "Z20=",
    "share_version": 0,
    "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
  }
}

Para obtener todas las manchas en el espacio de nombres a la altura del bloque, use get-all en lugar de get:

bash

celestia blob get-all 252614 0x42690c204d39600fddd3 \
  --node.store $NODE_STORE

Esto devolverá lo siguiente:

json

{
  "result": [
    {
      "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAEJpDCBNOWAP3dM=",
      "data": "gm",
      "share_version": 0,
      "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
    }
  ]
}

Para mostrar la respuesta en base64, use:

bash

celestia blob get-all 252614 0x42690c204d39600fddd3 \
  --base64=TRUE --node.store $NODE_STORE

Lo que volverá:

json

{
  "result": [
    {
      "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAEJpDCBNOWAP3dM=",
      "data": "gm",
      "share_version": 0,
      "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
    }
  ]
}

Establecer el precio del gas

El --gas.price flag le permite especificar el precio del gas para el envío. Si no se especifica, se utilizará un precio predeterminado del gas. El límite de gas se calcula automáticamente en función del tamaño de la gota que se envía.

Para establecer el precio del gas, puede usar el --gas.price bandera. El precio del gas se establecerá como predeterminado (0.002) si no se pasa ningún valor.

Aprender más sobre tarifas y límites de gas.

Para establecer un precio de gas más alto de 0.004 utia, use el --gas.price 0.004 bandera:

bash

celestia blob submit 0x42690c204d39600fddd3 'gm' --gas.price 0.004 \
  --node.store $NODE_STORE

Recibirá la altura y el compromiso del bloque en el que se incluyó la transacción para estos tres ejemplos:

json

{
  "result": {
    "height": 62562,
    "commitment": "IXg+08HV5RsPF3Lle8PH+B2TUGsGUsBiseflxh6wB5E="
  }
}

Ejemplos

Comprueba tu saldo

Consultemos nuestro nodo para el saldo de su cuenta predeterminada (que es la cuenta asociada con el CELESTIA_NODE_AUTH_TOKEN clave que generamos arriba):

bash

celestia state balance --node.store $NODE_STORE

La respuesta se verá similar a:

json

{
  "jsonrpc": "2.0",
  "result": {
    "denom": "utia",
    "amount": "172118057"
  },
  "id": 1
}

Compruebe el saldo de otra dirección

Aquí hay un ejemplo del formato de la balance-for-address comando:

bash

celestia state balance-for-address <address> \
  --node.store $NODE_STORE

Consultemos nuestro nodo para el saldo de otra dirección:

bash

celestia state balance-for-address celestia10rtd9lhel2cuh6c659l25yncl6atcyt37umard \
  --node.store $NODE_STORE

La respuesta será el saldo de la dirección que consultó:

json

{
  "jsonrpc": "2.0",
  "result": {
    "denom": "utia",
    "amount": "1000000"
  },
  "id": 1
}

Obtenga su ID de nodo

Esta es una llamada RPC para obtener la información peerId de su nodo:

bash

celestia p2p info --node.store $NODE_STORE

El ID de nodo está en el ID valor de la respuesta:

json

{
  "jsonrpc": "2.0",
  "result": {
    "ID": "12D3KooWFFhCaAqY56oEqY3pLZUdLsv4RYAfVWKATZRepUPdosLp",
    "Addrs": [
      "/ip4/10.0.0.171/tcp/2121",
      "/ip4/10.0.0.171/udp/2121/quic-v1",
      "/ip4/71.200.65.106/tcp/25630",
      "/ip4/71.200.65.106/udp/25630/quic-v1",
      "/ip6/::1/tcp/2121",
      "/ip6/::1/udp/2121/quic-v1"
    ]
  },
  "id": 1
}

Obtenga la dirección de su cuenta

Esta es una llamada RPC para obtener la dirección de la cuenta de su nodo:

bash

celestia state account-address --node.store $NODE_STORE

Respuesta:

json

{
  "jsonrpc": "2.0",
  "result": "celestia1znk24rh52pgcd9z5x2x42jztjh6raaaphuvrt3",
  "id": 1
}

Obtenga el encabezado del bloque por altura

Aquí hay un ejemplo del formato de la GetByHeight comando:

bash

celestia header get-by-height <height> \
  --node.store $NODE_STORE

Ahora, obtengamos la información del encabezado del bloque.

Aquí obtendremos el encabezado del Bloque 1:

bash

celestia header get-by-height 1 \
  --node.store $NODE_STORE```

It will output something like this:

<!-- markdownlint-disable MD013 -->

```json
{
  "jsonrpc": "2.0",
  "result": {
    "header": {
      "version": {
        "block": "11",
        "app": "1"
      },
      "chain_id": "arabica-11",
      "height": "1",
      "time": "2023-06-27T13:02:39.741743Z",
      "last_block_id": {
        "hash": "",
        "parts": {
          "total": 0,
          "hash": ""
        }
      },
      "last_commit_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
      "data_hash": "3D96B7D238E7E0456F6AF8E7CDF0A67BD6CF9C2089ECB559C659DCAA1F880353",
      "validators_hash": "6363C68770C200FD794445668F9B18F5B1DD1125180D6E8D5AB004F7DD7A0F48",
      "next_validators_hash": "6363C68770C200FD794445668F9B18F5B1DD1125180D6E8D5AB004F7DD7A0F48",
      "consensus_hash": "048091BC7DDC283F77BFBF91D73C44DA58C3DF8A9CBC867405D8B7F3DAADA22F",
      "app_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
      "last_results_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
      "evidence_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
      "proposer_address": "91E04695CF9CF531BC0891E7B1D602B3E8022C86"
    },
    "validator_set": {
      "validators": [
        {
          "address": "91E04695CF9CF531BC0891E7B1D602B3E8022C86",
          "pub_key": {
            "type": "tendermint/PubKeyEd25519",
            "value": "9aNBAxno1B4X5LR2qY5qWqwrMNOzejkctXwzq9BExsg="
          },
          "voting_power": "500000000",
          "proposer_priority": "0"
        }
      ],
      "proposer": {
        "address": "91E04695CF9CF531BC0891E7B1D602B3E8022C86",
        "pub_key": {
          "type": "tendermint/PubKeyEd25519",
          "value": "9aNBAxno1B4X5LR2qY5qWqwrMNOzejkctXwzq9BExsg="
        },
        "voting_power": "500000000",
        "proposer_priority": "0"
      }
    },
    "commit": {
      "height": 1,
      "round": 0,
      "block_id": {
        "hash": "7A5FABB19713D732D967B1DA84FA0DF5E87A7B62302D783F78743E216C1A3550",
        "parts": {
          "total": 1,
          "hash": "D85C907CE660878A8203AC74BAA147CCC1F87114B45B568B72AD207B62AFE45E"
        }
      },
      "signatures": [
        {
          "block_id_flag": 2,
          "validator_address": "91E04695CF9CF531BC0891E7B1D602B3E8022C86",
          "timestamp": "2023-06-30T08:40:19.299137127Z",
          "signature": "qmaEzrnbtgEXCRYc8pCvGRbS+uMuknIBoRAE4qyE7oSgWCRwBVYS/oPReXQLg9ER1oEY1De4MkWvMjlFnQOOCg=="
        }
      ]
    },
    "dah": {
      "row_roots": [
        "//////////////////////////////////////7//////////////////////////////////////huZWOTTDmD36N1F75A9BshxNlRasCnNpQiWqIhdVHcU",
        "/////////////////////////////////////////////////////////////////////////////5iieeroHBMfF+sER3JpvROIeEJZjbY+TRE0ntADQLL3"
      ],
      "column_roots": [
        "//////////////////////////////////////7//////////////////////////////////////huZWOTTDmD36N1F75A9BshxNlRasCnNpQiWqIhdVHcU",
        "/////////////////////////////////////////////////////////////////////////////5iieeroHBMfF+sER3JpvROIeEJZjbY+TRE0ntADQLL3"
      ]
    }
  },
  "id": 1
}

Comandos combinados

bash

celestia share get-by-namespace "$(celestia header get-by-height 147105 \
  --node.store  $NODE_STORE | jq '.result.dah' -r)" 0x42690c204d39600fddd3 \
  --node.store $NODE_STORE

Obtenga estadísticas de muestreadores de disponibilidad de datos

bash

celestia das sampling-stats --node.store $NODE_STORE

Transferir saldo de utia a otra cuenta

Primero, establezca su dirección como una variable:

bash

export ADDRESS=celestia1c425ckmve2489atttx022qpc02gxspa29wmh0d

Luego, transfiera la cantidad de tokens que desea, mientras establece la dirección del destinatario, la tarifa de gas y gasLimit. Así es como se verá el formato:

bash

celestia state transfer $ADDRESS <amount in utia> <gas fee in utia> <gas fee in utia> \
  --node.store $NODE_STORE

Aquí hay un ejemplo, enviando 0.1 TIA, con una tarifa de gas de 0.008 TIA, y un límite de gas de 0.08:

bash

celestia state transfer $ADDRESS 100000 8000 80000 \
  --node.store $NODE_STORE

Si desea devolver el hash de la transacción, puede usar jq:

bash

celestia state transfer $ADDRESS 100000 8000 80000 --node.store $NODE_STORE | jq .result.txhash

Versión API

Para consultar la versión API de su nodo, puede usar el siguiente comando:

bash

celestia node info --node.store $NODE_STORE

Ayuda

Para obtener ayuda y ver el menú CLI, utilice el siguiente comando:

bash

celestia --help

Para ver el menú de ayuda para un método específico, utilice el siguiente comando:

bash

celestia <module> <method> --node.store $NODE_STORE --help

Ejemplo avanzado

Este ejemplo nos muestra usando el jq comando para analizar la salida del celestia header get-by-height método para obtener el encabezado extendido utilizado en celestia share get-by-namespace:

bash

celestia share get-by-namespace \
  "$(celestia header get-by-height 252614 --node.store $NODE_STORE | jq '.result.dah' -r)" \
  0x42690c204d39600fddd3 --node.store $NODE_STORE

Recursos adicionales

Enviar una gota usando curl

Para publicar una gota usando curl, necesitará un nodo de luz que se ejecute con el --core.ip string flag, proporcionando acceso a un punto final de consenso. El indicador indica que el nodo se conecta al nodo de consenso central dado. Ejemplos: 127.0.0.1 o subdomain.domain.tld. El uso de IP o DNS asume que el puerto RPC 26657 y el puerto gRPC 9090 son predeterminados a menos que se especifique lo contrario.

En su terminal, configure el token de autenticación para la red deseada. En este ejemplo, usaremos Mainnet Beta.

bash

export CELESTIA_NODE_AUTH_TOKEN=$(celestia light auth admin --p2p.network celestia)

Publica tu blob con:

bash

curl -H "Content-Type: application/json" -H "Authorization: Bearer $CELESTIA_NODE_AUTH_TOKEN" -X POST --data '{"id": 1,
  "jsonrpc": "2.0",
  "method": "blob.Submit",
  "params": [
    [
      {
        "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAAECAwQFBgcICRA=",
        "data": "VGhpcyBpcyBhbiBleGFtcGxlIG9mIHNvbWUgYmxvYiBkYXRh",
        "share_version": 0,
        "commitment": "AD5EzbG0/EMvpw0p8NIjMVnoCP4Bv6K+V6gjmwdXUKU="
      }
    ],
    {
      "Fee": 10000,
      "GasLimit": 100000
    }
  ]
}' 127.0.0.1:26658

Tras la presentación exitosa de la mancha, el resultado mostrará la altura del bloque:

bash

{"jsonrpc":"2.0","result":362101,"id":1}

La transacción de ejemplo puede ser encontrado en Celenium.

Publicar un SVG como PFB

Si desea crear su propio SVG, publicarlo en Celestia y recuperarlo, puede consultar el Tutorial Base64 SVG.

Guía de golang

Si está interesado en interactuar con la API del nodo en Go (client.go), puedes usar el da-rpc-cliente-tutorial repo.

Solución de problemas

Si encuentra un error como:

"rpc error: code = NotFound desc = account celestia1krkle0n547u0znz3unnln8paft2dq4z3rznv86 not found"

Es posible que la cuenta a la que está intentando enviar PayForBlobs from aún no tiene tokens testnet. Asegúrese de que el grifo de testnet haya financiado su cuenta con tokens y luego intente nuevamente.

PreviousAPI de nodo NextRápido Scavenger

Last updated 6 months ago