# What Is DA Compression in Fuel Core? Architecture and Implementation Guide

> Discover DA compression in Fuel Core, a storage optimization that secures historic block data off-chain while guaranteeing availability. Learn about its architecture and implementation.

- Repository: [Fuel Labs/fuel-core](https://github.com/FuelLabs/fuel-core)
- Tags: internals
- Published: 2026-03-06

---

**DA compression in Fuel Core is a configurable storage optimization that compresses historic block data into a compact representation containing only headers and transaction IDs, storing full transaction payloads off-chain while maintaining data-availability guarantees through a dedicated compression service.**

DA compression (Data‑Availability compression) is a first‑class feature of the [FuelLabs/fuel-core](https://github.com/FuelLabs/fuel-core) repository designed to reduce on‑chain storage requirements. When enabled, the node maintains a temporal registry of compressed blocks in a separate RocksDB column family, allowing operators to specify retention periods for historic data while keeping essential metadata accessible via the GraphQL API.

## How DA Compression Works in Fuel Core

### The DaCompressionMode Configuration Enum

At the heart of the feature lies the `DaCompressionMode` enum defined in [`crates/fuel-core/src/service/config.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/config.rs). This enum controls whether compression is active and configures retention policies via the `DaCompressionConfig` struct.

```rust
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum DaCompressionMode {
    #[default]
    Disabled,
    Enabled(DaCompressionConfig),
}

```

*Source:* [[`crates/fuel-core/src/service/config.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/config.rs) (lines 440‑447)](https://github.com/FuelLabs/fuel-core/blob/master/crates/fuel-core/src/service/config.rs#L440-L447)

### The Compression Service Architecture

When the node starts, [`sub_services.rs`](https://github.com/FuelLabs/fuel-core/blob/main/sub_services.rs) inspects the configuration variant. If enabled, it spawns the **CompressionService** from `crates/services/compression`. This background task watches the block production pipeline, compresses completed blocks, and maintains a temporal registry mapping block‑level keys (addresses, contract IDs, script code) to their compressed values.

```rust
let compression_service = match &config.da_compression {
    DaCompressionMode::Disabled => None,
    DaCompressionMode::Enabled(cfg) => Some(CompressionService::new(cfg.clone())),
};

```

*Source:* [[`crates/fuel-core/src/service/sub_services.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/sub_services.rs) (lines 452‑456)](https://github.com/FuelLabs/fuel-core/blob/master/crates/fuel-core/src/service/sub_services.rs#L452-L456)

### VersionedCompressedBlock and Storage Format

The core data structure `VersionedCompressedBlock` lives in [`crates/compression/src/lib.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/compression/src/lib.rs). It stores the block header and a list of transaction IDs without the full transaction payloads, dramatically reducing the storage footprint while preserving data‑availability proofs.

## Enabling DA Compression: Code Examples

### CLI Parsing in the Fuel Core Binary

The `fuel-core` binary accepts the `--da-compression` flag in [`bin/fuel-core/src/cli/run.rs`](https://github.com/FuelLabs/fuel-core/blob/main/bin/fuel-core/src/cli/run.rs), converting the retention duration into the enabled mode.

```rust
let da_compression = match da_compression {
    Some(retention) => DaCompressionMode::Enabled(DaCompressionConfig {
        retention_duration: retention,
        ..Default::default()
    }),
    None => DaCompressionMode::Disabled,
};

```

*Source:* [[`bin/fuel-core/src/cli/run.rs`](https://github.com/FuelLabs/fuel-core/blob/main/bin/fuel-core/src/cli/run.rs) (lines 595‑607)](https://github.com/FuelLabs/fuel-core/blob/master/bin/fuel-core/src/cli/run.rs#L595-L607)

### Config Struct Integration

The top‑level `Config` struct holds the compression mode alongside other node settings.

```rust
pub struct Config {
    // ...
    pub da_compression: DaCompressionMode,
    // ...
}

```

*Source:* [[`crates/fuel-core/src/service/config.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/config.rs) (lines 101‑106)](https://github.com/FuelLabs/fuel-core/blob/master/crates/fuel-core/src/service/config.rs#L101-L106)

## Accessing Compressed Blocks via GraphQL

### Schema and Resolver Implementation

The GraphQL layer exposes compressed blocks through [`crates/fuel-core/src/schema/da_compressed.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/schema/da_compressed.rs). The resolver obtains the `DaCompressionProvider` from the context to fetch `VersionedCompressedBlock` data from the off‑chain store.

```rust
let da_compression_provider = ctx.data_unchecked::<DaCompressionProvider>();

```

*Source:* [[`crates/fuel-core/src/schema/da_compressed.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/schema/da_compressed.rs) (lines 42‑44)](https://github.com/FuelLabs/fuel-core/blob/master/crates/fuel-core/src/schema/da_compressed.rs#L42-L44)

GraphQL queries use the `daCompressedBlock` field:

```graphql
type Query {
  daCompressedBlock(height: UInt32!): DaCompressedBlock
}

```

## Testing DA Compression

### Integration Test Validation

The test suite in [`tests/tests/da_compression.rs`](https://github.com/FuelLabs/fuel-core/blob/main/tests/tests/da_compression.rs) verifies the full pipeline, ensuring that nodes can start, produce blocks, restart with compression enabled, and correctly populate the compression database.

```rust
#[tokio::test]
async fn da_compression__starts_and_compresses_blocks_correctly_from_empty_database() {
    // 1. Start node without compression.
    // 2. Produce a few blocks.
    // 3. Restart node with `--da-compression 7d`.
    // 4. Ensure compressed blocks appear in the compression DB.
}

```

*Source:* [[`tests/tests/da_compression.rs`](https://github.com/FuelLabs/fuel-core/blob/main/tests/tests/da_compression.rs) (lines 214‑236)](https://github.com/FuelLabs/fuel-core/blob/master/tests/tests/da_compression.rs#L214-L236)

## Key Source Files in the Fuel Core Repository

Understanding DA compression requires familiarity with these specific files:

- **[`crates/fuel-core/src/service/config.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/config.rs)** – Defines `DaCompressionMode`, `DaCompressionConfig`, and the top‑level `Config` struct.
- **[`crates/fuel-core/src/service/sub_services.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/service/sub_services.rs)** – Wires the `CompressionService` into the node’s service graph based on the configuration variant.
- **[`crates/fuel-core/src/schema/da_compressed.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/fuel-core/src/schema/da_compressed.rs)** – Implements the GraphQL resolver and `DaCompressionProvider` interface.
- **[`crates/services/compression/src/lib.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/services/compression/src/lib.rs)** – Public API of the compression service, exposing the background task and configuration ports.
- **[`crates/compression/src/lib.rs`](https://github.com/FuelLabs/fuel-core/blob/main/crates/compression/src/lib.rs)** – Core data structures including `VersionedCompressedBlock` and `CompressedBlockPayload`.
- **[`bin/fuel-core/src/cli/run.rs`](https://github.com/FuelLabs/fuel-core/blob/main/bin/fuel-core/src/cli/run.rs)** – Parses the `--da-compression` CLI argument and initializes the config.
- **[`tests/tests/da_compression.rs`](https://github.com/FuelLabs/fuel-core/blob/main/tests/tests/da_compression.rs)** – End‑to‑end integration tests exercising the compression pipeline.

## Summary

- **DA compression** reduces on‑chain storage by retaining only block headers and transaction IDs, moving full transaction data to an off‑chain RocksDB column family.
- **`DaCompressionMode`** controls the feature via CLI flags, supporting configurable retention periods through `DaCompressionConfig`.
- **`CompressionService`** runs as a background sub‑service, asynchronously compressing blocks and maintaining the temporal registry for efficient historical lookups.
- **`VersionedCompressedBlock`** serves as the compact, versioned storage format for compressed payloads.
- **GraphQL integration** exposes compressed data via the `daCompressedBlock` query, backed by the `DaCompressionProvider` trait.
- The implementation spans the configuration layer, service architecture, compression algorithms, and public API surface of `fuel-core`.

## Frequently Asked Questions

### What triggers DA compression in Fuel Core?

The compression service activates automatically when the node starts with `DaCompressionMode::Enabled`. It listens for newly produced blocks via the block production pipeline and compresses them asynchronously, writing the resulting `VersionedCompressedBlock` to a dedicated storage column without blocking consensus or block import.

### How do I enable DA compression on my Fuel Core node?

Pass the `--da-compression` flag followed by a retention duration when starting the binary. For example, `--da-compression 7d` enables compression with a seven‑day retention window. The parser in [`bin/fuel-core/src/cli/run.rs`](https://github.com/FuelLabs/fuel-core/blob/main/bin/fuel-core/src/cli/run.rs) converts this argument into `DaCompressionMode::Enabled(DaCompressionConfig { retention_duration: ... })`, which the service constructor uses to initialize the background compressor.

### Does DA compression affect data availability or security?

No critical data is lost. The compressed representation preserves the block header and transaction IDs, maintaining data‑availability guarantees required for validation. Only the full transaction payloads move to off‑chain storage, remaining accessible through the node’s database or GraphQL queries via the `DaCompressionProvider` interface.

### Can I disable DA compression after enabling it?

Yes, but changing modes requires a node restart. Setting `DaCompressionMode::Disabled` stops the compression service and returns the node to storing full blocks in the main database. Historical compressed blocks already written to the compression column family remain there until the configured retention period expires or manual pruning occurs.