Graven

The database that can't be faked.

[Graven @gravendatabase]

We recorded it, so you can see how to test it.

Watch anyone open the Graven playground, write a record, and seal it on Solana mainnet in seconds.

This is not a testnet mock and not a staged clip.
It is the live database running against real onchain anchoring.

https://t.co/PfyaOknWh4

Once a record is sealed, its history is locked.
The Merkle root sits on chain, permanent and unchangeable, so data can never be quietly faked again. Try to tamper with it and audit() catches it instantly and names the exact record that was touched.

A database where forging history is no longer possible.

Live, on mainnet, working today.
Test it yourself!
https://t.co/WcI2c0l4Ee

[Graven @gravendatabase]

REST API.

Today you use Graven as an embedded engine in Node.

A hosted REST API and language SDKs are on the roadmap, so you will be able to put, get, anchor, prove and audit over HTTP from any stack, not just JavaScript.

That is what unlocks Graven for Python, Go, Rust and beyond, and for teams that want the integrity layer as a service rather than a library.

Until it ships, the engine is the way in, and the live playground already exercises the same operations end to end.

https://t.co/grddEPhZ7h

[Graven @gravendatabase]

Materialized state for fast reads (shipped)

integrity should not cost you query speed.

Graven maintains a normal state table with the current value of each key, so reads run at full database speed and the cryptography never sits in the read path.

The table is a cache, fully re derivable from the event log, which is also a security feature: if someone edits it to show a fake value, replaying the sealed events catches the mismatch.

Fast where you need fast, provable where you need proof.

[Graven @gravendatabase]

We don't know what the fud is about tbh.

We worked months on this to finally release, locking every single creator reward buy and shipping hourly.

There are no bundles, no insiders, nothing!

[Graven @gravendatabase]

@LEVELUPm2v We will keep shipping ✍️

[Graven @gravendatabase]

We shipped Graven to npm today.

A database that anchors a Merkle root of its entire write history on Solana.

You can independently recompute that root and verify your data was never edited, down to the exact record if it was.

No trust in the operator required.
Open source, drop in.

npm install @gravendatabase/graven

[Graven @gravendatabase]

Hashing every event into a Merkle tree collapses your entire history into one 32 byte root, so a single value can commit to millions of records.

That is what makes anchoring cheap.

The same structure gives inclusion proofs, which let you prove that one specific record belongs to a sealed root without revealing any of the others.

One root for the whole truth, one small proof for a single fact, nothing else exposed.

Shipped, including standalone proof verification anyone can run.

[Graven @gravendatabase]

Graven, in plain words:

You seal the current state of your database into a single hash and anchor it on Solana.

At any moment you can hash your data again and compare it to the latest seal on chain.

If they match, nothing was touched.
If one byte changed, they will not, and Graven names the exact record.

It cannot be faked, because the proof lives on a chain no one controls.

The first database you can actually prove was never altered.

[Graven @gravendatabase]

@CJCJC1995 https://t.co/yyn0fMTmG4

[Graven @gravendatabase]

We recorded it, so you can see how to test it.

Watch anyone open the Graven playground, write a record, and seal it on Solana mainnet in seconds.

This is not a testnet mock and not a staged clip.
It is the live database running against real onchain anchoring.

https://t.co/PfyaOknWh4

Once a record is sealed, its history is locked.
The Merkle root sits on chain, permanent and unchangeable, so data can never be quietly faked again. Try to tamper with it and audit() catches it instantly and names the exact record that was touched.

A database where forging history is no longer possible.

Live, on mainnet, working today.
Test it yourself!
https://t.co/WcI2c0l4Ee

[Graven @gravendatabase]

Every database can be edited in secret.
That is the dirty truth nobody talks about.

Your admin, your cloud provider, anyone with access can change a balance or a log and you would never know.

Graven fixes the one thing databases never could. Every write is hash chained and sealed on Solana, so anyone can prove your data was never touched. Edit one byte and it gets caught instantly, with the exact record named.

Nobody built this because it meant marrying a real database to a real chain without killing speed. We did. Fast reads, provable integrity, drop in.

The first database that cannot lie!

https://t.co/QgEdPlkm0v

[Graven @gravendatabase]

A word on how we think about $GRAVEN.

We take the creator fees and use them to constantly buy back supply from the market, and every buy back is locked for 2 years.

The fees flow straight back into the token and get put away.

Our money does not come from the token.
It comes from our product.

Graven is a real tamper evident database, and we earn through our pricing plans, the hosted anchoring, the dashboard and the enterprise tier that teams actually pay for.

So the token is not the business.
The business funds the token.

Revenue keeps the lights on, creator fees keep buying and locking supply.

Built to last, aligned by design.
https://t.co/ct5jcvOBfM

[Graven @gravendatabase]

A hash is only trustworthy if the same data always produces the same hash, on every machine, forever.

Graven serializes each event into a strict canonical form, with object keys always in the same order, before hashing it with SHA256.

Without this determinism, the same logical record could serialize two ways and produce two different fingerprints, quietly breaking verification.

