ARPA Whitepaper

TL;DR

This paper presents a secure, privacy-preserving computation layer for blockchain networks that ensures correctness under malicious conditions, supports private smart contracts, and enhances scalability by separating computation and verification.

Contribution

It introduces a novel layer2 solution using advanced multiparty computation and cryptographic techniques to enable secure, verifiable, and efficient off-chain computations on blockchain.

Findings

Verifiable correctness under malicious majority using information-theoretic MAC.

Supports private smart contracts with privacy-preserving data exchange.

Achieves linear transaction processing speed with computational sharding.

Abstract

We propose a secure computation solution for blockchain networks. The correctness of computation is verifiable even under malicious majority condition using information-theoretic Message Authentication Code (MAC), and the privacy is preserved using Secret-Sharing. With state-of-the-art multiparty computation protocol and a layer2 solution, our privacy-preserving computation guarantees data security on blockchain, cryptographically, while reducing the heavy-lifting computation job to a few nodes. This breakthrough has several implications on the future of decentralized networks. First, secure computation can be used to support Private Smart Contracts, where consensus is reached without exposing the information in the public contract. Second, it enables data to be shared and used in trustless network, without disclosing the raw data during data-at-use, where data ownership and data usage is safely separated. Last but not least, computation and verification processes are separated, which can be perceived as computational sharding, this effectively makes the transaction processing speed linear to the number of participating nodes. Our objective is to deploy our secure computation network as an layer2 solution to any blockchain system. Smart Contracts\cite{smartcontract} will be used as bridge to link the blockchain and computation networks. Additionally, they will be used as verifier to ensure that outsourced computation is completed correctly. In order to achieve this, we first develop a general MPC network with advanced features, such as: 1) Secure Computation, 2) Off-chain Computation, 3) Verifiable Computation, and 4)Support dApps' needs like privacy-preserving data exchange.

Figures

Tables

Table 1. Table 1: Performance Comparison of HE and MPC

Category	Scheme	Security parameter		Operation
HE	Hardware implementation	n	q	homomorphic multiplication
	YASHE-NTT	4096	125 bits	6.5ms
	YASHE-NTT	16384(SIMD)	512 bits	48ms
	YASHE-NTT	32768(SIMD)	1228 bits	121ms
MPC	Software implementation	Statistical security parameter		Mult triples generations
	MPC	128 bits		0.23ms
	Overdrive: High Gear	128 bits		0.43ms
	Overdrive: Low Gear	128 bits		0.067ms

Table 2. Table 2: Secure Computation and Trusted Execution

	MPC	FHE	ZK-SNARK	TEE
Efficiency	Acceptable to Fast	Prohibitively Slow	Acceptable	Fast
Privacy-preserving	Yes	Yes	No	No
Trustless	Yes	Yes	No	No
Proof of Correctness	Yes	No	Yes	No
Proof of Computation	Yes	No	No	No
Proof of Secureness	Yes	Yes	No	No

Table 3. Table 3: Circuit Comparison

Circuits	Arithmetic	Boolean
Elements	Bit {$0$,$1$} / ${𝔽}_2$	Finite field ${\left({𝔽}_{p^k}\right)}^s$
Underlying Operations	OR, NOT, AND, XOR	Addition, Multiplication
Transform	Like an Arithmetic Logic Unit in processor	0 as addition neutral 1 as multiplication neutral $\text{OR}(a,b)=a+b-a\times b$

Table 4. Table 4: Coordinated chance

Coordinated%	Quorun	Chance
50%	100	0.00%
60%	100	0.00%
70%	100	0.00%
80%	100	0.00%
90%	100	0.00%
95%	100	0.59%
98%	100	13.26%
99%	100	36.60%

Table 5. Table 5: Vickrey Auction Performance

Party number	Offline phase	Online phase
100	98 s	1.4 s

Equations

$$⟨z⟩$$

$$=⟨a\cdot b+(x-a)\cdot b+(y-b)\cdot a+(x-a)\cdot (y-b)⟩$$

$$=⟨x\cdot y⟩$$

$$⟨x⟩=(x_1,\dots ,x_n,m_1,\dots ,m_n,{\alpha }_1,\dots ,{\alpha }_n)$$

$$x=\sum _{i=1}^n{x}_i,x\cdot \alpha =\sum _{i=1}^n{m}_i,\alpha =\sum _{i=1}^n{\alpha }_i.$$

$$\sum _i{\sigma }_i$$

$$x=max(computationstake,intelvaluestake)\cdot securitymultiplier$$

$$computationstake=(totalcomputationresourcesestimated)\ast (n-1)$$

Full text

Our objective is to deploy our secure computation network as an layer2 solution to any blockchain system. Smart Contracts[41] will be used as bridge to link the blockchain and computation networks. Additionally, they will be used as verifier to ensure that outsourced computation is completed correctly. In order to achieve this, we first develop a general MPC network with advanced features, such as: 1) Secure Computation, 2) Off-chain Computation, 3) Verifiable Computation, and 4)Support dApps’ needs like privacy-preserving data exchange.

The remainder of this paper is organized as follows: Section 1 introduces the real world motivations which inspired us to build a secure computation network. Following motivations, we highlight our contributions in section 2. We then cover the background of secure computation, along with a comparison of similar technologies. Our system overview is presented in section 4. There, we briefly describe our system design and implementation. In section 5-7, we discuss, in detail, the major components of our multiparty computation protocol, secure computation process, and considerations in cryptoeconomics. Lastly, we review the implications and applications of the real world; this includes ecosystem design, business cases, and milestones.

1. 1 Motivations

2. 1.1 Off-Chain Computation

3. 1.2 Secure Computation

4. 1.3 Centralized Dataset

5. 1.4 Data Security in Exchange

6. 2 Contributions

7. 3 Background

8. 3.1 Multiparty Computation (MPC)

9. 3.2 Other Candidates of Secure Computation

10. 3.2.1 Homomorphic encryption

11. 3.2.2 Zero-Knowledge Proof (ZKP)

12. 3.2.3 zk-SNARK

13. 3.2.4 Trusted Execution Environment (TEE)

14. 3.3 Comparison

15. 3.3.1 Trust Dependency

16. 3.3.2 Scalability and Flexibility

17. 3.3.3 Practical Efficiency

18. 3.3.4 Conclusion

19. 4 System Overview

20. 4.1 Interoperability

21. 4.2 ARPA Virtual Machine (AVM)

22. 5 ARPA Multiparty Computation Protocol

23. 5.1 Computation Phase

24. 5.1.1 Sharing secrets

25. 5.1.2 Evaluating circuits

26. 5.1.3 Information Theoretic MAC

27. 5.1.4 Revealing outcomes

28. 5.2 Preprocessing Process

29. 5.2.1 Compiling functions

30. 6 The Secure Computation processes

31. 6.1 Smart Contract

32. 6.2 Nodes Selection

33. 6.3 Off-Chain Computation

34. 6.4 Computation Verification

35. 6.5 MAC with Off-chain computation

36. 6.6 Data Storage

37. 7 Cryptoeconomics

38. 7.1 Economic Rationality

39. 7.2 Identity and Reputation

40. 7.3 Accountable safety

41. 7.4 Uncoordinated majority

42. 7.5 Bribing attacker model

43. 7.6 Consensus Algorithm

44. 7.6.1 Nakamoto Consensus

45. 7.6.2 Lottery Consensus

46. 7.7 Token Usage

47. 8 Experiments

48. 8.1 Vickrey Auction

49. 8.2 Deep Learning

50. 9 Ecosystem & Applications

51. 9.1 Design

52. 9.2 Participants

53. 9.2.1 Computation Nodes

54. 9.2.2 Data Providers

55. 9.2.3 Data Consumer

56. 9.2.4 Model providers

57. 9.2.5 Data / Model Backers

58. 9.3 Business Flow for Data Renting

59. 10 Roadmap

1 Motivations

1.1 Off-Chain Computation

Current blockchain technology reaches on-chain consensus in such a way that a smart contract [41] runs on every blockchain node. There is no final authority in a decentralized network, such as Bitcoin [29], so that every miner has to validate each transaction before accepting and recording it on the blockchain. In other words, there is no way to verify the result without actually running it on a trustless network. The most prominent problem is the amount of transaction fee for every transaction. As the network grows, the amount of computation in the network combined can easily exceed the gas limit[36], causing more forks and raising more security issues.

Off-chain Computation solves this problem by bringing the computation work off the public network, and by verifying the result in public, only when disputes arise. The key in off-chain computation is to have verifiable property in the out-sourced computation task. This property effectively solves the scalability issue[22] on blockchain networks. Therefore, we can achieve the throughput of the network being linear to the participating notes.

1.2 Secure Computation

One of the ostensible selling points of blockchain technology is its potential to bring greater transparency to financial markets. At its core, blockchain is a means for humans to conduct secure, verifiable, and recordable transactions online without a centralized party. As consensus is reached in public and the result is auditable, the blockchain is claimed to be transparent and public-accessible by design.

However, full transparency can be problematic in the real world. Imagine you opened an account at a bank and soon find out that its ledgers are public, where anyone can access the transaction history of your account (and others). Or, if you made a transaction using Bitcoin at an ice-cream truck and the cashier would be able to know how much money is in your account.

Unfortunately, a privacy feature is not shipped with today’s blockchain technology. The growing demand for blockchain and smart contract [37, 4, 14] technologies sets the challenge to protect users from intellectual property theft and other attacks[3]: security, confidentiality and privacy are the key issues holding back the adoption of blockchain[24].

