From the blockchain to your database. Index RWAs, Stablecoins, and Digital Assets.

quixote

quixote is a lightweight, high-performance EVM event indexer built in Rust. It lets you capture, store, and query blockchain events with minimal setup. Get it up and running in two commands.

Index and query on-chain data from stablecoins, RWAs, DeFi protocols, or any asset on EVM-compatible blockchains.

Just point it at an RPC, specify the events you care about, and start querying your data with SQL.

Quickstart

Install:

curl -fsSL https://quixote.bilinearlabs.io/install | bash -s

Index all existing pools in Uniswap V4:

quixote -r https://gateway.tenderly.co/public/mainnet \
  -c 0x000000000004444c5dc75cB358380D2e3dE08A90 \
  -e "Initialize(bytes32 indexed id, address indexed currency0, address indexed currency1, uint24 fee, int24 tickSpacing, address hooks, uint160 sqrtPriceX96, int24 tick)" \
  -s 21688329

Now quixote will start indexing the Initialize event for this smart contract starting from block 21688329 and dumping all the content into quixote_indexer.duckdb. You can check the sync status as follows.

curl http://localhost:9720/list_events

And the database schema as follows.

curl http://localhost:9720/db_schema

You can also pass raw SQL queries as follows.

curl -X POST http://localhost:9720/raw_query \
-H "Content-Type: application/json" \
-d '{"query": "SELECT * FROM event_1_initialize_dd466 limit 5"}'

And quixote ships with a built-in frontend that you can use to query data in a simple way, showing the content as a table. Go to http://127.0.0.1:8501

Features

• Simple to run: Single binary, minimal configuration. Point to an RPC and start indexing.
• Dual database support: Choose between DuckDB (file-based, zero setup) or PostgreSQL (scalable, production-ready). See docs.
• Any EVM chain: Works with Ethereum, Arbitrum, Optimism, Polygon, and any EVM-compatible chain.
• Flexible event selection: Index specific events or entire ABIs. Filter by address, topic, or any indexed parameter.
• Built-in REST API: List events, query contracts, or execute raw SQL via HTTP endpoints.
• Built-in frontend: Embedded Streamlit dashboard at http://localhost:8501 for data exploration.
• Auto resume: Automatically resumes from the last synced block.
• Resilient: Exponential backoff and retry logic for network issues and RPC rate limits.
• RPC cost control: The --block-range parameter controls blocks per request to match provider limits.
• YAML configuration: Advanced filtering and multi-job support via config files.
• Built in Rust: Fast, safe, and memory-efficient.

Data integrity

Data integrity, or, in other words, ensuring that the data indexed in your database reflects exactly what happened on-chain—is our top priority. To achieve this, we have implemented several measures:

• By default, the indexer runs on finalized blocks, meaning no reorgs can occur that would alter transaction history.
• We process events in atomic batches. In the event of a crash or failure of any kind, the indexer remains in a consistent state.
• We process events in order, meaning we never perform out-of-order inserts. This simplifies recovery: if the indexer stops or errors, there is no need to roll back or fill gaps.
• We have conducted extensive testing, including reconciliation against the on-chain state, to ensure we can faithfully reproduce it from the indexed events.

Learn more about data integrity.

License

This project is open source and available under the MIT License.

About Bilinear Labs

quixote is built and maintained by Bilinear Labs, a team passionate about building high-performance infrastructure for blockchain and finance.

Need help with custom indexing solutions, high-performance backends, or managed infrastructure? We're happy to help. Whether it's tailoring quixote for your specific use case, building something bespoke, or running the infrastructure so you don't have to. Feel free to reach out.