Chain Security and Commitments

The foundation of Space and Time’s trustless data processing is its unique commitment-based architecture. Instead of storing raw data directly onchain, SXT Chain stores cryptographic commitments that act as tamper-evident fingerprints for entire SQL tables. These commitments are the cornerstone of the protocol’s integrity guarantees and are updated using secure, decentralized consensus.

Tamperproof Tables with Cryptographic Commitments

Each table in Space and Time has an associated commitment—a succinct, cryptographic digest that represents the current state of the table. This commitment is generated using advanced commitment schemes such as KZG, Dory, or HyperKZG, which support:

Succinctness: Commitments are small and easy to store onchain.
Homomorphic Updates: New rows can be added without needing to recompute the entire commitment.
Efficient Proof Verification: Commitments can be verified onchain with minimal gas using pairing-based cryptography or polynomial evaluation techniques.

These properties enable the chain to represent arbitrarily large datasets as a compact, verifiable state hash—similar to how blockchains use Merkle roots to commit to a list of transactions.

Byzantine Fault Tolerant Consensus

Validator nodes operate under a Byzantine Fault Tolerant Consensus (BFT) consensus protocol. When a new set of rows is inserted into a table, validators will:

Independently verify the data and the source (e.g., signature, ZK proof, indexer quorum).
Update the table’s cryptographic commitment to reflect the new state.
Threshold-sign the new commitment using a multisignature scheme.
Submit the signed commitment to the chain, finalizing the insert.

This process ensures that any table modification—no matter the data source—must be verified by a decentralized quorum of validators before being accepted. No single node can manipulate or rewrite table contents.

Sources of Ingested Data and Trust Models

To support diverse data sources and use cases, SXT Chain supports multiple verification pathways before updating table commitments:

Signed ECDSA/ED25519 Inserts (Gas-Sponsored Client Data)

For consumer applications like games or social platforms, data can be inserted by having the end-user sign a message (ECDSA or ED25519) representing the data payload (e.g., user_id=0xabc... action="liked" post_id=123). The application then submits the insert to SXT Chain, sponsoring the gas cost on the user's behalf. Validators verify the user’s signature before including the insert and updating the table commitment.
This method is used by dapps where the end user cryptographically signs the data they are contributing (e.g., social apps, games, wallets).

The user signs a payload (e.g., user_id=0xabc... action="liked" post_id=123) using their ECDSA (Ethereum-compatible) or ED25519 keypair.
The application submits the signed message to the SXT Chain insert endpoint or an onchain insert contract.
The SXT validator set verifies the signature and inserts the payload if the signature is valid.
The table’s cryptographic commitment is updated via BFT consensus.

This method enables gasless UX for end users (apps can pay gas) while preserving end-to-end verifiability of who submitted the data.

Redundant Inserts via Indexer Quorum (Chain-Indexed Data)

For onchain data from networks like Ethereum, Base, etc. a decentralized network of Indexer nodes monitors blockchain activity and transforms event logs, transactions, and state diffs into SQL-compatible rows. These Indexers independently submit proposed inserts to SXT Chain for each data slice.
The validator set then compares incoming inserts from multiple Indexers. If a quorum (e.g., 2-of-3) submit identical rows for a given block height and table, SXT validators threshold-sign a new cryptographic commitment for the table and finalize the insert.

This process guarantees trustless, consensus-based indexing of any chain into a tamperproof SQL format.

A decentralized network of Indexer nodes continuously monitors the source chain using light clients and RPCs.
Each Indexer transforms chain data (blocks, events, txs, balances) into SQL-ready rows and submits the same inserts to SXT Chain.
Validators compare insert proposals across Indexers. If a quorum (e.g., 2-of-3) submit matching rows, validators threshold-sign and finalize the insert.

This mechanism enables tamperproof, trustless indexing of any blockchain into relational format, ensuring that even the most data-heavy protocols (e.g., DEXs, lending markets) can be queried verifiably.

zkTLS Verifications on Insert (End-User Verified Data)

Applications that collect user-consented offchain data (e.g., TradFi accounts, GitHub activity, browser metadata) can insert data into Space and Time using zero-knowledge TLS (zkTLS) proofs. These proofs ensure that data presented by the app was retrieved from a verified HTTPS source (e.g., api.tradfi.com) and that the user explicitly opted in via wallet signature. The insert transaction includes both the payload and the zkTLS proof, which is verified by SXT Chain validators before updating the table’s commitment.

The user signs a payload (e.g., user_id=0xabc... action="liked" post_id=123) using their ECDSA (Ethereum-compatible) or ED25519 keypair.
The application submits the signed message to the SXT Chain insert endpoint or an onchain insert contract.
The SXT validator set verifies the signature and inserts the payload if the signature is valid.
The table’s cryptographic commitment is updated via BFT consensus

This method also enables gasless UX for end users (apps can pay gas) while preserving end-to-end verifiability of who submitted the data.

All these models converge on a single principle: data must be cryptographically proven before it is committed.

Commitment Verification During Query Execution

Commitment Verification During Query Execution

When a Prover node executes a SQL query, it must prove not only that the computation was performed correctly, but that the data used in the query matches the latest validator-approved commitment. This two-part proof ensures:

The Prover cannot fabricate rows or modify past data.
The query result is mathematically guaranteed to be correct.

This is the core innovation behind Space and Time: a decentralized, cryptographically verifiable chain of custody for data that enables smart contracts to trust results without needing to re-run the computation themselves.

For more information on SXT Chain Commitments, check out our whitepaper!