ARPA is built to provide secure computation capability as an off-chain solution for most blockchain networks.

1.3 Centralized Dataset

Large internet companies collect data from users’ online activities to train recommendation systems that predict the customers’ future interest and actions. Health data from different hospitals and government organizations can be used to produce new diagnostic models, while financial companies and payment networks can combine transaction history, merchant data, and account holder information to train more accurate fraud-detection engines.

All this data needs to be aggregated from an individual level, but the profits realized from the data have never been shared with the data contributors. The General Data Protection Regulation (GDPR[39]) made it clear that data holders have the responsibility to facilitate the portability of the data. To really enforce this regulation, our data should not be stored at the company’s hard drive as it faces the inevitable risk of being breached.

Unfortunately, companies have found it difficult to protect their critical data from determined attackers. The convention with data holding is ill-formed in the following ways:

Centralized data-at-risk 2. 2.

Unfair value distribution - individual users never get paid for their data 3. 3.

Established player dominance creates an unfriendly moat that deters new and innovative challengers from competing. 4. 4.

Talented individuals can’t build a good model without joining the company

We need a decentralized data sharing scheme that enable everyone to build models on it, reward those who contribute to it, and at the same time keep the data secure.

1.4 Data Security in Exchange

There is a tension that arises when individuals, companies, or governments deal with sensitive data. On the one hand, data science is a fundamental component of the informational age. We often hear that “data is the new oil”: there is immense financial and social value in acquiring raw data. A recent paper from Google [11] (Figure 1) confirms a well-known fact that data size is positively correlated to model performance, regardless of model quality. It explains the motivation for companies to collecting extensive amount of user data.

On the other hand, the more value there is to be gained by piecing data together, the more cautious everyone has become about data sharing, since data breaches can cause financial, legal, and political harms. This appears to be a central trade-off: we can share data in order to learn new insights that benefit the society as a whole, or we can isolate data into protected silos that safeguard our individual privacy.

Privacy-preserving computation is the solution for this paradox.

2 Contributions

Secure Computation

Computation is carried out securely so that no participating node can learn anything more than its prescribed output.

Verifiable Computation

Computation can be audited publicly, and its correctness can be proven. Therefore, it is possible to outsource computation from the blockchain network.

Layer2 Solution

Combining secure and verifiable computation, the heavy-lifting work of computation is done off-chain. Essentially, making our secure computation protocol adaptable to any existing blockchain network.

Scalability

ARPA is designed as a Layer2 solution. Because the verification has complexity of O(1), the on-chain network will never reach its computation (gas) limit. Therefore, we can improve the computation scalability and TPS(transaction per second) of any network. The computation capacity is increased linearly to participating nodes.

Efficiency

State-of-the-art implementation of MPC protocol is used to speed-up the secure computation.Though this implementation, 5-6 magnitudes of speed improvement are achieved compared to Fully Homomorphic Encryption (FHE).

Availability

World’s first general purpose MPC network for secure computation. With high availability and low cost, we promote data security and privacy practice that is difficult to achieve otherwise.

3 Background

3.1 Multiparty Computation (MPC)

Multiparty Computation(MPC) is a way by which multiple parties can compute some function of their individual secret inputs, without any party revealing anything to the other parties about their input, other than what can be learned from the output. Unlike traditional cryptographic tasks, where the adversary is outside the system of sender and receiver, the adversary is a part of the participants. This model frees the cryptographers from the centralized paradigm to the distributed paradigm. Many unsolved problems like Yao’s millionaires’ problem [42] or secure auction system [8] can be perfectly settled. In a sense, MPC is rather a new paradigm than a specific cryptographic algorithm.

MPC can be considered as a configurable framework with a mixture of crypto tools, which gives participants the right to organize the specific protocol according to the security level and efficiency limitation of a scenario. The beauty of multiparty protocols is that they use a rich body of tools and sub-protocols, some of which have been developed especially for MPC and others previously developed for the cryptographic non-distributed setting. These tools include zero-knowledge proof (ZKP) [33], probabilistic encryption, information-theoretic Message Authentication Code (MAC), various distributed commitment schemes, and oblivious transfer [32]. Most importantly, secret-sharing [31] and computing with shares of a secret is fundamental to achieving secure multiparty computation. In particular, the polynomial secret sharing of Shamir [35] in the case of passive adversary is a cornerstone in multiparty computations, and the verifiable secret sharing [12] plays an analogous role in the Byzantine adversary case.

There are various MPC protocols built with different assumptions in terms of security models. For example, Sharemind [7] and VIFF [17] assume a semi-honest scenario where the adversary will follow the given protocol but only try to reveal others’ private input. Whereas, under malicious situation the participants will manipulate whatever they need to get the data, including colluding and/or malicious computation.

With theoretical and practical achievements over the last decade, MPC has finally evolved to a point where performance shouldn’t be considered the primary impediment to use. With theoretical constructions going back 35 years, there are substantial improvements in algorithmic and engineering designs over the past decade to improve performance. The performance of MPC has improved by 4-5 orders of magnitude over the past decade (Figure 2). Both for comparison purposes and to account for the effects of Moore’s law, we also show the performance of native AES computation over the same time period.

Our goal is to build a MPC network with high availability for the first time, where any business needs for secure computation can be conducted on the network or by using smart contracts on existing blockchains such as Ethereum or EOS. This will bring several benefits: 1) MPC computation will be as simple as plug-and-play. No prior knowledge is needed to set it up correctly. 2) Since dedicated nodes run MPC, the cost for conducting such work will be much lower. and 3) The MPC ”cloud” can bring awareness to the business world, as well as the general public, so that more secure computation can be conducted using MPC.

3.2 Other Candidates of Secure Computation

In the past ten years, several technologies towards practical secure computation protocols have been proposed and studied. These efforts have been classified into three primary domains, i.e. homomorphic encryption (HE), multiparty computation (MPC), and trusted execution environment (TEE).

3.2.1 Homomorphic encryption

Homomorphic Encryption(HE) is a form of encryption that allows computation on ciphertext, generating an encrypted result which, when decrypted, matches the result of the operations as if they had been performed on the plaintext. With such a tool, one could outsource storage and/or computation without endangering data privacy. Because HE allows calculation on encrypted data while remaining encrypted, it has been extensively researched as a candidate for secure computation.

The first concrete HE scheme was proposed in 2009, according to the work of Gentry. It introduced an interesting structure, as well as, a nice trick called bootstrapping to reduced the inherent noise that accompanied the running of additions and multiplications. This allowed practical somewhat homomorphic encryption (SHE) to develop into fully homomorphic encryption (FHE).

Nevertheless, cutting-edge homomorphic schemes cannot provide an efficient way to compute large depth arithmetic circuits due to the following constraints. First, “bootstrapping” adds an extra cost to an already quite heavy process. Currently, practical use of HE focuses mainly on optimization of an evaluated function, which avoids expensive processes by limiting the circuit multiplication depth. In addition, using HE schemes will lead to a huge ciphertext expansion, by the overhead from 2,000 to 500,000 or even 1,000,000 (times) according to the scheme and the targeted security level. This is due to the fact that homomorphic schemes must be probabilistic to ensure semantic security, and to the particular underlying mathematical structures. As we can see, SHE schemes are the most promising today in HE variants, and it will be utilized in our secure computation program mentioned later.

3.2.2 Zero-Knowledge Proof (ZKP)

Zero-Knowledge Proof (ZKP) is a method by which one party (the prover Peggy) can prove to another party (the verifier Victor) that she knows a value x, without conveying any information apart from the fact that she knows the value x. Recent blockchain project was developed to leverage ZKP as a trusted off-chain computation solution. In this protocol, the function is compiled into a circuit and transmitted to a third-party execution environment where the data will be evaluated using the circuit. Similar to FHE scheme, it cannot prove that the actual amount of work being done in remote environment. In addition to that, ZKP simply cannot guarantee the computation is secured from hacker of malicious party.

3.2.3 zk-SNARK

Zero-Knowledge Succinct Non-Interactive Argument of Knowledge (zk-SNARK) is a protocol which creates a framework in which a person – called prover – can quickly convince another person – called verifier – that she or he “knows” a secret without revealing anything about the secret. The first constructions of SNARK protocols were inspired by the Probabilistically Checkable Proof (PCP) theorem which shows that (Nondeterministic Polynomial time) NP problems statements have “short” PCPs[26]. New instantiations were found which allow faster and shorter proofs, when a pre-processing state is permitted.

zk-SNARKs intend to enhance the privacy of users transacting on the Zcash blockchain. With cryptocurrencies such as Bitcoin, an individual can identify user addresses and track the movement of value between transacting parties on the blockchain. In this case, Bitcoin only provides users with pseudonymous protection, rather than complete anonymity. zk-SNARKs are designed to solve this problem by completely encrypting user transaction information on the Zcash blockchain. An abstract zk-SNARK description can be denoted as Alg. 1

3.2.4 Trusted Execution Environment (TEE)

Trusted Execution Environment (TEE) is a tamper resistant processing environment that runs on a separation kernel [2]. It is another trend to solve a secure computation problem. An ideal TEE guarantees the authenticity of the executed code, the integrity of the runtime states (e.g. CPU registers, memory and sensitive I/O), and the confidentiality of its code, data and runtime states stored on a persistent memory. In addition, it shall be able to provide remote attestation that proves its trustworthiness for third-parties.

