Philosophy

Two worlds, one platform

Traditional finance has spent decades perfecting what blockchains cannot do: sub-millisecond matching, deterministic sequencing, and throughput measured in millions of operations per second. It runs on dedicated hardware, regulated infrastructure, and institutional trust that predates the internet.

Decentralised finance has built something traditional markets never had: a programmable settlement layer. Smart contracts that compose, assets that move between protocols without intermediaries, and an execution environment where any participant can deploy logic that interacts with the full state of the system.

These worlds have been treated as opposites. Olympus combines them.

The matching engine delivers the execution quality of a traditional venue — a price-time priority CLOB on a dedicated thread, zero lock contention, deterministic tick-by-tick replay. The embedded EVM delivers the programmability of a blockchain — smart contracts, on-chain settlement, composable DeFi primitives. They run in the same process, connected by typed channels and a bridge that settles trades into on-chain state as they happen.

Institutional trust, cryptographic audit

The exchange is operated by a financial market infrastructure provider. Trust comes from the institution — its regulatory obligations, capital requirements, and legal accountability. This is the same trust model that underpins every major exchange in the world.

But trust doesn't mean opacity. Every tick the engine processes is persisted to a durable append log. The execution is deterministic: given the same sequence of transactions, any instance of the engine produces identical state. Cryptographic commitments — state roots, trade roots — are posted on-chain via a settlement contract. Regulators can replay the full tick history and verify it against immutable on-chain anchors.

This is a validium architecture. Transaction data lives off-chain where it can be processed at full speed. Commitments live on-chain where they can't be altered. The result is an exchange that runs as fast as a traditional venue but produces a cryptographic audit trail that a traditional venue cannot.

The EVM as a co-located execution environment

The embedded reth node is not a separate blockchain. It's a co-located EVM that shares a process boundary with the matching engine. There is no consensus mechanism, no validator set, no fee market. The operator produces blocks. Gas is zero.

This is deliberate. The value of the EVM here is not decentralisation — it's programmability within the perimeter of a regulated venue. Participants deploy their own contracts: custom settlement logic, conditional order strategies, structured products, on-chain risk engines. These contracts read exchange state — committed batch roots, trade counts, settlement history — with a local contract call. No oracles. No cross-chain bridges. No latency.

Think of it as an institutional DeFi runtime. The same Solidity toolchain, the same ERC standards, the same composability patterns — but executing against a matching engine that fills orders in microseconds instead of block times.

Performance is architectural

Sub-millisecond matching isn't achieved by optimising a slow design. It's the result of structural decisions that eliminate contention by construction.

The core engine runs on a dedicated OS thread and owns its state outright. It communicates downstream through channels and publishes snapshots for API readers via atomic pointer swaps. Nothing locks the engine. Nothing shares its memory. The hot path — receiving a tick, matching orders, updating the ledger, computing a state hash — runs without interruption.

The sequencer batches incoming transactions at 1ms intervals (configurable via OLYMPUS_TICK_INTERVAL_MS) and assigns monotonic sequence numbers. This serves two purposes: it bounds latency to a known tick interval, and it makes the entire execution history a deterministic function of the tick log. Crash recovery replays the log from the last snapshot. Regulatory audit replays from the beginning. Both produce identical state because the sequencer's ordering is the single source of truth.

API reads are lock-free. Every tick, the engine publishes a new EngineSnapshot via ArcSwap — an atomic pointer swap that readers pick up without blocking the writer. Market data and balance queries may be one tick stale (1ms at the default interval). That's a trade-off worth making: read load never affects matching throughput.

On-chain settlement

After every tick, the engine produces a TickResult containing trades, order updates, bridge instructions, and a trades_root — a merkle root over all trades in that tick. The settlement service accumulates these results and periodically commits them on-chain in batches:

function commitBatch(
    uint64 fromSeq, uint64 toSeq,
    bytes32 stateRoot, bytes32 tradesRoot,
    uint64 tradeCount
) external onlyOperator;

On-chain contracts can read committed roots directly. BatchCommitted events are indexed by Blockscout. The result is a public, immutable record of every batch of trades the exchange has processed — anchored to the same EVM where participants deploy their own logic.

The bridge layer connects the two sides: when trades settle, wrapped tokens are minted on the EVM so that on-chain contracts can reference real positions. When users burn wrapped tokens, the corresponding assets are unlocked in the exchange ledger. Same institution, same process, same security model — but now assets flow between a matching engine and a programmable settlement layer without friction.

Built for what's next

Traditional exchanges are fast but closed. Decentralised exchanges are open but slow. The gap between them is where institutional DeFi lives — venues that deliver the execution quality regulators and participants expect, with the programmability and composability that smart contracts enable.

Olympus is built for that gap. A Rust matching engine for speed. An embedded EVM for programmability. A validium architecture for auditability. And a trust model that matches how regulated markets actually work.