Skip to content

Commit 5b86e98

Browse files
johnoliverdriscolljohnoliverdriscoll
committed
feat(wasm-mps): use bincode-next for serialization
Ticket: HSM-394
1 parent c744b64 commit 5b86e98

3 files changed

Lines changed: 118 additions & 33 deletions

File tree

‎packages/wasm-mps/Cargo.lock‎

Lines changed: 44 additions & 4 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎packages/wasm-mps/Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ crate-type = ["cdylib"]
1313
all = "warn"
1414

1515
[dependencies]
16-
bincode = "1.3"
16+
bincode = { package = "bincode-next", version = "3.1.1", features = ["serde"] }
1717
crypto_box = "0.9"
1818
getrandom = { version = "0.2", features = ["js"] }
1919
js-sys = "0.3"

‎packages/wasm-mps/src/lib.rs‎

Lines changed: 73 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -189,8 +189,10 @@ mod mps {
189189
};
190190

191191
Ok(MsgState {
192-
msg: bincode::serialize(&msg1).map_err(|_| MpsError::SerializationError)?,
193-
state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
192+
msg: bincode::serde::encode_to_vec(msg1, bincode::config::standard())
193+
.map_err(|_| MpsError::SerializationError)?,
194+
state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
195+
.map_err(|_| MpsError::SerializationError)?,
194196
})
195197
}
196198