Hardware manufacturers are eager to propose their own trusted hardware solutions but lack a general standard over different platforms. Most prominent process unit designers have embedded their hardware secure module in their products (Ex. Intel Software Guard Extensions (SGX), ARM TrustZone, AMD Secure Encrypted Virtualization (SEV) and NVIDIA Trusted Little Kernel (TLK).

Software Guarded Execution (SGX) is a set of instructions promoted by Intel to enable code to be run at private region of CPU. The benefit of such implementation is that the application is secured at hardware level with cost of developing a software. Most solutions to provide privacy to smart contracts are based on SGX, which was a sensible choice years ago. Several projects existed are using SGX as off-chain computation solution.

However, recent attacks have proven SGX to be inadequate. This seemingly secure protocol is, in fact, not secure at all. The remote attestation does not prevent a malicious cloud service provider from first faithfully responding to remote attestation queries, but then emulate the rest of the protocol (such as KeyGen and CSR) outside of the enclave. In other words, SGX is not a protocol designed for “Universal Composition” (UC) where, the real-world behavior and the ideal-world definition (function) of a protocol are computationally indistinguishable for every adversary-controlled environment. In simple term, with TEE, one can trust the hardware but not the person controlling the hardware. Therefore, the SGX stack is best used in a permissioned network[20], where all nodes are pre-approved and the environment is certified and trusted.

Furthermore, SGX instructions can only be used on Intel’s CPU. In cases like deep learning, where algorithms are accelerated on GPU, or in situation that Intel is not considered to be trustworthy, the SGX solution will bear significant risk. In addition, the proper use of TEE is also a nontrivial work, especially the collaboration of different TEE modules.

3.3 Comparison

3.3.1 Trust Dependency

Privacy-preserving computation can be sorted into two development directions: secure computation and trusted computation. The prior mainly focuses on the cryptography security brought by hard problems that are elaborately designed using mathematics. The security is derived purely from the number theory, which means even with unaffordable computing power, an adversary cannot break the encryption. The latter one starts from a different point, which tries to enforce the computing involvement to consistently behave in the expected way. Enforcing the behavior is achieved by hardware authentication, memory encryption, specific instruction design, etc. These technologies are always bound to the hardware platform such as the memory storage or processing elements.

Obviously, both Homomorphic Encryption and MPC belong to secure computation, and Trusted Execution Environment(TEE) is the effort of trusted computation. In brief, secure computation is more suitable to be used in permissionless network while trusted computation relies more on physical entities and can be used in a permissioned network such as Hyperledger[38].

3.3.2 Scalability and Flexibility

Given the foundation of mentioned computation methods, it can be observed that one can evaluate a secure computation on any computing power, either a data center or an edge device such as an automobile and phone. Due to the TEE’s design methodology, users have to transplant the program from one platform to another by fitting their work into the safes. This feature makes the TEE less flexible than the pure protocol solutions. Considering the underlying device independency, MPC or HE can take advantage of mutual tool chains of hardware manufacturers and have future potentials for hardware accelerations.

As for different scenarios of computation, MPC can transform into a suitable pattern to make a trade-off between computation complexity and secureness. The nature of MPC can also satisfy various data-privacy input conditions. HE may support multiparty input as well by using distributed encryption and decryption, but the overhead of bootstrapping limits the secure functions evaluated on the HE.

3.3.3 Practical Efficiency

Thanks to the continuous effort of cryptographers and computer scientists in the last decade, different frameworks of MPC designed to solve various type of cases have been invented. We will develop a general purpose MPC network that achieves security in a malicious, dishonest, majority n-party setup.

Taking Intel SGX[27] as the representative of TEE, the main overhead of SGX, compared with plaintext manipulating, is caused by fetching input from normal memory to the enclave local memory that involves encryption. According to the experiments on the enclaves, the Intel enclave instructions did not achieve the best performance. On the other hand, the optimal algorithm on plaintext cannot get the same throughput when processing enclave local memory.

For S/FHE and MPC implementation, multiplication over ciphertext is the most frequently called and fundamental operation. Table 1 lists the state-of-the-art literal performance for both systems. The final column shows the latency of multiplication for different parameter settings. Although the diagram compares hardware implementation of SHE[9] with practical software MPC[21], it can be observed that MPC is 1-2 orders of magnitude faster than SHE. Considering in the future, dedicated hardware acceleration of MPC building blocks will be developed, and there should be another 10-100 times throughput improvement potential for MPC. Therefore, there exists 3-4 orders of magnitude of performance gap between HE and MPC. Furthermore, the most expensive operation of FHE is bootstrapping which enables unlimited multiplication depth is not listed in table. This may bring another slowdown in FHE computation.

3.3.4 Conclusion

In this section we discussed the history of MPC and its cryptographic properties and demonstrated that it is actually a very good candidate for mutually-distrusted parties to conduct secure computation together – a very similar setting to the blockchain network.

We also visited several technologies currently existing as candidates of secure computation, namely Homomorphic Encryption, Zero-Knowledge Proof, and Trusted Execution Environment. Our discoveries indicate that, while some technologies have advantage such as computation efficiency, they are not offering security and features needed in a permissionless network. In essence, we need to be able to verify the secureness, correctness and privacy-preservingness of computation. Detailed aspects under consideration are as follows:

Efficiency

The speed of computation. Our experiments have found that, TEE is on par with clear text computation. Followed by MPC, about one magnitude slower, as forementioned. As for ZK-SNARK, it has around $10^{3}$ times overhead[6]. The least favorable choice in terms of efficiency is FHE, with about $10^{7}$ to $10^{8}$ times slower.[9]

Privacy-preserving

Privacy-preserving here refers to the capability of evaluating a function on a dataset, while not revealing the detail to anyone. This is the core of secure computation.

Proof of Correctness

Prove that the computation work is actually using the prescribed function.

In a trustless network, it is very important to prove that a certain function is evaluated in a correct way. In blockchain, it is simply done by repeated computation on every node running the smart contract. Consensus can be made once every participating node reaches on the same result. However, in the context of secure computation, computation is not carried out on every node but delegated to certain node(s) for the task. One needs to submit proof that computation has done the work with prescribed routine, or the result cannot be trusted.

Proof of Computation

Prove the amount of work the participating node has done.

In Bitcoin and other PoW-style blockchain network, participating nodes prove their work by solving a hard problem (puzzle) and submit the hash value according to the nonce determined at the beginning of the block. It is trivial work for nodes to verify the result (hash) and prove that the node has indeed solved the puzzle. In a computation network, it is also important to know how much work has been done in the computation, so the node can be rewarded with a corresponding token. In MPC, the amount of computation can be proved by counting the triples consumed during the computation.

Proof of Secureness

Prove that the computation is actually carried out in the secured environment.

When computation is not repeated on every node, one needs to submit proof that the computation is carried out in a secured environment. Although this is what TEE is designed for, this seemingly naive question is actually very hard to prove. As mentioned earlier, secure computation is a cryptography process that guarantees the computation process is following the protocol or the result cannot be accepted. But trusted computation, on the other hand, enforces the process to be consistent with designed security (i.e. run the function) using trusted hardware. Nevertheless, in a permissionless network, one cannot convince other nodes to trust his result just by claiming it got remote attestation from a centralized server. Furthermore, even the remote attestation proves the security of the environment, one cannot prove the code is executed in that trusted environment.

A final conclusion with all facts related to blockchain construction is listed in table 2.

4 System Overview

The ARPA network is designed with two layers: consensus layer and computation layer. The computation layer is responsible for conducting ARPA’s Multiparty Computation protocol, while the consensus layer makes sure that transactions and other metadata are recorded and reach consensus. Each blockchain node is comprised of two layers/services.

The system’s overall design is illustrated in Figure 5.

Consensus layer

ARPA’s network is designed as a permissionless network where participants can join autonomously, contribute their computation resources, and earn economic return. To achieve this, we need to faithfully record the transaction information, as well as verification scheme for the computation. This allows the network to form the quorum based on historical performance (with a credit system).

The consensus service includes Account Signature, Computation Verification, Node Communication, Credit system, and Consensus protocol. A decentralized ledger is implemented to record transnational and stateful data.

We leverage Secret Sharing and Threshold Signature to create decentralized randomness in block generation. This uncertainty is used to prevent anyone from seizing control of the block by creating above average probability of block-signing rights.

Computation layer

This layer is mainly a protocol for participating nodes to jointly perform secure Multiparty Computation (MPC) with arandom quorum, additional coordination, model compilation, Secret Sharing, distributed storage, error handling, computation proof generation, decentralized preprocessing, network load-balancing, and other tools to make sure nodes in a quorum can finish task with designated cryptography features.

The MPC protocol is designed with an economic incentive/penalty so that it will cost a malicious node more than it can gain from the system.

We will come back to this in Section 7.

4.1 Interoperability

The need for privacy-preserving computation is universal. It would be a greater benefit for other popular blockchains, such as Ethereum and EOS, to have secure computation capability. Therefore, APRA’s system is designed to be inter-operable with other blockchain systems, while maintaining our own chain as a standalone network for secure computation. To be able to conduct off-chain computation, our network nodes need to monitor smart contract information on other chains, and act upon requests from these smart contracts. This realization of secure computation is called Private Smart Contract. This completely obscures the data from the public, while keeping the computation auditable. Private Smart Contracts will later be described in further detail.

4.2 ARPA Virtual Machine (AVM)

Similar to Ethereum Virtual Machine (EVM), The Arpa Virtual Machine is a Turing Complete Virtual Machine that can run smart contracts in it. However, to enable secure computation and other advanced features such as Private Smart Contract, AVM is shipped with a stronger toolset with close to native performance. To this end, AVM adopts WebAssembly(WASM), a binary instruction for a stack-based Virtual Machine, which lets us do more with less. WASM brings faster code, smaller deliverables, and less overhead. The Virtual Machine can execute bytecode compiled from scripting language, such as JavaScript and Python, for better adoption and less learning curve.

To enable the execution of ”Private Smart Contract”, a smart contract that can protect data privacy, function privacy, participants’ identify and their state change, the EVM has a built-in function cryptography library for easier computation dispatch and verification.

AVM also supports native Oracle implementation. External data can be fetched and processed without the need to setup an oracle server. This will be very handy when the computation verification package is sent back from the secure computation layer.

5 ARPA Multiparty Computation Protocol

The protocol implemented in ARPA’s computation network is organized as Figure 6. The procedure can be viewed as a two-phase protocol: Preprocessing and Computation. The computation phase is the main procedure that involves secret sharing, function evaluation, and revealing outcomes. On the other hand, the preprocessing phase is the foundation which provides necessary raw materials for computation. We separate these two phases apart because preprocessing is independent of both the function and the data.

5.1 Computation Phase

During the computation phase, the main task is to securely evaluate an arbitrary circuit on private inputs which is keep secret throughout and reveal the result only when the parties follow the prescribed protocol. This phase can be concluded as a 3-stage protocol: input, evaluation, output. After private inputs are provided and secretly shared, all parties perform addition and multiplication on shared values, collaboratively, according to the arithmetic circuit. Eventually, results are opened after computing verification.

5.1.1 Sharing secrets

At the beginning of the computation phase, the input needs to be shared among all parties. This process is called secret sharing. Secret sharing is the method of distributing a secret among a group of participants, each of whom is allocated a share of the secret. The secret can be revealed only when a sufficient number of shares are combined together. Individual shares are unreadable ciphertext on their own.

A secret sharing scheme usually consists of two main functions, Share and Reconstruct. Share allows one party to share a secret, $x$, among n parties such that the secret remains secure against an adversary up to $t-1$ parties in a $(t,n)$-threshold scheme. While Reconstruct allows any group of t or more parties together to open the secrets. In ARPA MPC, we design the secret-sharing scheme to work effectively under universally composable security so that the threshold is set to $n$, meaning our system is secure up to $n-1$ colluded malicious parties.

In the Input step, parties need to use shares of random values: each party $P_{i}$ holds some $r_{i}$ and the secret value $r_{i}$ is uniformly random and not known by any party. First, every party sends their share $r_{i}$ of $r$ to party $P_{provider}$. This is called a ‘partial opening’ because now $P_{provider}$ discovers the value of $r$ by summing the shares. Party $P_{provider}$ then broadcasts his input $x-r$. Party $P_{1}$ sets its share of x as $x_{1}=x-r+r_{1}$, and for $Pi$ sets its x share of as $x_{i}=r_{i}$. In practice, it is not always $P_{1}$ who does a different computation. Now we turn $x$ into $\langle x\rangle$ and shares are $x_{i}$.

5.1.2 Evaluating circuits

On ARPA’s MPC framework, the function to be evaluated should be expressed in an arithmetic circuit representative. A general method to transfer high-level functions into arithmetic circuits are included in our compiler. which is concretely described in the preprocessing phase in section5.2. This compilation is done prior to computation phase.

The arithmetic circuit basically consists of addition and multiplication operations. In the evaluation step, since the secret sharing scheme is additive and linear, addition can be done via local computation which has no communication cost. Specifically, to compute $\langle a+b\rangle$ or $\langle\alpha\cdot a\rangle$, each party simply does $a_{i}+b_{i}$ or $\alpha\cdot a_{i}$. We then get the $\langle a+b\rangle$ and $\langle\alpha\cdot a\rangle$ in secret shares type.

Multiplication on secret values, however, requires some interaction between the parties. Beaver’s triples are used to facilitate the online multiplication. When parties are scheduled to compute $\langle x\cdot y\rangle$ given $\langle x\rangle$ and $\langle y\rangle$ one available ‘triple’ $\langle a\rangle$, $\langle b\rangle$, $\langle c\rangle$, where $c=a\times b$ is taken from the pre-processed raw material. Then, by broadcasting $x_{i}-a_{i}$ and $y_{i}-b_{i}$, each party can compute $x-a$ and $y-b$. Which now means these intermediates are publicly known. Eventually everyone can locally compute $z_{i}=(x-a)(y-b)+x_{i}(y-b)+y_{i}(x-a)+c_{i}$, so that they have a secret share of $\langle z\rangle$.

[TABLE]

The upshot is that with enough amount of triples, the MPC engine can perform any multiplication depth computing on secret shared data, and hence we can compute any arithmetic circuit. For the reason that some intermediates like $x-a$ are opened for subsequent procedure, triples cannot be reused because this would reveal information about the secrets.

Importantly, it can be observed that triples are independent of not only the input data, but also the circuit to be evaluated. This means that we can generate these triples at any point prior to evaluating the circuit. The value of triples are not known by any parties when generated. Each party only knows a share of each of ‘some values’ for which they are told this relation holds. Moreover, since addition, scalar multiplication, and field multiplication are inexpensive in terms of communication and computation, the computation phase is both highly efficient and information-theoretically secure.

With the methodology of addition and multiplication on secret shares, we can build any computable functions on arithmetic circuits. Taking an example of secure signed floating number multiplication like Alg.2 [2] which involves exponents addition, sign bit operation and mantissa multiplication. Specifically, multiplication of two floating point numbers $\langle v_{1},p_{1},z_{1},s_{1}\rangle$ and $\langle v_{2},p_{2},z_{2},s_{2}\rangle$ is performed by first multiplying their mantissa $v_{1}$ and $v_{2}$ to obtain a $2l$-bit product $v$. The product then needs to be truncated by either $l$ or $l-1$ bits depending on whether the most significant bit of $v$ is $1$ or not. In the protocol below, it is accomplished obliviously on lines 2-4. Partitioning this truncation into two steps allows us to reduce the number of interactive operations at a slight increase in the number of rounds. After computing the zero and sign bits of the product (lines 5-6), we obviously adjust the exponent for non-zero values by the amount of previously performed truncation.

Combining the above, we have now established roughly how to evaluate an arithmetic circuit.

5.1.3 Information Theoretic MAC

When using multiplication triples and a linear secret-sharing scheme with threshold $t$, we obtain a passively secure MPC protocol that tolerates up to $t$ corruptions. In the dishonest majority setting with up to $n-1$ corruptions, the most natural secret sharing scheme to use is simple additive secret sharing, where $x\in F$ is shared between n parties by distributing n random shares $x_{i}$ satisfying $x=\sum_{1}^{n}x_{i}$. Clearly, any $n-1$ shares reveal no information about the secret. However, to achieve active security, this is not enough to guarantee correct opening.

Message Authentication Code (MAC) is a value that can be used to confirm a message has been created by a certain party who knows the MAC key, and to detect if a message has been changed. The main tool for achieving active security in modern, secret sharing-based protocols is information-theoretic MAC, as mentioned in the [13] [13]. A typical information-theoretic MAC scheme is listed as Alg.3.

The security requirement is that the verification algorithm should succeed if and only if $m$ is a valid MAC on $x$, except with negligible probability. The information-theoretic property of the MAC scheme means that security holds even for an unbounded adversary. The MAC scheme we deployed in computation network derives purely from information theory. In other words, it cannot be broken even if the adversary had unlimited computing power. The adversary simply does not have enough information to break the encryption.

MAC plays a crucial role in making MPC verifiable. MAC check scheme makes sure that malicious party in the group can not bypass the security check by blending the verification value into the computation process.

5.1.4 Revealing outcomes

Once we have the MAC representations, it is fairly easy to describe the online phase of an MPC protocol in the preprocessing model. Since both of the authenticated secret-sharing methods described are linear, the parties can perform linear computations by simply computing locally on the shares. We can also add a public constant c to a shared value $[x]:P_{1}$ adds c to her share, and each party $P_{i}$ adjusts their MAC by $c\cdot\alpha_{i}$.

To multiply two secret-shared values, the parties need a random authenticated multiplication triple from the preprocessing phase. We also need some additional preprocessing data for sharing inputs, in the form of random authenticated masks where only the party providing input knows the value. When outputting a result of the computation the parties must check the MACs using the MAC check procedure described previously, which we denote by $\prod{MACCheck}$.

In summary, the computation process can be concluded as the protocol Alg.4

5.2 Preprocessing Process

The preprocessing model began with Beaver’s “circuit randomization” technique, which allows any arithmetic circuit to be securely computed by randomizing the inputs to each multiplication gate, using a multiplication triple, which is a triple of secret shared values $\langle a\rangle,\langle b\rangle,\langle c\rangle$ where $a$ and $b$ are uniformly random (in a finite field) and $c=a\cdot b$. Given this, two secret shared values $\langle x\rangle$, $\langle y\rangle$ can be multiplied by publicly reconstructing $d=x-a$ and $e=y-b$ and then computing

Since $a$ and $b$ are uniformly random, revealing $d$ and $e$ does not leak any information on the inputs x,y. The key advantage of this approach is that any MPC protocol based on linear secret sharing that operates on circuits in a gate-by-gate manner can now be easily recast in the preprocessing model: the preprocessing phase simply consists of creating many multiplication triples, and in the online phase the circuit is securely evaluated using these triples. Note that additions and linear operations can be evaluated locally because the secret sharing scheme is linear. After evaluating the circuit, each party broadcasts their secret shares of the outputs and reconstructs the result. The preprocessing stage is completely independent of both the inputs to the function being computed and the function itself (apart from an upper bound on its multiplicative size), and creating triples is typically the bottleneck of a protocol.

Considering the malicious security model, we introduced two methods to solve the following issues: First, Zero-knowledge is applied to prove that certain values lie within a certain bound in case that the adversaries introduces noise to pollute honest parties’ input. Second, distributed decryption allows corrupted party to add noise in triples, where we use sacrifice to double check triples validation.

Circuit used in this paper is the terminology describing evaluation functions in cryptography, but not the hardware circuit. To represent a computation, we can use either Boolean circuits or Arithmetic circuits. The main difference is with respect to their input’s types and their gates types. It is nature to use Boolean notation when processing programs on bits and by Boolean operations, such as XOR, AND. Nevertheless, arithmetic circuits work on inputs in fields F by arithmetic operations, like field additions and multiplications. Figure 7 shows a sample of arithmetic circuit.

5.2.1 Compiling functions

An MPC compiler translates a conventional function into an arithmetic or boolean circuit, in order for it to be accepted in MPC virtual machine. Corresponding to the normal compiler, which transforms high level language to assembly code, The MPC compiler turns the high-level function into MPC-friendly instructions.

The difference between arithmetic and Boolean function is not about functionality but the modality. The reason to choose one representative depends on the functions type to perform. Due to the mathematical basis, cryptography tools rely mainly on computation of field elements, which are treated as single input but not a string of bits. Then it makes sense to represent in arithmetic ways. However, many applications involve non-arithmetic operations like integer comparison, which is a basic procedure in many computations. In this case, implementing this non-arithmetic operation as an arithmetic one would be very inefficient, and Boolean circuits are a more natural representation.

The two representatives of circuits can be transformed to each other by an arbitrary translation shown in Table 3. The computable functions class of Boolean circuits of polynomial size correspond to the class of arithmetic circuits of polynomial size. Actually, we can picture arithmetic circuits as a generalization of Boolean circuits to arbitrary fields. There have been many papers that worked on extending cryptographic methods that work well for computations represented as Boolean circuit to the setting of computations which are best captured by arithmetic circuits, to get efficiency improvements for those circuits, or on bridging between methods adapted to both circuits, to capture computation whose best representation is a mix between the two.

6 The Secure Computation processes

The Secure Computation process starts from the application layer, typically by triggering a smart contract. To support off-chain computation, our network will observe smart contract events on a designated blockchain network, execute the computation work on ARPA, then submit results and proofs back to the smart contract. This process consists of 5 steps, as illustrated in Figure 8.

On the application layer, a smart contract representing a real-world contractual logic is initiated by a party who wants a heavy computation task or privacy-preserving task to be executed in the network while keeping the detail in private. The smart contract was created by the data provider (who charges a fee for providing information but doesn’t want to expose the data to the public), or by several parties who want to engage in some private business logic.

To support off-chain computation, the smart contract could be one on another blockchain network. Our nodes can optionally observe the particular event defined in smart contract. And the result can be sent back to the smart contract by sending a message to the smart contract.

Once the smart contract received the deposit and other necessary information, such as data provider and function to be evaluated, the observing nodes will broadcast the event in the ARPA network, inviting other parties to join the MPC task. 2. 2.

All computation nodes who are interested in participating in the computation will start the bidding process. They are asked to deposit minimum required token to be eligible (detailed in Cryptoeconomics section). Next, a group of computation nodes are randomly selected, based on node’s performance and condition, success rate, latency, etc. The random function used in this selection process is a decentralized random function, discussed in subsection 6.2.

One thing worth mentioning is that the data provider and data consumer are included in the group, making the computation nodes impossible to collude. This design is required so that at least one party is honest. Because our threshold protocol is secure up to n-1 parties, we can claim that this setup is cryptographically guaranteed to be secure.

Once the quorum is determined, all bidding notes will know the result locally. This is a very important feature because even if the bribing attacker exists, he doesn’t know whom to bribe or attack. The selected nodes don’t need to broadcast the fact that they are selected, but instead they hold the cryptographic proof till the end of the process. 3. 3.

At the computation layer, the nodes in the pre-selected quorum coordinate together to perform ARPA MPC. As already described in previous section, they first secret-share the data. Then, a compiled function, in the form of boolean/arithmetic circuit is prepared for all parties. For each party, their job is simply to evaluate the function by following the circuit’s instruction. During the computation, the parties actively exchange values on peer-to-peer communication, which is also secured with TLS. When the computation reaches the end, results and computation proofs will be produced. The computation proofs are Information Theoretic MACs produced alongside with the computation, i.e. they generated with the same computation steps as the result, making it impossible to forge. The results and MAC values will be signed with all nodes’ secret keys to prevent forgery.

MACs are information-theoretic secure to convey the correctness of computation, so that the computation is verifiable. The validation complexity is $O(1)$, which means it consumes constant time to compute. Therefore it is possible to be executed in any VM. 4. 4.

If the verification is passed, the payment will be processed, the gas fee will be distributed, and the meta-data of the transaction will be recorded on the blockchain. The ARPA consensus algorithm is discussed in section 7.6. 5. 5.

The result and MACs will also be sent back to smart contract. All nodes running smart contract will validate the authenticity of MACs, and then check the MAC’s correctness. The detail of verification procedure is detailed section 6. If the smart contract is running on another blockchain network, then other nodes will reach consensus by their own consensus algorithm.

6.1 Smart Contract

A smart contract is executable code that runs on the blockchain to facilitate, execute and prove an agreement between untrusted parties without the involvement of a trusted third party. The benefit of a smart contract is that it can reliably transfer value, make decisions or perform computation as if there is a trusted third party. It also makes the whole executing process transparent, as anyone on the chain can audit the smart contract code and run the code to verify the results. The data processed or generated by a smart contract is also traceable in the receipt.

With many advantages, a smart contract has its limitations. The correctness of the smart contract is based on a network-wide consensus, which naturally requires every validating node to re-run it for verification purpose. This redundancy makes executing the smart contract very expensive, or in another words, the usability of the smart contract is limited. Another concern is privacy, as the smart contract itself and its data are transparent to every node on the blockchain network.

Therefore, our approach to support off-chain computation for other chains is using smart contracts to carry the meta operations, including computation initiation, task broadcasting, and validation, so that the blockchain can reach consensus with computation proof. A pseudo-code example is provided to illustrate this concept. All of the heavy-lifting computation, including secret sharing and multiparty computation, are conducted by the MPC network.

6.2 Nodes Selection

The nodes who will be participating in the computation are randomly selected based on a decentralized random function(DRF). One good candidate of such function is RANDAO, which is also a proposed in Ethereum PoS system[10].

Combined with randomness from DRF, participating nodes are also selected based on the node’s performance, condition, success rate, latency, etc.

6.3 Off-Chain Computation

Currently on-chain consensus is reached when everyone is receiving the same result, by executing smart contracts on each individual VM. There is no final authority when decentralized. Everyone has to validate every transaction in order to agree with others. The most prominent problem is the amount of gas consumed for every block. The reason that everyone has to repeat the same calculation is that blockchain is a trustless network and everyone must do the same and reach to the same result to trust others. In other words, there is no way to verify the result without actually going over the whole process, i.e. executing the code, in a trustless network.

Computation-intensive calculations are expensive on Ethereum and solidity is not good at expressing complex functionality. One way to compute complex function is to simply run it off-chain. Various solutions[19, 18] are focused on how to prove the correctness of an off-chain computation.

In order to bring computation off-chain, we need a verifiable scheme in the computation delegation process. For example, if one wants to prove that they have been somewhere, the best proof is an item that is unique to that place, such as a souvenir. We can think of off-chain computation as a delegation process, and the envoy has to prove that he actually did finish the task. Similar to this concept, an off-chain computation scheme needs a verification scheme that:

Can prove that the computation is faithfully done, 2. 2.

The amount of work done cannot be exaggerated, and more importantly, 3. 3.

The privacy of the content is guaranteed and nothing is revealed to the participants.

This relationship is illustrated in Figure 9

We use Information Theoretic MAC to attain these desired properties. The following section will describe how MAC is used and why it can become the critical component in off-chain computation.

6.4 Computation Verification

Computation Verification scheme is the cornerstone of verifiable computation. As mentioned earlier, the current state of smart contract execution is duplicated across all nodes on blockchain. However, using MPC, the computation is guaranteed by mathematics and can be safely delegated to another set of nodes. In other words, the process can be trusted by a third party, as long as they provide proof that the process is done in a correct way. This question can be further broken down into three conceptual parts:

The computation is conducted with prescribed function and correct input data, 2. 2.

The proof cannot be forged, and 3. 3.

The proof can be verified by other nodes.

Under our MPC protocol, we are securing up to n-1 malicious notes using MAC. As described earlier, MAC is a value that can be used to confirm a message has been created by a certain party who knows the MAC key, and to detect if a message has been changed.

While the Smart Contract is being executed, a secure computation request is sent out from an external blockchain node to the computation layer. The computation network then selects several nodes for the task, and data provider’s node is also included in the group. If any other party deviates from the protocol, such as sending incorrect result, the proof-carrying data will not be reconciled and the result will be discarded. Therefore, part 1 is guaranteed by our MPC protocol cryptographically.

After each party in the computation group finishes their work, they sign their MAC with their own private key, and store them on the DHT-based distributed storage. This prevents the MAC from being forged by a third party. Therefore, the proof cannot be forged and can be trusted to be authentic, even on a publicly-accessible storage. This produces desired property of part 2.

On the consensus layer, it is easier to claim that nodes should not trust other computation proof if they did not participate in the actual computation. Since the computation nodes was selected randomly, it takes all $n$ nodes to be colluded to pass the MAC check, which is a negligible probability or extremely high cost for the malicious party to control almost all the nodes in the network. And in such case, the network is probably does not exist anymore. In other words, the probability that can one trust the consensus network but not the computation network is not plausible.

Therefore, under the protocol, we know that if MAC does not pass the check, it means the computation was wrong because some node did it incorrectly. On the opposite, if the MAC does pass the check, we know that the computation was done correctly and the result can be trusted.

In summary, we now can conclude that the secure computation can be broken down into computation and verification parts. Further, we are able to prove that by using a privately-signed MAC, we can trust the related result, as well the identity of the signer.

6.5 MAC with Off-chain computation

In our off-chain computation phase, MAC is used in secret sharing schemes to ensure that corrupted parties cannot lie about their share and cause an incorrect value to be opened during reconstruction. The following equation shows how MAC proves correctness and integrity of computation. The protocol is under a full threshold active security model where security is guranteed even there is one honest party. This particular party can be data provider or computation initiator who has natural motivation to follow rules.

An authenticated secret value $x\in\mathbb{F}$ is defined as the following:

[TABLE]

where each party $P_{i}$ holds an additive sharing tuple $(x_{i},m_{i},\alpha_{i})$ such that:

[TABLE]

When open a value $\langle x\rangle$, all players do the following protocol:

Compute $\sigma_{i}=m_{i}-\alpha x_{i}$. 2. 2.

Call FCommit with (Commit, $\sigma_{i}$) to receive handle $\tau_{i}$ 3. 3.

Broadcast $\sigma_{i}$ to all parties by calling FCommit with (Open, $\sigma_{i}$). 4. 4.

If $\sum_{i}{\sigma_{i}}\neq 0$ then abort and output $\perp$; otherwise continue.

The protocol achieves the integrity and correctness of computation by information-theoretic security of secret sharing and the following property.

[TABLE]

It can be observed that, when given a MAC global key or value $x$, the protocol can check the result with MACs. These two ways can be used to ensure the correctness of computation by checking on intermediate and result by checking on output. Now we can see how MAC helps to protect the computation when at least 1 party act honestly.

Furthermore, we can also find that the broadcast value $i$ leaks no information on either secret value or MAC value because they are not correlated. Therefore, it is possible to transfer this check from computation layer to consensus layer, which helps to reach consensus on-chain. Also, the final summation of $i$ is mathematically simple to deploy any kind of virtual machine. In conclusion, MAC check is the ideal operation to promote consensus and protect computation privacy.

Public auditable MPC [5] lift verifiability to arbitrary secure computations. Auditability means that even if all the servers are corrupted, anyone with access to the transcript of the protocol can check that the output is indeed correct. This characteristic enables the separation of the input parties, computing parties, and the validator. After the protocol is executed, anyone acting as the validator can retrieve the transcript of the protocol from the bulletin board, and determine if the result is valid or not by using only the circuit and the output. The protocol will instruct computing parties to make part of their conversation public and logged on the bulletin. The verification is reached by linear commitments on secret inputs instead of traditional use of non-interactive zero knowledge proof.

The more ambitious properties that public auditable MPC is willing to achieve are universal verifiability, where the validators must not know the output and observe any process of the computation, but still hold computing parties accountable by Pedersen commitment.

6.6 Data Storage

The Distributed Hash Table (DHT) is a decentralized distributed storage system that provides a look-up service similar to a hash table. The data is distributed over the whole network of nodes, while any data is searchable by querying any node. To achieve that, the DHT (Figure 10) defines a key space (for example, 160-bit string) and maps the entire data set onto this key space. The key space is then partitioned into chunks and assigned to nodes so that a node is only responsible for storing part of the data set. Another property is that every node keeps an index of mapping from key to the address of node(s) which stores the data with that key. With an overlay network connecting all nodes, a query that reaches any node can leverage the index to be routed to the node hosting queried data.

The decentralization and fault tolerance nature enable DHT to be more resilient to a hostile attacker than a typical centralized storage system. DHT can also be designed to have Byzantine fault tolerance[23]. This makes it feasible to handle MAC value storage in ARPA’s network, as no individual MPC node can be trusted. On the other hand, if we choose an arbitrary MPC node to store the MAC value, there is a chance that the node will supply a forged value, either because it happens to be a malicious node or it is under hostile attack.

7 Cryptoeconomics

Bitcoin is considered the first massive deployment of a Byzantine Fault Tolerant (BFT) protocol in real world. Byzantine failures are considered the most general and most difficult class of failures among the failure modes. In 1999, the Practical Byzantine Fault Tolerant(PBFT)[28] was introduced and received immediate notice. The algorithm is designed to work in asynchronous systems and is optimized to be high-performance, with an impressive overhead runtime, and only a slight increase in latency. However, the solution works on a permissioned system, meaning that the nodes have to be authorized to join the network. This property works well on closed blockchain system like Hyperledger[1], Steller[25] and Ripple[34].

The Bitcoin network, on the other hand, is a permissionless network. It works in parallel to generate a blockchain allowing the system to overcome Byzantine failures and reach a coherent global view of the system’s state. To achieve decentralized consensus on a permissionless network, Bitcoin invented a new consensus scheme called proof-of-work. This consensus scheme has three major properties:

The ”work” is a NP hard problem to prover but easy to verify by verifier. 2. 2.

The more stake (computation device) and cost (electricity) a node is willing to put into the system, the higher the chance that this node will be the first to solve the work. 3. 3.

The node who solves the work first will be rewarded and its ledger is broadcasted and trusted.

The prover, who found the hash value that satisfies the nonce, can be trusted because he puts tremendous efforts/cost/stake in this game, and it would not be a rational decision to hack the system. Otherwise he gained nothing with depreciating token value.

The difference between PBFT and Bitcoin is that the former makes an honest assumption of participants (a permissioned network), while the later gives a more realistic and real-world assumption of Economic Rationality[30], a concept from neoclassical economics, which is maximization of subjective utility. Chain-based blockchain systems like Bitcoin or Ethereum prefer plausible liveness to correctness, while BFT consensus algorithm can ensure transactional correctness but may not be able to finalize conflicting blocks and can get stuck.

In Ethereum and other blockchain networks based on the Nakamoto(Proof-of-Work, or PoW) consensus, the fundamental assumption is that the computation resource is scarce. If everyone is verifying transactions, there will be no final state of transaction history agreed by everyone. If a leader in the network propose a block of transaction and everyone else only has to verify that, the situation is alleviated. Therefore, consensus is reached based on block of transactions, proposed by a participating node who solved a cryptographic puzzle using fairly large amount of computation power. This brings a trustworthy ”finality” to the blockchain network. In essence, Bitcoin created a game where verification (of the hash work) is much more simpler than the computation of the function(verify the transactions). Nakamoto consensus protocol transfers the trust needed to verify transactions to a puzzle game. With economic rationality mentioned ahead, the finality of the state is set by a trusted leader who solves the hash puzzle.

Similar to how Bitcoin reached decentralized consensus, our work makes Economic Rationality assumption to MPC, so that the cryptographic protocol can be deployed as a permissionless network. On the contrary to the assumption of Proof-of-Work consensus, ARPA designed the MPC protocol where verification of computation is even simpler than hash verification, using information theoretic MAC. This feature opens new possibilities of consensus, explained in the Consensus(7.6) section.

7.1 Economic Rationality

We aim to deploy an MPC network with cryptoeconomics considered. While in cryptography the most basic assumption is that some parties are simply honest (or not), in economics the assumption is that the parties are rational and their utilities can be quantified, such that with a proper incentive mechanism all (or at least most) of them can be discouraged from deviating the protocol.

Under rational behavior, everyone will attempt to break from the rule and gain as much as possible. But to a point where no more economic benefits one can gain. If the situation occurs where deviating the protocol, or even sabotaging the whole network, is in the best interest for the participating nodes, they would do so for their own benefit. On the contrary, participants will follow the protocol if the incentive received when following protocol is more than expected return from breaking it.

We designed a incentive system that will punish those who deviates from the protocol, and the punishment is more than the expected return when colluding with others. This will eliminate participating nodes to take chance in the system. This system will be explained in detail in section 7.3.

Sybil attack is common in peer-to-peer network, in which spawning identities will help the attacker to gain disproportional advantage on voting or influence. In PoW consensus scheme, the spawned nodes are bounded by the real computation power on their physical machine. Therefore, the risk of sybil attack is mitigated.

We designed a credit system that each node is in multiround game system, and it is the best interest for them to keep the same identity (than register a new address) and follow the protocol.

Without rationality, one can simply believe that the super admin of AWS (or anyone with unlimited computation resources) can attack Bitcoin and destroy its belief system. But in reality, it doesn’t have to be worried because

A rational person would not do so without a budget. 2. 2.

When invested with computation resources, a rational participant would rather make more economic return by staking in the game than sabotage a network with some upfront cost. 3. 3.

A rational person will not assume that others would so that

Therefore, it can be concluded that this sabotage behavior will never happen.

With a properly designed incentive system, one brings the question from a mathematical (absolute) perspective to a more realistic angle, where every participant can be ”guided” to follow the protocol, and those who don’t will be punished.

7.2 Identity and Reputation

At the time a new node joins the computation network, it is allocated a unique account in the consensus layer. The account will be served as public identity of such node. With asymmetric encryption, the network can generate private/public key pairs as the identity for a node. The public key serves as the node identification and information authentication. To prove the authenticity of the result, one has to sign the MAC value with its private key.

7.3 Accountable safety

The computation node participating in the computation has to put up a stake in order to participate in a computation task.

We require the staking value to be:

[TABLE]

where:

[TABLE]

and $Security\>multiplier$ can be a constant determined by the network

There are several ways to break the protocol and be a malicious node. Each case is listed and we will analyze how our system can handle such behavior.

Not following the circuit

: functions are compiled in an arithmetic circuit for the nodes to compute jointly. If a node does not follow the instruction, the result will be incorrect. However, since we require MAC as a proof of computation, and the proof is tightly linked to the computation process, we can immediately tell if the result deviates from the assigned function by verifying the MAC all together. Using MPC validation, there is actually no point of doing so. Another argument of not doing so is that, since the computation is heavy, it makes more sense to just abort the task if one wants to sabotage the computation, in which case we will refer to case 4).

