ZEROBASE 백서

ZEROBASE

원문

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
프로젝트로 돌아가기