In today’s Web3 architecture, data processing often faces a tension between privacy and transparency. On one hand, data needs to be protected. On the other, results need to be verified. By combining zero knowledge proofs (ZK) with trusted execution environments (TEE), ZEROBASE builds a “Trust-Minimized Execution Network” that coordinates on-chain and off chain computation.
Looking at the overall flow, ZEROBASE breaks data processing into multiple stages, including data input, processing, computation execution, and result verification. Through “distributed computing + proof mechanisms,” it creates an end to end trusted process.
Overview of ZEROBASE’s Data Processing Mechanism
ZEROBASE’s data processing mechanism can be understood as a proof centered computing system. Its defining feature is that data itself does not circulate directly; instead, its state is expressed through verifiable results. In other words, the system is not focused on “data being seen,” but on “results being proven.”
This mechanism is built on three core design principles. The first is Minimal Disclosure, meaning the system outputs only verified results rather than the original data itself, reducing the possibility of exposing sensitive information. The second is Trust Minimization, which uses cryptographic proofs and isolated execution environments to reduce reliance on any single executor, allowing computation to be valid without depending on trust. The third is Composable Proofs, where outputs from different computation modules can serve as inputs for other modules, making “proof” a common interaction language inside the system.
Under this structure, “Proof” is not merely a verification tool. It becomes the basic interface through which the system operates. Modules coordinate by exchanging proofs rather than the underlying data itself, forming a proof driven distributed computing network.
Source: zerobase.pro
ZEROBASE’s data sources mainly include both on-chain and off chain data. When entering the system, both follow a unified input processing flow. When users or applications initiate a request, they submit not only the data itself, but also the computation logic or task objective to be executed.
After data enters the system, it is not directly exposed to execution nodes. Instead, it is sent into a protected execution environment for processing. Specifically, ZEROBASE uses trusted execution environments (TEE) to perform isolated computation on the data, keeping it encrypted or controlled throughout processing and preventing node operators from accessing it.
This mechanism creates a form of processing in which “data is usable but not visible.” Nodes can complete computation tasks, but they cannot obtain the original data content. This is especially important for scenarios involving sensitive information or private data, allowing data to participate in computation while maintaining security and compliance.
Data Indexing and Processing Flow: Data Parsing, Indexing, and Structured Processing
After data input is complete, it needs to be parsed and structured before entering the next computation stage. This process is similar to traditional on-chain data indexing mechanisms, but ZEROBASE goes a step further by combining “data processing” with “computation execution.”
The system first parses the original data and converts it into a standardized structure, allowing it to fit different computation modules. This structuring process not only improves data usability, but also provides a unified input format for subsequent computation.
At the same time, ZEROBASE does not directly output the processed raw data. Instead, it generates a corresponding “state expression.” For example, the system may output the risk interval or return range of a given strategy, but this information is not presented as plaintext data. It is expressed and verified through zero knowledge proofs.
This “structured + proof based” approach allows data to retain two characteristics throughout its lifecycle: it can participate in computation, and it can be verified without being reconstructed. In this way, ZEROBASE balances privacy protection with trusted execution.
How Computation Tasks Are Executed: Distributed Computing and Task Distribution Mechanism
During the computation execution stage, ZEROBASE uses a task driven distributed computing model. The network coordination layer breaks tasks apart and distributes them to multiple computing nodes, known as Provers, for execution. Different nodes participate in computation based on their resource capacity and task type, allowing overall computing power to scale dynamically.
In actual execution, Prover nodes are responsible not only for completing the computation logic, but also for generating the corresponding zero knowledge proofs to prove the correctness of the computation process. This means that the node’s output is not just the result itself, but also a verifiable computation credential.
At the same time, the system coordinates and transfers proofs between different modules through a structure similar to “Proof Mesh,” allowing various computation results to be reused across different applications. This mechanism treats “proof” as a common interface, enabling modules to collaborate by verifying results rather than sharing data.
Overall, this design brings two key features. First, tasks can be executed in parallel, improving computation efficiency. Second, all results are verifiable and can be directly used by other modules. For this reason, ZEROBASE’s computing network is not merely an execution layer, but a collaborative network centered on “verifiable computation.”
Result Output and Usage: Data Result Return and Application Interfaces
After task execution is complete, ZEROBASE outputs two core results: the computation result itself and the corresponding zero knowledge proof. Together, they form the system’s standard output format.
The computation result usually appears as structured data, such as an analysis result, status interval, or metric information. The zero knowledge proof is used to verify the correctness of these results without revealing the original data involved in the computation process.
These outputs can be submitted on-chain for verification, or they can be called by external applications through interfaces. Unlike traditional APIs that return only data, ZEROBASE provides a combination of “result + proof,” giving data verifiability when it is used.
In addition, because proofs are composable, these results can be used directly as inputs for other protocols or applications. For example, in DeFi or data analysis scenarios, the output of one module can become the input for another, creating cross system collaboration and automated workflows.
Although ZEROBASE offers stronger capabilities in privacy protection and result trustworthiness, its data processing flow inevitably involves several trade offs.
First, generating zero knowledge proofs usually involves relatively high computational overhead. This is especially true for complex or high frequency computation tasks, where it may affect overall processing speed. As a result, the system needs to balance performance and security.
Second, while trusted execution environments (TEE) strengthen data security, they also introduce additional system complexity and may depend on specific hardware environments, which can affect deployment flexibility.
In addition, while a distributed computing network improves resource utilization, it may also create task scheduling and network communication latency. When nodes are widely distributed or workloads are uneven, overall execution efficiency may be affected.
For this reason, ZEROBASE’s operating mechanism is fundamentally a trade off among “performance, privacy, and decentralization,” with its architecture designed to find a balance among different requirements.
Summary
By combining zero knowledge proofs, trusted execution environments, and distributed computing, ZEROBASE builds a data processing flow centered on “verifiable computation.” Its key innovation is embedding trust in computation results directly into the execution process, so data processing can not only complete the task itself, but also provide verifiable proof, improving system reliability and transparency.
This mechanism breaks through the limitations of traditional data services between privacy and verification. It offers a new implementation path for Web3 data infrastructure and provides foundational support for the integration of privacy computing and on-chain applications.
FAQ
- How does ZEROBASE process on-chain data?
Through distributed computing and zero knowledge proofs, it enables data processing and result verification.
- Can nodes see the data?
No. Data is processed inside TEE and is not disclosed to nodes.
- What is “verifiable computation”?
It means computation results can be proven correct without revealing the original data.
- How is it different from a traditional data API?
A traditional API provides results, while ZEROBASE provides “results + proofs.”
- Does it support complex computation tasks?
Its architecture supports complex data processing and computation tasks, including analysis and model based computation.
