The first database to support cryptographic proofs for complex queries

Built by the developers of

Features

Query proofs

The first database to support proofs for queries more complex than single-key retrievals

Secondary indexes

Create indexes, including unique and compound indexes, on any field

Mutable and immutable data storage

Built-in functionality to support both within the same database

Inclusion and absence proofs

Verify the presence or absence of items using Merkle proofs

Operation costs

Get the costs of operations and estimate them beforehand

ACID compliancy

Benefit from ACID properties

Comparison Table

	GroveDB	ImmuDB	ProvenDB	Trillian	BigchainDB
Complex Queries
Query Proofs		-	-	-	-
Inclusion Proofs					-
Non-Inclusion Proofs		-	-	-	-
Data Immutability
Data Mutability		-	-	-	-
Operation Costs		-	-	-	-
Language	Rust	Go	JavaScript	Go	Python

Design

GroveDB is a "grove" of Merkle trees, where the root hashes of lower-level trees are stored in nodes of higher-level trees, and the root hash of the root tree can be used to prove the state of the entire database.

What are secondary indexes?

What are cryptographic proofs?

HADS

GroveDB is the first production-level implementation of a HADS, largely inspired by Database Outsourcing with Hierarchical Authenticated Data Structures.

HADS stands for "hierarchical authenticated data structure". Simply speaking, it's an ADS (authenticated data structure), such as a Merkle tree, which contains additional ADSs.

The HADS architecture is what enables GroveDB to be the first database to support proofs for complex queries. Trees can be created for secondary indexes, where each secondary index tree (such as for "city" in a data set of restaurants) has additional subtrees for each unique value (such as "New York City" and "Phoenix"), and the items in that subtree (all the restaurants in New York City or Phoenix) can refer to the records in the primary index tree, where the full data of each item (restaurant) is stored.

Note that the secondary index trees only contain references to items, rather than the items themselves, for storage space efficiency.

Benefits of a HADS:

Efficient proofs for complex queries

Efficient handling of duplicate values

Different ADS types can be used within the same HADS

Supports compound indexes

Merk

All trees in GroveDB are Merk trees by default.

Merk is a Merkle AVL tree designed for performance. Notable features include concurrent operations for higher throughput, an optimized key/value layout for performant usage of the backing store, and efficient proof generation to enable bulk tree replication.

Read Documentation

Features of a Merk tree

Fast reads/writes

Reads have no overhead compared to a normal RocksDB store, and writes are optimized for batch operations (e.g. blocks in a blockchain).

Fast proof generation

Since Merk implements an AVL tree rather than a trie, it is very efficient to create and verify proofs for ranges of keys.

Concurrency

Unlike most other Merkle stores, all operations utilize all available cores, giving huge performance gains and allowing nodes to scale along with Moore's Law.

Replication

The tree is optimized to efficiently build proofs of large chunks, allowing for nodes to download the entire state (e.g. "state syncing").

Checkpointing

Merk creates checkpoints on disk (an immutable view of the entire store at a certain point in time) without delays in availability or liveness.

Web-friendly

Being written in Rust means it is easy to run the proof-verification code in browsers with WebAssembly, allowing for light-clients that can verify data for themselves.

Fits any Profile

Performant on RAM-constrained Raspberry Pi's and beefy validator rigs alike.