Sending out incorrect result:

as detailed in MAC session, it is impossible to send the wrong value with the correct MAC, as the MAC is paired with the result and can be detected.

Sending out incorrect MAC:

the MAC cannot pass the validation process and there is no benefit of doing so.

Abort attack:

similar to DoS (Denial of Service) attack, the node simply stops in the middle of the collaborative computation. Under such case, we can set up a timeout parameter for the computation task. If one party in the computation task fails to return before the timeout, then the task can be deemed as failure. The party then should compensate others the cost of computation resources already spent in the task. A stake larger than $(total\>computation\>resources\>estimated)\cdot(n-1)$ should be required at the election phase to prevent abort attack.

Stealing the data:

MPC is designed to deal with this problem – how to compute a function with distrusted parties without leaking the data. Our MPC protocol is designed to be secure up to $n-1$ colluded parties. In our case, in addition to the original $n$ party who agreed to compute, we will also select $m$ additional random nodes to increase the security. One has to collude all $n+m$ parties to steal information. This is impossible because the original data owner cannot be colluded.

In sum, our staking mechanism is designed in such a way that, it is in the best interest of each participant to follow the protocol. This is due to the greatest benefit of the malicious action being lesser than the greatest expected loss of following the protocol.

7.4 Uncoordinated majority