With it, anyone anywhere can recompute the exact same hashes and confirm the chain.

Shipped, and it is the quiet foundation everything else stands on.

[Graven @gravendatabase]

https://t.co/JQ7LsR64qZ

It is live. Graven is now on npm!

npm install @gravendatabase/graven

The full tamper evident database engine, in your project in one command. Hash chained writes, Merkle proofs, real Solana anchoring and one call audit, all open source, all yours.

import { Graven } from '@gravendatabase/graven'
const db = new Graven({ file: 'data.graven' })
db.put('accounts', 'alice', { balance: 1200 })
await db.anchor() // sealed on Solana
db.audit().ok // provably untampered

This is not a preview and not a mock.
The same engine running on mainnet in our playground is the one you just installed.

Write data, seal it on chain, then try to fake it and watch it get caught.

A database where forging history is no longer possible, shipping today.

https://t.co/JQ7LsR64qZ
https://t.co/TMWM05qOHO

[Graven @gravendatabase]

new Graven(options) opens or creates a database with a file and an optional Solana config.

put(table, key, value) appends a write and returns a receipt of the sequence number and the event hash, where value is any JSON serializable object.

get(table, key) is a fast read of the current value, or null.

del(table, key) appends a delete and also returns a receipt.

Notice there is no special syntax to learn and no integrity ceremony at the call site.

You write like normal, and Graven seals it underneath.

[Graven @gravendatabase]

Anchoring is the step that makes integrity public and cheap.

Graven builds a Merkle tree over every event hash, which collapses your entire history into one 32 byte root, and writes that root into a single Solana memo transaction.

One tiny transaction seals millions of records, so cost scales with how often you seal, not with how much you store.

The same tree gives you inclusion proofs: you can prove that one specific record belongs to a sealed root without revealing any of the others.

One root commits to everything, and one proof reveals only what you choose.

[Graven @gravendatabase]

The npm package and our GitHub repository will be published today of course!

[Graven @gravendatabase]

Here is how little code it takes.

You open a database with new Graven, then you write with put and read with get, exactly like any key value store.

When you want to lock in history, you call anchor once, which computes the Merkle root and, if Solana is configured, seals it on chain.

To prove integrity at any moment, you call audit, which returns whether anything was altered.

Write, seal, verify.
The hard cryptography is handled for you, and what is left is a tiny, familiar API.

That is the entire learning curve.
https://t.co/tZ3Wq1m0tG

[Graven @gravendatabase]

How it works, the materialized state. ⚙️

Fast reads and strong integrity usually pull in opposite directions.

Graven keeps both by separating them.
Alongside the event log it maintains a state table that holds the current value of each key, so queries are served at full database speed and the cryptography is never in the read path.

Crucially, that state table is treated as a cache, not the source of truth, because it is fully re derivable by replaying the event log.

This is why an attacker who edits the fast read table to show a fake value gets caught: replaying the sealed events no longer matches the state, and the audit flags the mismatch.

[Graven @gravendatabase]

The Graven roadmap, six phases from shipped to ambitious.

Phase 0, Foundation.
Shipped and live right now!

Append only hash chained log, SHA256 over canonical JSON, Merkle proofs, real Solana mainnet anchoring, one call audit that names the exact altered record, and a
guided playground you can poke today.

Phase 1, Developer preview.
In progress.

The graven npm package, a typed SDK, a hardened REST API, scheduled and batched anchoring, onchain root re verification, and a CLI.

Phase 2, Graven Cloud.
We host the hard parts. Managed anchoring, a live integrity dashboard, tamper alerts to Slack and webhooks, API keys, teams, and a shareable public verification page.

Phase 3, Integrations.
Postgres backend, Prisma and Drizzle adapters, blob references for S3, IPFS and Arweave, event stream connectors, and SDKs for Python, Go and Rust.

Phase 4, Security and compliance. SSO and RBAC, signed audit exports, a KMS and HSM backed signer, on prem and VPC deployment, selective disclosure proofs, and a SOC 2 path.

Phase 5, Ecosystem. An independent verifier network, cross chain anchoring to Ethereum and Bitcoin, an attestation marketplace, and real token utility for hosted anchoring and verification.

Two rules hold across all of it.
The core stays open source, we never charge you for the right to verify your own data.
And every item says exactly where it stands, no vaporware dressed up as shipped.

https://t.co/grddEPhZ7h

[Graven @gravendatabase]

How Graven makes money, in the open:

The full engine is open source and free, forever.
Self hosted, SQLite or Postgres, hash chain plus Merkle proofs, local or onchain anchoring, community support. The whole thing is yours.

Team, $99 a month.
Everything in open source plus a managed anchoring service, an integrity dashboard with alerts, REST API and SDKs, scheduled batch anchoring, and email support.

Enterprise, custom.
Everything in Team plus dedicated infrastructure, on prem or VPC deployment, SSO, roles and audit exports, an SLA with priority support, and compliance assistance.

Open core, done honestly.
You can run all of it yourself for free. You pay us when you want the anchoring, the dashboard and the support run for you.

https://t.co/ct5jcvO3qe