Bump dependency versions

taiga_halo2/Cargo.toml

@@ -17,13 +17,13 @@ subtle = { version = "2.3", default-features = false }
 dyn-clone = "1.0"
 reddsa = "0.5"
 vamp-ir = { git = "https://github.com/anoma/vamp-ir.git", rev = "6d401f8a479951727586ef0c44c42edab3139090"}
-bincode = "2.0.0-rc.1"
-borsh = {version = "0.9", features = ["const-generics"]}
+bincode = "2.0.0-rc.3"
+borsh = {version = "0.10.3", features = ["const-generics"]}
 byteorder = "1"
 num-bigint = "0.4.3"
 
 [dev-dependencies]
-criterion = "0.3"
+criterion = "0.5.1"
 proptest = "1.0.0"
 
 [[bench]]

taiga_halo2/src/action.rs

@@ -78,6 +78,28 @@ impl BorshDeserialize for ActionInstance {
             cv_net,
         })
     }
+
+    fn deserialize_reader<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let anchor_bytes = <[u8; 32]>::deserialize_reader(reader)?;
+        let anchor = Option::from(pallas::Base::from_repr(anchor_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "anchor not in field"))?;
+        let nf_bytes = <[u8; 32]>::deserialize_reader(reader)?;
+        let nf = Option::from(Nullifier::from_bytes(nf_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "nf not in field"))?;
+        let cm_x_bytes = <[u8; 32]>::deserialize_reader(reader)?;
+        let cm_x = Option::from(pallas::Base::from_repr(cm_x_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "cm_x not in field"))?;
+        let cv_net_bytes = <[u8; 32]>::deserialize_reader(reader)?;
+        let cv_net = Option::from(ValueCommitment::from_bytes(cv_net_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "cv_net not in field"))?;
+
+        Ok(ActionInstance {
+            anchor,
+            nf,
+            cm_x,
+            cv_net,
+        })
+    }
 }
 
 impl ActionInfo {

taiga_halo2/src/binding_signature.rs

@@ -59,6 +59,12 @@ impl BorshDeserialize for BindingSignature {
         let sig_bytes = <[u8; 64]>::deserialize(buf)?;
         Ok(Self::from_bytes(sig_bytes))
     }
+
+    fn deserialize_reader<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let mut sig_bytes = [0u8; 64];
+        reader.read_exact(&mut sig_bytes)?;
+        Ok(Self::from_bytes(sig_bytes))
+    }
 }
 
 impl BindingSigningKey {
@@ -93,6 +99,14 @@ impl BorshDeserialize for BindingSigningKey {
             io::Error::new(io::ErrorKind::InvalidData, "BindingSigningKey not in field")
         })
     }
+
+    fn deserialize_reader<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        let mut key_bytes = [0u8; 32];
+        reader.read_exact(&mut key_bytes)?;
+        Self::from_bytes(key_bytes).map_err(|_| {
+            io::Error::new(io::ErrorKind::InvalidData, "BindingSigningKey not in field")
+        })
+    }
 }
 
 impl From<pallas::Scalar> for BindingSigningKey {

taiga_halo2/src/circuit/vp_circuit.rs

@@ -134,6 +134,29 @@ impl BorshDeserialize for VPVerifyingInfo {
             public_inputs: public_inputs.into(),
         })
     }
+
+    fn deserialize_reader<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        // Read vk
+        use crate::circuit::vp_examples::TrivialValidityPredicateCircuit;
+        let params = SETUP_PARAMS_MAP.get(&VP_CIRCUIT_PARAMS_SIZE).unwrap();
+        let vk = VerifyingKey::read::<_, TrivialValidityPredicateCircuit>(reader, params)?;
+        // Read proof
+        let proof = Proof::deserialize_reader(reader)?;
+        // Read public inputs
+        let public_inputs: Vec<_> = (0..VP_CIRCUIT_PUBLIC_INPUT_NUM)
+            .map(|_| {
+                let bytes = <[u8; 32]>::deserialize_reader(reader)?;
+                Option::from(pallas::Base::from_repr(bytes)).ok_or_else(|| {
+                    io::Error::new(io::ErrorKind::InvalidData, "public input not in field")
+                })
+            })
+            .collect::<Result<_, _>>()?;
+        Ok(VPVerifyingInfo {
+            vk,
+            proof,
+            public_inputs: public_inputs.into(),
+        })
+    }
 }
 
 impl ValidityPredicatePublicInputs {

taiga_halo2/src/note.rs

@@ -377,6 +377,75 @@ impl BorshDeserialize for Note {
             rcm,
         ))
     }
