fix(stm): update 'bincode' dependency to '2.0'

Author: jpraynaud

Cargo.lock

@@ -45,7 +45,7 @@ num-traits = { version = "0.2.19", optional = true }
 rug = { version = "1.27.0", optional = true }
 
 [dev-dependencies]
-bincode = "1.3.3"
+bincode = { version = "2.0.1", features = ["serde"] }
 criterion = { version = "0.6.0", features = ["html_reports"] }
 num-bigint = "0.4.6"
 num-rational = "0.4.2"

mithril-stm/Cargo.toml

@@ -223,12 +223,12 @@ mod tests {
             assert_eq!(vkpop, vkpop2);
 
             // Now we test serde
-            let encoded = bincode::serialize(&vk).unwrap();
+            let encoded = bincode::serde::encode_to_vec(vk, bincode::config::legacy()).unwrap();
             assert_eq!(encoded, vk_bytes);
-            let decoded: VerificationKey = bincode::deserialize(&encoded).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<VerificationKey,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(vk, decoded);
-            let encoded = bincode::serialize(&vkpop).unwrap();
-            let decoded: VerificationKeyPoP = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(vkpop, bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<VerificationKeyPoP,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(vkpop, decoded);
         }
 
@@ -241,12 +241,12 @@ mod tests {
             assert_eq!(sk, sk2);
 
             // Now we test serde
-            let encoded = bincode::serialize(&sk).unwrap();
-            let decoded: SigningKey = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(&sk, bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<SigningKey,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(sk, decoded);
 
             // See that it is consistent with raw serialisation
-            let decoded_bytes: SigningKey = bincode::deserialize(&sk_bytes).unwrap();
+            let (decoded_bytes,_) = bincode::serde::decode_from_slice::<SigningKey,_>(&sk_bytes, bincode::config::legacy()).unwrap();
             assert_eq!(sk, decoded_bytes);
         }
 

mithril-stm/src/bls_multi_signature/mod.rs

@@ -260,16 +260,17 @@ mod tests {
                 let deserialised = Path::from_bytes(&bytes).unwrap();
                 assert!(t.to_commitment().check(&values[i], &deserialised).is_ok());
 
-                let encoded = bincode::serialize(&pf).unwrap();
-                let decoded: Path<Blake2b<U32>> = bincode::deserialize(&encoded).unwrap();
+                let encoded = bincode::serde::encode_to_vec(&pf, bincode::config::legacy()).unwrap();
+                let (decoded,_) = bincode::serde::decode_from_slice::<Path<Blake2b<U32>>,_>(&encoded, bincode::config::legacy()).unwrap();
                 assert!(t.to_commitment().check(&values[i], &decoded).is_ok());
             })
         }
 
         #[test]
         fn test_bytes_tree_commitment((t, values) in arb_tree(5)) {
-            let encoded = bincode::serialize(&t.to_commitment()).unwrap();
-            let decoded: MerkleTreeCommitment::<Blake2b<U32>> = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(t.to_commitment(), bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<MerkleTreeCommitment<Blake2b<U32>>,_>(&encoded, bincode::config::legacy()).unwrap();
+
             let tree_commitment = MerkleTree::<Blake2b<U32>>::create(&values).to_commitment();
             assert_eq!(tree_commitment.root, decoded.root);
         }
@@ -281,15 +282,15 @@ mod tests {
             let tree = MerkleTree::<Blake2b<U32>>::create(&values);
             assert_eq!(tree.nodes, deserialised.nodes);
 
-            let encoded = bincode::serialize(&t).unwrap();
-            let decoded: MerkleTree::<Blake2b<U32>> = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(&t, bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<MerkleTree<Blake2b<U32>>,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(tree.nodes, decoded.nodes);
         }
 
         #[test]
         fn test_bytes_tree_commitment_batch_compat((t, values) in arb_tree(5)) {
-            let encoded = bincode::serialize(&t.to_commitment_batch_compat()).unwrap();
-            let decoded: MerkleTreeCommitmentBatchCompat::<Blake2b<U32>> = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(t.to_commitment_batch_compat(), bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<MerkleTreeCommitmentBatchCompat<Blake2b<U32>>,_>(&encoded, bincode::config::legacy()).unwrap();
             let tree_commitment = MerkleTree::<Blake2b<U32>>::create(&values).to_commitment_batch_compat();
             assert_eq!(tree_commitment.root, decoded.root);
             assert_eq!(tree_commitment.get_nr_leaves(), decoded.get_nr_leaves());
@@ -379,8 +380,8 @@ mod tests {
             let deserialized = BatchPath::from_bytes(bytes).unwrap();
             assert!(t.to_commitment_batch_compat().check(&batch_values, &deserialized).is_ok());
 
-            let encoded = bincode::serialize(&bp).unwrap();
-            let decoded: BatchPath<Blake2b<U32>> = bincode::deserialize(&encoded).unwrap();
+            let encoded = bincode::serde::encode_to_vec(&bp, bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<BatchPath<Blake2b<U32>>,_>(&encoded, bincode::config::legacy()).unwrap();
             assert!(t.to_commitment_batch_compat().check(&batch_values, &decoded).is_ok());
         }
     }

mithril-stm/src/merkle_tree/tree.rs

@@ -1195,8 +1195,8 @@ mod tests {
             let bytes = initializer.to_bytes();
             assert!(StmInitializer::from_bytes(&bytes).is_ok());
 
-            let bytes = bincode::serialize(&initializer).unwrap();
-            assert!(bincode::deserialize::<StmInitializer>(&bytes).is_ok())
+            let bytes = bincode::serde::encode_to_vec(&initializer, bincode::config::legacy()).unwrap();
+            assert!(bincode::serde::decode_from_slice::<StmInitializer,_>(&bytes, bincode::config::legacy()).is_ok())
         }
 
         #[test]
@@ -1211,8 +1211,8 @@ mod tests {
                 let sig_deser = StmSig::from_bytes::<D>(&bytes).unwrap();
                 assert!(sig_deser.verify(&params, &ps[0].get_vk(), &ps[0].get_stake(), &avk, &msg).is_ok());
 
-                let encoded = bincode::serialize(&sig).unwrap();
-                let decoded: StmSig = bincode::deserialize(&encoded).unwrap();
+                let encoded = bincode::serde::encode_to_vec(&sig, bincode::config::legacy()).unwrap();
+                let (decoded,_) = bincode::serde::decode_from_slice::<StmSig,_>(&encoded, bincode::config::legacy()).unwrap();
                 assert!(decoded.verify(&params, &ps[0].get_vk(), &ps[0].get_stake(), &avk, &msg).is_ok());
             }
         }
@@ -1232,8 +1232,8 @@ mod tests {
                     let aggr2 = StmAggrSig::from_bytes(&bytes).unwrap();
                     assert!(aggr2.verify(&msg, &clerk.compute_avk(), &params).is_ok());
 
-                    let encoded = bincode::serialize(&aggr).unwrap();
-                    let decoded: StmAggrSig::<D> = bincode::deserialize(&encoded).unwrap();
+                    let encoded = bincode::serde::encode_to_vec(&aggr, bincode::config::legacy()).unwrap();
+                    let (decoded,_) = bincode::serde::decode_from_slice::<StmAggrSig<D>,_>(&encoded, bincode::config::legacy()).unwrap();
                     assert!(decoded.verify(&msg, &clerk.compute_avk(), &params).is_ok());
             }
         }