diff --git a/packages/wasm-mps/Cargo.lock b/packages/wasm-mps/Cargo.lock
index 97736688008..d8347659c54 100644
--- a/packages/wasm-mps/Cargo.lock
+++ b/packages/wasm-mps/Cargo.lock
@@ -32,11 +32,22 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
 name = "bincode"
-version = "1.3.3"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
 dependencies = [
+ "bincode_derive",
  "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
 ]
 
 [[package]]
@@ -878,12 +889,24 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
diff --git a/packages/wasm-mps/Cargo.toml b/packages/wasm-mps/Cargo.toml
index 9d6c435e563..b5f5e43e3cb 100644
--- a/packages/wasm-mps/Cargo.toml
+++ b/packages/wasm-mps/Cargo.toml
@@ -13,7 +13,7 @@ crate-type = ["cdylib"]
 all = "warn"
 
 [dependencies]
-bincode = "1.3"
+bincode = { version = "2.0.1", features = ["serde"] }
 crypto_box = "0.9"
 getrandom = { version = "0.2", features = ["js"] }
 js-sys = "0.3"
diff --git a/packages/wasm-mps/src/lib.rs b/packages/wasm-mps/src/lib.rs
index 4d9af3ecbfc..5e844c74477 100644
--- a/packages/wasm-mps/src/lib.rs
+++ b/packages/wasm-mps/src/lib.rs
@@ -189,8 +189,10 @@ mod mps {
         };
 
         Ok(MsgState {
-            msg: bincode::serialize(&msg1).map_err(|_| MpsError::SerializationError)?,
-            state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
+            msg: bincode::serde::encode_to_vec(msg1, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
+            state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
         })
     }
 
