Genkipool/radix-olympia-gateway-export

Radix Olympia Gateway database export (Parquet)

Also archived at https://archive.org/details/radix-olympia-gateway-export (tables; the lookup indexes are published here).

Full export of the PostgreSQL database of the Radix Olympia Gateway (mainnet), covering the whole Olympia ledger from state version 1 to the final state version 337,759,839 (28 September 2023, 06:33:34 UTC), when Olympia shut down before the Babylon migration.

How it was produced

1. Source node database: RADIXDB-api.tar.zst from the item radix-olympia-ledger-archive (SHA-256 d3a00f5a263bbb20274276ed23d77ec93744c3a08fd6c5ef04e4f949eb0bb60c).
2. The node database was served by radixdlt/radixdlt-core:1.5.0 (Core API with api.transactions.enable=true), on an isolated network with no peers.
3. The official Olympia Gateway software, radixdlt/ng-data-aggregator:1.1.14 and radixdlt/ng-gateway-api:1.1.14 with PostgreSQL 12, ingested the full ledger from that node (November 2026). The Gateway API reported ledger_state.version = 337759839, equal to its target_ledger_state.
4. Every table was exported to Parquet with DuckDB (zstd compression), ordered by its primary key.

The row count of every Parquet file was checked against the PostgreSQL table it came from (see ROWCOUNTS.txt).

Verification

The data was checked against two official sources, independent of this export (8 November 2026):

• The official Olympia Gateway (olympia-gateway.radixdlt.com), which is still online, frozen at version 337,759,839. For 50 random accounts, the transaction count, the liquid XRD and the tokens held are equal in all 50. Its validator list has the same 254 validators, and the XRD staked of 20 random validators is equal in all 20.
• The Babylon genesis (state versions 1 to 647), which loaded Olympia's final state into the Babylon ledger. 583,432 of 583,884 final balances are equal to the 18th decimal. The other 452 are XRD being unstaked or pending stake (kept with the stakes here, returned as liquid XRD by the genesis) and two tokens (e and test6) whose supply exceeded Babylon's maximum and were rescaled by the migration.

Scripts to repeat both checks: tools/olympia-archive-check. Full report: F0.1 progress report.

Files

• ledger_transactions.AAAAAAAAA-BBBBBBBBB.parquet: one row per ledger transaction, split into ranges of 20,000,000 state versions (inclusive). Includes transaction id, accumulator, message, fee, epoch/round and timestamps.
• raw_transactions.AAAAAAAAA-BBBBBBBBB.parquet: the raw transaction payloads, with the state_version added (joined from ledger_transactions) and the same ranges.
• One file per remaining table: accounts, account_transactions, operation_groups, account_resource_balance_history, account_resource_balance_substates, account_stake_unit_balance_substates, account_xrd_stake_balance_substates, account_validator_stake_history, resources, resource_data_substates, resource_supply_history, validators, validator_data_substates, validator_proposal_records, validator_stake_balance_substates, validator_stake_history, validator_system_metadata_substates, ledger_status, network_configuration.
• SHA256SUMS.txt: SHA-256 of every file. ROWCOUNTS.txt: rows per file and per source table.

Types

• PostgreSQL numeric(1000,0) amounts (fees, balances, supplies) are stored as text, so that no precision is lost (Parquet decimals are limited to 38 digits). Amounts are in the smallest unit (10^-18 of a token).
• bytea columns (transaction ids, accumulators, payloads, public keys, engine addresses) are stored as binary. Account and validator addresses (address) and token RRIs (rri) are text.
• Timestamps are timestamp with time zone (UTC).
• Ids such as account_id, resource_id and validator_id refer to the id column of accounts, resources and validators.

Example (DuckDB)

-- Transactions of one account, newest first
SELECT t.state_version, t.round_timestamp, at.is_fee_payer
FROM 'accounts.parquet' a
JOIN 'account_transactions.parquet' at ON at.account_id = a.id
JOIN 'ledger_transactions.*.parquet' t ON t.state_version = at.state_version
WHERE a.address = 'rdx1...'
ORDER BY t.state_version DESC
LIMIT 20;

Lookup indexes (index/)