We assume that all nodes are rational in a game-theoretic sense, but no more than some fraction (often between 25% and 50%) are capable of coordinating their actions. The Proof-of-Work in Bitcoin with Eyal and Sirer’s selfish mining fix is robust up to 50% under the honest majority assumption, and up to 23.21% under the uncoordinated majority assumption[16].

Under ARPA’s MPC framework, with $t-1$ unconditional security, coordinated majority is unrealistic, because the . Because the colluded party needs to collude almost all nodes to be able to control the network. See Table 4, where a coordinated attack requires all parties in a MPC computation to be colluded. With even 95% of the nodes are colluding together, they still have less than 1% chance to be able to break the security protocol.

Clearly, it is unrealistic to make economical benefit when 95% nodes are from the same party. Because it is virtually hosting a private network and hope to steal token issued on its own.

In addition, in most cases, the data provider will be a part of the MPC group. And because the data provider will not collude with others, there is zero chance that the colluding parties will break the protocol and get the secrets.

Similar to PoW, joining a MPC network requires a decent computer in order to be able to earn reward on MPC tasks. This investment prevents attacker to flood the network with virtual nodes.

7.5 Bribing attacker model

Attacker is motivated to make the network fail in some way. Attacker can be one of the participants, or the attacker can sits outside the protocol, and has the ability to bribe any participants to change their behavior. Attackers are modeled as having a $budget$, which is the maximum that they are willing to pay, and we can talk about their $cost$, the amount that they end up paying to disrupt the protocol equilibrium.