@@ -227,13 +229,23 @@ mod mps {
     {
         // Parse state
         let state: DkgStateR1<G> =
-            bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(state, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Parse messages
-        let i0_msg1: KeygenMsg1 = bincode::deserialize(round1_messages[0].as_slice())
-            .map_err(|_| MpsError::DeserializationError)?;
-        let i1_msg1: KeygenMsg1 = bincode::deserialize(round1_messages[1].as_slice())
-            .map_err(|_| MpsError::DeserializationError)?;
+        let i0_msg1: KeygenMsg1 = bincode::serde::decode_from_slice(
+            round1_messages[0].as_slice(),
+            bincode::config::standard(),
+        )
+        .map(|(v, _)| v)
+        .map_err(|_| MpsError::DeserializationError)?;
+        let i1_msg1: KeygenMsg1 = bincode::serde::decode_from_slice(
+            round1_messages[1].as_slice(),
+            bincode::config::standard(),
+        )
+        .map(|(v, _)| v)
+        .map_err(|_| MpsError::DeserializationError)?;
         let msgs = vec![i0_msg1, i1_msg1, state.msg];
 
         // Process all round0 messages together
@@ -249,8 +261,10 @@ mod mps {
         };
 
         Ok(MsgState {
-            msg: bincode::serialize(&msg2).map_err(|_| MpsError::SerializationError)?,
-            state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
+            msg: bincode::serde::encode_to_vec(&msg2, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
+            state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
         })
     }
 
@@ -280,14 +294,24 @@ mod mps {
         G::Scalar: ScalarReduce<[u8; 32]> + Serializable,
     {
         // Deserialize round2 messages from other parties
-        let i0_msg2: KeygenMsg2<G> = bincode::deserialize(round2_messages[0].as_slice())
-            .map_err(|_| MpsError::DeserializationError)?;
-        let i1_msg2: KeygenMsg2<G> = bincode::deserialize(round2_messages[1].as_slice())
-            .map_err(|_| MpsError::DeserializationError)?;
+        let i0_msg2: KeygenMsg2<G> = bincode::serde::decode_from_slice(
+            round2_messages[0].as_slice(),
+            bincode::config::standard(),
+        )
+        .map(|(v, _)| v)
+        .map_err(|_| MpsError::DeserializationError)?;
+        let i1_msg2: KeygenMsg2<G> = bincode::serde::decode_from_slice(
+            round2_messages[1].as_slice(),
+            bincode::config::standard(),
+        )
+        .map(|(v, _)| v)
+        .map_err(|_| MpsError::DeserializationError)?;
 
         // Deserialize state
         let state: DkgStateR2<G> =
-            bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(state, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Generate share
         let share = state
@@ -310,7 +334,8 @@ mod mps {
         let state = rem_prefix("mps-ed25519-dkg-round2-state$", &state.to_vec())?;
         let share = internal_dkg_round2_process::<EdwardsPoint>(&[i0_msg2, i1_msg2], &state)?;
         Ok(Share {
-            share: bincode::serialize(&share).map_err(|_| MpsError::SerializationError)?,
+            share: bincode::serde::encode_to_vec(&share, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
             pk: share.public_key.compress().to_bytes(),
             chaincode: share.root_chain_code,
         })
@@ -331,8 +356,10 @@ mod mps {
         };
 
         Ok(MsgState {
-            msg: bincode::serialize(&msg1).map_err(|_| MpsError::SerializationError)?,
-            state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
+            msg: bincode::serde::encode_to_vec(&msg1, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
+            state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
         })
     }
 
@@ -347,7 +374,9 @@ mod mps {
     ) -> Result<MsgState, MpsError> {
         // Deserialize share
         let keyshare: Keyshare<EdwardsPoint> =
-            bincode::deserialize(share).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(share, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Create signer party
         let p0 = SignerParty::<DsgR0, EdwardsPoint>::new_with_format::<_, Bip32Public>(
@@ -377,11 +406,15 @@ mod mps {
     {
         // Parse state
         let state: DsgStateR1<G> =
-            bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(state, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Parse messages
         let i0_msg1: SignMsg1 =
-            bincode::deserialize(round1_message).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(round1_message, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
         let msgs = vec![i0_msg1, state.msg];
 
         // Process all round1 messages together
@@ -397,8 +430,10 @@ mod mps {
         };
 
         Ok(MsgState {
-            msg: bincode::serialize(&msg2).map_err(|_| MpsError::SerializationError)?,
-            state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
+            msg: bincode::serde::encode_to_vec(&msg2, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
+            state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
+                .map_err(|_| MpsError::SerializationError)?,
         })
     }
 
@@ -436,11 +471,15 @@ mod mps {
 
         // Parse state
         let state: DsgStateR2<EdwardsPoint> =
-            bincode::deserialize(&state).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(&state, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Parse messages
         let i0_msg2: SignMsg2<EdwardsPoint> =
-            bincode::deserialize(&round2_message).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(&round2_message, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
         let msgs = vec![i0_msg2, state.msg];
 
         // Process all round2 messages together
@@ -461,11 +500,13 @@ mod mps {
         Ok(MsgState {
             msg: add_prefix(
                 "mps-ed25519-dsg-round3-message$",
-                &bincode::serialize(&msg3).map_err(|_| MpsError::SerializationError)?,
+                &bincode::serde::encode_to_vec(&msg3, bincode::config::standard())
+                    .map_err(|_| MpsError::SerializationError)?,
             ),
             state: add_prefix(
                 "mps-ed25519-dsg-round3-state$",
-                &bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
+                &bincode::serde::encode_to_vec(&state, bincode::config::standard())
+                    .map_err(|_| MpsError::SerializationError)?,
             ),
         })
     }
@@ -484,11 +525,15 @@ mod mps {
 
         // Parse state
         let state: DsgStateR3<EdwardsPoint> =
-            bincode::deserialize(&state).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(&state, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
 
         // Parse messages
         let i0_msg3: SignMsg3<EdwardsPoint> =
-            bincode::deserialize(&round3_message).map_err(|_| MpsError::DeserializationError)?;
+            bincode::serde::decode_from_slice(&round3_message, bincode::config::standard())
+                .map(|(v, _)| v)
+                .map_err(|_| MpsError::DeserializationError)?;
         let msgs = vec![i0_msg3, state.msg];
 
         // Process all round2 messages together