snarkVM

algorithms/src/snark/marlin/data_structures/circuit_proving_key.rs

@@ -54,17 +54,23 @@ impl<E: PairingEngine, MM: MarlinMode> ToBytes for CircuitProvingKey<E, MM> {
 impl<E: PairingEngine, MM: MarlinMode> FromBytes for CircuitProvingKey<E, MM> {
     #[inline]
     fn read_le<R: Read>(mut reader: R) -> io::Result<Self> {
-        //use web_sys::console;
+        use web_sys::console;
 
-        //console::log_1(&"Read Le 1".into());
+        // let mut buff = Vec::<u8>::new();
+        // let size = reader.read_to_end(&mut buff);
+
+        // let formatted_string = format!("Reader size: {:?} {:?}", size, buff.iter().take(1000).cloned().collect::<Vec<u8>>());
+        println!("Read Le 1");
+        console::log_1(&"Read Le 1".into());
+        // console::log_1(&formatted_string.into());
         let circuit_verifying_key = CanonicalDeserialize::deserialize_compressed(&mut reader)?;
-        //console::log_1(&"Read Le 2".into());
+        console::log_1(&"Read Le 2".into());
         let circuit_commitment_randomness = CanonicalDeserialize::deserialize_compressed(&mut reader)?;
-        //console::log_1(&"Read Le 3".into());
+        // console::log_1(&"Read Le 3".into());
         let circuit = CanonicalDeserialize::deserialize_compressed(&mut reader)?;
-        //console::log_1(&"Read Le 4".into());
+        // console::log_1(&"Read Le 4".into());
         let committer_key = Arc::new(FromBytes::read_le(&mut reader)?);
-        //console::log_1(&"Read Le 5".into());
+        // console::log_1(&"Read Le 5".into());
 
         Ok(Self { circuit_verifying_key, circuit_commitment_randomness, circuit, committer_key })
     }

algorithms/src/snark/marlin/data_structures/circuit_verifying_key.rs

@@ -155,6 +155,8 @@ impl<E: PairingEngine, MM: MarlinMode> ToMinimalBits for CircuitVerifyingKey<E,
 
 impl<E: PairingEngine, MM: MarlinMode> FromBytes for CircuitVerifyingKey<E, MM> {
     fn read_le<R: Read>(r: R) -> io::Result<Self> {
+        use web_sys::console;
+        console::log_1(&"Deserialize CVK".into());
         Self::deserialize_compressed(r).map_err(|_| error("could not deserialize CircuitVerifyingKey"))
     }
 }
@@ -174,6 +176,8 @@ impl<E: PairingEngine, MM: MarlinMode> CircuitVerifyingKey<E, MM> {
 
 impl<E: PairingEngine, MM: MarlinMode> ToConstraintField<E::Fq> for CircuitVerifyingKey<E, MM> {
     fn to_field_elements(&self) -> Result<Vec<E::Fq>, ConstraintFieldError> {
+        use web_sys::console;
+        console::log_1(&"CVK to field elements".into());
         let constraint_domain_size =
             EvaluationDomain::<E::Fr>::compute_size_of_domain(self.circuit_info.num_constraints).unwrap() as u128;
         let non_zero_a_domain_size =
@@ -183,6 +187,10 @@ impl<E: PairingEngine, MM: MarlinMode> ToConstraintField<E::Fq> for CircuitVerif
         let non_zero_c_domain_size =
             EvaluationDomain::<E::Fr>::compute_size_of_domain(self.circuit_info.num_non_zero_c).unwrap() as u128;
 
+        let formatted_string = format!("Domain sizes: {} , {}, {}, {}", constraint_domain_size, non_zero_a_domain_size, non_zero_b_domain_size, non_zero_c_domain_size);
+        console::log_1(&formatted_string.into());
+
+
         let mut res = Vec::new();
         res.append(&mut E::Fq::from(constraint_domain_size).to_field_elements()?);
         res.append(&mut E::Fq::from(non_zero_a_domain_size).to_field_elements()?);
@@ -228,6 +236,8 @@ impl<E: PairingEngine, MM: MarlinMode> Serialize for CircuitVerifyingKey<E, MM>
 impl<'de, E: PairingEngine, MM: MarlinMode> Deserialize<'de> for CircuitVerifyingKey<E, MM> {
     #[inline]
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        use web_sys::console;
+        console::log_1(&"Deserialize cvk 1".into());
         match deserializer.is_human_readable() {
             true => {
                 let s: String = Deserialize::deserialize(deserializer)?;

curves/Cargo.toml

@@ -53,6 +53,10 @@ version = "1.0.152"
 default-features = false
 features = [ "derive" ]
 
+[dependencies.web-sys]
+version = "0.3"
+features = ["console"]
+
 [dependencies.thiserror]
 version = "1.0"
 

curves/src/templates/macros.rs

@@ -124,6 +124,8 @@ macro_rules! impl_sw_curve_serializer {
                 validate: Validate,
             ) -> Result<Self, snarkvm_utilities::serialize::SerializationError> {
                 use snarkvm_utilities::serialize::SWFlags;
+                use web_sys::console;
+                console::log_1(&"deserialize here affine".into());
                 let point = if let Compress::Yes = compress {
                     let (x, flags) = P::BaseField::deserialize_with_flags::<_, SWFlags>(&mut reader)?;
                     if flags.is_infinity() {

fields/src/fp12_2over3over2.rs

@@ -536,6 +536,10 @@ impl<P: Fp12Parameters> CanonicalSerialize for Fp12<P> {
 impl<P: Fp12Parameters> CanonicalDeserializeWithFlags for Fp12<P> {
     #[inline]
     fn deserialize_with_flags<R: Read, F: Flags>(mut reader: R) -> Result<(Self, F), SerializationError> {
+        use web_sys::console;
+        console::log_1(&"deserialize here fp12".into());
+        println!("deserialize here fp12");
+
         let c0 = CanonicalDeserialize::deserialize_uncompressed(&mut reader)?;
         let (c1, flags) = Fp6::deserialize_with_flags(&mut reader)?;
         Ok((Self::new(c0, c1), flags))

fields/src/fp2.rs

@@ -457,6 +457,9 @@ impl<P: Fp2Parameters> CanonicalSerialize for Fp2<P> {
 impl<P: Fp2Parameters> CanonicalDeserializeWithFlags for Fp2<P> {
     #[inline]
     fn deserialize_with_flags<R: Read, F: Flags>(mut reader: R) -> Result<(Self, F), SerializationError> {
+        use web_sys::console;
+        console::log_1(&"deserialize here fp2".into());
+
         let c0: P::Fp = CanonicalDeserialize::deserialize_uncompressed(&mut reader)?;
         let (c1, flags): (P::Fp, _) = CanonicalDeserializeWithFlags::deserialize_with_flags(&mut reader)?;
         Ok((Fp2::new(c0, c1), flags))

fields/src/fp6_3over2.rs

@@ -555,6 +555,9 @@ impl<P: Fp6Parameters> Valid for Fp6<P> {
 impl<P: Fp6Parameters> CanonicalDeserializeWithFlags for Fp6<P> {
     #[inline]
     fn deserialize_with_flags<R: Read, F: Flags>(mut reader: R) -> Result<(Self, F), SerializationError> {
+        use web_sys::console;
+        console::log_1(&"deserialize here fp6".into());
+
         let c0 = CanonicalDeserialize::deserialize_uncompressed(&mut reader)?;
         let c1 = CanonicalDeserialize::deserialize_uncompressed(&mut reader)?;
         let (c2, flags): (_, _) = CanonicalDeserializeWithFlags::deserialize_with_flags(&mut reader)?;

fields/src/macros.rs

@@ -282,6 +282,10 @@ macro_rules! impl_primefield_serializer {
                 let flags = F::from_u8_remove_flags(&mut masked_bytes[output_byte_size - 1])
                     .ok_or(SerializationError::UnexpectedFlags)?;
 
+                let formatted_string = format!("Flags found: {:?}", flags.u8_bitmask());
+                // println!("Flags found: {}", )
+                console::log_1(&formatted_string.into());
+
                 Ok((Self::read_le(&masked_bytes[..])?, flags))
             }
         }
@@ -309,6 +313,8 @@ macro_rules! impl_primefield_serializer {
                 _validate: snarkvm_utilities::serialize::Validate,
             ) -> Result<Self, snarkvm_utilities::SerializationError> {
                 use snarkvm_utilities::serialize::EmptyFlags;
+                use web_sys::console;
+                console::log_1(&"deserialize here".into());
                 Self::deserialize_with_flags::<R, EmptyFlags>(reader).map(|(r, _)| r)
             }
         }

parameters/src/testnet3/mod.rs

@@ -154,16 +154,16 @@ macro_rules! impl_web {
                 let provider_lock = PARAMETER_PROVIDER.lock();
                 match provider_lock {
                     Ok(provider) => {
-                        //use web_sys::console;
+                        use web_sys::console;
 
                         let formatted_string = format!("{}: Loading Bytes", stringify!($name));
-                        // println!("{}: Loading Bytes", stringify!($name));
-                        //console::log_1(&formatted_string.into());
+                        println!("{}: Loading Bytes", stringify!($name));
+                        console::log_1(&formatted_string.into());
                         let bytes = provider.get(stringify!($name));
                         assert!(bytes.is_some(), "{} should be defined in the Parameter Provider", stringify!($name));
                         let unwrapped_bytes = bytes.unwrap().clone();
                         let formatted_string2 = format!("{}: Loaded Bytes Sucessfully", stringify!($name));
-                        //console::log_1(&formatted_string2.into());
+                        console::log_1(&formatted_string2.into());
                         Ok(unwrapped_bytes)
                     }
                     Err(_) => {
@@ -260,22 +260,22 @@ macro_rules! insert_key {
     ($map:ident, $string:tt, $type:ident<$network:ident>, ($name:tt, $circuit_key:expr)) => {{
         // Load the circuit key bytes.
         let formatted_string = format!("{}: Loading Circuit Keys", stringify!($string));
-        //web_sys:://console::log_1(&formatted_string.into());
+        web_sys::console::log_1(&formatted_string.into());
         let key_bytes: Vec<u8> = $circuit_key.expect(&format!("Failed to load {} bytes", $string));
         let formatted_string2 = format!("{}: Loaded Circuit Keys: {} Bytes", stringify!($string), key_bytes.len());
-        //web_sys:://console::log_1(&formatted_string2.into());
+        web_sys::console::log_1(&formatted_string2.into());
         // Recover the circuit key.
         let key = $type::<$network>::from_bytes_le(&key_bytes[2..]).expect(&format!("Failed to recover {}", $string));
         let formatted_string3 = format!("{}: Recovered Circuit Keys", stringify!($string));
-        //web_sys:://console::log_1(&formatted_string3.into());
+        web_sys::console::log_1(&formatted_string3.into());
         // Insert the circuit key.
         let thing = std::sync::Arc::new(key);
         let formatted_string10 = format!("{}: ARC Made", stringify!($string));
-        //web_sys:://console::log_1(&formatted_string10.into());
+        web_sys::console::log_1(&formatted_string10.into());
 
         $map.insert($name.to_string(), thing);
         let formatted_string4 = format!("{}: Inserted Circuit Key", stringify!($string));
-        //web_sys:://console::log_1(&formatted_string4.into());
+        web_sys::console::log_1(&formatted_string4.into());
     }};
 }
 

utilities/src/serialize/traits.rs

@@ -205,6 +205,7 @@ where
     T: DeserializeOwned,
 {
     fn take_from_value<D: Deserializer<'de>>(value: &mut serde_json::Value, field: &str) -> Result<Self, D::Error> {
+
         serde_json::from_value(
             value
                 .get_mut(field)