As discussed at section 6.2, the participating nodes are selected at random, and the selected party will not be publicly known until they have completed the computation. Therefore, there is no target for the attacker to bribe with.

Without a bribing target, an attacker needs to bribe more than 95% nodes to make a substantial impact on the network. Even the attacker can wait passively until the chance to appear, the cost to bribe the whole network is much more than a reasonable attacking budget and thus rendered unrealistic.

With a proper penalty designed, a hidden bribing target, and a high threshold to bribe the whole network, ARPA’s network can still be secure under this security model.

7.6 Consensus Algorithm

The blockchain consensus algorithm mainly solves two problems - who is responsible for mining the block and what to do when there is a fork. Difficulties usually lie on how to solve the fork, that is, when there are two or more legitimate forks, how to let everyone agree on one chain and continue, which requires a unified standard of judgment. Nakamoto consensus chooses the most expensive fork with the highest cost, and verification of the most expensive chain has to be objective and verifiable, which is, the Proof-of-Work. It does not mean that there is only one way to solve the fork. Such as God’s dice, where everyone agrees on the fairness of the dice. Whenever there is a fork, the dice can decide on a fork. This consensus can also ensure the normal operation of the blockchain system.

How to design a practical and verifiable fair random number generator based on the blockchain has become an important research problem in recent years. There were programs Randao proposed by Vitalik Buterin[40], some DApps that used Oraclize to obtain the random numbers from the off-chain service, to implement a blockchain random number generator. The Ethereum Foundation also listed random number generation on the blockchain as an important issue to be researched for the next 2 to 3 years[15] and invited all parties to participate on a solution.