@@ -227,13 +229,23 @@ mod mps {
227229
{
228230
// Parse state
229231
let state: DkgStateR1<G> =
230-
bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
232+
bincode::serde::decode_from_slice(state, bincode::config::standard())
233+
.map(|(v, _)| v)
234+
.map_err(|_| MpsError::DeserializationError)?;
231235

232236
// Parse messages
233-
let i0_msg1: KeygenMsg1 = bincode::deserialize(round1_messages[0].as_slice())
234-
.map_err(|_| MpsError::DeserializationError)?;
235-
let i1_msg1: KeygenMsg1 = bincode::deserialize(round1_messages[1].as_slice())
236-
.map_err(|_| MpsError::DeserializationError)?;
237+
let i0_msg1: KeygenMsg1 = bincode::serde::decode_from_slice(
238+
round1_messages[0].as_slice(),
239+
bincode::config::standard(),
240+
)
241+
.map(|(v, _)| v)
242+
.map_err(|_| MpsError::DeserializationError)?;
243+
let i1_msg1: KeygenMsg1 = bincode::serde::decode_from_slice(
244+
round1_messages[1].as_slice(),
245+
bincode::config::standard(),
246+
)
247+
.map(|(v, _)| v)
248+
.map_err(|_| MpsError::DeserializationError)?;
237249
let msgs = vec![i0_msg1, i1_msg1, state.msg];
238250

239251
// Process all round0 messages together
@@ -249,8 +261,10 @@ mod mps {
249261
};
250262

251263
Ok(MsgState {
252-
msg: bincode::serialize(&msg2).map_err(|_| MpsError::SerializationError)?,
253-
state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
264+
msg: bincode::serde::encode_to_vec(&msg2, bincode::config::standard())
265+
.map_err(|_| MpsError::SerializationError)?,
266+
state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
267+
.map_err(|_| MpsError::SerializationError)?,
254268
})
255269
}
256270

@@ -280,14 +294,24 @@ mod mps {
280294
G::Scalar: ScalarReduce<[u8; 32]> + Serializable,
281295
{
282296
// Deserialize round2 messages from other parties
283-
let i0_msg2: KeygenMsg2<G> = bincode::deserialize(round2_messages[0].as_slice())
284-
.map_err(|_| MpsError::DeserializationError)?;
285-
let i1_msg2: KeygenMsg2<G> = bincode::deserialize(round2_messages[1].as_slice())
286-
.map_err(|_| MpsError::DeserializationError)?;
297+
let i0_msg2: KeygenMsg2<G> = bincode::serde::decode_from_slice(
298+
round2_messages[0].as_slice(),
299+
bincode::config::standard(),
300+
)
301+
.map(|(v, _)| v)
302+
.map_err(|_| MpsError::DeserializationError)?;
303+
let i1_msg2: KeygenMsg2<G> = bincode::serde::decode_from_slice(
304+
round2_messages[1].as_slice(),
305+
bincode::config::standard(),
306+
)
307+
.map(|(v, _)| v)
308+
.map_err(|_| MpsError::DeserializationError)?;
287309

288310
// Deserialize state
289311
let state: DkgStateR2<G> =
290-
bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
312+
bincode::serde::decode_from_slice(state, bincode::config::standard())
313+
.map(|(v, _)| v)
314+
.map_err(|_| MpsError::DeserializationError)?;
291315

292316
// Generate share
293317
let share = state
@@ -310,7 +334,8 @@ mod mps {
310334
let state = rem_prefix("mps-ed25519-dkg-round2-state$", &state.to_vec())?;
311335
let share = internal_dkg_round2_process::<EdwardsPoint>(&[i0_msg2, i1_msg2], &state)?;
312336
Ok(Share {
313-
share: bincode::serialize(&share).map_err(|_| MpsError::SerializationError)?,
337+
share: bincode::serde::encode_to_vec(&share, bincode::config::standard())
338+
.map_err(|_| MpsError::SerializationError)?,
314339
pk: share.public_key.compress().to_bytes(),
315340
chaincode: share.root_chain_code,
316341
})
@@ -331,8 +356,10 @@ mod mps {
331356
};
332357

333358
Ok(MsgState {
334-
msg: bincode::serialize(&msg1).map_err(|_| MpsError::SerializationError)?,
335-
state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
359+
msg: bincode::serde::encode_to_vec(&msg1, bincode::config::standard())
360+
.map_err(|_| MpsError::SerializationError)?,
361+
state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
362+
.map_err(|_| MpsError::SerializationError)?,
336363
})
337364
}
338365

@@ -347,7 +374,9 @@ mod mps {
347374
) -> Result<MsgState, MpsError> {
348375
// Deserialize share
349376
let keyshare: Keyshare<EdwardsPoint> =
350-
bincode::deserialize(share).map_err(|_| MpsError::DeserializationError)?;
377+
bincode::serde::decode_from_slice(share, bincode::config::standard())
378+
.map(|(v, _)| v)
379+
.map_err(|_| MpsError::DeserializationError)?;
351380

352381
// Create signer party
353382
let p0 = SignerParty::<DsgR0, EdwardsPoint>::new_with_format::<_, Bip32Public>(
@@ -377,11 +406,15 @@ mod mps {
377406
{
378407
// Parse state
379408
let state: DsgStateR1<G> =
380-
bincode::deserialize(state).map_err(|_| MpsError::DeserializationError)?;
409+
bincode::serde::decode_from_slice(state, bincode::config::standard())
410+
.map(|(v, _)| v)
411+
.map_err(|_| MpsError::DeserializationError)?;
381412

382413
// Parse messages
383414
let i0_msg1: SignMsg1 =
384-
bincode::deserialize(round1_message).map_err(|_| MpsError::DeserializationError)?;
415+
bincode::serde::decode_from_slice(round1_message, bincode::config::standard())
416+
.map(|(v, _)| v)
417+
.map_err(|_| MpsError::DeserializationError)?;
385418
let msgs = vec![i0_msg1, state.msg];
386419

387420
// Process all round1 messages together
@@ -397,8 +430,10 @@ mod mps {
397430
};
398431

399432
Ok(MsgState {
400-
msg: bincode::serialize(&msg2).map_err(|_| MpsError::SerializationError)?,
401-
state: bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
433+
msg: bincode::serde::encode_to_vec(&msg2, bincode::config::standard())
434+
.map_err(|_| MpsError::SerializationError)?,
435+
state: bincode::serde::encode_to_vec(&state, bincode::config::standard())
436+
.map_err(|_| MpsError::SerializationError)?,
402437
})
403438
}
404439

@@ -436,11 +471,15 @@ mod mps {
436471

437472
// Parse state
438473
let state: DsgStateR2<EdwardsPoint> =
439-
bincode::deserialize(&state).map_err(|_| MpsError::DeserializationError)?;
474+
bincode::serde::decode_from_slice(&state, bincode::config::standard())
475+
.map(|(v, _)| v)
476+
.map_err(|_| MpsError::DeserializationError)?;
440477

441478
// Parse messages
442479
let i0_msg2: SignMsg2<EdwardsPoint> =
443-
bincode::deserialize(&round2_message).map_err(|_| MpsError::DeserializationError)?;
480+
bincode::serde::decode_from_slice(&round2_message, bincode::config::standard())
481+
.map(|(v, _)| v)
482+
.map_err(|_| MpsError::DeserializationError)?;
444483
let msgs = vec![i0_msg2, state.msg];
445484

446485
// Process all round2 messages together
@@ -461,11 +500,13 @@ mod mps {
461500
Ok(MsgState {
462501
msg: add_prefix(
463502
"mps-ed25519-dsg-round3-message$",
464-
&bincode::serialize(&msg3).map_err(|_| MpsError::SerializationError)?,
503+
&bincode::serde::encode_to_vec(&msg3, bincode::config::standard())
504+
.map_err(|_| MpsError::SerializationError)?,
465505
),
466506
state: add_prefix(
467507
"mps-ed25519-dsg-round3-state$",
468-
&bincode::serialize(&state).map_err(|_| MpsError::SerializationError)?,
508+
&bincode::serde::encode_to_vec(&state, bincode::config::standard())
509+
.map_err(|_| MpsError::SerializationError)?,
469510
),
470511
})
471512
}
@@ -484,11 +525,15 @@ mod mps {
484525

485526
// Parse state
486527
let state: DsgStateR3<EdwardsPoint> =
487-
bincode::deserialize(&state).map_err(|_| MpsError::DeserializationError)?;
528+
bincode::serde::decode_from_slice(&state, bincode::config::standard())
529+
.map(|(v, _)| v)
530+
.map_err(|_| MpsError::DeserializationError)?;
488531

489532
// Parse messages
490533
let i0_msg3: SignMsg3<EdwardsPoint> =
491-
bincode::deserialize(&round3_message).map_err(|_| MpsError::DeserializationError)?;
534+
bincode::serde::decode_from_slice(&round3_message, bincode::config::standard())
535+
.map(|(v, _)| v)
536+
.map_err(|_| MpsError::DeserializationError)?;
492537
let msgs = vec![i0_msg3, state.msg];
493538

494539
// Process all round2 messages together

0 commit comments

Comments
 (0)