A few days ago, I saw a report that Space and Time received investment from Microsoft M12 Fund (leading investment of $20 million in 2022 and participating in a $20 million Series A in 2024). So, why did Microsoft M12 Fund invest in Space and Time? How to easily understand the Space and Time project? What exactly does it do? What is the significance of existence in the field of encryption? For the sake of abbreviation, Space and Time (@ SpaceandTimeDB) is referred to as the SXT chain below. What problem does SXT Chain want to solve? SXT Chain mainly focuses on one of the important issues that limit the development of smart contracts: how to lift the restrictions on data processing of smart contracts. So, what are these restrictions mainly reflected in? One limitation is data access. At present, most smart contracts can only access wallet balance, current transaction data, internal status, etc. As for cross chain data, off chain data, and historical data, they often rely on external systems; Secondly, there is a lack of native query engines that are unable to handle complex data queries, which limits the usage scenarios of dApps; Thirdly, the current ZK scheme still has limitations, such as requiring dedicated language or hardware support, and slow speed on large-scale datasets; Finally, the solution is not decentralized enough. Currently, most oracle solutions introduce trust assumptions and are not yet centralized. That is to say, the current restrictions are not conducive to expanding dApps to more usage scenarios. SXT Chain aims to promote the greater development of dApp applications by addressing these data processing limitations. How can SXT chain solve the problem of limited data processing To solve the above problems, several aspects must be met, including support for complex data queries, correct and complete query results, fast query speed, decentralization, etc. Therefore, SXT Chain has proposed its core solution: Proof of SQL. Before understanding the Proof of SQL protocol, we can first take a look at the architecture of the SXT chain, which is a decentralized network with nodes playing the following roles: index nodes, proof nodes, and validators. *Indexing nodes are mainly responsible for extracting block data from mainstream blockchains (such as Ethereum, etc.), including transaction, balance status, contract event logs, etc. These will be converted into SQL compatible formats and perform operations such as extraction, conversion, and loading. These converted data will be submitted as insertion transactions to the SXT chain and stored in a tamper proof table. Pledge assets and receive rewards or punishments based on the correctness and completeness of the query data. *Prover is mainly responsible for processing ZK validation SQL query requests from clients (such as smart contracts), producing proofs to verify the correctness of query calculations and the integrity of data. The most important point here is not only the proof itself, but also the performance. Without performance, there is no scalability. SXT Chain adopts GPU acceleration and supports sub second generation of proofs. If it can be implemented, it will be one order of magnitude faster than existing zkVM. *Validator is mainly responsible for maintaining network integrity, updating on chain encryption commitments, and ensuring that tamper proof tables reflect the latest data status. It mainly uses BFT (Byzantine Fault Tolerant) consensus mechanism to perform threshold signature on new commitments, which is to achieve decentralized security verification. The general process is that the client (smart contract) sends a query request to the SXT chain validator contract and makes payment, and then initiates the query, proof generation, etc; The proof node will listen for on chain events, execute Proof of SQL, and ultimately generate ZK proofs and query results. The verifier will verify the proof and return the result to the client (smart contract). From the above, it can be seen that the core of these is based on decentralized query verifiability. This is the core reason why SXT Chain launched the Proof of SQL protocol. The Proof of SQL Protocol for SXT Chain Proof of SQL is a ZK protocol that supports the verifiability of SQL queries. It is executed off chain and its main steps include data digestion, query requests, and proofs. Among them, data digestion mainly involves: dAPP or smart contracts and other data sources sending data to validators, generating encrypted commitments, validators storing commitments, and data routing and storage in databases. The query request is mainly sent to the proof node, the proof node parses the query, calculates the result and generates a ZK proof, and the verifier uses commitment to verify the correctness of the proof and result. Proof section: Parse SQL queries into abstract syntax trees, generate ZK circuits, execute queries and build proofs, use multilinear summation check protocols to generate proofs, and validate data columns through commitment schemes. Its key sub protocols include Equality Protocol and Group by Protocol, with the former proving the correctness of the results through witness columns; The latter processes aggregate queries and uses random challenges to ensure that witness columns are tamper proof. From the overall technical solution of SXT chain, it can be focused on several aspects: first, on chain verification, which achieves EVM internal verification through ZK proof and is basically compatible with current major blockchains; The second is the speed of generating proofs, which is one of the key steps in implementation. It supports 100GB level queries and sub second level responses,; Thirdly, the comprehensive coverage of data includes storing complete data sources such as transactions, blocks, logs, and time, as well as supporting cross chain queries. Fourthly, optimization in SQL queries involves optimizing circuit design and focusing on SQL operations to achieve efficient ZK circuits and reduce computational costs. Additionally, blockchain data is decomposed into relational tables (wallets, blocks, transactions, etc.) to adapt to SQL queries. Fifthly, using ZK proof can achieve no need for trust, reduce dependence on licensed nodes, and improve scalability. Finally, Proof of SQL has been launched on GitHub and integrated into Google BigQuery. Interested users can follow it on their own. These technical solutions are precisely designed to address the various limitations and shortcomings in data queries mentioned at the beginning. In addition, compared to The Graph for indexing and Chainlink for oracle, SXT Chain focuses on decentralized databases with SQL queries and ZK validation. 3. Unlock more usage scenarios The most important aspect of SXT Chain's solution is not solving the limitations of data processing, but whether it can unlock more usage scenarios. Through it, more application scenarios can be supported.