+
+    fn deserialize_reader<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        // Read app_vk
+        let mut app_vk_bytes = [0u8; 32];
+        reader.read_exact(&mut app_vk_bytes)?;
+        let app_vk = Option::from(pallas::Base::from_repr(app_vk_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "app_vk not in field"))?;
+        // Read app_data_static
+        let mut app_data_static_bytes = [0u8; 32];
+        reader.read_exact(&mut app_data_static_bytes)?;
+        let app_data_static = Option::from(pallas::Base::from_repr(app_data_static_bytes))
+            .ok_or_else(|| {
+                io::Error::new(io::ErrorKind::InvalidData, "app_data_static not in field")
+            })?;
+        // Read app_data_dynamic
+        let mut app_data_dynamic_bytes = [0u8; 32];
+        reader.read_exact(&mut app_data_dynamic_bytes)?;
+        let app_data_dynamic = Option::from(pallas::Base::from_repr(app_data_dynamic_bytes))
+            .ok_or_else(|| {
+                io::Error::new(io::ErrorKind::InvalidData, "app_data_dynamic not in field")
+            })?;
+        // Read note value
+        let value = reader.read_u64::<LittleEndian>()?;
+        // Read nk_container
+        let mut nk_container_type = [0u8; 1];
+        reader.read_exact(&mut nk_container_type)?;
+        let nk_container_type = nk_container_type[0];
+        let mut nk_container_bytes = [0u8; 32];
+        reader.read_exact(&mut nk_container_bytes)?;
+        let nk = Option::from(pallas::Base::from_repr(nk_container_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "nk not in field"))?;
+        let nk_container = if nk_container_type == 0x01 {
+            NullifierKeyContainer::from_commitment(nk)
+        } else {
+            NullifierKeyContainer::from_key(nk)
+        };
+        // Read rho
+        let mut rho_bytes = [0u8; 32];
+        reader.read_exact(&mut rho_bytes)?;
+        let rho = Option::from(Nullifier::from_bytes(rho_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "rho not in field"))?;
+        // Read psi
+        let mut psi_bytes = [0u8; 32];
+        reader.read_exact(&mut psi_bytes)?;
+        let psi = Option::from(pallas::Base::from_repr(psi_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "psi not in field"))?;
+        // Read rcm
+        let mut rcm_bytes = [0u8; 32];
+        reader.read_exact(&mut rcm_bytes)?;
+        let rcm = Option::from(pallas::Base::from_repr(rcm_bytes))
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "rcm not in field"))?;
+        // Read is_merkle_checked
+        let mut is_merkle_checked_byte = [0u8; 1];
+        reader.read_exact(&mut is_merkle_checked_byte)?;
+        let is_merkle_checked_byte = is_merkle_checked_byte[0];
+        let is_merkle_checked = is_merkle_checked_byte == 0x01;
+        // Construct note
+        Ok(Note::from_full(
+            app_vk,
+            app_data_static,
+            app_data_dynamic,
+            value,
+            nk_container,
+            rho,
+            is_merkle_checked,
+            psi,
+            rcm,
+        ))
+    }
 }
 
 impl NoteType {

taiga_halo2/src/shielded_ptx.rs

@@ -237,6 +237,23 @@ impl BorshDeserialize for ShieldedPartialTransaction {
             outputs: outputs.try_into().unwrap(),
         })
     }
+
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        let actions: Vec<_> = (0..NUM_NOTE)
+            .map(|_| ActionVerifyingInfo::deserialize_reader(reader))
+            .collect::<Result<_, _>>()?;
+        let inputs: Vec<_> = (0..NUM_NOTE)
+            .map(|_| NoteVPVerifyingInfoSet::deserialize_reader(reader))
+            .collect::<Result<_, _>>()?;
+        let outputs: Vec<_> = (0..NUM_NOTE)
+            .map(|_| NoteVPVerifyingInfoSet::deserialize_reader(reader))
+            .collect::<Result<_, _>>()?;
+        Ok(ShieldedPartialTransaction {
+            actions: actions.try_into().unwrap(),
+            inputs: inputs.try_into().unwrap(),
+            outputs: outputs.try_into().unwrap(),
+        })
+    }
 }
 impl ActionVerifyingInfo {
     pub fn create<R: RngCore>(action_info: ActionInfo, mut rng: R) -> Result<Self, Error> {