Update function signatures for bincode 2.0

Cargo.lock

@@ -130,6 +130,7 @@ dependencies = [
 name = "cmzcred_derive"
 version = "0.1.0"
 dependencies = [
+ "bincode",
  "darling",
  "proc-macro2",
  "quote",

Cargo.toml

@@ -16,9 +16,9 @@ serde_bytes = "0.11"
 serde_with = "3"
 sigma_compiler = { path = "../sigma_compiler" }
 thiserror = "2"
+bincode = { version = "2.0.1", features = ["serde"] }
 
 [dev-dependencies]
-bincode = { version = "2.0.1", default-features = false, features = ["serde"] }
 curve25519-dalek = { version = "4", features = [ "group", "rand_core", "digest" ] }
 rand = "0.8.5"
 sha2 = "0.10"

cmzcred_derive/Cargo.lock

@@ -2,12 +2,22 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "serde",
+ "unty",
+]
+
 [[package]]
 name = "cmzcred_derive"
 version = "0.1.0"
 dependencies = [
+ "bincode",
  "darling",
- "log",
  "proc-macro2",
  "quote",
  "syn",
@@ -60,12 +70,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
-[[package]]
-name = "log"
-version = "0.4.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -84,6 +88,26 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -106,3 +130,9 @@ name = "unicode-ident"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"

cmzcred_derive/src/lib.rs

@@ -1590,22 +1590,25 @@ fn protocol_macro(
         let decls = clientstate_fields.field_decls();
         quote! {
             #[serde_as]
-            #[derive(Clone,Debug,serde::Serialize,serde::Deserialize)]
+            #[derive(bincode::Encode, bincode::Decode, Clone,Debug,serde::Serialize,serde::Deserialize)]
             pub struct ClientState {
                 #decls
             }
 
             impl TryFrom<&[u8]> for ClientState {
-                type Error = bincode::error::Error;
+                type Error = bincode::error::DecodeError;
 
-                fn try_from(bytes: &[u8]) -> bincode::Result<ClientState> {
-                    bincode::decode_from_slice::<ClientState>(bytes)
+                fn try_from(bytes: &[u8]) -> Result<ClientState, bincode::error::DecodeError> {
+                    match bincode::serde::decode_from_slice::<ClientState, bincode::config::Configuration>(bytes, bincode::config::legacy()) {
+                        Ok(result) => Ok(result.0),
+                        Err(_) => bincode::error::DecodeError,
+                    }
                 }
             }
 
             impl From<&ClientState> for Vec<u8> {
                 fn from(req: &ClientState) -> Vec<u8> {
-                    bincode::encode_to_vec(req).unwrap();
+                    bincode::serde::encode_to_vec(req,bincode::config::legacy()).unwrap();
                 }
             }
 
@@ -1623,22 +1626,25 @@ fn protocol_macro(
         let repdecls = reply_fields.field_decls();
         quote! {
             #[serde_as]
-            #[derive(Clone,Debug,serde::Serialize,serde::Deserialize)]
+            #[derive(bincode::Encode, bincode::Decode, Clone,Debug,serde::Serialize,serde::Deserialize)]
             pub struct Request {
                 #reqdecls
             }
 
             impl TryFrom<&[u8]> for Request {
-                type Error = bincode::error::Error;
+                type Error = bincode::error::DecodeError;
 
-                fn try_from(bytes: &[u8]) -> bincode::Result<Request> {
-                    bincode::deserialize::<Request>(bytes)
+                fn try_from(bytes: &[u8]) -> Result<Request, bincode::error::DecodeError> {
+                    match bincode::serde::decode_from_slice::<Request, bincode::config::Configuration>(bytes, bincode::config::legacy()) {
+                        Ok(result) => Ok(result.0),
+                        Err(e) => bincode::error::DecodeError,
+                }
                 }
             }
 
             impl From<&Request> for Vec<u8> {
                 fn from(req: &Request) -> Vec<u8> {
-                    bincode::encode_to_vec(req).unwrap()
+                    bincode::serde::encode_to_vec(req, bincode::config::legacy()).unwrap()
                 }
             }
 
@@ -1649,22 +1655,26 @@ fn protocol_macro(
             }
 
             #[serde_as]
-            #[derive(Clone,Debug,serde::Serialize,serde::Deserialize)]
+            #[derive(bincode::Encode, bincode::Decode, Clone,Debug,serde::Serialize,serde::Deserialize)]
             pub struct Reply {
                 #repdecls
             }
 
             impl TryFrom<&[u8]> for Reply {
-                type Error = bincode::error::Error;
+                type Error = bincode::error::DecodeError;
 
-                fn try_from(bytes: &[u8]) -> bincode::Result<Reply> {
-                    bincode::deserialize::<Reply>(bytes)
+                fn try_from(bytes: &[u8]) -> Result<(Reply, bincode::error::DecodeError>) {
+                    match bincode::serde::decode_from_slice::<Reply, bincode::config::Configuration>(bytes, bincode::config::legacy()) {
+                        Ok(result) => Ok(result.0),
+                        Err(e) => bincode::error::DecodeError,
+
+                    }
                 }
             }
 
             impl From<&Reply> for Vec<u8> {
                 fn from(rep: &Reply) -> Vec<u8> {
-                    bincode::encode_to_vec(rep).unwrap()
+                    bincode::serde::encode_to_vec(rep, bincode::config::legacy()).unwrap()
                 }
             }
 

src/lib.rs

@@ -2,6 +2,7 @@
 // lowercase letters
 #![allow(non_snake_case)]
 
+use bincode::{Decode, Encode};
 pub use cmzcred_derive::*;
 use core::any::Any;
 use ff::{Field, PrimeField};
@@ -64,7 +65,7 @@ impl<'de, G: Group + GroupEncoding> DeserializeAs<'de, G> for SerdePoint {
 
 /// The CMZMac struct represents a MAC on a CMZ credential.
 #[serde_as]
-#[derive(Copy, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Encode, Decode, Copy, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct CMZMac<G: PrimeGroup> {
     #[serde_as(as = "SerdePoint")]
     pub P: G,
@@ -74,7 +75,7 @@ pub struct CMZMac<G: PrimeGroup> {
 
 /// The CMZPrivkey struct represents a CMZ private key
 #[serde_as]
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Encode, Decode, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct CMZPrivkey<G: PrimeGroup> {
     // Is this key for µCMZ or classic CMZ14?
     pub muCMZ: bool,
@@ -91,7 +92,7 @@ pub struct CMZPrivkey<G: PrimeGroup> {
 
 /// The CMZPubkey struct represents a CMZ public key
 #[serde_as]
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Encode, Decode, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct CMZPubkey<G: PrimeGroup> {
     #[serde_as(as = "Option<SerdePoint>")]
     pub X0: Option<G>,
@@ -415,7 +416,7 @@ where
 macro_rules! CMZ {
     ( $name: ident < $G: ident > : $( $id: ident ),+ ) => {
         #[serde_as]
-        #[derive(CMZCred,Clone,Debug,Default,Serialize,Deserialize)]
+        #[derive(Encode, Decode, CMZCred,Clone,Debug,Default,Serialize,Deserialize)]
         #[cmzcred_group(group = $G)]
         pub struct $name {
         $(
@@ -429,7 +430,7 @@ macro_rules! CMZ {
     };
     ( $name: ident : $( $id: ident ),+ ) => {
         #[serde_as]
-        #[derive(CMZCred,Clone,Debug,Default,Serialize,Deserialize)]
+        #[derive(Encode, Decode, CMZCred,Clone,Debug,Default,Serialize,Deserialize)]
         #[cmzcred_group(group = G)]
         pub struct $name {
         $(

tests/basic.rs

@@ -26,18 +26,29 @@ fn test_basic() {
     let (privkey, pubkey) = Basic::cmz14_gen_keys(&mut rng);
 
     // Serialize and deserialize
-    let privkey_bytes = bincode::encode_to_vec(&privkey, bincode::config::standard()).unwrap();
-    let pubkey_bytes = bincode::encode_to_vec(&pubkey, bincode::config::standard()).unwrap();
-
-    let privkey_serde = bincode::deserialize::<CMZPrivkey<RistrettoPoint>>(&privkey_bytes).unwrap();
-    let pubkey_serde = bincode::deserialize::<CMZPubkey<RistrettoPoint>>(&pubkey_bytes).unwrap();
+    let privkey_bytes = bincode::serde::encode_to_vec(&privkey, bincode::config::legacy()).unwrap();
+    let pubkey_bytes = bincode::serde::encode_to_vec(&pubkey, bincode::config::legacy()).unwrap();
+
+    let privkey_serde = bincode::serde::decode_from_slice::<
+        CMZPrivkey<RistrettoPoint>,
+        bincode::config::Configuration,
+    >(&privkey_bytes, bincode::config::legacy().with_no_limit())
+    .unwrap()
+    .0;
+    let pubkey_serde = bincode::serde::decode_from_slice::<
+        CMZPubkey<RistrettoPoint>,
+        bincode::config::Configuration,
+    >(&pubkey_bytes, bincode::config::legacy())
+    .unwrap()
+    .0;
 
     assert!(privkey == privkey_serde);
     assert!(pubkey == pubkey_serde);
 
     let mut basic_cred = Basic::using_privkey(&privkey_serde);
 
-    let basic_cred_bytes = bincode::encode_to_vec(&basic_cred).unwrap();
+    let basic_cred_bytes =
+        bincode::serde::encode_to_vec(&basic_cred, bincode::config::legacy()).unwrap();
 
     println!("{:#?}", basic_cred);