Introduction to Multi-Party Computation (MPC)
Multi-Party Computation (MPC): A Foundation for Obscura's Privacy
Multi-party computation (MPC) is a cryptographic technique that has been extensively studied since the 1980s but has only recently begun to find applications in decentralized finance (DeFi). Obscura leverages MPC as a core component of its anonymous trading pools, enabling secure and private computation without reliance on a centralized intermediary.
What is MPC?
To understand MPC, consider the concept of an "ideal evaluator":
Multiple parties send private data to a trusted evaluator.
The evaluator computes a function using the private inputs.
The evaluator then sends the result of the computation to the parties while discarding the private inputs.
The key property here is that the private inputs remain confidential, as only the output is shared. This approach allows multiple parties to compute a function collaboratively without revealing their individual inputs.
For example, two parties could use MPC to solve Yao’s Millionaire Problem: Each holds a private number, and the protocol determines who has the larger value without revealing the numbers themselves.
How MPC Works Without a Trusted Party
In practice, MPC eliminates the need for a trusted evaluator. Instead, mutually distrusting parties collaboratively compute the desired output while keeping their inputs secret. This functionality is achieved using cryptographic protocols that securely simulate the role of the ideal evaluator.
There are two primary classes of MPC algorithms:
Garbled Circuits: These algorithms rely on encrypted representations of functions for computation.
Secret-Sharing Algorithms: In these methods, private inputs are divided into shares, which are distributed among the parties. For instance, Shamir Secret Sharing splits private inputs into pieces, allowing calculations to be performed on these shares.
One commonly studied secret-sharing-based protocol is BGW, which serves as a foundational framework for many MPC implementations.
MPC in Anonymous Pools
The application of MPC in Obscura’s anonymous pools is straightforward:
Each trader’s private order book serves as the input.
The output is a list of tokens swapped after running the matching engine on the order books.
With MPC, two traders can anonymously match their orders without ever revealing their private inputs to one another or to any central party. If no match occurs, the only information revealed is that no valid counter-order exists. This ensures full functionality as an anonymous pool, without the need for a trusted operator.
Addressing Input Validity with MPC
While MPC enables private order matching, it does not inherently verify the validity of each trader’s inputs. For instance, the protocol must ensure that traders have sufficient balances to support their orders. Without this guarantee, the integrity of the system could be compromised.
To solve this, Obscura combines MPC with zero-knowledge proofs (ZKP), creating a robust system where:
MPC ensures private computation of order matches.
ZKP verifies the validity of trader balances and orders against on-chain data.
This combination ensures that all computations within Obscura’s anonymous pool are private, secure, and consistent with the blockchain’s state.
The Power of MPC in Obscura
By integrating MPC, Obscura provides:
End-to-end privacy for all trades.
Anonymous order matching without revealing order details.
A decentralized dark pool with no need for a central operator.
For a deeper understanding of how Obscura integrates MPC with zero-knowledge proofs, explore The MPC-ZKP Architecture, where we detail the full lifecycle of secure, private trading on our platform.
Obscura combines cutting-edge cryptography with the principles of decentralization to deliver a new standard of privacy in DeFi trading.
Last updated