Nanosecond timestamps

Sub-slot transaction timing via the tx_timestamps table: high-precision entry timestamps captured at our Amsterdam shred receiver, for MEV and microstructure analysis.

// updated 2026-08-22

Block-level data tells you which slot a transaction landed in. tx_timestamps tells you when inside that slot - captured the instant the transaction's shred reached our Amsterdam receiver.

TIP

When this matters: MEV analysis, market-microstructure research, comparing on-chain execution against centralized-exchange fills, transaction-propagation studies. If you are working in milliseconds, block-level timing is too coarse.

The problem with block-level timing

Solana blocks reveal transaction sequence within a block through tx_idx, but not the timing behind it. Trading and MEV happen on millisecond timescales while blocks arrive roughly every 400 ms, so standard block data hides everything that matters about latency.

Where the timing lives

Timing is not a column on the swap tables - it is a separate table you join.


Table	`tx_timestamps`
Rows	2.74 billion (16 Aug 2026 snapshot)
Join key	`(slot, tx_idx)`, or `signature`
Timing column	`entry_timestamp` - `Float64`, high-precision Unix timestamp
Partition key	`toYYYYMMDD(toDateTime(entry_timestamp))`
Retention	14 days

WARNING

Fourteen days, then it is gone. tx_timestamps is the shortest-retention table in the database. Any latency study reaching further back has to be exported while the window is still open - arrange it with @supanode_tgs before you start collecting.

What the timestamp means

entry_timestamp is the moment the transaction's shred arrived at our receiver, not the moment the transaction was created and not the moment the block was finalized.

WARNING

The reference point is Amsterdam. If your application or exchange runs elsewhere, factor in the geographic offset.
Nanosecond resolution, not nanosecond accuracy. The clock has nanosecond precision, but real-world variance is at the microsecond level - still far finer than block-time granularity.
Coverage follows the shred feed. A transaction only appears here if its shred reached the receiver, so treat a missing join as "not observed", not as "did not happen".

How it is captured

A lock-free path on the Amsterdam shred receiver:

1
Detect and stamp
The primary thread monitors Geyser entry streams and records timestamps with zero contention - no locks and no buffering between detecting a transaction and stamping it.
2
Correlate and persist
A dedicated worker pool handles slot correlation and database writes concurrently in the background.

Splitting the two keeps stamp accuracy at its maximum - nothing competes with the timestamp path - while persistence is decoupled from it.

Joining it to a swap table

SELECT
    s.signature,
    s.slot,
    s.tx_idx,
    s.direction,
    s.quote_token_amount / 1e9 AS sol_amount,
    t.entry_timestamp
FROM pumpswap_all_swaps AS s
INNER JOIN tx_timestamps AS t
    ON s.slot = t.slot AND s.tx_idx = t.tx_idx
PREWHERE s.block_date_utc = today()
ORDER BY t.entry_timestamp DESC
LIMIT 50

Arrival spread inside a slot

Transactions that share a slot did not arrive together. This measures how far apart they actually were:

SELECT
    s.slot                                          AS slot,
    count()                                         AS tx_count,
    min(t.entry_timestamp)                          AS first_entry,
    max(t.entry_timestamp)                          AS last_entry,
    round((max(t.entry_timestamp) - min(t.entry_timestamp)) * 1000, 3) AS spread_ms
FROM pumpfun_v2_swaps AS s
INNER JOIN tx_timestamps AS t
    ON s.slot = t.slot AND s.tx_idx = t.tx_idx
PREWHERE s.block_date_utc = today()
GROUP BY slot
HAVING tx_count > 10
ORDER BY spread_ms DESC
LIMIT 20

Use cases

Benchmark against a CEX

Match arrival time to off-chain quote timestamps and compare on-chain execution with exchange fills.

Quantify your own latency

Distance between transaction creation in your logs and arrival at our receiver.

Propagation behaviour

Correlate entry_timestamp with slot and tx_idx to map how transactions spread.

Microstructure models

Build on real arrival timing instead of block-level approximations.