In ARPA’s network, consensus is designed with a two step development plan. Phase 1 is a PoW consensus scheme, where a new block is found and broadcast by a mining node who find a hash result satisfying the nonce of the network. A phase 2 consensus is reached by a lottery system, where participants purchase tickets a few blocks ahead to enter the candidate pool. At block creation time, the candidates together calculate a pseudo-random function, using block header and other transitional information as the seed for the random function.

7.6.1 Nakamoto Consensus

ARPA is dedicated to make a general-purpose secure computation network available for the first time in history. While Proof-of-Work consensus is known for its waste of energy, its stableness and secureness are still being recognized and used in most major blockchain networks.

At the beginning of our development phase, ARPA’s team will focus on solving the cryptographic challenges in MPC protocols and computation layers of the network. Rather than being innovative at every corner of our first release, a decent and proven version consensus algorithm will be used at our first release of mainnet. Therefore, a Proof-of-Work consensus algorithm will be chosen so that we can spend more efforts to the development of secure computation layer and make it really robust.

We will use multiple hashing functions at random to prevent ASIC chips mining in our network, because we prefer participating nodes joining ARPA to have decent computing power using CPUs (the capability desired by MPC). Choosing hashing function randomly at each block guarantees that the mining nodes would be able to conduct general-purpose computation with the capability of CPUs, one that cannot be reached by ASIC chips.

7.6.2 Lottery Consensus

The pseudo-random function must have the following characteristics: deterministic, provability, uncontrollability, unpredictability and Tamper-resistant to attacks.

• •

Deterministic: given all information revealed, the result will be determined and unique.

• •

Provability: The result can be validated by anyone after the information was revealed.

• •

Uncontrollability: The result cannot be influenced by anyone, or a partially colluded group.

• •

Unpredictability: Using transitional information such as block header, time, participants address, will result unpredictable random result.

• •

Tamper-resistant: The result cannot neither be calculated ahead of time, nor be forged with huge amount of computation power.

• •

Privacy: The random result is opened but only the winner knows he won the lottery. Therefore the attacker doesn’t know the target until the winner broadcasts the signed validation.

Several choices for random generator are: RANDAO, BLS-based multisig, or Secret-sharing based pseudorandom. All can achieve the desired characteristics mentioned above. Our protocol is designed as follows: At block time $t$, the nodes who want to become the validator, purchase a ticket to be eligible and submit a hash proof. At time $t+x$, where $x$ is the waiting period, each party generates $p_{i}$ corresponded to the hash committed before. We formally describe the procedure in Alg.6

If the authentication check passed, we calculate $r=R\>MOD\>n$, and obtain the randomly selected group of nodes. One of the nodes will become the $prover$, and the rest will become the $validator$. The $prover$ will create a block containing all recent valid transactions, and the $validator$ will challenge the $prover$ by checking the validity of the new block. If $prover$ failed to create a valid block, it will lose its deposit. Otherwise, the $prover$ will be rewarded with a small fee, along with the ticket price.

7.7 Token Usage

ARPA tokens, the native token for ARPA, perform five interconnected and critical functions within the ecosystem, over dispersed, dynamic networks:

Medium of Exchange – all transactions within ARPA computation network use ARPA tokens as the medium of exchange for services. For example, data providers receive token payment from data consumers, while model providers receive token payment from data owners

Computing Cost – ARPA tokens are exchanged to perform secure multiparty computation and compensate for computation providers. Computation cost is measured in triples used during the process and other factors

Stake – computational power providers will use the ARPA token as a form of safety deposit for launching and fulfilling computation jobs. Abort during computation and other malicious actions result in loss of stake. This will ensure fairness for all parties and limit misuse of ARPA by bad actors

Transaction Fee – similar to gas fee on Ethereum, ARPA tokens are paid to nodes facilitating the transaction as a fee

Backing of Data or Model – all audiences of ARPA’s network, ranging from normal crypto audiences and network stakeholders to professional investment entities, can back public data or model following Additive Backing System. Additive Backing System broadens ARPA’s audiences and incentivizes early adopters and backers of ARPA’s data marketplace.

8 Experiments

Various experiments are conducted in privacy-sensitive applications, like auction or machine learning. The performance of the practical results shows that under suitable optimization and diligent function compilation, the overhead caused by computation and communication can be largely mitigated. With such effort, the security and privacy brought by MPC is worth the price of only 2-3 magnitudes of additional computation power.

8.1 Vickrey Auction

