fix: k256 decompress

core/src/io.rs

@@ -62,6 +62,11 @@ impl SuccinctStdout {
         self.buffer.read()
     }
 
+    /// Read a slice of bytes from the buffer.
+    pub fn read_slice(&mut self, slice: &mut [u8]) {
+        self.buffer.read_slice(slice);
+    }
+
     /// Write a value to the buffer.
     pub fn write<T: Serialize + DeserializeOwned>(&mut self, data: &T) {
         self.buffer.write(data);

core/src/syscall/precompiles/k256/decompress.rs

@@ -255,7 +255,11 @@
         let y_limbs = limbs_from_access(&self.y_access);
         builder
             .when(self.is_real)
-            .when(AB::Expr::one() - (y_is_odd.into() - should_be_odd.clone()))
+            .when(
+                (y_is_odd.into() * should_be_odd.clone())
+                    + ((AB::Expr::one() - y_is_odd.into())
+                        * (AB::Expr::one() - should_be_odd.clone())),
+            )
             .assert_all_eq(self.y.multiplication.result, y_limbs);
         builder
             .when(self.is_real)
@@ -370,35 +374,29 @@
     use rand::rngs::StdRng;
     use rand::SeedableRng;
 
+    use crate::utils::setup_logger;
     use crate::utils::tests::SECP256K1_DECOMPRESS_ELF;
-    use crate::utils::BabyBearBlake3;
-    use crate::{
-        runtime::{Program, Runtime},
-        utils::{prove_core, setup_logger},
-    };
+    use crate::{SuccinctProver, SuccinctStdin, SuccinctVerifier};
 
     #[test]
     fn test_k256_decompress() {
         setup_logger();
         let mut rng = StdRng::seed_from_u64(2);
 
-        for _ in 0..4 {
+        for _ in 0..10 {
             let secret_key = k256::SecretKey::random(&mut rng);
             let public_key = secret_key.public_key();
             let encoded = public_key.to_encoded_point(false);
             let decompressed = encoded.as_bytes();
             let compressed = public_key.to_sec1_bytes();
-            let mut result: [u8; 65] = [0; 65];
-
-            let program = Program::from(SECP256K1_DECOMPRESS_ELF);
-            let mut runtime = Runtime::new(program);
-            runtime.write_stdin_slice(&compressed);
-            runtime.run();
-            runtime.read_stdout_slice(&mut result);
 
+            let inputs = SuccinctStdin::from(&compressed);
+            let mut proof = SuccinctProver::prove(SECP256K1_DECOMPRESS_ELF, inputs).unwrap();
+            let mut result = [0; 65];
+            proof.stdout.read_slice(&mut result);
             assert_eq!(result, decompressed);
-            let config = BabyBearBlake3::new();
-            prove_core(config, &mut runtime);
+
+            SuccinctVerifier::verify(SECP256K1_DECOMPRESS_ELF, &proof).unwrap();
         }
     }
 }

core/src/utils/buffer.rs

@@ -4,6 +4,7 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
 #[derive(Serialize, Deserialize)]
 pub struct Buffer {
     pub data: Vec<u8>,
+    #[serde(skip)]
     pub ptr: usize,
 }
 
@@ -36,6 +37,11 @@ impl Buffer {
         result
     }
 
+    pub fn read_slice(&mut self, slice: &mut [u8]) {
+        slice.copy_from_slice(&self.data[self.ptr..self.ptr + slice.len()]);
+        self.ptr += slice.len();
+    }
+
     /// Write the serializable object from the buffer.
     pub fn write<T: Serialize + DeserializeOwned>(&mut self, data: &T) {
         let mut tmp = Vec::new();