diff --git a/packages/wasm-mps/Cargo.lock b/packages/wasm-mps/Cargo.lock
index 97736688008..1b39ca8f69f 100644
--- a/packages/wasm-mps/Cargo.lock
+++ b/packages/wasm-mps/Cargo.lock
@@ -31,12 +31,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
-name = "bincode"
-version = "1.3.3"
+name = "bincode-next"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+checksum = "1d6626829353ae29293be5c86f42de5f0468bc758af074b0c7d08f07e538ccbc"
 dependencies = [
+ "bincode_derive-next",
+ "pastey",
+ "rapidhash",
  "serde",
+ "unty-next",
+]
+
+[[package]]
+name = "bincode_derive-next"
+version = "3.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409532b1da3be643427e49c2f79e0c47d445f695e1b028270d9e80e9044d7d1c"
+dependencies = [
+ "virtue-next",
 ]
 
 [[package]]
@@ -512,6 +525,12 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "pastey"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
+
 [[package]]
 name = "pkcs8"
 version = "0.10.2"
@@ -596,6 +615,15 @@ dependencies = [
  "getrandom",
 ]
 
+[[package]]
+name = "rapidhash"
+version = "4.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e48930979c155e2f33aa36ab3119b5ee81332beb6482199a8ecd6029b80b59"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "ripemd"
 version = "0.1.3"
@@ -878,12 +906,24 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "unty-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16062d030850f35054e37746427b9febb74a2f24c9c6dd6fa2d0c13c5f53221e"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "virtue-next"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d5208a9710a6ca1c2da0d64289a5dcca13deb05afdedf651f4e11bcd9fc53eb"
+
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
@@ -939,7 +979,7 @@ dependencies = [
 name = "wasm-mps"
 version = "0.1.0"
 dependencies = [
- "bincode",
+ "bincode-next",
  "crypto_box",
  "ed25519-dalek",
  "getrandom",
diff --git a/packages/wasm-mps/Cargo.toml b/packages/wasm-mps/Cargo.toml
index 9d6c435e563..f004edde1d6 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 = { package = "bincode-next", version = "3.1.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