frost-p256 2.0.0

A Schnorr signature scheme over the NIST P-256 curve that supports FROST.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#![cfg(feature = "serialization")]

mod helpers;

use frost_p256::{
    keys::{
        dkg::{round1, round2},
        KeyPackage, PublicKeyPackage, SecretShare,
    },
    round1::{SigningCommitments, SigningNonces},
    round2::SignatureShare,
    SigningPackage,
};

use helpers::samples;
use insta::assert_snapshot;

#[test]
fn check_signing_nonces_postcard_serialization() {
    let nonces = samples::signing_nonces();
    let bytes: Vec<_> = nonces.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(nonces, SigningNonces::deserialize(&bytes).unwrap());
}

#[test]
fn check_signing_commitments_postcard_serialization() {
    let commitments = samples::signing_commitments();
    let bytes: Vec<_> = commitments.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        commitments,
        SigningCommitments::deserialize(&bytes).unwrap()
    );
}

#[test]
fn check_signing_package_postcard_serialization() {
    let signing_package = samples::signing_package();
    let bytes: Vec<_> = signing_package.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        signing_package,
        SigningPackage::deserialize(&bytes).unwrap()
    );
}

#[test]
fn check_signature_share_postcard_serialization() {
    let signature_share = samples::signature_share();
    let bytes = signature_share.serialize();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        signature_share,
        SignatureShare::deserialize(&bytes).unwrap()
    );
}
#[test]
fn check_secret_share_postcard_serialization() {
    let secret_share = samples::secret_share();
    let bytes: Vec<_> = secret_share.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(secret_share, SecretShare::deserialize(&bytes).unwrap());
}

#[test]
fn check_key_package_postcard_serialization() {
    let key_package = samples::key_package();
    let bytes: Vec<_> = key_package.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(key_package, KeyPackage::deserialize(&bytes).unwrap());
}

#[test]
fn check_public_key_package_postcard_serialization() {
    let public_key_package = samples::public_key_package();
    let bytes: Vec<_> = public_key_package.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        public_key_package,
        PublicKeyPackage::deserialize(&bytes).unwrap()
    );
}

#[test]
fn check_round1_package_postcard_serialization() {
    let round1_package = samples::round1_package();
    let bytes: Vec<_> = round1_package.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        round1_package,
        round1::Package::deserialize(&bytes).unwrap()
    );
}

#[test]
fn check_round2_package_postcard_serialization() {
    let round2_package = samples::round2_package();
    let bytes: Vec<_> = round2_package.serialize().unwrap();
    assert_snapshot!(hex::encode(&bytes));
    assert_eq!(
        round2_package,
        round2::Package::deserialize(&bytes).unwrap()
    );
}