Derived files, built from the tables above with DuckDB, sorted by their lookup key and written with small row groups (2,048 to 10,240 rows), so that a point lookup over HTTP range requests reads only a few KB. Amounts are text (full precision, smallest unit).

File	Sorted by	Contents
tx_by_id.parquet	transaction_id	the 2,711,747 non-round-change transactions: id (lowercase hex text), state_version, timestamp, epoch, fee, message
accounts_by_address.parquet	address	address → account_id, public key, first state version
account_balance_changes.parquet	account_id, state_version	per transaction and token: balance change (delta) and resulting balance
account_final_balances.parquet	account_id	non-zero token balances at the end of Olympia
account_final_stakes.parquet	account_id	stakes at the end of Olympia (stake units, pending stake/unstake), with the validator totals needed to convert stake units to XRD
operations_by_account.parquet	account_id, state_version	inferred actions (transfer, stake, unstake, mint, burn…) in both directions, with counterparty, token and validator
resources_by_rri.parquet	rri	tokens with metadata (symbol, name, description, URL, icon), granularity, mutability, owner, Babylon resource address, final supply, minted and burnt amounts, and number of holders
validators_by_address.parquet	address	validators with name, URL, fee, owner and final stake totals
user_tx_by_version.parquet	state_version	the same transactions by state version, with fee payer address and number of accounts involved
account_tx_detail.parquet	account_id, state_version	each account's transactions with id, timestamp, fee, fee payer / signer flags and message (epoch-change system transactions excluded)
operations_by_version.parquet	state_version, operation_group_index	the actions of each transaction with from / to / validator addresses, amount and token
balance_changes_by_version.parquet	state_version	the balance changes of each transaction, per account and token
raw_user_tx_by_version.parquet	state_version	the raw payload of each non-round-change transaction
resources_by_babylon_address.parquet	babylon_resource_address	Babylon resource address → Olympia RRI (derived with the Radix Engine Toolkit)
final_balances_by_resource.parquet	rri, then balance descending	token holders at the end of Olympia
final_stakes_by_validator.parquet	validator_address, then stake descending	delegators at the end of Olympia, with their stake in XRD
accounts_by_babylon_address.parquet	babylon_address	Babylon account address (derived from the Olympia public key with the Radix Engine Toolkit) → Olympia address and account_id; accounts_by_address also carries babylon_address
account_staking_rewards_daily.parquet	account_id, day	staking rewards per account, validator and UTC day: delegator reward and validator-owner fee, in XRD
validator_staking_rewards_daily.parquet	validator_id, day	per validator and UTC day: rewards to delegators, owner fee and total stake (XRD)
account_stake_history.parquet	account_id, from_state_version	every stake position of every account over time (stake units, pending stake, pending unstake units, exiting XRD), valid for state versions [from_state_version, to_state_version]; an open row ends at 337,759,839
validator_stake_history.parquet	validator_id, from_state_version	every validator's totals over time (XRD staked, stake units, units being unstaked), same validity ranges, to value stake units at any state version

Staking rewards follow the Olympia node rules (EpochConstructionState.calculateEmission): at each epoch change the validator emission minus its fee goes to the stake pool (raising the XRD value of a stake unit), and the fee is staked for the validator owner. Stake unit value = total_xrd_staked / (total_stake_units + total_prepared_unstake_units). Delegator rewards are computed as stake units held × increase of the stake unit value; owner fees as the stake units added to the owner at an epoch change that do not come from a prepared stake. Check: the sum of delegator rewards (576.47 M XRD) equals the stake-pool emission computed epoch by epoch from validator_stake_history. Rewards are floating-point XRD (not exact subunits).

An account's stake at state version V: its account_stake_history rows covering V, each valued with the validator_stake_history row of its validator covering V, as above. Checked against the official Olympia Gateway (/account/stakes and /account/unstakes with at_state_identifier): 30 of 30 random cases equal.

Consistency check: for every account and token, the sum of delta in account_balance_changes equals the balance in account_final_balances. SHA-256 of the indexes: index/SHA256SUMS.txt.

License

CC0 1.0 Universal (public domain dedication). Anyone may copy, modify, distribute and use this data, including commercially, without asking permission and without attribution. It is provided as is, without warranties of any kind: see the legal code.

The data is a copy of the public Radix Olympia ledger, as the official Olympia Gateway software indexed it.