Merge pull request #180 from sine-fdn/single-array-param-as-multiple-parties

Treat a main fn with a single array param as multiple parties

Author: fkettelhoit

garble_docs/src/SUMMARY.md

@@ -3,7 +3,7 @@
 - [What is Garble?](./landing.md)
 - [A Guide to Garble](./guide/intro.md)
   - [Installation](./guide/installation.md)
-  - [Functions](./guide/basics.md)
+  - [Functions](./guide/functions.md)
   - [Variables and Mutability](./guide/variables.md)
   - [Data Types](./guide/data_types.md)
   - [If/Else and Pattern Matching](./guide/control_flow.md)

garble_docs/src/guide/const.md

@@ -15,6 +15,8 @@ pub fn main(x: u16) -> u16 {
 }
 ```
 
+## Min & Max
+
 Garble also supports taking the `min()` / `max()` of several constants as part of the declaration of a constant, which, for instance, can be useful to set the size of a collection to the size of the biggest collection provided by different parties:
 
 ```rust
@@ -37,4 +39,24 @@ pub fn main(x: u16) -> u16 {
 
 > Garble currently does not support type inference in const declarations, which is why you always have to use type suffixes even for simple number literals, e.g. use `2u16` instead of `2`.
 
+## A Dynamic Number of Parties
+
+Using `const` declarations is especially useful for writing Garble programs that work for any number of parties. Simply use a single array as the argument of the main function, Garble will then assume that each array element is provided by a different party:
+
+```rust
+const PARTIES: usize = PARTIES::TOTAL;
+
+pub fn main(array: [u16; PARTIES]) -> u16 {
+    let mut result = 0u16;
+    for elem in array {
+        result = result + elem;
+    }
+    result
+}
+```
+
+The above program can be type checked without specifying the exact number of parties, but all parties need to agree on the number of parties during compilation (if each party is compiling the program locally), otherwise the same program (but with different `PARTIES::TOTAL` constants) would be compiled into incompatible circuits.
+
+## Compiling Consts
+
 Garble programs can be type checked without providing concrete values for the declared constants, but all const values must be provided during compilation, using [`garble_lang::compile_with_constants`](https://docs.rs/garble_lang/latest/garble_lang/fn.compile_with_constants.html). See [MPC Engine Integration](../integration.md) for more details.

garble_docs/src/guide/basics.md garble_docs/src/guide/functions.md

@@ -2,7 +2,7 @@
 
 Garble is a programming language for [MPC](https://en.wikipedia.org/wiki/Secure_multi-party_computation) that is quite easy to learn and mostly works like Rust, except that it is much simpler and only implements a subset of Rust (without the borrow checker). The following guide introduces the main features of Garble.
 
-A minimal Garble program is a public function (conventionally called `main`), with each function argument conceptually belonging to a different party in an MPC protocol based on Boolean circuits, e.g. [Garbled Circuits](https://en.wikipedia.org/wiki/Garbled_circuit). For example, the following program computes the Boolean `and` of two parties:
+A minimal Garble program is a public function (conventionally called `main`), with each argument coming from a different party in an MPC protocol based on Boolean circuits, e.g. [Garbled Circuits](https://en.wikipedia.org/wiki/Garbled_circuit). For example, the following program computes the Boolean `and` of two parties:
 
 ```rust
 pub fn main(party_a: bool, party_b: bool) -> bool {
@@ -17,3 +17,11 @@ pub fn main(a: u32, b: u32, c: u32) -> u32 {
     a + b + c
 }
 ```
+
+It is also possible to use a single array as the argument of the main function, Garble will then assume that each array element is coming from a different party. So we could also write the above as:
+
+```rust
+pub fn main(parties: [u32; 3]) -> u32 {
+    parties[0] + parties[1] + parties[2]
+}
+```

garble_docs/src/guide/intro.md

@@ -22,4 +22,4 @@ pub fn main(a: u64, b: u64) -> Richest {
 }
 ```
 
-Garble is developed by the [SINE Foundation](https://sine.foundation/) and is [open source](https://github.com/sine-fdn/garble-lang). We developed Garble for our own MPC engine, but you can use Garble in any [MPC engine](./integration.md) that executes Boolean circuits.
+Garble is developed by the [SINE Foundation](https://sine.foundation/) and is [open source](https://github.com/sine-fdn/garble-lang). Garble is integrated into [Polytune](https://github.com/sine-fdn/polytune), our own MPC engine, but you can use Garble in [any MPC engine](./integration.md) that executes Boolean circuits.

garble_docs/src/landing.md

@@ -239,15 +239,40 @@ impl TypedProgram {
         let Some(fn_def) = self.fn_defs.get(fn_name) else {
             return Err(vec![CompilerError::FnNotFound(fn_name.to_string())]);
         };
-        for param in fn_def.params.iter() {
-            let type_size = param.ty.size_in_bits_for_defs(self, &const_sizes);
-            let mut wires = Vec::with_capacity(type_size);
-            for _ in 0..type_size {
-                wires.push(wire);
-                wire += 1;
+        let single_array_as_multiple_parties = if fn_def.params.len() == 1 {
+            let param = &fn_def.params[0];
+            match &param.ty {
+                Type::Array(elem_ty, size) => Some((param, elem_ty, size)),
+                Type::ArrayConst(elem_ty, size) => {
+                    Some((param, elem_ty, const_sizes.get(size).unwrap()))
+                }
+                _ => None,
+            }
+        } else {
+            None
+        };
+        if let Some((param, elem_ty, size)) = single_array_as_multiple_parties {
+            let mut wires = vec![];
+            for _ in 0..*size {
+                let type_size = elem_ty.size_in_bits_for_defs(self, &const_sizes);
+                for _ in 0..type_size {
+                    wires.push(wire);
+                    wire += 1;
+                }
+                input_gates.push(type_size);
             }
-            input_gates.push(type_size);
             env.let_in_current_scope(param.name.clone(), wires);
+        } else {
+            for param in fn_def.params.iter() {
+                let type_size = param.ty.size_in_bits_for_defs(self, &const_sizes);
+                let mut wires = Vec::with_capacity(type_size);
+                for _ in 0..type_size {
+                    wires.push(wire);
+                    wire += 1;
+                }
+                input_gates.push(type_size);
+                env.let_in_current_scope(param.name.clone(), wires);
+            }
         }
         let mut circuit = CircuitBuilder::new(input_gates, const_sizes.clone());
         for (const_name, const_def) in self.const_defs.iter() {

src/compile.rs

@@ -1321,8 +1321,8 @@ pub fn main(i: usize) -> i32 {
 #[test]
 fn compile_main_with_array_io() -> Result<(), Error> {
     let prg = "
-pub fn main(nums: [u8; 5]) -> [u8; 5] {
-    let mut sum = 0u16;
+pub fn main(nums: [u8; 5], init: u16) -> [u8; 5] {
+    let mut sum = init;
     for n in nums {
         sum = sum + n as u16;
     }
@@ -1338,6 +1338,7 @@ pub fn main(nums: [u8; 5]) -> [u8; 5] {
     let mut eval = compiled.evaluator();
     let input = compiled.parse_arg(0, "[1, 2, 3, 4, 5]")?;
     eval.set_literal(input.as_literal())?;
+    eval.set_u16(0);
     let output = eval.run().map_err(|e| pretty_print(e, prg))?;
     let r = output.into_literal().map_err(|e| pretty_print(e, prg))?;
     assert_eq!(r.to_string(), "[15, 15, 15, 15, 15]");
@@ -2009,7 +2010,7 @@ pub fn main(x: u16) -> u16 {
 fn compile_const_size_in_fn_param() -> Result<(), Error> {
     let prg = "
 const MY_CONST: usize = max(PARTY_0::MY_CONST, PARTY_1::MY_CONST);
-pub fn main(array: [u16; MY_CONST]) -> u16 {
+pub fn main(array: [u16; MY_CONST], _: u8) -> u16 {
     array[1]
 }
 ";
@@ -2032,6 +2033,7 @@ pub fn main(array: [u16; MY_CONST]) -> u16 {
     let compiled = compile_with_constants(prg, consts).map_err(|e| pretty_print(e, prg))?;
     let mut eval = compiled.evaluator();
     eval.parse_literal("[7, 8]").unwrap();
+    eval.set_u8(0);
     let output = eval.run().map_err(|e| pretty_print(e, prg))?;
     assert_eq!(u16::try_from(output).map_err(|e| pretty_print(e, prg))?, 8);
     Ok(())
@@ -2041,7 +2043,7 @@ pub fn main(array: [u16; MY_CONST]) -> u16 {
 fn compile_const_size_for_each_loop() -> Result<(), Error> {
     let prg = "
 const MY_CONST: usize = max(PARTY_0::MY_CONST, PARTY_1::MY_CONST);
-pub fn main(array: [u16; MY_CONST]) -> u16 {
+pub fn main(array: [u16; MY_CONST], _: u8) -> u16 {
     let mut result = 0u16;
     for elem in array {
         result = result + elem;
@@ -2068,6 +2070,7 @@ pub fn main(array: [u16; MY_CONST]) -> u16 {
     let compiled = compile_with_constants(prg, consts).map_err(|e| pretty_print(e, prg))?;
     let mut eval = compiled.evaluator();
     eval.parse_literal("[7, 8]").unwrap();
+    eval.set_u8(0);
     let output = eval.run().map_err(|e| pretty_print(e, prg))?;
     assert_eq!(u16::try_from(output).map_err(|e| pretty_print(e, prg))?, 15);
     Ok(())
@@ -2345,3 +2348,78 @@ pub fn main(_x: i32) -> i32 {
     }
     Ok(())
 }
+
+#[test]
+fn compile_single_array_as_3_parties() -> Result<(), Error> {
+    let prg = "
+pub fn main(parties: [u32; 3]) -> u32 {
+  parties[0] + parties[1] + parties[2]
+}";
+    let compiled = compile(prg).map_err(|e| pretty_print(e, prg))?;
+    let mut eval = compiled.evaluator();
+    eval.set_u32(2);
+    eval.set_u32(4);
+    eval.set_u32(6);
+    let output = eval.run().map_err(|e| pretty_print(e, prg))?;
+    assert_eq!(
+        u32::try_from(output).map_err(|e| pretty_print(e, prg))?,
+        2 + 4 + 6,
+    );
+    Ok(())
+}
+
+#[test]
+fn compile_single_array_as_4_parties() -> Result<(), Error> {
+    let prg = "
+pub fn main(parties: [u32; 4]) -> u32 {
+  let mut result = 0u32;
+  for p in parties {
+    result += p
+  }
+  result
+}";
+    let compiled = compile(prg).map_err(|e| pretty_print(e, prg))?;
+    let mut eval = compiled.evaluator();
+    eval.set_u32(2);
+    eval.set_u32(4);
+    eval.set_u32(6);
+    eval.set_u32(8);
+    let output = eval.run().map_err(|e| pretty_print(e, prg))?;
+    assert_eq!(
+        u32::try_from(output).map_err(|e| pretty_print(e, prg))?,
+        2 + 4 + 6 + 8,
+    );
+    Ok(())
+}
+
+#[test]
+fn compile_single_array_with_const_size_as_multiple_parties() -> Result<(), Error> {
+    let prg = "
+const PARTIES: usize = PARTIES::TOTAL;
+pub fn main(array: [u16; PARTIES]) -> u16 {
+    let mut result = 0u16;
+    for elem in array {
+        result = result + elem;
+    }
+    result
+}
+";
+    let consts = HashMap::from_iter(vec![(
+        "PARTIES".to_string(),
+        HashMap::from_iter(vec![(
+            "TOTAL".to_string(),
+            Literal::NumUnsigned(3, UnsignedNumType::Usize),
+        )]),
+    )]);
+    let compiled = compile_with_constants(prg, consts).map_err(|e| pretty_print(e, prg))?;
+    let mut eval = compiled.evaluator();
+    eval.set_u16(2);
+    eval.set_u16(4);
+    eval.set_u16(6);
+    let output = eval.run().map_err(|e| pretty_print(e, prg))?;
+    assert_eq!(
+        u16::try_from(output).map_err(|e| pretty_print(e, prg))?,
+        2 + 4 + 6
+    );
+    Ok(())
+}