mpc-framework

A framework that makes MPC easy in TypeScript.

Choose from multiple existing circuit generators and MPC engines, or create
your own.

What is MPC?

MPC stands for _Multi-Party Computation_. In regular computation, all inputs,
outputs, and intermediate calculations are necessarily visible on the device
performing the computation. MPC, by contrast, allows multiple devices to
collaborate on a computation while keeping intermediate calculations and others'
inputs private.

Here's some ways that can be useful:

- Provide analysis on patient data to researchers without revealing the patient data
- Play Rock Paper Scissors Lizard Spock while keeping your move secret
- Hold an auction while keeping the bids secret (only the winning bidder and price is revealed)
- Match employers and job-seekers that each have hidden criteria
- Arrange optimal asset swaps (eg sports players / trading cards / corporate assets / NFTs) using hidden valuations
- Find out if you qualify for an insurance policy without sharing your health data and without requiring the insurer to reveal the policy requirements
- Quantify how much you have in common with someone and then figure out the commonalities together (or choose not to)
- Create an embarassing songs playlist for a party where each song is liked by >=N people

For a bit more of an introduction to MPC, I recommend Barry Whitehat's talk
2PC is for Lovers. The
lovers' app described in the talk has been implemented using mpc-framework
here.

For a more technical introduction, see Computerphile's video on Garbled Circuits. For a deeper dive: Pragmatic MPC.

Usage Guide

In addition to mpc-framework, you will need:

- a circuit generator to turn your MPC program into a circuit (or byo precompiled or handwritten circuit)
- an mpc-framework engine to do the underlying cryptography

``sh
npm install mpc-framework
npm install summon-ts # circuit generator
npm install emp-wasm-engine # engine
`

$3

The computation to be done inside MPC must be specified in the form of a
circuit. This is a special simplified program in the form of a fixed tree
specifying how to combine values together. Regular programs allow the CPU to
branch into different code paths, and circuits can't do that. It's possible to
write these circuits by hand (or using third party tools), but you might find it
easier to use summon:

`ts
// This isn't exactly TypeScript, but it uses the same syntax and has enough in
// common that you can use the .ts extension and get useful intellisense

export default (io: Summon.IO) => {
// Alice provides a number called 'a'
const a = io.input('alice', 'a', summon.number());

// Bob provides a number called 'b'
const b = io.input('bob', 'b', summon.number());

let result;

// This seems like a branch that I just said is not allowed, but this is just
// an abstraction, and summon will compile it down to a fixed circuit. Loops
// are possible too. See the summon docs for more detail.
if (isLarger(a, b)) {
result = a;
} else {
result = b;
}

// Everyone gets an output called 'result'
io.outputPublic('result', result);
}

// We could inline this, but we're just demonstrating that summon supports
// modularity (multi-file works too and many other TS features).
function isLarger(a: number, b: number) {
return a > b;
}
`

$3

`ts
import * as summon from 'summon-ts';

// ...

await summon.init();

const { circuit } = summon.compile({
// Specify the entry point, similar to the main field of package.json
path: 'circuit/main.ts',

// This is the bit width of numbers in your summon program. You can use any
// width you like, but all numbers in the program will be the same. You can
// achieve smaller bit widths within the program using masking (the unused
// gates will be optimized away). It's also possible to define classes for
// matrices/floats/etc.
boolifyWidth: 8,

// File tree to compile
files: {
'circuit/main.ts':
// Include code from step 1
// This can be inlined or you can use build tools to just include a
// directory from your source tree
// (eg https://github.com/privacy-scaling-explorations/mpc-hello/tree/main/client-client)
,
// Other files can be specified here
},
});
`

$3

`ts
import { Protocol } from 'mpc-framework';
import { EmpWasmEngine } from 'emp-wasm-engine';

// ...

const protocol = new Protocol(circuit, new EmpWasmEngine());
`

$3

`ts
function send(to: string, msg: Uint8Array) {
// implement sending a message to the specified party
}

const session = protocol.join('alice', { a: 3 }, send);

// This is just a hypothetical API for getting external messages
onMessageReceived((from: string, msg: Uint8Array) => {
// The important part is that you provide the messages to the session like
// this
session.handleMessage(from, msg);
});

// have another device (or tab) join as bob and provide { b: 5 }

console.log(await session.output()); // { main: 5 }
`

$3

For clarity, a complete version of the example above is provided as
mpc-hello.

Circuit Generators

| Name | Similar to | Related Repos |
| ----------------------------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| summon-ts | TypeScript | summon, boolify, ValueScript |
| circom-2-arithc-ts | Circom | circom-2-arithc, circom |

Engines

| Name | Description | Related Repos |
| ------------------------------------------------------------------- | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| emp-wasm-engine | Secure MPC using authenticated garbling | emp-wasm, emp-ag2pc, emp-agmpc |
| mpz-ts | Semi-honest 2PC | mpz` |

Example Projects

- MPC Hello
- 2PC is for Lovers
- MPC Lizard Spock