bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 1쪽
1
ZEROBASE: At the Intersection of Trusted Computing and Verifiable
Privacy
I. INTRODUCTION
In recent years, as data sovereignty, privacy protection, and
system transparency have become central themes in global
policy and industry discourse, the demand for a technical
foundation that enables ”controllable yet non-intrusive” infras-
tructure has become a critical challenge for the architectures
of digital finance and the sharing economy. In traditional
paradigms, on-chain execution provides verifiability but suffers
from performance bottlenecks and limited privacy guarantees,
making it ill-suited for high-frequency trading, complex strate-
gies, and sensitive data processing. Off-chain systems, while
more efficient, sacrifice verifiability and trustlessness, resulting
in increased trust costs and structural risks for users.
ZEROBASE proposes a hybrid paradigm that integrates
off-chain Trusted Execution Environments (TEEs) with on-
chain Zero-Knowledge Proofs (ZKPs), achieving both privacy
in execution and verifiability in outcomes—without reliance
on centralized intermediaries [1]–[3]. This architecture lever-
ages three foundational technologies—zero-knowledge proofs,
hardware-based circuit-level encryption (e.g., AMD SEV-
SNP), and programmable liquidity engines—to construct a
highly available, modular, and sustainable privacy-preserving
execution network. It provides unified, accessible, and trust-
worthy infrastructure for developers, asset providers, and end-
users alike.
Therefore, ZEROBASE is not intended as an isolated proto-
col but as a generalized execution platform capable of support-
ing complex strategy deployment, resource assetization, and
trusted off-chain computation—serving as a systemic anchor
and universal trust layer for diverse application scenarios.
A. Vision and Mission: Restructuring Trust in Financial Exe-
cution
The mission of ZEROBASE is to address two long-standing
challenges in on-chain ecosystems: (1) the inability of users
to verify complex strategies, leading to widespread ”black-
box execution”; and (2) the inherent tension between privacy
preservation and system transparency, which forces users and
developers to trade off efficiency against trust.
We argue that a truly sustainable execution network must
satisfy three essential conditions: preserving confidential space
for strategists, defining clear risk boundaries for capital par-
ticipants, and minimizing integration and composability costs
for builders.
To this end, ZEROBASE aims to establish a philosophy of
structural transparency—a system built not on trust assump-
tions, but on mathematical guarantees, architectural isolation,
and standardized interfaces, thereby enabling a trustworthy
multi-party collaboration framework.
Our vision can be summarized in four core pillars:
•Verifiable Strategy Execution: Support for complex strate-
gies (e.g., hedge funds, algorithmic trading) to run pri-
vately off-chain, while exposing key risk metrics such as
leverage ratios and value-at-risk (VaR) intervals via zero-
knowledge range proofs—achieving “auditable privacy”
without blind trust.
•Resource Assetization: Enable bandwidth, storage, GPU
cycles, and other shareable resources to participate
in DeFi mechanisms—collateralization, lending, atomic
swaps—by generating on-chain attestations through
trusted execution and ZK proofs, thereby unlocking their
on-chain liquidity potential.
•Composable User Experience: All core modules (e.g., cir-
cuits, zkStaking, ZK browser) adopt standardized, nested-
callable interfaces. Developers can easily compose and
reuse capabilities to rapidly construct composite applica-
tions with minimal friction.
•Frictionless Ecosystem Collaboration: Through well-
defined interface specifications and stable tooling, ZK
applications can interoperate without requiring additional
consensus layers, transitioning from isolated protocols to
a structurally collaborative ecosystem.
Guided by these principles, ZEROBASE is committed to
building a decentralized execution ecosystem that is struc-
turally sound, clearly bounded, and collaboration-efficient—a
platform that demands neither trust concessions nor privacy
sacrifices.
B. Technical Philosophy and Design Principles: Reconstruct-
ing Trust Boundaries between Mathematics and Hardware
ZEROBASE is not merely an incremental upgrade to ex-
isting paradigms—it represents a foundational reconfigura-
tion of the trust model itself. It is a systemic logic that
unites mathematical formalism, cryptographic mechanisms,
and trusted hardware into a cohesive operational frame-
work—where “trustlessness” becomes the default assumption.
This structurally transparent execution network is governed
by three core design principles:
•Minimal Disclosure. Information is no longer disclosed
as “raw data,” but as cryptographic “proofs.” Whether
representing strategy risk, yield performance, or liquidity
status, ZEROBASE employs range proofs or structured
ZKPs to express system states, ensuring that users can
establish trust without accessing underlying data. For
example, statements like “leverage does not exceed 2x” or
“daily yield falls between 0.1% and 0.3%” are presented
as verifiable outputs, rather than plaintext disclosures.
2
•Trust Minimization. Off-chain execution in ZEROBASE
operates within AMD SEV-SNP’s confidential comput-
ing environment, with remote attestation verifying the
integrity of the runtime. On-chain verification is per-
formed via formally constructed ZK circuits. As a result,
the system eliminates dependence on any single trusted
party and ensures logical correctness through crypto-
graphic primitives and architectural compartmentaliza-
tion—achieving end-to-end structural trustlessness from
hardware root-of-trust to governance mechanisms.
•Composable Proofs. In the ZEROBASE architecture,
proofs function as the “intermediate language” for inter-
module cooperation. Each strategy module outputs a uni-
fied state digest (e.g., risk intervals, performance metrics,
solvency indicators [4]) that can be directly consumed
by DeFi protocols, liquidation engines, or collateral-
ized lending structures. This abstraction—“proof as in-
terface”—dramatically reduces verification costs, clearly
defines module boundaries, and fosters innovation across
chains and execution domains.
ZEROBASE thus embraces a novel ethical framework: privacy
is usable, trust is computable, and structure is composable. A
truly trustworthy system requires no justification—it proves
itself through its own architecture.
C. Market Landscape and Core Challenges: Fragmented Pri-
vacy Solutions and Absent Systemic Coordination
Amidst rapid advances in cryptographic finance, distributed
computing, and modular protocols, the greatest challenge
today is not the absence of technological tools—but the lack of
an integrated architecture that harmonizes them. Users demand
privacy, capital demands verifiability, systems rely on off-chain
execution, and resources seek on-chain monetization—yet
existing architectures typically satisfy only one of these needs,
often at the expense of the others.
This has led to several structural dilemmas:
•Users require privacy, yet protocol design mandates data
transparency;
•Strategies need secrecy to preserve alpha, yet participants
demand clear exposure metrics;
•System performance depends on off-chain execution, but
verification logic is constrained by on-chain infrastruc-
ture;
•Resources are shareable but not composable, making
”off-chain value” difficult to tokenize.
These tensions highlight the absence of structural coordina-
tion as a systemic bottleneck. From opaque operations on
centralized platforms to the indiscriminate public exposure
of on-chain data; from fragmented mining yield structures to
inconsistent privacy standards—the broader crypto ecosystem
lacks a unified hub that integrates execution, verification, and
incentive mechanisms.
The Trust-Minimized Execution Network (TMEN) proposed
by ZEROBASE is not tailored to a specific application. Rather,
it is a foundational capability layer designed to make off-chain
execution verifiable on-chain, to interconnect ZKP and TEE
systems, and to unify resources and strategies in a composable
structure. Its core value lies not in expanding application
coverage, but in offering:
•A reusable bridge between off-chain and on-chain envi-
ronments;
•An interface architecture that accommodates diverse
proof systems and hardware models;
•A modular framework that abstracts assets, strategies, and
resources into standardized I/O formats;
•A unified platform that synchronizes execution, verifica-
tion, and incentive flows.
Built atop this interface layer, developers can freely build
complex interactions, users can engage with confidence, re-
source providers can monetize participation, and the system
as a whole gains evolutionary resilience through architectural
alignment.
II. SYSTEMARCHITECTURE
ZEROBASE seeks to construct a trust-minimized and
privacy-verifiable execution network that serves as a structural
bridge of trust for off-chain computation, addressing the pre-
vailing reliability gap between on-chain and off-chain systems.
This network is built upon the coordinated operation of three
core technological components:
•Trusted Execution Environments (TEE) for off-chain
privacy-preserving and integrity-guaranteed computation;
•Zero-Knowledge Proofs (ZKP) on-chain to enable result
verifiability without revealing sensitive data;
•A unified proof mediation layer (Proof Mesh) for cross-
layer and cross-protocol standardization and interoper-
ability.
This tripartite architecture not only ensures trust and pri-
vacy for off-chain computation, but also supports strategy
abstraction, modular composition, and verifiable state transi-
tions—forming a scalable foundation for decentralized finance
(DeFi), shared computing, and AI computation.
A. Three-Layer Architectural Design: TEE, ZKP , and Proof
Mesh
The ZEROBASE execution network is organized into three
architectural layers, each fulfilling distinct functional respon-
sibilities and interfacing through standardized protocols. This
layered design enhances system modularity, maintainability,
and extensibility.
1) Trusted Execution Layer (TEE Layer):At the core of
the execution network lies the TEE Layer, responsible for all
sensitive off-chain computations, including strategy execution,
resource scheduling, and data processing. Each strategy en-
gine, transaction node, or resource provider operates within
a hardware-isolated trusted execution environment, such as
AMD SEV-SNP, Intel TDX, or ARM CCA [5]–[7]. TEE tech-
nologies enforce memory encryption and CPU-level access
control to isolate the runtime environment and protect against
external inspection or tampering.
To prevent malicious nodes from impersonating trusted
computing agents, the system employs Remote Attestation
mechanisms [5]–[7]. Each node must submit hardware-signed
3
Fig. 1: Network Architecture
attestations during registration or execution, proving the au-
thenticity, integrity, and consistency of its execution environ-
ment. These attestations form the basis for a decentralized
reputation model that balances openness with security across
the ZEROBASE network.
Logic executed within the TEE is subject to rigorous audit
and encapsulation, functioning externally as a “black box.” It
accepts encrypted inputs from on-chain or off-chain sources,
performs private computations internally, and produces both
a final output and a proof digest for on-chain verification.
Throughout this process, user data, strategy logic, and resource
access patterns remain encrypted—ensuring full execution
privacy.
2) Zero-Knowledge Proof Layer (ZKP Layer):Following
execution within the TEE, results must be verifiably con-
veyed to on-chain validators. This task is handled by the
ZKP Layer, which transforms key execution semantics into
cryptographic zero-knowledge proofs. Serving as the system’s
“trust extension mechanism,” the ZKP Layer enables each
node to use standardized circuit templates to convert inputs,
state transitions, and outputs into verifiable zk-SNARK or
zk-STARK proofs [1], [8]–[11]. To promote generalizability
and developer efficiency, ZEROBASE offers a standardized
circuit library encompassing multiple commonly-used proof
types [12], [13], including:
•Range Proofs: Verifying that a numerical value lies within
a specified interval [12];
•Validity Proofs: Confirming that a computation was per-
formed on valid inputs and states;
•State Transition Proofs: Verifying that a state change from
s0 tos 1 adheres to predefined logical constraints;
•Merkle Path Proofs: Proving inclusion of a specific ele-
ment in an off-chain Merkle-based state tree.
The current implementation integrates major proof systems
such as PLONK, Groth16, and STARKs to optimize for
low verification cost and compact proof sizes. For long-term
resilience against quantum threats, ZEROBASE also envisions
incorporating lattice-based zero-knowledge systems, including
constructions based on LWE and SIS [14], [15], to combine
cryptographic hardness with programmability and structural
flexibility.
3) Proof Mediation Layer (Proof Mesh Layer):The Proof
Mesh serves as the structural adaptor between TEE-based off-
chain execution and on-chain integration, representing one
of ZEROBASE’s most novel architectural components. It
performs several critical roles that enable high-efficiency, high-
generalizability, and high-composability coordination across
layers.
First, the Proof Mesh standardizes all ZKPs produced by
the TEE Layer. This involves formatting (e.g., unified field
names and proof structures), semantic annotations (e.g., proof
type, purpose, timestamp), and protocol version control. These
standards allow on-chain smart contracts to interface with off-
chain proofs via uniform APIs without needing to interpret
implementation-specific logic—significantly lowering integra-
tion overhead.
Second, the Proof Mesh enables advanced proof-level func-
tionalities, such as:
•Proof Aggregation. Compressing multiple independent
proofs into a single proof to reduce on-chain verification
overhead [9], [12], [16];
•Recursive Proofs: Embedding one proof within another,
allowing hierarchical modeling of complex off-chain pro-
cesses [9], [10], [30];
•Cross-Protocol Invocation: Facilitating the reuse and in-
vocation of proofs across different modules and DApps,
forming a ”proof-as-a-service” data layer [17]–[19].
In addition, the Proof Mesh introduces version control and
event subscription mechanisms, enabling support for “off-
chain computation logs” and “on-chain event triggers.” For
example, a DApp can subscribe to the publication of specific
types of execution proofs and trigger automated logic in
response to newly generated proofs.
Through the coordinated operation of these three
architectural layers—secure execution (TEE), verifiable
translation (ZKP), and interoperable mediation (Proof
Mesh)—ZEROBASE establishes a complete trust-preserving
execution loop. Each off-chain computation is encapsulated
into a standardized, succinct, and verifiable “proof package,”
ready for dissemination and invocation on-chain.
This design embodies a new execution paradigm where
“results become interfaces, and proofs define structure,”
transforming off-chain execution from a black-box process
into a first-class citizen within the on-chain economic sys-
tem—composable, callable, and trust-minimized by construc-
tion.
III. NETWORKTOPOLOGY ANDNODEMANAGEMENT
To achieve both scalability and resilience against adversarial
behavior, the ZEROBASE network adopts a hierarchical rout-
ing architecture, as shown in Figure 1, whereby Worker nodes
are organized into subnets managed by Hub nodes. Each Hub
is responsible for a subset of Worker nodes, and the routing
structure is built on a Kademlia-like topology, where node
identifiers (Node IDs) are derived by hashing the node’s IP
address and port number using SHA-1 (160-bit), which also
4
Fig. 2: Node Distance
serves as the basis for logical distance calculation and routing
table construction [20].
A. Node Identification and Logical Distance Metrics
Every node in the network—whether a Hub or a
Worker—generates a unique 160-bit Node ID upon joining
the system by hashing its IP address and port number:
ID = SHA1(IP, Port)
As shown in Figure 2, the logical distance between any two
nodes is defined as the bitwise XOR of their Node IDs. For in-
stance, given two nodes with IDs:X= 1101, Y= 1000.This
XOR-based metric does not reflect physical proximity but is
used solely for constructing logical routing paths. When a
Worker joins the network, it computes its logical distance to
all existing Hubs and binds to the nearest Hub, which is then
responsible for maintaining and managing its state.
B. Node Assignment and Distance-Based Layering
Consider a network with three Hub nodes: Hub 0, Hub 1,
and Hub 2, with corresponding Node IDsX,Y, andZ. A
new Worker node with IDTjoins the network. The Worker
computes its XOR distance to each Hub:
D(T, X) =T⊗X D(T, Y) =T⊗Y D(T, Z) =T⊗Z
Suppose
X= 0001Y= 0010Z= 0100T= 1000
Then
T⊗X= 1001T⊗Y= 1010T⊗Z= 1100
Since the node ID is a 160-bit binary string, each Hub needs to
maintain 160 lists (K-buckets) to store other Hub information,
such as IP, port, and ID.
Consider the following scenario: Hub1’s ID is 101. If the
first digits of Hub2’s ID are the same as Hub1’s ID, and only
the last digit is different, that is, 100, the XOR of the two Hub
IDs is101⊕100 = 001, that is, the distance is 1; for Hub2,
Hub1 will put it into ”K-Bucket 1”.
Consider the IDs of some Hubs, where all the first digits
are the same and the second-to-last digits are different. There
are two such Hubs, whose IDs are 111 and 110, respectively.
The XOR values of these Hubs with the ID of Hub1 are101⊕
111 = 010and101⊕110 = 011, that is, the distance ranges
are 2 and 3. For these two Hubs, Hub1 will put them into
”K-Bucket 2”. The specific details are shown in Figure 3.
Fig. 3: Node Assign
Consider the IDs of some Hubs, where all the first digits are
the same and the third digit from the last is different. There
are only four such Hubs, and their IDs are: 000, 001, 010,
011, and the XOR values of these Hubs with the ID of Hub1
are101⊕000 = 101,101⊕001 = 100,101⊕010 = 111,
101⊕011 = 110, that is, the distance ranges are 4, 5, 6, and 7;
Hub1 will put these four Hubs into ”K-Bucket 3”. As shown
in the figure below, for Hub with ID 101, it adds Hub with
ID0× ×to ”K-Bucket 3”, Hub with ID11×to ”K-Bucket
2”, and Hub with ID 101 to ”K-Bucket 1”.
If the first digits of a Hub’s ID are the same, but the digits
from the last digit are different, there are only2 i−1 such Hubs,
and their distances from Hub1 are in the range of[2 i−1,2 i−1].
For Hub1, these Hubs will be placed in ”K-Bucket i”. The
specific details are shown in Table I and Figure 4
TABLE I: Bucket
K-Bucket Distance Interval
K-Bucket 1 [20,2 1 −1]
K-Bucket 2 [21,2 2 −1]
K-Bucket 3 [22,2 3 −1]
... ...
K-Bucket 160 [2159,2 160 −1]
Asiincreases, there are2 i−1 Hub information in K-
Bucket i, which will bring great storage overhead to the Hub.
Therefore, it is stipulated that each K-Bucket only records
the information of K Hubs, where K is an adjustable constant
parameter. Since the ID length is 160 bits, each Hub maintains
information of up to160×K(K is usually 20) other Hubs.
In addition, the position of the Hubs stored in each K-bucket
is arranged in the order of the last time they were seen, with
the earliest accessed at the head and the latest accessed at the
tail.
C. Instruction Set for Hub Nodes
Communication between Hub nodes is facilitated through a
concise set of protocol-level commands. The core instruction
set includes:
5
Fig. 4: K-Bucket
•PING: Used to probe the liveness of a target Hub node.
Essential for maintaining the health of K-Buckets.
•ADD WORKER: Instructs the recipient Hub to store state
and routing information fo프로젝트로 돌아가기