fabric: Add batch sharing methods

Author: joeykraut

src/algebra/authenticated_scalar.rs

@@ -117,10 +117,13 @@ impl AuthenticatedScalarResult {
         values: BatchScalarResult,
         n: usize,
     ) -> Vec<AuthenticatedScalarResult> {
-        // Convert to a set of scalar results, the identity gate does this when set to `n` output arity
+        // Convert to a set of scalar results
         let scalar_results = values
             .fabric()
-            .new_batch_gate_op(vec![values.id()], n, |args| args);
+            .new_batch_gate_op(vec![values.id()], n, |mut args| {
+                let scalars: Vec<Scalar> = args.pop().unwrap().into();
+                scalars.into_iter().map(ResultValue::Scalar).collect()
+            });
 
         Self::new_shared_batch(&scalar_results)
     }

src/algebra/authenticated_stark_point.rs

@@ -115,10 +115,13 @@ impl AuthenticatedStarkPointResult {
         values: BatchStarkPointResult,
         n: usize,
     ) -> Vec<AuthenticatedStarkPointResult> {
-        // Convert to a set of scalar results, the identity gate does this when set to `n` output arity
+        // Convert to a set of scalar results
         let scalar_results = values
             .fabric()
-            .new_batch_gate_op(vec![values.id()], n, |args| args);
+            .new_batch_gate_op(vec![values.id()], n, |mut args| {
+                let args: Vec<StarkPoint> = args.pop().unwrap().into();
+                args.into_iter().map(ResultValue::Point).collect_vec()
+            });
 
         Self::new_shared_batch(&scalar_results)
     }

src/algebra/stark_curve.rs

@@ -529,8 +529,10 @@ impl StarkPointResult {
             .chain(a.iter().flat_map(|a| a.ids()))
             .collect_vec();
 
-        let results =
-            fabric.new_batch_gate_op(all_ids, n /* output_arity */, move |mut args| {
+        let results = fabric.new_batch_gate_op(
+            all_ids,
+            AUTHENTICATED_STARK_POINT_RESULT_LEN * n, /* output_arity */
+            move |mut args| {
                 let points: Vec<StarkPoint> = args.drain(..n).map(StarkPoint::from).collect_vec();
 
                 let mut results = Vec::with_capacity(AUTHENTICATED_STARK_POINT_RESULT_LEN * n);
@@ -549,7 +551,8 @@ impl StarkPointResult {
                 }
 
                 results
-            });
+            },
+        );
 
         AuthenticatedStarkPointResult::from_flattened_iterator(results.into_iter())
     }

src/fabric.rs

@@ -1064,4 +1064,30 @@ impl MpcFabric {
         let (left, right) = authenticated_left_right.split_at(n);
         (left.to_vec(), right.to_vec())
     }
+
+    /// Sample a random shared bit from the beaver source
+    pub fn random_shared_bit(&self) -> AuthenticatedScalarResult {
+        let bit = self
+            .inner
+            .beaver_source
+            .lock()
+            .expect("beaver source poisoned")
+            .next_shared_bit();
+
+        let bit = self.allocate_scalar(bit);
+        AuthenticatedScalarResult::new_shared(bit)
+    }
+
+    /// Sample a batch of random shared bits from the beaver source
+    pub fn random_shared_bits(&self, n: usize) -> Vec<AuthenticatedScalarResult> {
+        let bits = self
+            .inner
+            .beaver_source
+            .lock()
+            .expect("beaver source poisoned")
+            .next_shared_bit_batch(n);
+
+        let bits = self.allocate_scalars(bits);
+        AuthenticatedScalarResult::new_shared_batch(&bits)
+    }
 }

src/fabric/result.rs

@@ -65,8 +65,9 @@ impl From<ResultValue> for NetworkPayload {
         match value {
             ResultValue::Bytes(bytes) => NetworkPayload::Bytes(bytes),
             ResultValue::Scalar(scalar) => NetworkPayload::Scalar(scalar),
+            ResultValue::ScalarBatch(scalars) => NetworkPayload::ScalarBatch(scalars),
             ResultValue::Point(point) => NetworkPayload::Point(point),
-            _ => panic!("not a valid network payload type"),
+            ResultValue::PointBatch(points) => NetworkPayload::PointBatch(points),
         }
     }
 }