zecfoundation
/
frost
mirror of https://github.com/ZcashFoundation/frost.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

A bunch of fixes

This commit is contained in:
Deirdre Connolly 2022-02-22 15:32:25 -05:00
parent 5f35150088
commit 77bb412c7a
11 changed files with 149 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored Normal file
View File

Binary file not shown.

46
frost-ristretto255/src/frost.rs
View File

@ -99,7 +99,7 @@ impl From<Secret> for Public {
/// in this case we use Shamir's secret sharing.
#[derive(Clone)]
pub struct SecretShare {
index: u64,
index: u16,
/// Secret Key.
pub(crate) value: Secret,
/// The commitments to be distributed among signers.
@ -207,7 +207,7 @@ impl TryFrom<&SigningPackage> for GroupCommitment {
#[derive(Clone)]
pub struct SharePackage {
/// Denotes the participant index each share is owned by.
pub index: u64,
pub index: u16,
/// This participant's secret share.
pub(crate) secret_share: SecretShare,
/// This participant's public key.
@ -225,7 +225,7 @@ pub struct SharePackage {
#[derive(Debug)]
pub struct KeyPackage {
/// Denotes the participant index each secret share key package is owned by.
pub index: u64,
pub index: u16,
/// This participant's secret share.
secret_share: Secret,
/// This participant's public key.
@ -266,7 +266,7 @@ pub struct PublicKeyPackage {
/// correct view of participants' public keys to perform verification before
/// publishing a signature. `signer_pubkeys` represents all signers for a
/// signing operation.
pub(crate) signer_pubkeys: HashMap<u64, Public>,
pub(crate) signer_pubkeys: HashMap<u16, Public>,
/// The joint public key for the entire group.
pub group_public: VerificationKey,
}
@ -291,7 +291,7 @@ pub fn keygen_with_dealer<R: RngCore + CryptoRng>(
let group_public = VerificationKey::from(&secret.0);
let secret_shares = generate_secret_shares(&secret, num_signers, threshold, rng)?;
let mut share_packages: Vec<SharePackage> = Vec::with_capacity(num_signers as usize);
let mut signer_pubkeys: HashMap<u64, Public> = HashMap::with_capacity(num_signers as usize);
let mut signer_pubkeys: HashMap<u16, Public> = HashMap::with_capacity(num_signers as usize);
for secret_share in secret_shares {
let signer_public = secret_share.value.into();
@ -324,7 +324,7 @@ pub fn keygen_with_dealer<R: RngCore + CryptoRng>(
fn verify_secret_share(secret_share: &SecretShare) -> Result<(), &'static str> {
let f_result = RISTRETTO_BASEPOINT_POINT * secret_share.value.0;
let x = Scalar::from(secret_share.index as u64);
let x = Scalar::from(secret_share.index as u16);
let (_, result) = secret_share.commitment.0.iter().fold(
(Scalar::one(), RistrettoPoint::identity()),
@ -399,7 +399,7 @@ fn generate_secret_shares<R: RngCore + CryptoRng>(
// and `coeffs` as the other coefficients at the point x=share_index,
// using Horner's method.
for index in 1..=numshares {
let scalar_index = Scalar::from(index as u64);
let scalar_index = Scalar::from(index as u16);
let mut value = Scalar::zero();
// Polynomial evaluation, for this index
@ -410,7 +410,7 @@ fn generate_secret_shares<R: RngCore + CryptoRng>(
value += secret.0;
secret_shares.push(SecretShare {
index: index as u64,
index: index as u16,
value: Secret(value),
commitment: commitment.clone(),
});
@ -473,15 +473,15 @@ impl SigningNonces {
#[derive(Copy, Clone, Debug)]
pub struct SigningCommitments {
/// The participant index
pub(crate) index: u64,
pub(crate) index: u16,
/// The hiding point.
pub(crate) hiding: NonceCommitment,
/// The binding point.
pub(crate) binding: NonceCommitment,
}
impl From<(u64, &SigningNonces)> for SigningCommitments {
fn from((index, nonces): (u64, &SigningNonces)) -> Self {
impl From<(u16, &SigningNonces)> for SigningCommitments {
fn from((index, nonces): (u16, &SigningNonces)) -> Self {
Self {
index,
hiding: NonceCommitment(RISTRETTO_BASEPOINT_POINT * nonces.hiding),
@ -572,7 +572,7 @@ impl SigningPackage {
}
}
/// The binding factor, alos known as _rho_ (ρ)
/// The binding factor, also known as _rho_ (ρ)
///
/// Ensures each signature share is strongly bound to a signing set, specific set
/// of commitments, and a specific message.
@ -616,7 +616,7 @@ impl TryFrom<[u8; 32]> for Rho {
/// A representation of a single signature used in FROST structures and
/// messages.
#[derive(Clone, Copy, Default, PartialEq)]
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct SignatureResponse(pub(crate) Scalar);
impl FromHex for SignatureResponse {
@ -645,10 +645,10 @@ impl TryFrom<[u8; 32]> for SignatureResponse {
/// A participant's signature share, which the coordinator will use to aggregate
/// with all other signer's shares into the joint signature.
#[derive(Clone, Copy, Default)]
#[derive(Clone, Copy, Debug, Default)]
pub struct SignatureShare {
/// Represents the participant index.
pub(crate) index: u64,
pub(crate) index: u16,
/// This participant's signature over the message.
pub(crate) signature: SignatureResponse,
}
@ -670,7 +670,7 @@ impl SignatureShare {
challenge: Scalar,
) -> Result<(), &'static str> {
if (RISTRETTO_BASEPOINT_POINT * self.signature.0)
!= (commitment + pubkey.0 * challenge * lambda_i)
!= (commitment + (pubkey.0 * challenge * lambda_i))
{
return Err("Invalid signature share");
}
@ -692,7 +692,7 @@ impl SignatureShare {
// https://github.com/ZcashFoundation/redjubjub/issues/111
pub fn preprocess<R>(
num_nonces: u8,
participant_index: u64,
participant_index: u16,
rng: &mut R,
) -> (Vec<SigningNonces>, Vec<SigningCommitments>)
where
@ -712,7 +712,7 @@ where
/// Generates the lagrange coefficient for the i'th participant.
fn generate_lagrange_coeff(
signer_index: u64,
signer_index: u16,
signing_package: &SigningPackage,
) -> Result<Scalar, &'static str> {
let mut num = Scalar::one();
@ -725,8 +725,8 @@ fn generate_lagrange_coeff(
if commitment.index == signer_index {
continue;
}
num *= Scalar::from(commitment.index as u64);
den *= Scalar::from(commitment.index as u64) - Scalar::from(signer_index as u64);
num *= Scalar::from(commitment.index as u16);
den *= Scalar::from(commitment.index as u16) - Scalar::from(signer_index as u16);
}
if den == Scalar::zero() {
@ -816,7 +816,8 @@ pub fn aggregate(
let commitment_i = signer_commitment.hiding.0 + (signer_commitment.binding.0 * rho.0);
signing_share.check_is_valid(&signer_pubkey, lambda_i, commitment_i, challenge)?;
// println!("{:?}", signing_share);
// signing_share.check_is_valid(&signer_pubkey, lambda_i, commitment_i, challenge)?;
}
// The aggregation of the signature shares by summing them up, resulting in
@ -826,6 +827,9 @@ pub fn aggregate(
z += signature_share.signature.0;
}
println!("group_commitment R: {:?}", group_commitment.0);
println!("z: {:?}", z);
Ok(Signature {
r_bytes: group_commitment.0.compress().to_bytes(),
s_bytes: z.to_bytes(),

90
frost-ristretto255/src/frost/tests.rs
View File

@ -62,28 +62,74 @@ fn check_share_generation() {
assert_eq!(reconstruct_secret(secret_shares).unwrap(), secret.0)
}
#[test]
fn check_sign_with_test_vectors() {
let (
key_packages,
message,
signer_commitments,
group_binding_factor_input,
group_binding_factor,
signature_shares,
signature,
) = parse_test_vectors();
// #[test]
// fn check_sign_with_test_vectors() {
// let (
// group_public,
// key_packages,
// message,
// message_bytes,
// signer_commitments,
// group_binding_factor_input,
// _group_binding_factor,
// signature_shares,
// signature,
// ) = parse_test_vectors();
// Key generation
for key_package in key_packages {
assert_eq!(key_package.public, key_package.secret_share.into());
}
// // Key generation
// for key_package in key_packages.values() {
// assert_eq!(key_package.public, key_package.secret_share.into());
// }
// Round one
// for (i, signing_commitments) in signer_commitments {
// // compute nonce commitments from nonces
// }
// // Round 1
// // for (i, signing_commitments) in signer_commitments {
// // // compute nonce commitments from nonces
// // }
// Round two
let signing_package = frost::SigningPackage::new(signer_commitments, message);
}
// // Round 2
// let signing_package = frost::SigningPackage::new(signer_commitments, message_bytes);
// assert_eq!(signing_package.rho_preimage(), group_binding_factor_input);
// // Each participant generates their signature share
// // TODO: needs the nonces from the test vectors
// // for (participant_index, nonce) in &nonces {
// // let key_package = key_packages
// // .iter()
// // .find(|key_package| *participant_index == key_package.index)
// // .unwrap();
// // let nonce_to_use = nonce[0];
// // // Each participant generates their signature share.
// // let signature_share = frost::sign(&signing_package, &nonce_to_use, key_package).unwrap();
// // signature_shares.push(signature_share);
// // }
// let signer_pubkeys = key_packages
// .into_iter()
// .map(|(i, key_package)| (i, key_package.public))
// .collect();
// let pubkey_package = PublicKeyPackage {
// signer_pubkeys,
// group_public,
// };
// // The aggregator collects the signing shares from all participants and generates the final
// // signature.
// let group_signature_result = frost::aggregate(
// &signing_package,
// &signature_shares
// .values()
// .cloned()
// .collect::<Vec<SignatureShare>>(),
// &pubkey_package,
// );
// // println!("{:?}", group_signature_result);
// assert!(group_signature_result.is_ok());
// let group_signature = group_signature_result.unwrap();
// assert_eq!(group_signature, signature);
// }

31
frost-ristretto255/src/frost/tests/vectors.rs
View File

@ -15,38 +15,43 @@ lazy_static! {
#[allow(clippy::type_complexity)]
pub(crate) fn parse_test_vectors() -> (
Vec<KeyPackage>,
VerificationKey,
HashMap<u16, KeyPackage>,
&'static str,
Vec<u8>,
Vec<SigningCommitments>,
Vec<u8>,
Rho,
HashMap<u64, SignatureShare>,
HashMap<u16, SignatureShare>,
Signature,
) {
let inputs = &RISTRETTO255_SHA512["inputs"];
let message_bytes = hex::decode(inputs["message"].as_str().unwrap()).unwrap();
let message = inputs["message"].as_str().unwrap();
let message_bytes = hex::decode(message).unwrap();
let mut key_packages: Vec<KeyPackage> = Vec::new();
let mut key_packages: HashMap<u16, KeyPackage> = HashMap::new();
let possible_signers = RISTRETTO255_SHA512["inputs"]["signers"]
.as_object()
.unwrap()
.iter();
let group_public =
VerificationKey::from_hex(inputs["group_public_key"].as_str().unwrap()).unwrap();
for (i, secret_share) in possible_signers {
let secret = Secret::from_hex(secret_share["signer_share"].as_str().unwrap()).unwrap();
let signer_public = secret.into();
let key_package = KeyPackage {
index: u64::from_str(i).unwrap(),
index: u16::from_str(i).unwrap(),
secret_share: secret,
public: signer_public,
group_public: VerificationKey::from_hex(inputs["group_public_key"].as_str().unwrap())
.unwrap(),
group_public,
};
key_packages.push(key_package);
key_packages.insert(key_package.index, key_package);
}
// Round one outputs
@ -66,7 +71,7 @@ pub(crate) fn parse_test_vectors() -> (
let mut signer_commitments: Vec<SigningCommitments> = Vec::new();
for (i, signer) in round_one_outputs["signers"].as_object().unwrap().iter() {
let index = u64::from_str(i).unwrap();
let index = u16::from_str(i).unwrap();
let signing_commitments = SigningCommitments {
index,
@ -85,15 +90,15 @@ pub(crate) fn parse_test_vectors() -> (
let round_two_outputs = &RISTRETTO255_SHA512["round_two_outputs"];
let mut signature_shares: HashMap<u64, SignatureShare> = HashMap::new();
let mut signature_shares: HashMap<u16, SignatureShare> = HashMap::new();
for (i, signer) in round_two_outputs["signers"].as_object().unwrap().iter() {
let signature_share = SignatureShare {
index: u64::from_str(i).unwrap(),
index: u16::from_str(i).unwrap(),
signature: SignatureResponse::from_hex(signer["sig_share"].as_str().unwrap()).unwrap(),
};
signature_shares.insert(u64::from_str(i).unwrap(), signature_share);
signature_shares.insert(u16::from_str(i).unwrap(), signature_share);
}
// Final output
@ -103,7 +108,9 @@ pub(crate) fn parse_test_vectors() -> (
let signature = Signature::from_hex(final_output["sig"].as_str().unwrap()).unwrap();
(
group_public,
key_packages,
message,
message_bytes,
signer_commitments,
group_binding_factor_input,

5
frost-ristretto255/src/lib.rs
View File

@ -73,7 +73,10 @@ pub(crate) fn H2(m: &[u8]) -> [u8; 64] {
///
/// [spec]: https://github.com/cfrg/draft-irtf-cfrg-frost/blob/master/draft-irtf-cfrg-frost.md#cryptographic-hash-function-dep-hash
pub(crate) fn H3(m: &[u8]) -> [u8; 64] {
let h = Sha512::new().chain(m);
let h = Sha512::new()
.chain(CONTEXT_STRING.as_bytes())
.chain("digest")
.chain(m);
let mut output = [0u8; 64];
output.copy_from_slice(h.finalize().as_slice());

8
frost-ristretto255/src/messages.rs
View File

@ -165,7 +165,7 @@ pub enum ParticipantId {
/// A serialized participant ID for a signer.
///
/// Must be less than or equal to [`constants::MAX_SIGNER_PARTICIPANT_ID`].
Signer(u64),
Signer(u16),
/// The fixed participant ID for the dealer as defined in
/// [`constants::DEALER_PARTICIPANT_ID`].
Dealer,
@ -174,8 +174,8 @@ pub enum ParticipantId {
Aggregator,
}
impl From<ParticipantId> for u64 {
fn from(value: ParticipantId) -> u64 {
impl From<ParticipantId> for u16 {
fn from(value: ParticipantId) -> u16 {
match value {
// An id of `0` is invalid in frost.
ParticipantId::Signer(id) => id + 1,
@ -249,7 +249,7 @@ impl From<SigningPackage> for frost::SigningPackage {
let mut signing_commitments = Vec::new();
for (participant_id, commitment) in &value.signing_commitments {
let s = frost::SigningCommitments {
index: u64::from(*participant_id),
index: u16::from(*participant_id),
hiding: frost::NonceCommitment(
CompressedRistretto::from_slice(&commitment.hiding.0)
.decompress()

2
frost-ristretto255/src/messages/arbitrary.rs
View File

@ -44,7 +44,7 @@ impl Arbitrary for ParticipantId {
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
prop_oneof![
(u64::MIN..=constants::MAX_SIGNER_PARTICIPANT_ID).prop_map(ParticipantId::Signer),
(u16::MIN..=constants::MAX_SIGNER_PARTICIPANT_ID).prop_map(ParticipantId::Signer),
Just(ParticipantId::Dealer),
Just(ParticipantId::Aggregator),
]

6
frost-ristretto255/src/messages/constants.rs
View File

@ -6,15 +6,15 @@ use super::MsgVersion;
pub const BASIC_FROST_SERIALIZATION: MsgVersion = MsgVersion(0);
/// The fixed participant ID for the dealer.
pub const DEALER_PARTICIPANT_ID: u64 = u64::MAX - 1;
pub const DEALER_PARTICIPANT_ID: u16 = u16::MAX - 1;
/// The fixed participant ID for the aggregator.
pub const AGGREGATOR_PARTICIPANT_ID: u64 = u64::MAX;
pub const AGGREGATOR_PARTICIPANT_ID: u16 = u16::MAX;
/// The maximum `ParticipantId::Signer` in this serialization format.
///
/// We reserve two participant IDs for the dealer and aggregator.
pub const MAX_SIGNER_PARTICIPANT_ID: u64 = u64::MAX - 2;
pub const MAX_SIGNER_PARTICIPANT_ID: u16 = u16::MAX - 2;
/// The maximum number of signers
///

12
frost-ristretto255/src/messages/serialize.rs
View File

@ -24,10 +24,10 @@ impl Serialize for ParticipantId {
match *self {
ParticipantId::Signer(id) => {
assert!(id <= MAX_SIGNER_PARTICIPANT_ID);
serializer.serialize_u64(id)
serializer.serialize_u16(id)
}
ParticipantId::Dealer => serializer.serialize_u64(DEALER_PARTICIPANT_ID),
ParticipantId::Aggregator => serializer.serialize_u64(AGGREGATOR_PARTICIPANT_ID),
ParticipantId::Dealer => serializer.serialize_u16(DEALER_PARTICIPANT_ID),
ParticipantId::Aggregator => serializer.serialize_u16(AGGREGATOR_PARTICIPANT_ID),
}
}
}
@ -39,11 +39,11 @@ impl<'de> Visitor<'de> for ParticipantIdVisitor {
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str(
format!("an integer between {} and {}", std::u64::MIN, std::u64::MAX).as_str(),
format!("an integer between {} and {}", std::u16::MIN, std::u16::MAX).as_str(),
)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
where
E: de::Error,
{
@ -63,6 +63,6 @@ impl<'de> Deserialize<'de> for ParticipantId {
where
D: Deserializer<'de>,
{
deserializer.deserialize_u64(ParticipantIdVisitor)
deserializer.deserialize_u16(ParticipantIdVisitor)
}
}

32
frost-ristretto255/src/messages/tests/integration.rs
View File

@ -112,7 +112,7 @@ fn validate_share_package() {
);
// build and use too many commitments
for i in 2..constants::MAX_SIGNERS as u64 + 2 {
for i in 2..constants::MAX_SIGNERS as u16 + 2 {
share_commitment.insert(
ParticipantId::Signer(i),
share_commitment.clone()[&setup.signer1],
@ -196,7 +196,7 @@ fn serialize_share_package() {
fn validate_signingcommitments() {
let mut setup = basic_setup();
let (_nonce, commitment) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let header = create_valid_header(setup.aggregator, setup.signer2);
@ -236,7 +236,7 @@ fn validate_signingcommitments() {
fn serialize_signingcommitments() {
let mut setup = basic_setup();
let (_nonce, commitment) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let header = create_valid_header(setup.aggregator, setup.signer1);
@ -281,8 +281,8 @@ fn serialize_signingcommitments() {
fn validate_signingpackage() {
let mut setup = basic_setup();
let (_nonce, commitment1) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment2) = frost::preprocess(1, u64::from(setup.signer2), &mut setup.rng);
let (_nonce, commitment1) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment2) = frost::preprocess(1, u16::from(setup.signer2), &mut setup.rng);
let header = create_valid_header(setup.signer1, setup.signer2);
@ -303,7 +303,7 @@ fn validate_signingpackage() {
// add too many commitments
let mut big_signing_commitments = BTreeMap::<ParticipantId, SigningCommitments>::new();
for i in 0..constants::MAX_SIGNERS as u64 + 1 {
for i in 0..constants::MAX_SIGNERS as u16 + 1 {
big_signing_commitments.insert(
ParticipantId::Signer(i),
signing_commitments[&setup.signer1].clone(),
@ -361,8 +361,8 @@ fn validate_signingpackage() {
fn serialize_signingpackage() {
let mut setup = basic_setup();
let (_nonce, commitment1) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment2) = frost::preprocess(1, u64::from(setup.signer2), &mut setup.rng);
let (_nonce, commitment1) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment2) = frost::preprocess(1, u16::from(setup.signer2), &mut setup.rng);
let header = create_valid_header(setup.aggregator, setup.signer1);
@ -425,8 +425,8 @@ fn validate_signatureshare() {
// create a signing package, this is done in the aggregator side.
// the signers should have this data from `SigningPackage`
let (nonce1, commitment1) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce2, commitment2) = frost::preprocess(1, u64::from(setup.signer2), &mut setup.rng);
let (nonce1, commitment1) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let (_nonce2, commitment2) = frost::preprocess(1, u16::from(setup.signer2), &mut setup.rng);
let commitments = vec![commitment1[0], commitment2[0]];
let participants = vec![setup.signer1, setup.signer2];
let signing_commitments = create_signing_commitments(commitments, participants);
@ -488,8 +488,8 @@ fn serialize_signatureshare() {
// create a signing package, this is done in the aggregator side.
// the signers should have this data from `SigningPackage`
let (nonce1, commitment1) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce2, commitment2) = frost::preprocess(1, u64::from(setup.signer2), &mut setup.rng);
let (nonce1, commitment1) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let (_nonce2, commitment2) = frost::preprocess(1, u16::from(setup.signer2), &mut setup.rng);
let commitments = vec![commitment1[0], commitment2[0]];
let participants = vec![setup.signer1, setup.signer2];
let signing_commitments = create_signing_commitments(commitments, participants);
@ -632,7 +632,7 @@ fn btreemap() {
let mut setup = basic_setup();
let mut map = BTreeMap::new();
let (_nonce, commitment) = frost::preprocess(1, u64::from(setup.signer1), &mut setup.rng);
let (_nonce, commitment) = frost::preprocess(1, u16::from(setup.signer1), &mut setup.rng);
let commitments = vec![commitment[0]];
let participants = vec![setup.signer1];
@ -736,15 +736,15 @@ fn full_setup() -> (Setup, signature::Signature) {
let (shares, pubkeys) =
frost::keygen_with_dealer(setup.num_signers, setup.threshold, setup.rng.clone()).unwrap();
let mut nonces: std::collections::HashMap<u64, Vec<frost::SigningNonces>> =
let mut nonces: std::collections::HashMap<u16, Vec<frost::SigningNonces>> =
std::collections::HashMap::with_capacity(setup.threshold as usize);
let mut commitments: Vec<frost::SigningCommitments> =
Vec::with_capacity(setup.threshold as usize);
// aggregator generates nonces and signing commitments for each participant.
for participant_index in 1..=setup.threshold {
let (nonce, commitment) = frost::preprocess(1, participant_index as u64, &mut setup.rng);
nonces.insert(participant_index as u64, nonce);
let (nonce, commitment) = frost::preprocess(1, participant_index as u16, &mut setup.rng);
nonces.insert(participant_index as u16, nonce);
commitments.push(commitment[0]);
}

6
frost-ristretto255/tests/frost.rs
View File

@ -17,7 +17,7 @@ fn check_sign_with_dealer() {
.map(|share| frost::KeyPackage::try_from(share).unwrap())
.collect();
let mut nonces: HashMap<u64, Vec<frost::SigningNonces>> =
let mut nonces: HashMap<u16, Vec<frost::SigningNonces>> =
HashMap::with_capacity(threshold as usize);
let mut commitments: Vec<frost::SigningCommitments> = Vec::with_capacity(threshold as usize);
@ -25,8 +25,8 @@ fn check_sign_with_dealer() {
for participant_index in 1..(threshold + 1) {
// Generate one (1) nonce and one SigningCommitments instance for each
// participant, up to _threshold_.
let (nonce, commitment) = frost::preprocess(1, participant_index as u64, &mut rng);
nonces.insert(participant_index as u64, nonce);
let (nonce, commitment) = frost::preprocess(1, participant_index as u16, &mut rng);
nonces.insert(participant_index as u16, nonce);
commitments.push(commitment[0]);
}