# Amadeus Protocol Block Time: Technical Deep Dive

> Discover the Amadeus Protocol block time. This high throughput blockchain targets a 500ms interval for rapid finality in demanding applications. Learn more.

- Repository: [Amadeus Protocol/node](https://github.com/amadeusprotocol/node)
- Tags: deep-dive
- Published: 2026-08-20

---

**The Amadeus Protocol targets a 500 millisecond (0.5 second) block interval**, making it one of the fastest finality blockchains designed for high‑throughput applications.

This 500 ms block time is hard‑coded into the protocol's consensus layer. Understanding this parameter is essential for validators, developers building on the network, and operators monitoring node performance.

## How the 500 ms Block Time Is Defined

The block interval originates from a single constant in the Rust source code that calculates expected daily block production.

### The `BLOCKS_PER_DAY` Constant

In [`ex/native/rdb/src/consensus/bic/lockup_vault.rs`](https://github.com/amadeusprotocol/node/blob/main/ex/native/rdb/src/consensus/bic/lockup_vault.rs), the protocol defines:

```rust
pub const BLOCKS_PER_DAY: u64 = 86_400_000 / 500; // 1 block per 500 ms

```

This calculation breaks down as follows:

- `86_400_000` — milliseconds in one day (24 × 60 × 60 × 1,000)
- `500` — target block interval in milliseconds
- Result: **172,800 blocks per day**

Dividing the daily millisecond count by the 500 ms target yields the intended block cadence. This constant drives consensus timing across the Amadeus Protocol node implementation.

## Monitoring Block Time in Production

Node operators can verify actual block time performance through the built‑in Prometheus metrics endpoint.

### The Prometheus Exporter

The metrics implementation in [`ex/lib/http/prometheus.ex`](https://github.com/amadeusprotocol/node/blob/main/ex/lib/http/prometheus.ex) exposes real‑time block time data:

```elixir
def metrics_kpi() do
  kpi = API.Chain.kpi()
  """
  # HELP amadeus_block_time_ms Block time in milliseconds

  # TYPE amadeus_block_time_ms gauge

  amadeus_block_time_ms #{kpi.block_time}
  """
end

```

The `API.Chain.kpi()` function retrieves current chain statistics, including the observed block time, which the exporter surfaces as `amadeus_block_time_ms`.

### Querying Block Time Metrics

Run this command against a local node's metrics endpoint to check current performance:

```bash
curl http://localhost:8080/metrics | grep amadeus_block_time_ms

```

Expected output alignment:

```

amadeus_block_time_ms 500

```

Values near **500 ms** indicate healthy consensus participation. Deviations may signal network latency, validator issues, or temporary congestion.

## Key Source Files for Amadeus Protocol Block Time

| File | Purpose |
|------|---------|
| [`ex/native/rdb/src/consensus/bic/lockup_vault.rs`](https://github.com/amadeusprotocol/node/blob/main/ex/native/rdb/src/consensus/bic/lockup_vault.rs) | Defines the `BLOCKS_PER_DAY` constant encoding the 500 ms target interval. |
| [`ex/lib/http/prometheus.ex`](https://github.com/amadeusprotocol/node/blob/main/ex/lib/http/prometheus.ex) | Implements the Prometheus metrics endpoint exporting `amadeus_block_time_ms`. |
| [`ex/lib/api/chain.ex`](https://github.com/amadeusprotocol/node/blob/main/ex/lib/api/chain.ex) | Provides `API.Chain.kpi/0` supplying block time data to monitoring systems. |

## Why Half‑Second Finality Matters

The 500 ms Amadeus Protocol block time enables use cases requiring rapid settlement:

- **High‑frequency trading** — near‑instant trade confirmation
- **Gaming and real‑time applications** — responsive user experiences
- **Payment processing** — merchant‑friendly confirmation speeds
- **Cross‑chain operations** — reduced latency for bridged transactions

Sub‑second finality distinguishes Amadeus from protocols with 10–15 minute or even 12–15 second block times, though this speed requires robust validator infrastructure and optimized networking.

## Summary

- The **Amadeus Protocol block time is 500 milliseconds**, defined by `86_400_000 / 500` in the consensus layer.
- The `BLOCKS_PER_DAY` constant in [`ex/native/rdb/src/consensus/bic/lockup_vault.rs`](https://github.com/amadeusprotocol/node/blob/main/ex/native/rdb/src/consensus/bic/lockup_vault.rs) establishes this timing.
- Operators monitor actual performance via `amadeus_block_time_ms` Prometheus gauge exposed in [`ex/lib/http/prometheus.ex`](https://github.com/amadeusprotocol/node/blob/main/ex/lib/http/prometheus.ex).
- The 0.5‑second interval supports high‑throughput, low‑latency applications at the protocol level.

## Frequently Asked Questions

### What is the exact block time for the Amadeus Protocol?

The Amadeus Protocol targets **500 milliseconds (0.5 seconds)** per block. This value is hard‑coded in the `BLOCKS_PER_DAY` calculation found in [`ex/native/rdb/src/consensus/bic/lockup_vault.rs`](https://github.com/amadeusprotocol/node/blob/main/ex/native/rdb/src/consensus/bic/lockup_vault.rs).

### How can I check the current block time of an Amadeus node?

Query the Prometheus metrics endpoint at `http://localhost:8080/metrics` and filter for `amadeus_block_time_ms`. The metric is exported by [`ex/lib/http/prometheus.ex`](https://github.com/amadeusprotocol/node/blob/main/ex/lib/http/prometheus.ex) using data from `API.Chain.kpi()`.

### What does `BLOCKS_PER_DAY = 86_400_000 / 500` mean?

This Rust constant calculates expected daily block production: 86,400,000 milliseconds per day divided by 500 milliseconds per block equals 172,800 blocks per day. The divisor `500` enforces the protocol's half‑second block interval.

### Is the Amadeus Protocol block time adjustable?

No — the analysis reveals no configuration parameters for this value. The 500 ms target is a compile‑time constant in the consensus code, requiring source modification and network upgrade to change.