roll back changes in circuit compression

src/compiler.rs

@@ -74,20 +74,18 @@ impl Compiler {
 
     /// Generates a [Prover] and [Verifier] from a buffer created by
     /// [Self::compress].
-    pub fn decompress_and_compile(
+    pub fn decompress(
         pp: &PublicParameters,
         label: &[u8],
         compressed: &[u8],
     ) -> Result<(Prover, Verifier), Error> {
-        let composer = CompressedCircuit::from_bytes(compressed)?;
-
-        Self::compile_with_composer(pp, label, &composer)
+        CompressedCircuit::from_bytes(pp, label, compressed)
     }
 
     /// Create a new arguments set from a given circuit instance
     ///
     /// Use the default implementation of the circuit
-    fn compile_with_composer(
+    pub(crate) fn compile_with_composer(
         pp: &PublicParameters,
         label: &[u8],
         composer: &Composer,

src/composer/compress.rs

@@ -13,6 +13,7 @@ use alloc::vec::Vec;
 use super::{
     BlsScalar, Circuit, Composer, Constraint, Error, Gate, Selector, Witness,
 };
+use crate::prelude::{Compiler, Prover, PublicParameters, Verifier};
 
 mod hades;
 
@@ -209,7 +210,11 @@ impl CompressedCircuit {
         miniz_oxide::deflate::compress_to_vec(&buf, 10)
     }
 
-    pub fn from_bytes(compressed: &[u8]) -> Result<Composer, Error> {
+    pub fn from_bytes(
+        pp: &PublicParameters,
+        label: &[u8],
+        compressed: &[u8],
+    ) -> Result<(Prover, Verifier), Error> {
         let compressed = miniz_oxide::inflate::decompress_to_vec(compressed)
             .map_err(|_| Error::InvalidCompressedCircuit)?;
         let (
@@ -353,6 +358,6 @@ impl CompressedCircuit {
             composer.append_custom_gate(constraint);
         }
 
-        Ok(composer)
+        Compiler::compile_with_composer(pp, label, &composer)
     }
 }

tests/composer.rs

@@ -88,7 +88,7 @@ fn circuit_with_all_gates() {
         .expect("failed to compress circuit");
 
     let (decompressed_prover, decompressed_verifier) =
-        Compiler::decompress_and_compile(&pp, label, &compressed).unwrap();
+        Compiler::decompress(&pp, label, &compressed).unwrap();
 
     let decoded_prover_bytes = decompressed_prover.to_bytes();
     let len = prover.serialized_size();