As for the high party number case, a secure Vickrey second price auction is implemented on AWS instances, where 100 parties input one bid each. The auction system will reveal the winning bidder and the second-high bid. The Vickrey auction requires 44,571 triples. The performance is listed in Table 5.

To make it more general. An evaluation experiment on different circuit depth and party numbers is performed. The underlying field is set as 61-bit Mersenne field, security is approximately 260. The test is done for different numbers of parties on a series of circuits of different depths, each with 1,000,000 multiplication gates, 1,000 inputs wires, 50 output wires. The circuits had 4 different depths: 20, 100, 1,000 and 10,000. The experiment was run on AWS in a local network configuration in North Virginia region AWS. Each party was run in an independent AWS C4.large instance (2-core Intel Xeon E5-2666 v3 with 2.9 GHz clock speed and 3.75 GB RAM). Each execution (configuration, number of parties, circuit) was run 5 times, and the result reported is the average run-time. The computation overhead is depicted in Figure 11

8.2 Deep Learning

We will describe the implementation of Convolutional Neural Networks (CNNs) using MPC. The biggest problem here, when training large neural networks, might be the maturity and availability of arbitrary precision arithmetic on GPUs. Although some hope exists, this area is still under developed and needs further exploration. In this experiment we will still use CPU as an execution environment. Our MPC approach uses secret-sharing to mask the values used in the computations. This allows for arithmetic circuit evaluation, which is greatly more efficient for training neural nets. Both the ReLU and max pooling are nonlinear operations, which are expensive to compute in MPC. Therefore, the ReLU is approximated using a polynomial and the max pooling is replaced by average pooling. A simple implementation of a convolutional layer can be found here, which is used as a basis for our implementation.

For the dot products, specialized triples are created, ensuring that every value used in a dot product is only masked once. And for the convolution for which holds: im2col$(A)\cdot B=C$. Therefore, only a masked version of both the inputs (masked with A) and the weights (masked with B) are communicated, without any duplicates.

Reusing triples

When a variable A is used in two operations with B and C to create D and E, we can create triples such that: $operation_{1}(A,B)=D$ and $operation_{2}(A,C)=E$. In the backward phase the error is typically used in two operations: once to compute the backpropagation error, for the previous layer, and once to compute the weight updates. Moreover, both the weights and the layer inputs have been used already in operations in the forward phase to compute the layer output, and can therefore be reused in the backward phase. To gain insight, we compare the number of values communicated per participant in one iteration for a batch size of 128 images from MNIST of a simple two layer convnet with the optimized version. For the baseline, the backward phase is more expensive than the forward phase. For the optimized model, it is the other way around. This is mainly because we can reuse the masks created in the forward phase.

9 Ecosystem & Applications

In this section we discuss how business logic and applications can be built when secure computation is available. This can happen either on other blockchain system with the ARPA system enabled, or directly on ARPA’s own blockchain.

9.1 Design

Developers can leverage ARPA to protect dApp data privacy and build privacy-preserving dApps, free of cryptography knowledge.

ARPA’s secure computation also allows data to be shared without disclosing the raw data to anyone during data-at-use. ARPA can potentially disrupt the whole data industry by eliminating trust issues and data intermediaries within: finance, healthcare, IoT, retail, energy sectors, and other sectors where data is a valuable and sensitive asset to enterprises and individuals.

A reputation system is established on our data marketplace scenario, where data providers are able to sell data value without disclosing the raw data, and a data consumer can discover and use the data without signing an NDA contract with the data provider.

A node’s reputation increases by being a reliable and responsible computation provider, and this reputation is permanently logged on the blockchain. After each transaction, each party can leave a review about data quality and model training results. Good reputation attracts more buyers and business, increasing the number of backers (we will discuss the incentive system later).

9.2 Participants

9.2.1 Computation Nodes

Computation nodes supply computing power and storage for multiparty computation. Computation nodes have to put up a safety deposit of ARPA’s token(s) for computation tasks based on projected triple consumption. In case of abort, the node’s safety deposit is compensated to other nodes in the same MPC task, as well as, to the next group of nodes performing the same task.

Computation nodes have the following attributes:

• •

Strong computing power to ensure fast triples generation during the data pre-processing phase of multiparty computation

• •

High availability and uptime during online computation, guaranteed by node’s stakes

• •

Fast and reliable internet connection, governed by the node’s stakes

9.2.2 Data Providers

Data providers can be either individuals, enterprises, research institutions, financial, and medical institutions that possess valuable but under-utilized data. ARPA enables data providers to securely monetize their data with privacy-preserved computation. Data providers earn token by sharing out data value but not data ownership. ARPA’s privacy-preserving feature for the data marketplace can potentially unlock massive amounts of data from enterprises, as well as, from individuals as a new way of data monetization.

9.2.3 Data Consumer

Data consumers can be enterprises, researchers, government, universities, and individual developers that rent data to run models, monetizing on analysis output and training AI/ML models. Data consumers pay token(s) for access to data, and benefit from lower costs by renting data. Not by buying data from suitable enterprises or individuals. Data consumers can also leave ratings and reviews for a data-set after the transaction takes place. Essentially ARPA’s privacy-preserving computation cuts out data aggregators and intermediaries that used to take majority of profit within data transactions.

9.2.4 Model providers

Model providers can be enterprises and individual developers that own models and would like to monetize models based on usage. Model providers earn tokens renting out models and also get incentivized sharing models to ARPA’s network. Models can be rented on a pay-per-use basis or by subscription. Without potential data leakage risks, data owners can screen for the best model available on ARPA, run the model with data in a cryptographically secure way, and get insightful output from the model provider. One use case can be running analysis for medical data from hospitals where a third-party AI developer directly processes encrypted medical data and sends back results to hospitals without access to raw data.

9.2.5 Data / Model Backers

Data and model backers can be individuals and enterprises that invest in public datasets or models, and receive revenue shares in tokens. Data and model backers can range from normal crypto audiences and network stakeholders, to professional investment entities. Any dataset or model made available to the public at ARPA will mock up 20% of the dataset selling price. This price difference will be distributed to data backers. It is generally hard to price datasets even when they are visible rather than encrypted, and therefore we introduce an Additive Backing System (ABS) to reflect data quality. ABS is designed to broaden ARPA audiences and attracts more early adopters of the network.

The basic rules of ABS are:

Based on the algorithm of ABS, we can now prove that the number of backers is positively correlated to the expected income of a dataset. A longer backing line represents better quality data, and it is a very visible indicator for a data consumer to find high quality datasets. Thus, we effectively outsourced the task of quantifying data quality to the ecosystem.

9.3 Business Flow for Data Renting

• •

The data provider uploads a dataset and chooses to make it public or private (for a designated data consumer only). The Data provider sets the price on a per-use basis.

• •

Data backers can view data samples and invest in public datasets to collectively share 20% of its future revenue. Backers are also able to see past transactions and reviews regarding the dataset. The amount of contribution is based on a Linear Backing Mechanism.

• •

A data consumer can request to run its model with the data provider’s dataset. In addition to the dataset usage cost, there will be estimated computation cost required.

• •

The smart contract ran by the data consumer, and a deposit will be required to initiate the MPC computation. Once deposit sends to the smart contract, the MPC task will be broadcasted.

• •

ARPA finishes the computation task. The data consumer and computation nodes get paid, and the data consumer gets the output data. Dataset backers also get their shares of the reward.

Case 1: Sharing of Behavioral Data in Various Sectors

A recent use case is data sharing and modeling as a service offered by banks to their corporate clients. For example, bank X is offering retail company Y data services by sharing the credit card transactions of all industries, as well as predictions on both individual and industry levels (e.g. customers’ lifestyle, shopping preference and industry outlook). This data is expected to be merged back to company Y’s customer data to be further used for various analytical functions. Currently the bank hashes PI data and then sends it to a 3rd party company to perform data matching with retailers’ data.

ARPA’s secure multiparty computation network can effectively eliminate 3rd party data matching intermediaries by secret-sharing a bank’s and retailer’s data to computation nodes, performing data matching with bank’s algorithm, and sending matched data to the retailer client.

To further protect bank’s raw data, ARPA’s computation network can run retail client’s analytical functions directly on matched data and only send back outputs to retail client. Now the bank has full discretion over the usage of its data.

Case 2: Privacy-Preserving Medical Diagnosis

Individual medical data contains sensitive information that is risky to run diagnosis using 3rd party models or tools. On the other hand, in recent years AI specialists have developed more accurate algorithms to assist medical professional’s judgment based on symptoms, medical history, CT scan images, etc. ARPA’s privacy-preserving feature allows data to be computed without leaking information to 3rd party model providers. Medical service entities or individuals can also screen for the best diagnosis model on a marketplace, such as genetic analysis.

Case 3: Identity Authentication

ARPA is capable of secure identity information storage and authentication for users in dApps and services. Identity information including fingerprint, face, voice unique to user is secret-shared to several nodes. The authentication process validates user identity via a private contract in a completely trustless way. This feature links blockchain with the real world.

10 Roadmap

Q1 2018

Idea Generation, Data Renting Business Case

Q2 2018

Initial Team Forming & Funding

Q3 2018

Whitepaper, Tech Notes

Q4 2018

MPC POC Demo, MPC Network Launch

Q1 2019

Testnet 1.0 (ASTRAEA) Release

Q2 2019

Testnet 2.0 (ATLAS) Release

Q3 2019

ARPA Mainnet Release

Q4 2019

Business Case Development, Off-chain Computation Solution

Q1 2020

Security Enhancement, Protocol Improvements