Introducing Orochi Network - The Operating System For High Performance dApp And Metaverse
Table of Contents
At Orochi Network, we are taking on the challenges of resolving three core issues in the decentralized gaming industry and metaverse, including computation limitation, data correctness, and data availability, by combining the advantage of traditional blockchain’s technology and the efficiency of modern zero-knowledge proof systems. Orochi Network aims to address these three aforementioned key issues with a comprehensive architecture powered by its UnityOS (Orochi Network Computation Layer). We aspire to offer an advanced solution for the new generation of decentralized games and metaverse projects that possess high performance, low latency, verifiable computation and superior experiences for gamers and metaverse participants.
What is Orochi Network?
Orochi Network is an advanced operating system of the new internet. We established this project to capture the inevitable future of the internet where metaverse is the center. Despite any drastic evolvement, its nature won’t be changed, the internet is an untrusted and trustless environment at the same time. Any participant on this internet will more or less encounter this challenge: we need the people on the internet (especially the providers) to be honest but due to the anonymity online, any party would have the tendency to cheat whenever they have a chance. To enforce consumer’s and provider’s honesty, Orochi Network is employing Zero-Knowledge Proof (ZKP), utilizing two main properties of ZKPs:
- Completeness: If the statement is true and the prover is honest, they can convince the verifier
- Soundness: A malicious prover cannot convince the verifier of a false statement.
With these two properties, the honest prover can convince the verifier about the validity of the statement and Orochi Network can guarantee high performance without sacrificing the decentralization.
Our UnityOS, a decentralized operating system that connects and redistributes the resources of the internet. It provides all necessary components that allow people to build and execute High Performance dApps. The pillars of the UnityOS among various components are:
- oWASM: This is a Zero-Knowledge Proof (ZKP) integrated version of WebAssembly (Wasm) run-time used as the application executor of UnityOS (Orochi Computation Layer). It allows programs to be written with popular programming languages and executed with a semi-native performance. The difference between oWASM and ordinary Wasm environment is that oWASM has a ZKP prover to prove all steps of the computational process to make sure that the result was computed honestly.
- Orocle: A decentralized Oracle that functions as a bridge between decentralized applications (dApp) and reality. It feeds bias-free data into the communication between dApps and the real-world.
- Orand: A decentralized Random Number Generator (Decentralized RNG), also known as a trustless source of randomness which can be used in the dApp to distribute digital assets, host lottery-related tasks or calculate item drop rate with utmost fairness.
- Orocom: An immutable ledger engine that can be used in the dApp to store and query data from an off-chain storage.
Each component will be discussed in detail in later sections.
Decentralized gaming & Metaverse Challenges vs. Orochi Network’s Solution
The limits of computation
Numerous blockchain games use Ethereum Virtual Machine (EVM) to execute the game logic. In short, EVM can be perceived as Ethereum’s CPU to execute smart contracts. EVM is a deterministic and turing-complete computer, allowing the execution of programs compiled to EVM opcode. The purpose of EVM is to create a deterministic environment to ensure the smart contract be executed equally on all machines. Ethereum-based blockchains use Solidity as the primary programming language; however, EVM and Solidity are not ideally designed for this purpose due to several following reasons:
- EVM can only process a limited number of states. It cannot execute an infinity loop to generate repeated responses to a series of events.
- EVM stores its state on the blockchain, making the EVM latency too high to execute game logic. In the traditional game industry, the acceptable latency is around 0 ~ 150 ms, while the average latency of EVM on Ethereum, for instance, is approximately 60,000 ms.
- It is almost impossible for EVM to reach a semi-native performance.
- Solidity was designed for smart contract execution. It does not have the proper design and required capacity to accommodate and implement game logic.
Orochi Network’s Solution - oWASM:
WebAssembly (Wasm) run-time environment was introduced in 2015, first released in 2017, and became a World Wide Web Consortium (W3C) recommendation in 2019. WebAssembly was created initially to execute high-performance applications on web pages and applications. WebAssembly has its own instruction set defined for its run-time. Compiling languages into WebAssembly opcode (Wasm Opcode) allows the WebAssembly run-time to execute opcodes independently from the environment, CPU architecture, and operating system. It was later realized that any language could easily compile the Wasm Opcode; furthermore, the Wasm run-time was also easy to integrate. Thus its application coverage is extended and no longer limited to the world wide web.
Wasm run-time can achieve semi-native performance, which is currently impossible for EVM run-time. In some cases, Wasm can be 2,000 times faster than the EVM.
There is no such thing as an end-to-end solution for data processing. If an adversary manipulates a step in the data pipeline, he/she can manipulate the result completely. Currently, traditional approaches built up a black box pipeline that is improvable by any methods:
- Sampling: In practice, the sampling process was done carelessly. Consumers don’t know where the data came from and how the data was sampled.
- Processing: After sampled raw data needs to be processed to remove unwanted noise and transformed to structured data. However, we do not have the method to guarantee the noise-omitting process has been carried on properly.
- Storing: Ordinary database do not provide immutability or tracking challenges
Orochi Network’s Solution - Orocle:
Oracle is the system library of UnityOS. It provides abilities for all applications to interact with the real-world. We introduce verifiable sampling and verifiable processing to make sure that no party is able to manipulate the data processing steps, even from the earliest. Orocle library will be executed by oWASM and eventually, a ZKP will be available to prove the correctness of computational result.
The current approach for accessing data is by requesting them from the centralized Oracle service. Whenever there is a request, data will go through the black box pipeline from sampling to feeding to smart contracts. This process has high latency and extremely high cost. For instance, it costs 9 dollars and 5~7 minutes to feed a single chunk of data. Decentralized Application’s performance is unsatisfactory at this point where it cannot access data immediately and the correctness of data depends on a third party service.
Other projects choose to store their data on blockchain. However, most will not be able to afford transaction fees in the long run as the cost covariates with the token price and the size of data.
Orochi Network’s Solution - Orocom:
Orocom is an immutable ledger engine. It establishes data accessible from a run-time environment for the first time. As the latency is improved, data can be provided immediately whenever needed. It is possible to increase the speed up to 11~66 ms depending on the physical distance between node and off-chain data storage. With Orochi Network’s technology, data will be stored in an off-chain immutable ledger; hence, the cost to store data will be decreased significantly. Moreover, we can achieve 1,000,000 times faster than on-chain storage.
By combining Orocle and Orocom, the data will be sampled at its source and stored at the immutable ledger. Therefore, we are able to create a verifiable data pipeline for the first time and prove every bit of data is correct.
UnityOS - Orochi Computation Layer
UnityOS manages a pool of computation power. It allows High Performance Decentralized Applications (High Performance dApp) to be hosted and processed without any centralized server. UnityOS runs in a server-less fashion with the underlying technology that can handle almost everything. Hence, the developers only need to focus on designing the logic of their dApps. This layer is built with distributed computing using oWASM. The dApp can be implemented by popular programming languages namely C++, Rust, Go and processes with semi-native performance. Computation layer will be allocated dynamically and thus, save operational costs and computational waste.
At the moment, very few projects are able to solve computational scalability, or even if they do, it is merely a distributed computing system without abilities to verify computational results. Therefore, developing a Computation Layer is an open challenge, which Orochi Network’s concept and vision for UnityOS aim to propose. When one person deploys a dApp to the Orochi Network, others can also inherit and use it. Users will then be routed to the nearest cluster of validators and the dApp will be executed on oWASM. At the end of a session, the result and ZKP will be committed. These results and proof can be verified by smart contracts on Layer-1 Blockchain.
Orocle - Decentralized Oracle
Orocle is the system library of UnityOS. It functions as a bridge between the dApp’s executor and the reality that allows the dApps to access and interact with the real world. Being a system library allows Orocle to minimize the interactive latency between dApps and itself. We can lower the latency to as low as 60~120 μs while the latency of the same task can be around 402~2200 ms if executed by a third party.
Our vision is to combine Orocle and Orocom to create the very first Verifiable Data Pipeline enforcing security with cryptography proofs (SNARKs). At the very end of our development, the result will be a Decentralized Data Lake for Web3, metaverse and dApp.
Orand - Decentralized Random Number Generator
Decentralized Random Number Generator is one of the biggest challenges in blockchain technology, which receives huge demand from the industry regardless of the cost of the solution. According to Chainlink VRF’s intel, there has been 8 million randomnesses each month. Although it can be a small figure for other fields, we should not underestimate its value and potential in the future since the more Decentralized Gaming and metaverse are developed, the more demand there is for trustless randomness. In Orochi Network’s speculation, metaverse can be the cause of the next information explosion, changing the landscape of the internet entirely. At the peak of Decentralized Gaming and metaverse, the demand for trustless randomness can reach trillion queries each month.
Orand is a trustless source of randomness. As a system library of UnityOS, Orand can provide randomness for all dApps on oWASM and smart contracts on supported Layer-1 chains. Deliberate proofs for some properties on the cross-chain randomness of Orand (counter-manipulation, open-sourced transparency, verifiability and high throughput) will be published in recognized scientific venues. So far, we have released Orand as an open source project based on Verifiable Random Functions (VRFs), licensed under Apache License 2.0. At this stage, Orand has already been implemented and under testing.
Orocom - Immutable Ledger Engine
Data availability has been the bottleneck preventing true decentralized application. Currently, there is no solution to resolve this issue completely. High latency and expensive storing fee leave decentralized applications no choice but to depend on a centralized service. To build a truly decentralized application, a Decentralized Data Lake is necessary for the future where 98% of decentralized application’s data will be stored on off-chain storage.
Immutable Ledger is a new branch of database that allows every change on data to be traceable as well as makes fraud and corruption visible. Orocom focuses on off-chain data storage and on-chain verification. The unique selling point of Orocom is its availability in the run-time environment that any program can perform data queries with zero latency and zero cost.
oWASM - Verifiable WebAssembly Run-time Environment
For Orochi Network, we aim to build our own Verifiable WebAssembly Run-time Environment as a verifiable run-time environment to play the role of a high performance dApp executor of UnityOS. oWASM is a general purpose verifiable run-time. It can implement any kind of business logic with any popular programming language.
oWASM is a ZKP-integrated run-time that constrains every opcode with the run-time’s context to generate a proof of validity of computation. ZKPs establish the ability to verify expensive computations on a weak device, which lacks computation power.
As Wasm is a standard allowing us to compile another programming language into text such as assembly (an assembly instruction usually corresponds to a CPU instruction). For this attribute, it is unarguably among the highest performing programming languages since Wasm opcodes can be translated directly to native opcodes which control the CPU. The Wasm compiler delivers better performance by encoding assembly texts into assembly bytecodes resulting in reduced size and faster processing on Wasm run-time environment. These general advantages of Wasm enable our oWASM to overcome the above-mentioned limitations of EVM and satisfy our requirements of executing dApps with high performance.
Orosign - Orochi Network Interface
Orosign will be the interface of web3 which offers more advanced features for the applications in the ecosystem namely on-chain custody, web3 authenticator, privacy KYC.
Orosign is the User Interface (UI) of MetaChain and UnityOS. It simplifies the users’ complicated operations in interacting with multi-chain warp zones, UnityOS native application store or universal transactions, hence making the process friendlier and more accessible. Orosign is a feature-rich wallet that can integrate multiple games and native decentralized applications.
About Orochi Network
Orochi Network provides missing building blocks for Decentralized Gaming and Metaverse, the first infrastructure that provides Verifiable Computation.
We allow computation to be processed off-chain at zero cost without sacrificing decentralization. Using Zero-Knowledge Proof to prove and verify the computation, projects can inherit the solutions to be verified on-chain by using smart contracts efficiently.
Verifiable Random Function
Verifiable Random Function