DOCSEARCHbyAlgolia
Submit Docs

Celestia Documentation

website·Indexed 38 days ago

https://docs.celestia.org/

Documentation for Celestia's modular data availability layer. Includes guides on posting and retrieving blobs, using Blobstream for contract and client integration, Private Blockspace, and TIA tokenomics. Provides technical tutorials for Go and Rust clients, as well as integration guides for Arbitrum Nitro, Hyperlane, and IBC.

Tokens
44.3K
Snippets
198
Records
334
Agent score
71%

What's inside Celestia

  1. Overview of the Blobstream orchestrator

    The Blobstream orchestrator signs attestations generated within the Celestia-app state machine using a validator's EVM private key. It operates by connecting to a Celestia-app full node or validator node via RPC and gRPC, querying new attestations, signing them, and pushing the signatures to a dedicated P2P network as DHT values.

  2. Overview of Celestia Multisig Accounts

    Celestia supports multisig accounts via the Cosmos SDK. Unlike regular accounts, multisig accounts require a predefined threshold of signatures to authorize a transaction. These accounts can be managed via the celestia-appd command line interface or graphical interfaces like Keplr.

  3. Overview of Arbitrum Nitro with Celestia DA

    Arbitrum Nitro integration allows Orbit chains to utilize Celestia for data availability (DA) as an alternative to Arbitrum AnyTrust. This is achieved through a sidecar architecture where a dedicated celestia-server manages Celestia-specific operations via RPC, ensuring that Nitro nodes remain lightweight.

  4. Overview of the Celestia Foundation Delegation Program

    The Celestia Foundation Delegation Program provides stake to a subset of validators (up to 35 of the 100 total active validator slots) to ensure a proficient, trustworthy, and dependable validator set while maintaining network stability. The program is organized into cohorts every 6 months. Most cohort members receive delegations for 12 months, while a smaller group (the bottom 7 validators) renews every 6 months.

  5. Overview of Blobstream architecture

    Blobstream enables Ethereum developers to build high-throughput L2s by using Celestia as a Data Availability (DA) layer. It allows an L2 to post data to Celestia and then verify that the data was published directly on a target EVM chain (such as Ethereum) via the Blobstream smart contract.

    Blobstream consists of two primary components:

    1. Orchestrator: Part of the validator setup. It queries attestations created by the Celestia App, signs them, and submits the signatures to the Blobstream P2P network.
    2. Relayer: Submits the attestation signatures from the Blobstream P2P network to the target EVM chain.

    Verification flow: Celestia validators sign commitments to the data $\rightarrow$ signatures are relayed to the EVM chain $\rightarrow$ the L2 or any party verifies the publication via the Blobstream smart contract.

  6. Overview of IBC on Celestia

    IBC (Inter-Blockchain Communication) is a protocol used on Celestia for authenticated, permissionless message passing and cross-chain asset transfers between Celestia-native chains and other compatible blockchains. It serves as one of the primary bridging standards alongside Hyperlane.

  7. Overview of OP Stack integration with Celestia

    The OP Stack integration with Celestia allows rollups to use Celestia as a modular data availability (DA) layer. Instead of posting transaction data as calldata to Ethereum, rollups post data to Celestia while continuing to settle on Ethereum, which reduces operational costs and improves scalability.

  8. Overview of the Lumina Rust client

    The Lumina Rust client (celestia-client) provides a high-level API for interacting with Celestia nodes via RPC and gRPC. It abstracts the lower-level celestia-rpc and celestia-grpc crates into a unified Client that supports two primary operational modes:

    1. Read-only mode: Used to query headers, blobs, and state via RPC (and optionally gRPC).
    2. Submit mode: Used to build, sign, and broadcast transactions (such as transfers and PayForBlobs) using gRPC and a local signer.

    The client re-exports essential Celestia types, including namespaces, blobs, and app versions, making it the primary integration point for Rust applications performing data retrieval and blob submission.

  9. Overview of Celestia Private Blockspace

    Private Blockspace is a framework that allows networks to publish encrypted state to Celestia. It ensures that sensitive data (such as positions, balances, and routing logic) remains confidential while remaining publicly accountable. This is achieved by adding an encryption and proof layer between the application and Celestia's data availability layer, implemented via the Private Blockspace Proxy. This allows anyone to verify data availability and protocol commitments without revealing the underlying plaintext.

  10. Overview of Celestia's Data Availability Layer

    Celestia is a modular data availability (DA) network that orders blobs and ensures they are available for execution and settlement layers. It decouples execution from consensus, allowing light nodes to verify that block data has been published and is downloadable without requiring them to download the entire block. This prevents the chain from stalling or being exploited due to missing transaction data.

  11. Overview of IBC relaying in Celestia

    Celestia utilizes the Inter-Blockchain Communication (IBC) protocol to enable cross-chain token transfers. Relayers are required to scan for outbound packets on one chain and submit them with proofs on the destination chain. The two standard relayer implementations are Hermes (written in Rust) and Go Relayer (written in Go).

  12. Overview of Celestia Private Blockspace

    Private blockspace allows users to encrypt blob data before it is posted to the Celestia network. This is achieved using a lightweight proxy that handles the encryption process. For developers who do not wish to run their own local Celestia nodes, hosted infrastructure (such as QuickNode) can be used to implement this end-to-end encrypted workflow in a fully containerized environment.