Celestia 백서

Celestia

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 20쪽 중 3쪽

after the previous command succeeds. The checks require exactly one JSON response with the expected result fields, including when the response is empty. A failed submission or validation leaves any existing `receipt.json` unchanged; do not use an old receipt for this attempt. An empty response or timeout does not prove that payment failed. Reconcile settlement as described below before retrying. On success, `Submit` has uploaded the shards, collected signatures and confirmed the payment transaction. Save all three receipt fields. For example, the validated small-blob run returned: ```json { "blob_id": "AMGy8xgg3+lxgxQxMedurPYBoj8Q9V1eZWH05AEyeNTk", "height": 1111896, "tx_hash": "26E4B81DC2E88F41301F89FD36B7852B049653CFC7F03DF7153AEBDA5F3F49BE" } ``` Your transaction hash and height will differ. The full response also contains `validator_signatures` and `payment_promise`. Download your own freshly submitted blob rather than relying on the historical example remaining stored. ## Download and verify the bytes Pass the returned `blob_id` unchanged. In JSON-RPC it is base64, whereas the native Go client's `BlobID.String()` prints hexadecimal. A payment promise hash shown by an explorer is a separate identifier, not the download blob ID. ```bash BLOB_ID=$(jq -er '.blob_id' receipt.json) jq -nc --arg id "$BLOB_ID" \ '{jsonrpc:"2.0",id:5,method:"fibre.Download",params:[$id]}' \ | rpc > download.json python3 - <<'PY' import base64, hashlib, json response = json.load(open('download.json')) if 'error' in response: raise SystemExit(response['error']) data = base64.b64decode(response['result']['data'], validate=True) if data != open('original.bin', 'rb').read(): raise SystemExit('Downloaded bytes differ from original') open('downloaded.bin', 'wb').write(data) print('Verified identical bytes; SHA-256:', hashlib.sha256(data).hexdigest()) PY ``` The response's `result` is `{"data":"SGVsbG8sIEZpYnJlIQo="}` for this payload. The expected SHA-256 is: ```text f0e7fdccb71e36e867930a1f6f0b55bf5cdb5d0d8eca369a8675a7c1cec64cba ``` ## Larger blobs and the native client There are two different size limits in the tested releases: | Path | Limit | |---|---| | Fibre version-0 payload | 128 MiB minus the 5-byte header: 134,217,723 bytes | | Node HTTP JSON-RPC request | 16 MiB including JSON and base64, leaving slightly less than 12 MiB for payload | The [node RPC server](https://github.com/celestiaorg/celestia-node/blob/v0.34.2-mocha/api/rpc/server.go) limits the request body independently of the [Fibre protocol](https://github.com/celestiaorg/celestia-app/blob/v10.2.0-mocha/fibre/protocol_params.go). For larger blobs, use the native celestia-app [Fibre client](https://github.com/celestiaorg/celestia-app/blob/v10.2.0-mocha/fibre/client.go). Its upload sends shards directly to validators; only the payment transaction goes through core. See [`fibre.Put`](https://github.com/celestiaorg/celestia-app/blob/v10.2.0-mocha/fibre/client_put.go) for a combined upload/settlement example and [`tools/fibre-txsim`](https://github.com/celestiaorg/celestia-app/blob/v10.2.0-mocha/tools/fibre-txsim/main.go) for the separate upload, transaction and download steps. Storage charges use the encoded, padded size, not just the original file's length. The release's [payment calculation](https://github.com/celestiaorg/celestia-app/blob/v10.2.0-mocha/x/fibre/types/gas.go) explains the charge. The observations below are test results, not permanent prices or performance guarantees. Budget escrow and transaction gas separately. ### Verified Mocha results Tests on 25 September 2026 used celestia-node v0.34.2-mocha for JSON-RPC and celestia-app v10.2.0-mocha for the native client. Each successful run confirmed settlement and verified downloaded bytes against the original payload and hash. | Payload | Path | Settlement height | Escrow charge, excluding gas | |---|---|---|---| | 14 bytes | JSON-RPC | [1,111,896](https://testnet.celestia.valopers.com/transactions/26E4B81DC2E88F41301F89FD36B7852B049653CFC7F03DF7153AEBDA5F3F49BE) | 0.695 testnet TIA | | 10 MiB | JSON-RPC | [1,112,086](https://testnet.celestia.valopers.com/transactions/B937331E897D90D6B50AD6F7630AF681F970D2577D1D3463A067F1D386A8832C) | 2.495 testnet TIA | | 128 MiB minus 5 bytes | Native Go | [1,113,071](https://testnet.celestia.valopers.com/transactions/ADD4C5190131D0AFB55AF3341B347700B2ADEC2B128FAF3C7CA06495852C5C16) | 23.69 testnet TIA | The maximum-size run's SHA-256 was `53a0a70e69fac696d73438aada6cfa989c5a36c90c3164525f262fed2775721f`. Its blob ID was `AJ+0/lcm8YgL/06EFKHMnnMaQfJp/ChDQskMk7rkd8FQ`; the [Tensile record](https://tensile.huginn.tech/blob/?tx=ADD4C5190131D0AFB55AF3341B347700B2ADEC2B128FAF3C7CA06495852C5C16) links to the settlement transaction. Tensile accepts transaction hashes, blob IDs (base64 or hexadecimal), and payment promise hashes. If an identifier matches multiple records, it shows all matches. The native test trusted the selected core endpoint for validator state; the light-node path uses locally verified headers. ## Retention and withdrawals Fibre storage is time-limited. Query current Mocha parameters before planning retention or a withdrawal: ```bash curl --fail --silent --show-error \ https://api-mocha.pops.one/fibre/v1/params | jq '.params' ``` `shard_retention` determines the minimum shard-retention period; `payment_promise_timeout` bounds the settlement promise. Keep your own copy of the data: a confirmed payment is not a permanent storage guarantee. `fibre.Withdraw` requests a withdrawal, reducing available escrow. The chain processes it after `withdrawal_delay`; it is not an immediate wallet transfer. Use `fibre.PendingWithdrawals` with the signer's address to inspect the amount and `available_timestamp`. Do not reuse escrow committed to outstanding payment promises, including uploads whose settlement outcome is still unknown. ## Asynchronous uploads and recovery `fibre.Upload` returns after upload and starts settlement in the background. In v0.34.2-mocha, background settlement errors are logged. An upload result is not proof of confirmed payment. Use `Submit` for the first walkthrough. A timeout or rate limit while confirming a transaction does not prove that it failed. In the maximum-size test, the core endpoint returned HTTP 429 during confirmation even though the transaction had settled. A second endpoint confirmed execution code `0` and the matching Fibre event. Before resubmitting, check the transaction hash, node logs and chain state through a working endpoint or explorer. Native clients should retain the broadcast transaction hash before waiting for confirmation. If the client returns no hash, inspect the signer's transactions and match the namespace and commitment. Signed promises can also be charged through the timeout path after an upload failure; blindly retrying can create another payment obligation. ## Troubleshoot the walkthrough | Symptom | Check | |---|---| | `fibre client is not available` | Configure a Fibre-capable core endpoint, then restart the node. | | Missing Fibre services or method not found | Check both the node release and the core endpoint's app version and exposed services. | | Unfunded signer or insufficient escrow | Verify the selected key/address; fund the wallet and deposit into that signer's escrow. Retain wallet funds for gas. | | Deposit gas-estimation panic after faucet funding | Restart v0.34.2-mocha after the signer is funded, then query escrow before retrying. | | Header syncing or historical state unavailable | Wait for header sync and use a core endpoint that serves the required state. | | Not enough voting power, unreachable providers or TLS failures | Check registered/reachable provider stake and client logs. Some stored shards may be retrievable even when signature quorum was not reached. | | HTTP 429 or uncertain settlement | Back off or use another endpoint; reconcile payment status before resubmitting. | | Large JSON-RPC request rejected | Account for base64 and JSON overhead, or use the native client. | | Download fails after retention expires | Recover from your own stored copy. The on-chain receipt does not contain the blob bytes. | --- Title: Overview to posting and retrieving blobs on Celestia URL: https://docs.celestia.org/build/post-retrieve-blob/overview.md Source: app/build/post-retrieve-blob/overview/page.mdx --- # Overview to posting and retrieving blobs on Celestia This section will show you how to post and retrieve blobs on Celestia using the transaction client in Golang and Rust. There are two transaction clients available: | Option | What you need | Endpoints to set | Guides | | ---------- | ----------------------------------- | --------------------------------- | --------------------------------------------------------- | | **Golang** | Local keyring handled by the client | **2** — DA bridge RPC + Core gRPC | [Go client tutorial](/build/post-retrieve-blob/client/go) | | **Rust** | Local keyring handled by the client | **2** — DA bridge RPC + Core gRPC | [Rust client](/build/post-retrieve-blob/client/rust) | For Fibre storage on Mocha, follow [Submit and retrieve a Fibre blob](/build/post-retrieve-blob/fibre). That guide covers escrow, on-chain settlement, retrieval and the separate Fibre size limits. --- Title: About Private Blockspace URL: https://docs.celestia.org/build/private-blockspace/about.md Source: app/build/private-blockspace/about/page.mdx --- # About Private Blockspace The highest-stakes onchain markets—including perpetual exchanges, order books, and institutional rails—depend on information that cannot be public. Positions, balances, liquidations, and routing logic are inherently sensitive. Yet pushing that data offchain reintroduces trusted operators and weakens the core promise of being onchain: **independent auditing, verifiability, and safe exits when it matters most.** **Private Blockspace** is Celestia’s approach to solving this problem: keep sensitive state **confidential**, while still making it **publicly accountable**. Private Blockspace enables networks to publish **encrypted state to Celestia**, allowing anyone to verify data availability and protocol commitments **without revealing the underlying contents**. The result is **private systems with public verifiability guarantees**—fault-resistant, auditable, and designed to support safe exit mechanisms. At a high level, Private Blockspace adds an encryption + proof layer between your application and Celestia’s data availability layer. This layer is implemented as the **Private Blockspace Proxy**: a lightweight service that encrypts, proves, and routes data **without modifying existing Celestia integrations**. ## Submitting a blob The Private Blockspace Proxy acts as an intermediary between your JSON-RPC client and the Celestia network. When you submit a blob: 1. The proxy encrypts the data. 2. The proxy generates a proof inside a zkVM attesting to correct encryption and any configured “anchors” about the plaintext. 3. The proxy stores the job result in a local database and returns an acknowledgement while processing continues. 4. Once the proof completes, the result is cached so identical submissions can return immediately. 5. The proxy submits the verifiably encrypted blob to Celestia via `blob.Submit`. From the client’s perspective, posting encrypted data feels like a single RPC call, while the proxy handles encryption, verifiability, and coordination with Celestia behind the scenes. ```mermaid sequenceDiagram participant JSON RPC Client participant Proxy participant Celestia Node JSON RPC Client->>+Proxy: blob.Submit(blobs, options)<br>{AUTH_TOKEN in header} Proxy->>Proxy: Job Processing...<br>{If no DB entry, start new zkVM Job} Proxy->>-JSON RPC Client: Response{"Call back"} Proxy->>Proxy: ...Job runs to completion... JSON RPC Client->>+Proxy: blob.Submit(blobs, options)<br>{AUTH_TOKEN in header} Proxy->>Proxy: Query Job DB<br>Done!<br>{Job Result cached} Proxy->>Celestia Node: blob.Submit(V. Encrypt. blobs, options) Celestia Node->>Proxy: Response{Inclusion Block Height} Proxy->>-JSON RPC Client: Response{Inclusion Block Height} ``` ## Retrieving a blob When retrieving a blob, the proxy behaves as a transparent relay: 1. The client calls `blob.Get(height, namespace, commitment)`. 2. The proxy forwards the request to a Celestia node. 3. The proxy receives the raw blob response. 4. The proxy attempts to deserialize and decrypt using the configured encryption key. If the blob was encrypted through the proxy, decryption succeeds and the proxy returns the original plaintext bytes. If it was not, the proxy passes the response through unchanged. This ensures compatibility with both encrypted and unencrypted blobs, so existing clients can adopt Private Blockspace incrementally. ```mermaid sequenceDiagram participant JSON RPC Client participant Proxy participant Celestia Node JSON RPC Client->>+Proxy: blob.Get(height, namespace, commitment) Proxy->>Celestia Node: <Passthrough> Celestia Node->>Proxy: Response{namespace,data,<br>share_version,commitment,index} Proxy->>Proxy: *Try* deserialize & decrypt Proxy->>-JSON RPC Client: *Success* -> Response{...,decrypted bytes,...} Proxy->>JSON RPC Client: *Failure* -> <Passthrough> ``` ## Verifiable Encryption (VE) With normal encryption, ciphertext should be indistinguishable from random noise. That property is what keeps data private—but it also makes it difficult to prove _anything_ about encrypted data without decrypting it. Private Blockspace uses **Verifiable Encryption (VE)** to bridge this gap. VE enables proofs of _select properties_ of fully encrypted data **without decryption**. For example, a system can prove statements like: - “This encrypted blob contains a Merkle proof whose root is `0xabc123…`” - “This ciphertext was produced using the expected algorithm, key format, and nonce rules” - “The plaintext hashes to a specific commitment” This is accomplished by running encryption inside a zkVM, producing a proof that encryption was executed correctly while also exposing application-defined “anchors” (such as hashes or commitment checks) that remain safe to reveal. **Outcome:** anyone can verify availability and correctness constraints, while only authorized parties can decrypt the underlying contents. ## Key exchange and management strategies A critical design question in Private Blockspace is key management: > If keys are withheld, then the data is effectively withheld. Private Blockspace is designed to support different key exchange and reconstruction strategies depending on your application requirements and threat model. ### Account-centric model A proposed account-centric model enforces that **all account state is published and available**, while also being encrypted such that only the intended party (or parties) can decrypt. Key properties of this approach: - **User-defined encryption keys:** users define keys for encrypting their own account state, ensuring they can always decrypt their data and enabling forward secrecy. - **Conditional selective disclosure:** users can allow decryption by specific parties using standard public key cryptography, key exchange protocols, and/or threshold schemes. - **User-initiated protocol progression:** applications can allow users to progress the protocol themselves by proving correct state transitions onchain, enabling “forced” state updates such as withdrawals. This model is designed to support systems that remain private during normal operation, while still enabling safe exits and recovery paths under application-defined conditions. ## Use cases Private Blockspace is designed for applications where **privacy is required**, but **public accountability cannot be sacrificed**. ### Accountable offchain exchanges Operators of offchain or hybrid exchanges can keep internal state private while still being required (by protocol design) to prove state availability and commitments publicly. This improves fault tolerance and auditability without forcing users to trust an opaque operator for safe exits. **In production: Hibachi** Hibachi is the first independent deployment using Private Blockspace for a fast perps exchange. Hibachi publishes verifiably encrypted exchange state to Celestia, keeping balances and positions private while making data availability and correctness publicly verifiable. ### Trust-minimized data marketplaces Private Blockspace can also support trust-minimized private data markets: - sellers publish verifiably encrypted data to Celestia - buyers verify availability and integrity before payment—without seeing the plaintext - payment is enforced only once availability is proven This shifts trust away from intermediaries and toward verification, producing private exchange workflows that are auditable and fault-resistant by design. ## References and further reading - [Private Blockspace Proxy repo on GitHub](https://github.com/celestiaorg/private-blockspace-proxy/) - [Verifiable Encryption (VE) in depth](https://github.com/celestiaorg/private-blockspace-proxy/blob/main/doc/verifiable_encryption.md) - [Forum post: Account-centric model](https://forum.celestia.org/t/account-user-centric-private-blockspace/2155) --- Title: Private blockspace quickstart URL: https://docs.celestia.org/build/private-blockspace/quickstart.md Source: app/build/private-blockspace/quickstart/page.mdx --- # Private blockspace quickstart Private blockspace encrypts your blob data before it’s posted to Celestia using a lightweight proxy. In this quickstart, you’ll use hosted Celestia nodes (like Quicknode) instead of running your own. ## Troubleshooting | Error message | Cause | Fix | | --- | --- | --- | | `TLS_CERTS_PATH required` | Missing or commented-out cert vars | Generate certs (see above). | | `account not found` | Unfunded signer | Use [Mocha faucet](https://faucet.celestia-mocha.com). | | `blob: not found` | Wrong commitment | Run `blob.GetAll` to find the real one. | | `grpc-status header missing` | Invalid gRPC URL | Must be `https://<host>:9090`, no token. | ## ✅ You’re done You’re running **private blockspace** end-to-end using hosted infrastructure. ✅ No local Celestia node ✅ Fully containerized ✅ Encrypted data posted to Celestia --- Title: Client Libraries URL: https://docs.celestia.org/build/rpc/clients.md Source: app/build/rpc/clients/page.mdx --- # Client Libraries Celestia Node API can be accessed through various client libraries in different programming languages. ## Official Clients ### Golang Client Official Go implementation of the Celestia Node RPC client and Transaction Client - **Repository**: [celestiaorg/celestia-node @ /api/client](https://github.com/celestiaorg/celestia-node/tree/main/api/client) - **Tutorial**: [Go Client Tutorial](/build/post-retrieve-blob/client/go/) - Learn how to submit and retrieve blobs without running your own node ### Rust Client Official Rust implementation of the Celestia Node RPC client (Lumina) - **Repository**: [celestiaorg/lumina](https://github.com/celestiaorg/lumina) - **Tutorial**: [Rust Client Tutorial](/build/post-retrieve-blob/client/rust/) - Submit and retrieve blobs using the Lumina Rust client ## Community Clients ### Python Client Community-maintained Python client for the Celestia Node RPC API - **Repository**: [grumpyp/celestia-node-client-py](https://github.com/grumpyp/celestia-node-client-py) ### TypeScript Client Community-maintained TypeScript/JavaScript client for the Celestia Node RPC API - **Repository**: [ashishbhintade/cntsc](https://github.com/ashishbhintade/cntsc) ## Getting Started Each client library provides methods to interact with the Celestia Node RPC API. Choose the language that best fits your project requirements. For API reference and method documentation, see the [Node API](/build/rpc/node-api) section. --- Title: Node API URL: https://
프로젝트로 돌아가기