KalqiX Data Availability: Why Anyone Can Rebuild Our Trading State
A ZK proof tells you KalqiX's trades followed the rules. Published trade data on Avail DA lets you rebuild the whole trading state yourself. Here's why you need both.
On KalqiX, every batch of trades comes with a zero-knowledge proof, and a smart contract on Base checks that proof. If the matching engine broke price-time priority or reordered an order, the proof would fail.
That is a strong guarantee. But a proof answers one question: were the rules followed? It doesn't answer a second question that matters just as much: what actually happened, and what does every account look like right now?
Answering that second question is the job of data availability. KalqiX publishes its trade data to Avail DA so anyone can rebuild the full trading state on their own, without asking us for anything. This post explains how that works, why it's a different job from proof verification on Base, and what it means for traders, market makers and the exchanges building on KalqiX.
Two questions every trustless system has to answer
Any system that asks you not to trust its operator has to settle two separate things.
- Validity: was every change to the state correct?
- Availability: can anyone get the data needed to know what the state actually is?
These sound similar. They aren't.
Think of a company's accounts. An auditor can sign a certificate saying the books are correct. That certificate is valuable, but it doesn't tell you what's in the books. If you want to know your own balance, check a specific transaction or carry on keeping the accounts after the company closes, you need the ledger itself.
On KalqiX, the ZK proof is the auditor's certificate. The trade data on Avail DA is the ledger, published where anyone can read it.
What the ZK proof on Base guarantees
KalqiX's matching engine is written in Rust and matches orders by price-time priority, the same rule used by the NYSE and NASDAQ. The best price fills first, and at the same price, the order that arrived first fills first. Matching takes under 10 milliseconds.
Every batch of trades from that engine is proven with a zero-knowledge proof built with Succinct's SP1, a zkVM that can prove ordinary Rust programs. The proof shows that orders in the batch were matched by price-time priority and that nothing was front-run or reordered. A smart contract on Base verifies the proof, and that's where trades settle. Trades match instantly; the proofs follow.
If you want the longer version of how this works, our guide on what ZK proofs mean for traders walks through it.
The important thing here is what makes ZK proofs useful in the first place: they are compact. The verifier on Base doesn't redo the matching, and it doesn't need every detail of every trade to confirm the batch was correct. That's why verification is cheap and fast.
It's also exactly why a proof, on its own, can't be the whole story. A system designed so the verifier doesn't need all the data is, by design, not a system that gives everyone all the data.
The data withholding problem
Imagine a version of KalqiX with perfect proofs but no published data.
Every batch would be proven correct. Every state change would pass verification on Base. And yet, outside the operator, nobody could:
- work out a given account's balance from first principles
- check the full history of trades in a market
- confirm that the numbers shown in any app match what really happened
- carry on tracking the state if the operator's servers disappeared
The system would be correct but opaque. You would know the rules were followed without being able to see what they were followed on.
Rollup designers call this the data availability problem, and it's why rollups have to publish their transaction data somewhere public. Some publish it to Ethereum itself (as blobs). Others use a dedicated data availability layer built specifically for this job. KalqiX uses Avail DA.
How KalqiX handles it: trade data on Avail DA
KalqiX's stack is modular. Each layer does one job, and data availability has its own layer.
| Layer | What it does | Question it answers |
|---|---|---|
| Matching engine (Rust) | Matches encrypted orders by price-time priority in under 10 ms | How were orders matched? |
| SP1 proof, verified on Base | Proves each batch was matched correctly | Were the rules followed? |
| Avail DA | Receives KalqiX's published trade data, with 250 ms preconfirmations | What exactly happened? |
| KalqiX contract on Base | Holds user funds, settles trades, offers the escape hatch | Where are the funds, and can I get them out? |
Avail started inside Polygon and spun out in March 2023, and Avail DA went live in July 2024. It's built to publish data so anyone can download it, which is the property KalqiX needs. The 250 ms preconfirmations mean trade data gets an early confirmation of publication quickly, in step with a matching engine that works in milliseconds.
We covered the Avail side in more depth in how Avail DA and Nexus power ZK trading on KalqiX.
What "independently rebuildable" means in practice
Rebuilding the state means taking the published trade data, replaying it in order and arriving at the same picture of the system that KalqiX shows: which trades happened, and what that means for every account.
Put the two layers together and you get something neither gives alone:
- The proof tells you each batch was matched correctly.
- The data lets you reconstruct each batch yourself.
If your reconstruction ever disagreed with what an interface displayed, you would know, and you wouldn't need anyone's permission or cooperation to find out.
Who actually does this? Not every trader, and that's fine. What matters is that anyone can. In practice, that includes:
- Market makers and algo traders reconciling their own records against an independent copy of the trade history.
- Exchanges and projects running on KalqiX. Every partner's frontend feeds one shared order book, so a partner can check the activity behind its own users' trades without relying on KalqiX's reporting.
- Analysts and researchers who want to measure volume and activity from raw data rather than a dashboard.
- Anyone who doubts us. The KalqiX explorer and our analytics site are convenient views. Published data means you never have to depend on any single view, including ours.
That last point matters more than it sounds. In an industry where reported volume can mislead and exchanges have collapsed after their numbers turned out to be fiction, a record that only the operator can read is a record you're asked to take on faith.
Why this matters for self-custody
On KalqiX, funds sit in the KalqiX contract on Base, not with an operator. An escape hatch lets you withdraw directly on-chain even if every other component goes offline. Withdrawals always go back to your own wallet.
Data availability supports the same idea from a different direction. Self-custody is about who controls the funds. Data availability is about who controls the record. A system where you hold your own funds but only the operator can read the full history is still asking you to trust something. Publishing trade data to Avail DA means the record of what happened on KalqiX doesn't live only on our servers.
What's public and what stays private
A fair question: if trade data is published, doesn't that undo KalqiX's privacy?
No, because the privacy KalqiX offers is about your order before it's matched. Orders are encrypted before they leave your device, and there's no public mempool, so nobody sees an order before it's matched. That's what stops front-running and sandwich attacks, which only work when someone can see a pending trade and act ahead of it.
After matching, trades are public, the same as on any on-chain venue, and you can see them on the explorer. The data published to Avail DA describes trades that have already happened. By then there's nothing left to front-run.
So the two properties fit together: private while it counts, verifiable once it's done.
FAQ
What is data availability in crypto?
Data availability means the data behind a blockchain or rollup's state has been published so anyone can download it. It lets people independently check and rebuild the state instead of trusting whoever produced it. It's why rollups post their data to Ethereum or to a dedicated layer like Avail DA.
If KalqiX already has ZK proofs, why does it need data availability?
A ZK proof confirms that each batch of trades followed the rules, but it's designed to be compact, so it doesn't carry the full trade data. Data availability publishes that data so anyone can see exactly what happened and rebuild the state. One proves correctness; the other makes the record readable by everyone.
Does KalqiX publish my orders before they're matched?
No. Orders are encrypted before they leave your device and there's no public mempool, so nobody sees them before matching. Only matched trades become public, as on any on-chain venue.
What happens to my funds if KalqiX goes offline?
Your funds sit in the KalqiX contract on Base, not with an operator. The escape hatch lets you withdraw directly on-chain even if every other component goes offline, and funds always go back to your own wallet.
The takeaway
Verifiability is more than seeing a green checkmark next to a proof. The proof on Base tells you KalqiX matched trades by price-time priority with nothing front-run or reordered. The trade data on Avail DA lets anyone rebuild what actually happened, account by account, without asking us. That's why both layers are part of how KalqiX is built.
Want to trade on an order book you can check for yourself? Start at app.kalqix.com. Building with the API? Head to docs.kalqix.com. Want your own exchange on this stack? Get in touch through kalqix.com.