vsss_rs/
set.rs

1//! Sets store shares and other data associated with secret sharing operations,
2//! such as splitting, combining, and verifying. Sizes greater than 32 should
3//! probably use `Vec` instead of fixed-size storage because of stack allocations.
4use crate::*;
5use core::{
6    marker::PhantomData,
7    ops::{Deref, DerefMut},
8};
9use generic_array::{ArrayLength, GenericArray};
10use hybrid_array::{Array, ArraySize};
11
12/// Represents a readable data store for secret shares
13pub trait ReadableShareSet<S>: AsRef<[S]>
14where
15    S: Share,
16{
17    /// Convert the given shares into a field element
18    fn combine(&self) -> VsssResult<S::Value> {
19        let mut secret = S::Value::default();
20        self.combine_in_place(&mut secret)?;
21        Ok(secret)
22    }
23
24    /// Convert the given shares into a field element, writing into `out`.
25    fn combine_in_place(&self, out: &mut S::Value) -> VsssResult<()> {
26        let shares = self.as_ref();
27        validate_share_set(shares)?;
28        interpolate_in_place(shares, out)
29    }
30}
31
32/// Validate that a share set has enough shares, non-zero identifiers, and no duplicate identifiers.
33pub fn validate_share_set<S>(shares: &[S]) -> VsssResult<()>
34where
35    S: Share,
36{
37    if shares.len() < 2 {
38        return Err(Error::SharingMinThreshold);
39    }
40    for s in shares {
41        if s.identifier().is_zero().into() {
42            return Err(Error::SharingInvalidIdentifier);
43        }
44    }
45    if dup_checker(shares) {
46        return Err(Error::SharingDuplicateIdentifier);
47    }
48    Ok(())
49}
50
51/// Represents a data store for secret shares
52pub trait WriteableShareSet<S>: ReadableShareSet<S> + AsMut<[S]>
53where
54    S: Share,
55{
56    /// Create a new writable share set
57    fn create(size_hint: usize) -> Self;
58}
59
60impl<S, B: AsRef<[S]>> ReadableShareSet<S> for B where S: Share {}
61
62/// Combine an iterator of owned shares into a secret.
63///
64/// All shares yielded by the iterator are retained until interpolation completes.
65#[cfg(any(feature = "alloc", feature = "std"))]
66pub fn combine_iter<S>(shares: impl IntoIterator<Item = S>) -> VsssResult<S::Value>
67where
68    S: Share,
69{
70    let shares: Vec<_> = shares.into_iter().collect();
71    shares.combine()
72}
73
74/// Combine an iterator of owned shares into a secret, writing into `out`.
75///
76/// All shares yielded by the iterator are retained until interpolation completes.
77#[cfg(any(feature = "alloc", feature = "std"))]
78pub fn combine_iter_in_place<S>(
79    shares: impl IntoIterator<Item = S>,
80    out: &mut S::Value,
81) -> VsssResult<()>
82where
83    S: Share,
84{
85    let shares: Vec<_> = shares.into_iter().collect();
86    shares.combine_in_place(out)
87}
88
89/// Combine exactly `share_count` shares from an asynchronous stream into a secret.
90///
91/// Returns [`Error::NotEnoughShares`] if the stream ends before yielding
92/// `share_count` shares. Items after `share_count` are left in the stream.
93#[cfg(feature = "stream")]
94#[cfg_attr(docsrs, doc(cfg(feature = "stream")))]
95pub async fn combine_stream<S>(
96    share_count: usize,
97    shares: impl futures_core::Stream<Item = S>,
98) -> VsssResult<S::Value>
99where
100    S: Share,
101{
102    if share_count < 2 {
103        return Err(Error::SharingMinThreshold);
104    }
105    let shares = collect_stream_exact(share_count, shares, Error::NotEnoughShares).await?;
106    shares.combine()
107}
108
109/// Combine exactly `share_count` shares from an asynchronous stream, writing into `out`.
110///
111/// Returns [`Error::NotEnoughShares`] if the stream ends before yielding
112/// `share_count` shares. Items after `share_count` are left in the stream.
113#[cfg(feature = "stream")]
114#[cfg_attr(docsrs, doc(cfg(feature = "stream")))]
115pub async fn combine_stream_in_place<S>(
116    share_count: usize,
117    shares: impl futures_core::Stream<Item = S>,
118    out: &mut S::Value,
119) -> VsssResult<()>
120where
121    S: Share,
122{
123    if share_count < 2 {
124        return Err(Error::SharingMinThreshold);
125    }
126    let shares = collect_stream_exact(share_count, shares, Error::NotEnoughShares).await?;
127    shares.combine_in_place(out)
128}
129
130fn interpolate_in_place<S>(shares: &[S], secret: &mut S::Value) -> VsssResult<()>
131where
132    S: Share,
133{
134    *secret = S::Value::default();
135    // Calculate Lagrange interpolation.
136    for (i, x_i) in shares.iter().enumerate() {
137        let mut num = S::Identifier::one();
138        let mut den = S::Identifier::one();
139        for (j, x_j) in shares.iter().enumerate() {
140            if i == j {
141                continue;
142            }
143
144            // x_j / (x_j - x_i) * ...
145            let d = x_j.identifier().as_ref().clone() - x_i.identifier().as_ref().clone();
146            *den.as_mut() *= d;
147            *num.as_mut() *= x_j.identifier().as_ref();
148        }
149
150        let den = den.invert()?;
151        let basis: S::Identifier = (num.as_ref().clone() * den.as_ref()).into();
152        let t = x_i.value().clone() * &basis;
153        *secret.as_mut() += t.as_ref();
154    }
155
156    Ok(())
157}
158
159impl<S, const L: usize> WriteableShareSet<S> for [S; L]
160where
161    S: Share,
162{
163    fn create(_size_hint: usize) -> Self {
164        core::array::from_fn(|_| S::default())
165    }
166}
167
168impl<S, L> WriteableShareSet<S> for GenericArray<S, L>
169where
170    S: Share,
171    L: ArrayLength,
172{
173    fn create(_size_hint: usize) -> Self {
174        Self::try_from_iter((0..L::to_usize()).map(|_| S::default())).unwrap()
175    }
176}
177
178impl<S, L> WriteableShareSet<S> for Array<S, L>
179where
180    S: Share,
181    L: ArraySize,
182{
183    fn create(_size_hint: usize) -> Self {
184        Self::try_from_iter((0..L::to_usize()).map(|_| S::default())).unwrap()
185    }
186}
187
188#[cfg(any(feature = "alloc", feature = "std"))]
189impl<S> WriteableShareSet<S> for Vec<S>
190where
191    S: Share,
192{
193    fn create(size_hint: usize) -> Self {
194        (0..size_hint).map(|_| S::default()).collect()
195    }
196}
197
198fn dup_checker<S>(set: &[S]) -> bool
199where
200    S: Share,
201{
202    for (i, x_i) in set.iter().enumerate() {
203        for x_j in set.iter().skip(i + 1) {
204            if x_i.identifier() == x_j.identifier() {
205                return true;
206            }
207        }
208    }
209    false
210}
211
212/// Objects that represent the ability to verify Shamir shares using
213/// Feldman verifiers.
214pub trait FeldmanVerifierSet<S, G>: Sized
215where
216    S: Share,
217    G: ShareVerifier<S>,
218{
219    /// Create a new verifier set
220    fn empty_feldman_set_with_capacity(size_hint: usize, generator: G) -> Self;
221
222    /// Create a new verifier set.
223    fn with_capacity(size_hint: usize, generator: G) -> Self {
224        Self::empty_feldman_set_with_capacity(size_hint, generator)
225    }
226
227    /// Create a verifier set from an existing set of verifiers and generator
228    fn feldman_set_with_generator_and_verifiers(generator: G, verifiers: &[G]) -> Self {
229        let mut set = Self::empty_feldman_set_with_capacity(verifiers.len(), generator);
230        set.verifiers_mut().copy_from_slice(verifiers);
231        set
232    }
233
234    /// Create a verifier set from an existing set of verifiers and generator.
235    fn with_generator_and_verifiers(generator: G, verifiers: &[G]) -> Self {
236        Self::feldman_set_with_generator_and_verifiers(generator, verifiers)
237    }
238
239    /// The generator used for the verifiers
240    fn generator(&self) -> G;
241
242    /// The verifiers
243    fn verifiers(&self) -> &[G];
244
245    /// The writable verifiers
246    fn verifiers_mut(&mut self) -> &mut [G];
247
248    /// Evaluate this verifier set at a share identifier.
249    fn evaluate_verifier_at(&self, identifier: &S::Identifier) -> VsssResult<G> {
250        if identifier.is_zero().into() {
251            return Err(Error::InvalidShare);
252        }
253        if self.generator().is_zero().into() {
254            return Err(Error::InvalidGenerator("Generator is identity"));
255        }
256
257        evaluate_commitments_at::<S, G>(self.verifiers(), identifier)
258    }
259
260    /// Evaluate this verifier set at a share identifier.
261    fn evaluate_at(&self, identifier: &S::Identifier) -> VsssResult<G> {
262        self.evaluate_verifier_at(identifier)
263    }
264
265    /// Verify a share with this set
266    fn verify_share(&self, share: &S) -> VsssResult<()> {
267        if share.value().is_zero().into() {
268            return Err(Error::InvalidShare);
269        }
270
271        let rhs = self.evaluate_verifier_at(share.identifier())?;
272        let s = share.value();
273        let lhs = self.generator() * s;
274
275        let res: G = rhs - lhs;
276
277        if res.is_zero().into() {
278            Ok(())
279        } else {
280            Err(Error::InvalidShare)
281        }
282    }
283}
284
285/// Objects that represent the ability to verify Shamir shares using
286/// Pedersen verifiers.
287pub trait PedersenVerifierSet<S, G>: Sized
288where
289    S: Share,
290    G: ShareVerifier<S>,
291{
292    /// Create a new verifier set
293    fn empty_pedersen_set_with_capacity(
294        size_hint: usize,
295        secret_generator: G,
296        blinder_generator: G,
297    ) -> Self;
298
299    /// Create a new verifier set.
300    fn with_capacity(size_hint: usize, secret_generator: G, blinder_generator: G) -> Self {
301        Self::empty_pedersen_set_with_capacity(size_hint, secret_generator, blinder_generator)
302    }
303
304    /// Create a verifier set from an existing set of verifiers and generators
305    fn pedersen_set_with_generators_and_verifiers(
306        secret_generator: G,
307        blinder_generator: G,
308        verifiers: &[G],
309    ) -> Self {
310        let mut set = Self::empty_pedersen_set_with_capacity(
311            verifiers.len(),
312            secret_generator,
313            blinder_generator,
314        );
315        set.blind_verifiers_mut().copy_from_slice(verifiers);
316        set
317    }
318
319    /// Create a verifier set from an existing set of verifiers and generators.
320    fn with_generators_and_verifiers(
321        secret_generator: G,
322        blinder_generator: G,
323        verifiers: &[G],
324    ) -> Self {
325        Self::pedersen_set_with_generators_and_verifiers(
326            secret_generator,
327            blinder_generator,
328            verifiers,
329        )
330    }
331
332    /// The generator used for the verifiers of secrets
333    fn secret_generator(&self) -> G;
334
335    /// The generator used for the verifiers of blinders
336    fn blinder_generator(&self) -> G;
337
338    /// The verifiers
339    fn blind_verifiers(&self) -> &[G];
340
341    /// The writable verifiers
342    fn blind_verifiers_mut(&mut self) -> &mut [G];
343
344    /// Evaluate this verifier set at a share identifier.
345    fn evaluate_verifier_at(&self, identifier: &S::Identifier) -> VsssResult<G> {
346        if identifier.is_zero().into() {
347            return Err(Error::InvalidShare);
348        }
349        let blind_generator = self.blinder_generator();
350        let generator = self.secret_generator();
351
352        if generator == G::default() || blind_generator == G::default() {
353            return Err(Error::InvalidGenerator(
354                "Generator or Blind generator is an identity",
355            ));
356        }
357
358        evaluate_commitments_at::<S, G>(self.blind_verifiers(), identifier)
359    }
360
361    /// Evaluate this verifier set at a share identifier.
362    fn evaluate_at(&self, identifier: &S::Identifier) -> VsssResult<G> {
363        self.evaluate_verifier_at(identifier)
364    }
365
366    /// Verify a share and blinder with this set
367    fn verify_share_and_blinder(&self, share: &S, blinder: &S) -> VsssResult<()> {
368        if (share.value().is_zero() | blinder.value().is_zero()).into() {
369            return Err(Error::InvalidShare);
370        }
371
372        let secret = share.value();
373        let blinder = blinder.value();
374        let rhs = self.evaluate_verifier_at(share.identifier())?;
375        let blind_generator = self.blinder_generator();
376        let generator = self.secret_generator();
377
378        let g: G = generator * secret;
379        let h: G = blind_generator * blinder;
380
381        let res = rhs - g - h;
382
383        if res == G::default() {
384            Ok(())
385        } else {
386            Err(Error::InvalidShare)
387        }
388    }
389
390    /// Verify a share and blinder with this set.
391    fn verify_blinded_share(&self, share: &S, blinder: &S) -> VsssResult<()> {
392        self.verify_share_and_blinder(share, blinder)
393    }
394}
395
396fn evaluate_commitments_at<S, G>(commitments: &[G], identifier: &S::Identifier) -> VsssResult<G>
397where
398    S: Share,
399    G: ShareVerifier<S>,
400{
401    if commitments.is_empty() {
402        return Err(Error::InvalidSizeRequest);
403    }
404
405    let mut i = S::Identifier::one();
406    // FUTURE: execute this sum of products as a constant-time simultaneous
407    // multiple point multiplication.
408    let mut rhs = commitments[0];
409    for v in &commitments[1..] {
410        *i.as_mut() *= identifier.as_ref();
411        rhs += *v * i.clone();
412    }
413    Ok(rhs)
414}
415
416impl<S: Share, G: ShareVerifier<S>, const L: usize> FeldmanVerifierSet<S, G> for [G; L] {
417    fn empty_feldman_set_with_capacity(_size_hint: usize, generator: G) -> Self {
418        let mut t = [G::default(); L];
419        t[0] = generator;
420        t
421    }
422
423    fn generator(&self) -> G {
424        self[0]
425    }
426
427    fn verifiers(&self) -> &[G] {
428        &self[1..]
429    }
430
431    fn verifiers_mut(&mut self) -> &mut [G] {
432        self[1..].as_mut()
433    }
434}
435
436impl<S: Share, G: ShareVerifier<S>, L: ArrayLength> FeldmanVerifierSet<S, G>
437    for GenericArray<G, L>
438{
439    fn empty_feldman_set_with_capacity(_size_hint: usize, generator: G) -> Self {
440        let mut t = Self::default();
441        t[0] = generator;
442        t
443    }
444
445    fn generator(&self) -> G {
446        self[0]
447    }
448
449    fn verifiers(&self) -> &[G] {
450        &self[1..]
451    }
452
453    fn verifiers_mut(&mut self) -> &mut [G] {
454        self[1..].as_mut()
455    }
456}
457
458impl<S: Share, G: ShareVerifier<S>, L: ArraySize> FeldmanVerifierSet<S, G> for Array<G, L> {
459    fn empty_feldman_set_with_capacity(_size_hint: usize, generator: G) -> Self {
460        let mut t = Self::default();
461        t[0] = generator;
462        t
463    }
464
465    fn generator(&self) -> G {
466        self[0]
467    }
468
469    fn verifiers(&self) -> &[G] {
470        &self[1..]
471    }
472
473    fn verifiers_mut(&mut self) -> &mut [G] {
474        self[1..].as_mut()
475    }
476}
477
478/// A wrapper around a fixed-size array of verifiers.
479/// Allows for convenient type aliasing.
480/// ```
481/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ShareVerifierGroup, ArrayFeldmanVerifierSet};
482///
483/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
484/// type K256FeldmanVerifierSet = ArrayFeldmanVerifierSet<K256Share, ShareVerifierGroup<k256::ProjectivePoint>, 3>;
485/// ```
486#[derive(Debug, Clone, Copy)]
487#[repr(transparent)]
488pub struct ArrayFeldmanVerifierSet<S, V, const L: usize>
489where
490    S: Share,
491    V: ShareVerifier<S>,
492{
493    /// The inner array set to threshold + 1
494    pub inner: [V; L],
495    /// Marker for phantom data
496    pub _marker: PhantomData<S>,
497}
498
499impl<S, V, const L: usize> From<[V; L]> for ArrayFeldmanVerifierSet<S, V, L>
500where
501    S: Share,
502    V: ShareVerifier<S>,
503{
504    fn from(inner: [V; L]) -> Self {
505        Self {
506            inner,
507            _marker: PhantomData,
508        }
509    }
510}
511
512impl<S, V, const L: usize> From<&[V; L]> for ArrayFeldmanVerifierSet<S, V, L>
513where
514    S: Share,
515    V: ShareVerifier<S>,
516{
517    fn from(inner: &[V; L]) -> Self {
518        Self {
519            inner: *inner,
520            _marker: PhantomData,
521        }
522    }
523}
524
525impl<S, V, const L: usize> From<ArrayFeldmanVerifierSet<S, V, L>> for [V; L]
526where
527    S: Share,
528    V: ShareVerifier<S>,
529{
530    fn from(set: ArrayFeldmanVerifierSet<S, V, L>) -> Self {
531        set.inner
532    }
533}
534
535impl<S, V, const L: usize> From<&ArrayFeldmanVerifierSet<S, V, L>> for [V; L]
536where
537    S: Share,
538    V: ShareVerifier<S>,
539{
540    fn from(set: &ArrayFeldmanVerifierSet<S, V, L>) -> Self {
541        set.inner
542    }
543}
544
545impl<S, V, const L: usize> Deref for ArrayFeldmanVerifierSet<S, V, L>
546where
547    S: Share,
548    V: ShareVerifier<S>,
549{
550    type Target = [V; L];
551
552    fn deref(&self) -> &Self::Target {
553        &self.inner
554    }
555}
556
557impl<S, V, const L: usize> DerefMut for ArrayFeldmanVerifierSet<S, V, L>
558where
559    S: Share,
560    V: ShareVerifier<S>,
561{
562    fn deref_mut(&mut self) -> &mut Self::Target {
563        &mut self.inner
564    }
565}
566
567impl<S, V, const L: usize> Default for ArrayFeldmanVerifierSet<S, V, L>
568where
569    S: Share,
570    V: ShareVerifier<S>,
571    [V; L]: Default,
572{
573    fn default() -> Self {
574        Self {
575            inner: Default::default(),
576            _marker: PhantomData,
577        }
578    }
579}
580
581impl<S, V, const L: usize> FeldmanVerifierSet<S, V> for ArrayFeldmanVerifierSet<S, V, L>
582where
583    S: Share,
584    V: ShareVerifier<S>,
585{
586    fn empty_feldman_set_with_capacity(size_hint: usize, generator: V) -> Self {
587        Self {
588            inner: <[V; L] as FeldmanVerifierSet<S, V>>::empty_feldman_set_with_capacity(
589                size_hint, generator,
590            ),
591            _marker: PhantomData,
592        }
593    }
594
595    fn generator(&self) -> V {
596        <[V; L]>::generator(&self.inner)
597    }
598
599    fn verifiers(&self) -> &[V] {
600        <[V; L]>::verifiers(&self.inner)
601    }
602
603    fn verifiers_mut(&mut self) -> &mut [V] {
604        <[V; L]>::verifiers_mut(&mut self.inner)
605    }
606}
607
608/// A wrapper around a generic array of verifiers.
609/// Allows for convenient type aliasing.
610/// ```
611/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, GenericArrayFeldmanVerifierSet};
612/// use generic_array::typenum::U3;
613///
614/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
615/// type K256FeldmanVerifierSet = GenericArrayFeldmanVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>, U3>;
616/// ```
617#[derive(Debug, Clone)]
618#[repr(transparent)]
619pub struct GenericArrayFeldmanVerifierSet<S, V, L>
620where
621    S: Share,
622    V: ShareVerifier<S>,
623    L: ArrayLength,
624{
625    /// The inner generic array set to threshold + 1
626    pub inner: GenericArray<V, L>,
627    /// Marker for phantom data
628    pub _marker: PhantomData<S>,
629}
630
631impl<S, V, L> From<GenericArray<V, L>> for GenericArrayFeldmanVerifierSet<S, V, L>
632where
633    S: Share,
634    V: ShareVerifier<S>,
635    L: ArrayLength,
636{
637    fn from(inner: GenericArray<V, L>) -> Self {
638        Self {
639            inner,
640            _marker: PhantomData,
641        }
642    }
643}
644
645impl<S, V, L> From<&GenericArray<V, L>> for GenericArrayFeldmanVerifierSet<S, V, L>
646where
647    S: Share,
648    V: ShareVerifier<S>,
649    L: ArrayLength,
650{
651    fn from(inner: &GenericArray<V, L>) -> Self {
652        Self {
653            inner: inner.clone(),
654            _marker: PhantomData,
655        }
656    }
657}
658
659impl<S, V, L> From<GenericArrayFeldmanVerifierSet<S, V, L>> for GenericArray<V, L>
660where
661    S: Share,
662    V: ShareVerifier<S>,
663    L: ArrayLength,
664{
665    fn from(set: GenericArrayFeldmanVerifierSet<S, V, L>) -> Self {
666        set.inner
667    }
668}
669
670impl<S, V, L> From<&GenericArrayFeldmanVerifierSet<S, V, L>> for GenericArray<V, L>
671where
672    S: Share,
673    V: ShareVerifier<S>,
674    L: ArrayLength,
675{
676    fn from(set: &GenericArrayFeldmanVerifierSet<S, V, L>) -> Self {
677        set.inner.clone()
678    }
679}
680
681impl<S, V, L> Deref for GenericArrayFeldmanVerifierSet<S, V, L>
682where
683    S: Share,
684    V: ShareVerifier<S>,
685    L: ArrayLength,
686{
687    type Target = GenericArray<V, L>;
688
689    fn deref(&self) -> &Self::Target {
690        &self.inner
691    }
692}
693
694impl<S, V, L> DerefMut for GenericArrayFeldmanVerifierSet<S, V, L>
695where
696    S: Share,
697    V: ShareVerifier<S>,
698    L: ArrayLength,
699{
700    fn deref_mut(&mut self) -> &mut Self::Target {
701        &mut self.inner
702    }
703}
704
705impl<S, V, L> Default for GenericArrayFeldmanVerifierSet<S, V, L>
706where
707    S: Share,
708    V: ShareVerifier<S>,
709    L: ArrayLength,
710    GenericArray<V, L>: Default,
711{
712    fn default() -> Self {
713        Self {
714            inner: Default::default(),
715            _marker: PhantomData,
716        }
717    }
718}
719
720impl<S, V, L> FeldmanVerifierSet<S, V> for GenericArrayFeldmanVerifierSet<S, V, L>
721where
722    S: Share,
723    V: ShareVerifier<S>,
724    L: ArrayLength,
725{
726    fn empty_feldman_set_with_capacity(size_hint: usize, generator: V) -> Self {
727        Self {
728            inner:
729                <GenericArray<V, L> as FeldmanVerifierSet<S, V>>::empty_feldman_set_with_capacity(
730                    size_hint, generator,
731                ),
732            _marker: PhantomData,
733        }
734    }
735
736    fn generator(&self) -> V {
737        <GenericArray<V, L>>::generator(&self.inner)
738    }
739
740    fn verifiers(&self) -> &[V] {
741        <GenericArray<V, L>>::verifiers(&self.inner)
742    }
743
744    fn verifiers_mut(&mut self) -> &mut [V] {
745        <GenericArray<V, L>>::verifiers_mut(&mut self.inner)
746    }
747}
748
749/// A wrapper around a hybrid array of verifiers.
750/// Allows for convenient type aliasing.
751/// ```
752/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, HybridArrayFeldmanVerifierSet};
753/// use hybrid_array::typenum::U3;
754///
755/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
756/// type K256FeldmanVerifierSet = HybridArrayFeldmanVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>, U3>;
757/// ```
758#[derive(Debug, Clone)]
759#[repr(transparent)]
760pub struct HybridArrayFeldmanVerifierSet<S, V, L>
761where
762    S: Share,
763    V: ShareVerifier<S>,
764    L: ArraySize,
765{
766    /// The inner hybrid array set to threshold + 1
767    pub inner: Array<V, L>,
768    /// Marker for phantom data
769    pub _marker: PhantomData<S>,
770}
771
772impl<S, V, L> From<Array<V, L>> for HybridArrayFeldmanVerifierSet<S, V, L>
773where
774    S: Share,
775    V: ShareVerifier<S>,
776    L: ArraySize,
777{
778    fn from(inner: Array<V, L>) -> Self {
779        Self {
780            inner,
781            _marker: PhantomData,
782        }
783    }
784}
785
786impl<S, V, L> From<&Array<V, L>> for HybridArrayFeldmanVerifierSet<S, V, L>
787where
788    S: Share,
789    V: ShareVerifier<S>,
790    L: ArraySize,
791{
792    fn from(inner: &Array<V, L>) -> Self {
793        Self {
794            inner: inner.clone(),
795            _marker: PhantomData,
796        }
797    }
798}
799
800impl<S, V, L> From<HybridArrayFeldmanVerifierSet<S, V, L>> for Array<V, L>
801where
802    S: Share,
803    V: ShareVerifier<S>,
804    L: ArraySize,
805{
806    fn from(set: HybridArrayFeldmanVerifierSet<S, V, L>) -> Self {
807        set.inner
808    }
809}
810
811impl<S, V, L> From<&HybridArrayFeldmanVerifierSet<S, V, L>> for Array<V, L>
812where
813    S: Share,
814    V: ShareVerifier<S>,
815    L: ArraySize,
816{
817    fn from(set: &HybridArrayFeldmanVerifierSet<S, V, L>) -> Self {
818        set.inner.clone()
819    }
820}
821
822impl<S, V, L> Deref for HybridArrayFeldmanVerifierSet<S, V, L>
823where
824    S: Share,
825    V: ShareVerifier<S>,
826    L: ArraySize,
827{
828    type Target = Array<V, L>;
829
830    fn deref(&self) -> &Self::Target {
831        &self.inner
832    }
833}
834
835impl<S, V, L> DerefMut for HybridArrayFeldmanVerifierSet<S, V, L>
836where
837    S: Share,
838    V: ShareVerifier<S>,
839    L: ArraySize,
840{
841    fn deref_mut(&mut self) -> &mut Self::Target {
842        &mut self.inner
843    }
844}
845
846impl<S, V, L> Default for HybridArrayFeldmanVerifierSet<S, V, L>
847where
848    S: Share,
849    V: ShareVerifier<S>,
850    L: ArraySize,
851    Array<V, L>: Default,
852{
853    fn default() -> Self {
854        Self {
855            inner: Default::default(),
856            _marker: PhantomData,
857        }
858    }
859}
860
861impl<S, V, L> FeldmanVerifierSet<S, V> for HybridArrayFeldmanVerifierSet<S, V, L>
862where
863    S: Share,
864    V: ShareVerifier<S>,
865    L: ArraySize,
866{
867    fn empty_feldman_set_with_capacity(size_hint: usize, generator: V) -> Self {
868        Self {
869            inner: <Array<V, L> as FeldmanVerifierSet<S, V>>::empty_feldman_set_with_capacity(
870                size_hint, generator,
871            ),
872            _marker: PhantomData,
873        }
874    }
875
876    fn generator(&self) -> V {
877        <Array<V, L>>::generator(&self.inner)
878    }
879
880    fn verifiers(&self) -> &[V] {
881        <Array<V, L>>::verifiers(&self.inner)
882    }
883
884    fn verifiers_mut(&mut self) -> &mut [V] {
885        <Array<V, L>>::verifiers_mut(&mut self.inner)
886    }
887}
888
889#[cfg(any(feature = "alloc", feature = "std"))]
890impl<S: Share, G: ShareVerifier<S>> FeldmanVerifierSet<S, G> for Vec<G> {
891    fn empty_feldman_set_with_capacity(size_hint: usize, generator: G) -> Self {
892        vec![generator; size_hint + 1]
893    }
894
895    fn generator(&self) -> G {
896        self[0]
897    }
898
899    fn verifiers(&self) -> &[G] {
900        &self[1..]
901    }
902
903    fn verifiers_mut(&mut self) -> &mut [G] {
904        self[1..].as_mut()
905    }
906}
907
908#[cfg(any(feature = "alloc", feature = "std"))]
909/// A wrapper around a `Vec` of verifiers.
910/// Allows for convenient type aliasing.
911/// ```
912/// #[cfg(any(feature = "alloc", feature = "std"))]
913/// {
914///     use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, VecFeldmanVerifierSet};
915///     type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
916///     type K256FeldmanVerifierSet = VecFeldmanVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>>;
917/// }
918/// ```
919#[derive(Debug, Clone, Default)]
920#[repr(transparent)]
921pub struct VecFeldmanVerifierSet<S, V>
922where
923    S: Share,
924    V: ShareVerifier<S>,
925{
926    /// The inner vec set to threshold + 1
927    pub inner: Vec<V>,
928    /// Marker for phantom data
929    pub _marker: PhantomData<S>,
930}
931
932#[cfg(any(feature = "alloc", feature = "std"))]
933impl<S, V> From<Vec<V>> for VecFeldmanVerifierSet<S, V>
934where
935    S: Share,
936    V: ShareVerifier<S>,
937{
938    fn from(value: Vec<V>) -> Self {
939        Self {
940            inner: value,
941            _marker: PhantomData,
942        }
943    }
944}
945
946#[cfg(any(feature = "alloc", feature = "std"))]
947impl<S, V> From<&Vec<V>> for VecFeldmanVerifierSet<S, V>
948where
949    S: Share,
950    V: ShareVerifier<S>,
951{
952    fn from(value: &Vec<V>) -> Self {
953        Self {
954            inner: value.clone(),
955            _marker: PhantomData,
956        }
957    }
958}
959
960#[cfg(any(feature = "alloc", feature = "std"))]
961impl<S, V> From<VecFeldmanVerifierSet<S, V>> for Vec<V>
962where
963    S: Share,
964    V: ShareVerifier<S>,
965{
966    fn from(value: VecFeldmanVerifierSet<S, V>) -> Self {
967        value.inner
968    }
969}
970
971#[cfg(any(feature = "alloc", feature = "std"))]
972impl<S, V> From<&VecFeldmanVerifierSet<S, V>> for Vec<V>
973where
974    S: Share,
975    V: ShareVerifier<S>,
976{
977    fn from(value: &VecFeldmanVerifierSet<S, V>) -> Self {
978        value.inner.clone()
979    }
980}
981
982#[cfg(any(feature = "alloc", feature = "std"))]
983impl<S, V> Deref for VecFeldmanVerifierSet<S, V>
984where
985    S: Share,
986    V: ShareVerifier<S>,
987{
988    type Target = Vec<V>;
989
990    fn deref(&self) -> &Self::Target {
991        &self.inner
992    }
993}
994
995#[cfg(any(feature = "alloc", feature = "std"))]
996impl<S, V> DerefMut for VecFeldmanVerifierSet<S, V>
997where
998    S: Share,
999    V: ShareVerifier<S>,
1000{
1001    fn deref_mut(&mut self) -> &mut Self::Target {
1002        &mut self.inner
1003    }
1004}
1005
1006#[cfg(any(feature = "alloc", feature = "std"))]
1007impl<S, V> FeldmanVerifierSet<S, V> for VecFeldmanVerifierSet<S, V>
1008where
1009    S: Share,
1010    V: ShareVerifier<S>,
1011{
1012    fn empty_feldman_set_with_capacity(size_hint: usize, generator: V) -> Self {
1013        Self {
1014            inner: <Vec<V> as FeldmanVerifierSet<S, V>>::empty_feldman_set_with_capacity(
1015                size_hint, generator,
1016            ),
1017            _marker: PhantomData,
1018        }
1019    }
1020
1021    fn generator(&self) -> V {
1022        <Vec<V>>::generator(&self.inner)
1023    }
1024
1025    fn verifiers(&self) -> &[V] {
1026        <Vec<V>>::verifiers(&self.inner)
1027    }
1028
1029    fn verifiers_mut(&mut self) -> &mut [V] {
1030        <Vec<V>>::verifiers_mut(&mut self.inner)
1031    }
1032}
1033
1034impl<S: Share, G: ShareVerifier<S>, const L: usize> PedersenVerifierSet<S, G> for [G; L] {
1035    fn empty_pedersen_set_with_capacity(
1036        _size_hint: usize,
1037        secret_generator: G,
1038        blinder_generator: G,
1039    ) -> Self {
1040        let mut t = [G::default(); L];
1041        t[0] = secret_generator;
1042        t[1] = blinder_generator;
1043        t
1044    }
1045
1046    fn secret_generator(&self) -> G {
1047        self[0]
1048    }
1049
1050    fn blinder_generator(&self) -> G {
1051        self[1]
1052    }
1053
1054    fn blind_verifiers(&self) -> &[G] {
1055        &self[2..]
1056    }
1057
1058    fn blind_verifiers_mut(&mut self) -> &mut [G] {
1059        self[2..].as_mut()
1060    }
1061}
1062
1063/// A wrapper around an array of verifiers.
1064/// Allows for convenient type aliasing.
1065/// ```
1066/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, ArrayPedersenVerifierSet};
1067/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
1068/// type K256PedersenVerifierSet = ArrayPedersenVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>, 4>;
1069/// ```
1070#[derive(Debug, Clone, Copy)]
1071#[repr(transparent)]
1072pub struct ArrayPedersenVerifierSet<S, V, const L: usize>
1073where
1074    S: Share,
1075    V: ShareVerifier<S>,
1076{
1077    /// The inner array set to threshold + 2
1078    pub inner: [V; L],
1079    /// Marker for phantom data
1080    pub _marker: PhantomData<S>,
1081}
1082
1083impl<S, V, const L: usize> From<[V; L]> for ArrayPedersenVerifierSet<S, V, L>
1084where
1085    S: Share,
1086    V: ShareVerifier<S>,
1087{
1088    fn from(inner: [V; L]) -> Self {
1089        Self {
1090            inner,
1091            _marker: PhantomData,
1092        }
1093    }
1094}
1095
1096impl<S, V, const L: usize> From<&[V; L]> for ArrayPedersenVerifierSet<S, V, L>
1097where
1098    S: Share,
1099    V: ShareVerifier<S>,
1100{
1101    fn from(inner: &[V; L]) -> Self {
1102        Self {
1103            inner: *inner,
1104            _marker: PhantomData,
1105        }
1106    }
1107}
1108
1109impl<S, V, const L: usize> From<ArrayPedersenVerifierSet<S, V, L>> for [V; L]
1110where
1111    S: Share,
1112    V: ShareVerifier<S>,
1113{
1114    fn from(set: ArrayPedersenVerifierSet<S, V, L>) -> Self {
1115        set.inner
1116    }
1117}
1118
1119impl<S, V, const L: usize> From<&ArrayPedersenVerifierSet<S, V, L>> for [V; L]
1120where
1121    S: Share,
1122    V: ShareVerifier<S>,
1123{
1124    fn from(set: &ArrayPedersenVerifierSet<S, V, L>) -> Self {
1125        set.inner
1126    }
1127}
1128
1129impl<S, V, const L: usize> Deref for ArrayPedersenVerifierSet<S, V, L>
1130where
1131    S: Share,
1132    V: ShareVerifier<S>,
1133{
1134    type Target = [V; L];
1135
1136    fn deref(&self) -> &Self::Target {
1137        &self.inner
1138    }
1139}
1140
1141impl<S, V, const L: usize> DerefMut for ArrayPedersenVerifierSet<S, V, L>
1142where
1143    S: Share,
1144    V: ShareVerifier<S>,
1145{
1146    fn deref_mut(&mut self) -> &mut Self::Target {
1147        &mut self.inner
1148    }
1149}
1150
1151impl<S, V, const L: usize> Default for ArrayPedersenVerifierSet<S, V, L>
1152where
1153    S: Share,
1154    V: ShareVerifier<S>,
1155    [V; L]: Default,
1156{
1157    fn default() -> Self {
1158        Self {
1159            inner: Default::default(),
1160            _marker: PhantomData,
1161        }
1162    }
1163}
1164
1165impl<S, V, const L: usize> PedersenVerifierSet<S, V> for ArrayPedersenVerifierSet<S, V, L>
1166where
1167    S: Share,
1168    V: ShareVerifier<S>,
1169{
1170    fn empty_pedersen_set_with_capacity(
1171        size_hint: usize,
1172        secret_generator: V,
1173        blinder_generator: V,
1174    ) -> Self {
1175        Self {
1176            inner: <[V; L] as PedersenVerifierSet<S, V>>::empty_pedersen_set_with_capacity(
1177                size_hint,
1178                secret_generator,
1179                blinder_generator,
1180            ),
1181            _marker: PhantomData,
1182        }
1183    }
1184
1185    fn secret_generator(&self) -> V {
1186        <[V; L]>::secret_generator(&self.inner)
1187    }
1188
1189    fn blinder_generator(&self) -> V {
1190        <[V; L]>::blinder_generator(&self.inner)
1191    }
1192
1193    fn blind_verifiers(&self) -> &[V] {
1194        <[V; L]>::blind_verifiers(&self.inner)
1195    }
1196
1197    fn blind_verifiers_mut(&mut self) -> &mut [V] {
1198        <[V; L]>::blind_verifiers_mut(&mut self.inner)
1199    }
1200}
1201
1202impl<S: Share, G: ShareVerifier<S>, L: ArrayLength> PedersenVerifierSet<S, G>
1203    for GenericArray<G, L>
1204{
1205    fn empty_pedersen_set_with_capacity(
1206        _size_hint: usize,
1207        secret_generator: G,
1208        blinder_generator: G,
1209    ) -> Self {
1210        let mut t = Self::default();
1211        t[0] = secret_generator;
1212        t[1] = blinder_generator;
1213        t
1214    }
1215
1216    fn secret_generator(&self) -> G {
1217        self[0]
1218    }
1219
1220    fn blinder_generator(&self) -> G {
1221        self[1]
1222    }
1223
1224    fn blind_verifiers(&self) -> &[G] {
1225        &self[2..]
1226    }
1227
1228    fn blind_verifiers_mut(&mut self) -> &mut [G] {
1229        self[2..].as_mut()
1230    }
1231}
1232
1233impl<S: Share, G: ShareVerifier<S>, L: ArraySize> PedersenVerifierSet<S, G> for Array<G, L> {
1234    fn empty_pedersen_set_with_capacity(
1235        _size_hint: usize,
1236        secret_generator: G,
1237        blinder_generator: G,
1238    ) -> Self {
1239        let mut t = Self::default();
1240        t[0] = secret_generator;
1241        t[1] = blinder_generator;
1242        t
1243    }
1244
1245    fn secret_generator(&self) -> G {
1246        self[0]
1247    }
1248
1249    fn blinder_generator(&self) -> G {
1250        self[1]
1251    }
1252
1253    fn blind_verifiers(&self) -> &[G] {
1254        &self[2..]
1255    }
1256
1257    fn blind_verifiers_mut(&mut self) -> &mut [G] {
1258        self[2..].as_mut()
1259    }
1260}
1261
1262/// A wrapper around a generic array of verifiers.
1263/// Allows for convenient type aliasing.
1264/// ```
1265/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, GenericArrayPedersenVerifierSet};
1266/// use generic_array::typenum::U4;
1267/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
1268/// type K256PedersenVerifierSet = GenericArrayPedersenVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>, U4>;
1269/// ```
1270#[derive(Debug, Clone)]
1271#[repr(transparent)]
1272pub struct GenericArrayPedersenVerifierSet<S, V, L>
1273where
1274    S: Share,
1275    V: ShareVerifier<S>,
1276    L: ArrayLength,
1277{
1278    /// The inner generic array set to threshold + 2
1279    pub inner: GenericArray<V, L>,
1280    /// Marker for phantom data
1281    pub _marker: PhantomData<S>,
1282}
1283
1284impl<S, V, L> From<GenericArray<V, L>> for GenericArrayPedersenVerifierSet<S, V, L>
1285where
1286    S: Share,
1287    V: ShareVerifier<S>,
1288    L: ArrayLength,
1289{
1290    fn from(inner: GenericArray<V, L>) -> Self {
1291        Self {
1292            inner,
1293            _marker: PhantomData,
1294        }
1295    }
1296}
1297
1298impl<S, V, L> From<&GenericArray<V, L>> for GenericArrayPedersenVerifierSet<S, V, L>
1299where
1300    S: Share,
1301    V: ShareVerifier<S>,
1302    L: ArrayLength,
1303{
1304    fn from(inner: &GenericArray<V, L>) -> Self {
1305        Self {
1306            inner: inner.clone(),
1307            _marker: PhantomData,
1308        }
1309    }
1310}
1311
1312impl<S, V, L> From<GenericArrayPedersenVerifierSet<S, V, L>> for GenericArray<V, L>
1313where
1314    S: Share,
1315    V: ShareVerifier<S>,
1316    L: ArrayLength,
1317{
1318    fn from(set: GenericArrayPedersenVerifierSet<S, V, L>) -> Self {
1319        set.inner
1320    }
1321}
1322
1323impl<S, V, L> From<&GenericArrayPedersenVerifierSet<S, V, L>> for GenericArray<V, L>
1324where
1325    S: Share,
1326    V: ShareVerifier<S>,
1327    L: ArrayLength,
1328{
1329    fn from(set: &GenericArrayPedersenVerifierSet<S, V, L>) -> Self {
1330        set.inner.clone()
1331    }
1332}
1333
1334impl<S, V, L> Deref for GenericArrayPedersenVerifierSet<S, V, L>
1335where
1336    S: Share,
1337    V: ShareVerifier<S>,
1338    L: ArrayLength,
1339{
1340    type Target = GenericArray<V, L>;
1341
1342    fn deref(&self) -> &Self::Target {
1343        &self.inner
1344    }
1345}
1346
1347impl<S, V, L> DerefMut for GenericArrayPedersenVerifierSet<S, V, L>
1348where
1349    S: Share,
1350    V: ShareVerifier<S>,
1351    L: ArrayLength,
1352{
1353    fn deref_mut(&mut self) -> &mut Self::Target {
1354        &mut self.inner
1355    }
1356}
1357
1358impl<S, V, L> Default for GenericArrayPedersenVerifierSet<S, V, L>
1359where
1360    S: Share,
1361    V: ShareVerifier<S>,
1362    L: ArrayLength,
1363    GenericArray<V, L>: Default,
1364{
1365    fn default() -> Self {
1366        Self {
1367            inner: Default::default(),
1368            _marker: PhantomData,
1369        }
1370    }
1371}
1372
1373impl<S, V, L> PedersenVerifierSet<S, V> for GenericArrayPedersenVerifierSet<S, V, L>
1374where
1375    S: Share,
1376    V: ShareVerifier<S>,
1377    L: ArrayLength,
1378{
1379    fn empty_pedersen_set_with_capacity(
1380        size_hint: usize,
1381        secret_generator: V,
1382        blinder_generator: V,
1383    ) -> Self {
1384        Self {
1385            inner:
1386                <GenericArray<V, L> as PedersenVerifierSet<S, V>>::empty_pedersen_set_with_capacity(
1387                    size_hint,
1388                    secret_generator,
1389                    blinder_generator,
1390                ),
1391            _marker: PhantomData,
1392        }
1393    }
1394
1395    fn secret_generator(&self) -> V {
1396        <GenericArray<V, L>>::secret_generator(&self.inner)
1397    }
1398
1399    fn blinder_generator(&self) -> V {
1400        <GenericArray<V, L>>::blinder_generator(&self.inner)
1401    }
1402
1403    fn blind_verifiers(&self) -> &[V] {
1404        <GenericArray<V, L>>::blind_verifiers(&self.inner)
1405    }
1406
1407    fn blind_verifiers_mut(&mut self) -> &mut [V] {
1408        <GenericArray<V, L>>::blind_verifiers_mut(&mut self.inner)
1409    }
1410}
1411
1412/// A wrapper around a hybrid array of verifiers.
1413/// Allows for convenient type aliasing.
1414/// ```
1415/// use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, HybridArrayPedersenVerifierSet};
1416/// use hybrid_array::typenum::U4;
1417/// type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
1418/// type K256PedersenVerifierSet = HybridArrayPedersenVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>, U4>;
1419/// ```
1420pub struct HybridArrayPedersenVerifierSet<S, V, L>
1421where
1422    S: Share,
1423    V: ShareVerifier<S>,
1424    L: ArraySize,
1425{
1426    /// The inner hybrid array set to threshold + 2
1427    pub inner: Array<V, L>,
1428    /// Marker for phantom data
1429    pub _marker: PhantomData<S>,
1430}
1431
1432impl<S, V, L> From<Array<V, L>> for HybridArrayPedersenVerifierSet<S, V, L>
1433where
1434    S: Share,
1435    V: ShareVerifier<S>,
1436    L: ArraySize,
1437{
1438    fn from(inner: Array<V, L>) -> Self {
1439        Self {
1440            inner,
1441            _marker: PhantomData,
1442        }
1443    }
1444}
1445
1446impl<S, V, L> From<&Array<V, L>> for HybridArrayPedersenVerifierSet<S, V, L>
1447where
1448    S: Share,
1449    V: ShareVerifier<S>,
1450    L: ArraySize,
1451{
1452    fn from(inner: &Array<V, L>) -> Self {
1453        Self {
1454            inner: inner.clone(),
1455            _marker: PhantomData,
1456        }
1457    }
1458}
1459
1460impl<S, V, L> From<HybridArrayPedersenVerifierSet<S, V, L>> for Array<V, L>
1461where
1462    S: Share,
1463    V: ShareVerifier<S>,
1464    L: ArraySize,
1465{
1466    fn from(set: HybridArrayPedersenVerifierSet<S, V, L>) -> Self {
1467        set.inner
1468    }
1469}
1470
1471impl<S, V, L> From<&HybridArrayPedersenVerifierSet<S, V, L>> for Array<V, L>
1472where
1473    S: Share,
1474    V: ShareVerifier<S>,
1475    L: ArraySize,
1476{
1477    fn from(set: &HybridArrayPedersenVerifierSet<S, V, L>) -> Self {
1478        set.inner.clone()
1479    }
1480}
1481
1482impl<S, V, L> Deref for HybridArrayPedersenVerifierSet<S, V, L>
1483where
1484    S: Share,
1485    V: ShareVerifier<S>,
1486    L: ArraySize,
1487{
1488    type Target = Array<V, L>;
1489
1490    fn deref(&self) -> &Self::Target {
1491        &self.inner
1492    }
1493}
1494
1495impl<S, V, L> DerefMut for HybridArrayPedersenVerifierSet<S, V, L>
1496where
1497    S: Share,
1498    V: ShareVerifier<S>,
1499    L: ArraySize,
1500{
1501    fn deref_mut(&mut self) -> &mut Self::Target {
1502        &mut self.inner
1503    }
1504}
1505
1506impl<S, V, L> Default for HybridArrayPedersenVerifierSet<S, V, L>
1507where
1508    S: Share,
1509    V: ShareVerifier<S>,
1510    L: ArraySize,
1511    Array<V, L>: Default,
1512{
1513    fn default() -> Self {
1514        Self {
1515            inner: Default::default(),
1516            _marker: PhantomData,
1517        }
1518    }
1519}
1520
1521impl<S, V, L> PedersenVerifierSet<S, V> for HybridArrayPedersenVerifierSet<S, V, L>
1522where
1523    S: Share,
1524    V: ShareVerifier<S>,
1525    L: ArraySize,
1526{
1527    fn empty_pedersen_set_with_capacity(
1528        size_hint: usize,
1529        secret_generator: V,
1530        blinder_generator: V,
1531    ) -> Self {
1532        Self {
1533            inner: <Array<V, L> as PedersenVerifierSet<S, V>>::empty_pedersen_set_with_capacity(
1534                size_hint,
1535                secret_generator,
1536                blinder_generator,
1537            ),
1538            _marker: PhantomData,
1539        }
1540    }
1541
1542    fn secret_generator(&self) -> V {
1543        <Array<V, L>>::secret_generator(&self.inner)
1544    }
1545
1546    fn blinder_generator(&self) -> V {
1547        <Array<V, L>>::blinder_generator(&self.inner)
1548    }
1549
1550    fn blind_verifiers(&self) -> &[V] {
1551        <Array<V, L>>::blind_verifiers(&self.inner)
1552    }
1553
1554    fn blind_verifiers_mut(&mut self) -> &mut [V] {
1555        <Array<V, L>>::blind_verifiers_mut(&mut self.inner)
1556    }
1557}
1558
1559#[cfg(any(feature = "alloc", feature = "std"))]
1560impl<S: Share, V: ShareVerifier<S>> PedersenVerifierSet<S, V> for Vec<V> {
1561    fn empty_pedersen_set_with_capacity(
1562        size_hint: usize,
1563        secret_generator: V,
1564        blinder_generator: V,
1565    ) -> Self {
1566        let mut t = vec![blinder_generator; size_hint + 2];
1567        t[0] = secret_generator;
1568        t
1569    }
1570
1571    fn secret_generator(&self) -> V {
1572        self[0]
1573    }
1574
1575    fn blinder_generator(&self) -> V {
1576        self[1]
1577    }
1578
1579    fn blind_verifiers(&self) -> &[V] {
1580        &self[2..]
1581    }
1582
1583    fn blind_verifiers_mut(&mut self) -> &mut [V] {
1584        self[2..].as_mut()
1585    }
1586}
1587
1588#[cfg(any(feature = "alloc", feature = "std"))]
1589/// A wrapper around a `Vec` of verifiers.
1590/// Allows for convenient type aliasing.
1591/// ```
1592/// #[cfg(any(feature = "alloc", feature = "std"))]
1593/// {
1594///    use vsss_rs::{DefaultShare, IdentifierPrimeField, ValueGroup, VecPedersenVerifierSet};
1595///   type K256Share = DefaultShare<IdentifierPrimeField<k256::Scalar>, IdentifierPrimeField<k256::Scalar>>;
1596///  type K256PedersenVerifierSet = VecPedersenVerifierSet<K256Share, ValueGroup<k256::ProjectivePoint>>;
1597/// }
1598/// ```
1599#[derive(Debug, Clone, Default)]
1600#[repr(transparent)]
1601pub struct VecPedersenVerifierSet<S, V>
1602where
1603    S: Share,
1604    V: ShareVerifier<S>,
1605{
1606    /// The inner vec set to threshold + 2
1607    pub inner: Vec<V>,
1608    /// Marker for phantom data
1609    pub _marker: PhantomData<S>,
1610}
1611
1612#[cfg(any(feature = "alloc", feature = "std"))]
1613impl<S, V> From<Vec<V>> for VecPedersenVerifierSet<S, V>
1614where
1615    S: Share,
1616    V: ShareVerifier<S>,
1617{
1618    fn from(inner: Vec<V>) -> Self {
1619        Self {
1620            inner,
1621            _marker: PhantomData,
1622        }
1623    }
1624}
1625
1626#[cfg(any(feature = "alloc", feature = "std"))]
1627impl<S, V> From<&Vec<V>> for VecPedersenVerifierSet<S, V>
1628where
1629    S: Share,
1630    V: ShareVerifier<S>,
1631{
1632    fn from(inner: &Vec<V>) -> Self {
1633        Self {
1634            inner: (*inner).clone(),
1635            _marker: PhantomData,
1636        }
1637    }
1638}
1639
1640#[cfg(any(feature = "alloc", feature = "std"))]
1641impl<S, V> From<VecPedersenVerifierSet<S, V>> for Vec<V>
1642where
1643    S: Share,
1644    V: ShareVerifier<S>,
1645{
1646    fn from(set: VecPedersenVerifierSet<S, V>) -> Self {
1647        set.inner
1648    }
1649}
1650
1651#[cfg(any(feature = "alloc", feature = "std"))]
1652impl<S, V> From<&VecPedersenVerifierSet<S, V>> for Vec<V>
1653where
1654    S: Share,
1655    V: ShareVerifier<S>,
1656{
1657    fn from(set: &VecPedersenVerifierSet<S, V>) -> Self {
1658        set.inner.clone()
1659    }
1660}
1661
1662#[cfg(any(feature = "alloc", feature = "std"))]
1663impl<S, V> Deref for VecPedersenVerifierSet<S, V>
1664where
1665    S: Share,
1666    V: ShareVerifier<S>,
1667{
1668    type Target = Vec<V>;
1669
1670    fn deref(&self) -> &Self::Target {
1671        &self.inner
1672    }
1673}
1674
1675#[cfg(any(feature = "alloc", feature = "std"))]
1676impl<S, V> DerefMut for VecPedersenVerifierSet<S, V>
1677where
1678    S: Share,
1679    V: ShareVerifier<S>,
1680{
1681    fn deref_mut(&mut self) -> &mut Self::Target {
1682        &mut self.inner
1683    }
1684}
1685
1686#[cfg(any(feature = "alloc", feature = "std"))]
1687impl<S, V> PedersenVerifierSet<S, V> for VecPedersenVerifierSet<S, V>
1688where
1689    S: Share,
1690    V: ShareVerifier<S>,
1691{
1692    fn empty_pedersen_set_with_capacity(
1693        size_hint: usize,
1694        secret_generator: V,
1695        blinder_generator: V,
1696    ) -> Self {
1697        Self {
1698            inner: <Vec<V> as PedersenVerifierSet<S, V>>::empty_pedersen_set_with_capacity(
1699                size_hint,
1700                secret_generator,
1701                blinder_generator,
1702            ),
1703            _marker: PhantomData,
1704        }
1705    }
1706
1707    fn secret_generator(&self) -> V {
1708        <Vec<V>>::secret_generator(&self.inner)
1709    }
1710
1711    fn blinder_generator(&self) -> V {
1712        <Vec<V>>::blinder_generator(&self.inner)
1713    }
1714
1715    fn blind_verifiers(&self) -> &[V] {
1716        <Vec<V>>::blind_verifiers(&self.inner)
1717    }
1718
1719    fn blind_verifiers_mut(&mut self) -> &mut [V] {
1720        <Vec<V>>::blind_verifiers_mut(&mut self.inner)
1721    }
1722}
1723
1724#[cfg(test)]
1725mod tests {
1726    use super::{
1727        ArrayFeldmanVerifierSet, ArrayPedersenVerifierSet, FeldmanVerifierSet,
1728        GenericArrayFeldmanVerifierSet, GenericArrayPedersenVerifierSet,
1729        HybridArrayFeldmanVerifierSet, HybridArrayPedersenVerifierSet, PedersenVerifierSet,
1730        ReadableShareSet, VecFeldmanVerifierSet, VecPedersenVerifierSet, WriteableShareSet,
1731        validate_share_set,
1732    };
1733    use crate::{Error, IdentifierPrimeField, PrimeFieldShare, Share, ShareElement, ValueGroup};
1734    use generic_array::{
1735        GenericArray,
1736        typenum::{U3 as GenericU3, U4 as GenericU4},
1737    };
1738    use hybrid_array::{
1739        Array,
1740        typenum::{U3 as HybridU3, U4 as HybridU4},
1741    };
1742    use k256::{ProjectivePoint, Scalar};
1743    use std::{vec, vec::Vec};
1744
1745    type TestShare = PrimeFieldShare<Scalar>;
1746    type TestVerifier = ValueGroup<ProjectivePoint>;
1747
1748    fn share(identifier: u64, value: u64) -> TestShare {
1749        TestShare::with_identifier_and_value(
1750            IdentifierPrimeField(Scalar::from(identifier)),
1751            IdentifierPrimeField(Scalar::from(value)),
1752        )
1753    }
1754
1755    fn verifier(value: u64) -> TestVerifier {
1756        ValueGroup(ProjectivePoint::GENERATOR * Scalar::from(value))
1757    }
1758
1759    #[test]
1760    fn writable_share_sets_create_default_storage() {
1761        let array = <[TestShare; 3] as WriteableShareSet<TestShare>>::create(99);
1762        assert_eq!(array.len(), 3);
1763
1764        let generic =
1765            <GenericArray<TestShare, GenericU3> as WriteableShareSet<TestShare>>::create(99);
1766        assert_eq!(generic.len(), 3);
1767
1768        let hybrid = <Array<TestShare, HybridU3> as WriteableShareSet<TestShare>>::create(99);
1769        assert_eq!(hybrid.len(), 3);
1770
1771        let vec = <Vec<TestShare> as WriteableShareSet<TestShare>>::create(4);
1772        assert_eq!(vec.len(), 4);
1773    }
1774
1775    #[test]
1776    fn combine_iterator_entrypoints_work() {
1777        let shares = [share(1, 45), share(2, 47)];
1778        let expected = IdentifierPrimeField(Scalar::from(43u64));
1779
1780        assert_eq!(super::combine_iter(shares), Ok(expected));
1781
1782        let mut out = IdentifierPrimeField::default();
1783        super::combine_iter_in_place(shares, &mut out).unwrap();
1784        assert_eq!(out, expected);
1785    }
1786
1787    #[cfg(feature = "stream")]
1788    #[test]
1789    fn combine_stream_entrypoints_are_exact_and_report_errors() {
1790        use crate::tests::utils::{TestStream, block_on};
1791
1792        let shares = [share(1, 45), share(2, 47), share(3, 49)];
1793        let expected = IdentifierPrimeField(Scalar::from(43u64));
1794        let stream = TestStream::new(shares.into_iter());
1795        assert_eq!(block_on(super::combine_stream(2, stream)), Ok(expected));
1796
1797        let stream = TestStream::new(shares.into_iter());
1798        let mut out = IdentifierPrimeField::default();
1799        block_on(super::combine_stream_in_place(2, stream, &mut out)).unwrap();
1800        assert_eq!(out, expected);
1801
1802        let stream = TestStream::new(shares[..2].iter().cloned());
1803        assert_eq!(
1804            block_on(super::combine_stream(3, stream)),
1805            Err(Error::NotEnoughShares)
1806        );
1807
1808        let stream = TestStream::new([share(1, 45), share(1, 47)].into_iter());
1809        assert_eq!(
1810            block_on(super::combine_stream(2, stream)),
1811            Err(Error::SharingDuplicateIdentifier)
1812        );
1813    }
1814
1815    #[test]
1816    fn verifier_set_wrappers_default_deref_and_owned_conversions_work() {
1817        let mut array_feldman = ArrayFeldmanVerifierSet::<TestShare, TestVerifier, 3>::default();
1818        assert_eq!(array_feldman.len(), 3);
1819        array_feldman[0] = verifier(1);
1820        assert_eq!(array_feldman.generator(), verifier(1));
1821
1822        let mut generic_feldman =
1823            GenericArrayFeldmanVerifierSet::<TestShare, TestVerifier, GenericU3>::default();
1824        assert_eq!(generic_feldman.len(), 3);
1825        generic_feldman[0] = verifier(2);
1826        let generic_inner = GenericArray::<TestVerifier, GenericU3>::from(generic_feldman);
1827        let generic_feldman =
1828            GenericArrayFeldmanVerifierSet::<TestShare, TestVerifier, GenericU3>::from(
1829                generic_inner,
1830            );
1831        assert_eq!(generic_feldman.generator(), verifier(2));
1832
1833        let mut hybrid_feldman =
1834            HybridArrayFeldmanVerifierSet::<TestShare, TestVerifier, HybridU3>::default();
1835        assert_eq!(hybrid_feldman.len(), 3);
1836        hybrid_feldman[0] = verifier(3);
1837        let hybrid_inner = Array::<TestVerifier, HybridU3>::from(hybrid_feldman);
1838        let hybrid_feldman =
1839            HybridArrayFeldmanVerifierSet::<TestShare, TestVerifier, HybridU3>::from(hybrid_inner);
1840        assert_eq!(hybrid_feldman.generator(), verifier(3));
1841
1842        let mut array_pedersen = ArrayPedersenVerifierSet::<TestShare, TestVerifier, 4>::default();
1843        assert_eq!(array_pedersen.len(), 4);
1844        array_pedersen[0] = verifier(4);
1845        array_pedersen[1] = verifier(5);
1846        assert_eq!(array_pedersen.secret_generator(), verifier(4));
1847        assert_eq!(array_pedersen.blinder_generator(), verifier(5));
1848
1849        let mut generic_pedersen =
1850            GenericArrayPedersenVerifierSet::<TestShare, TestVerifier, GenericU4>::default();
1851        generic_pedersen[0] = verifier(6);
1852        generic_pedersen[1] = verifier(7);
1853        let generic_inner = GenericArray::<TestVerifier, GenericU4>::from(generic_pedersen);
1854        let generic_pedersen =
1855            GenericArrayPedersenVerifierSet::<TestShare, TestVerifier, GenericU4>::from(
1856                generic_inner,
1857            );
1858        assert_eq!(generic_pedersen.secret_generator(), verifier(6));
1859        assert_eq!(generic_pedersen.blinder_generator(), verifier(7));
1860
1861        let mut hybrid_pedersen =
1862            HybridArrayPedersenVerifierSet::<TestShare, TestVerifier, HybridU4>::default();
1863        hybrid_pedersen[0] = verifier(8);
1864        hybrid_pedersen[1] = verifier(9);
1865        let hybrid_inner = Array::<TestVerifier, HybridU4>::from(hybrid_pedersen);
1866        let hybrid_pedersen =
1867            HybridArrayPedersenVerifierSet::<TestShare, TestVerifier, HybridU4>::from(hybrid_inner);
1868        assert_eq!(hybrid_pedersen.secret_generator(), verifier(8));
1869        assert_eq!(hybrid_pedersen.blinder_generator(), verifier(9));
1870    }
1871
1872    #[test]
1873    fn vec_verifier_wrappers_default_empty_and_deref_mut_work() {
1874        let mut feldman = VecFeldmanVerifierSet::<TestShare, TestVerifier>::default();
1875        assert_eq!(feldman.len(), 0);
1876        feldman.push(verifier(1));
1877        feldman.push(verifier(2));
1878        assert_eq!(feldman.generator(), verifier(1));
1879        assert_eq!(feldman.verifiers(), &[verifier(2)]);
1880
1881        let mut feldman =
1882            VecFeldmanVerifierSet::<TestShare, TestVerifier>::empty_feldman_set_with_capacity(
1883                2,
1884                verifier(3),
1885            );
1886        assert_eq!(feldman.len(), 3);
1887        assert_eq!(feldman.generator(), verifier(3));
1888        feldman.verifiers_mut()[0] = verifier(4);
1889        assert_eq!(feldman.verifiers(), &[verifier(4), verifier(3)]);
1890
1891        let mut pedersen = VecPedersenVerifierSet::<TestShare, TestVerifier>::default();
1892        assert_eq!(pedersen.len(), 0);
1893        pedersen.push(verifier(5));
1894        pedersen.push(verifier(6));
1895        pedersen.push(verifier(7));
1896        assert_eq!(pedersen.secret_generator(), verifier(5));
1897        assert_eq!(pedersen.blinder_generator(), verifier(6));
1898        assert_eq!(pedersen.blind_verifiers(), &[verifier(7)]);
1899
1900        let mut pedersen =
1901            VecPedersenVerifierSet::<TestShare, TestVerifier>::empty_pedersen_set_with_capacity(
1902                2,
1903                verifier(8),
1904                verifier(9),
1905            );
1906        assert_eq!(pedersen.len(), 4);
1907        assert_eq!(pedersen.secret_generator(), verifier(8));
1908        assert_eq!(pedersen.blinder_generator(), verifier(9));
1909        assert_eq!(pedersen.blind_verifiers(), &[verifier(9), verifier(9)]);
1910        pedersen.blind_verifiers_mut()[1] = verifier(10);
1911        assert_eq!(pedersen.blind_verifiers(), &[verifier(9), verifier(10)]);
1912    }
1913
1914    #[test]
1915    fn readable_share_set_combine_handles_success_and_errors() {
1916        let good = vec![share(1, 7), share(2, 7), share(3, 7)];
1917        assert_eq!(validate_share_set(&good), Ok(()));
1918        assert_eq!(good.combine(), Ok(IdentifierPrimeField(Scalar::from(7u64))));
1919
1920        let mut out = IdentifierPrimeField(Scalar::from(99u64));
1921        assert_eq!(good.combine_in_place(&mut out), Ok(()));
1922        assert_eq!(out, IdentifierPrimeField(Scalar::from(7u64)));
1923
1924        let mut out = IdentifierPrimeField(Scalar::from(99u64));
1925        assert_eq!(
1926            vec![share(1, 7)].combine_in_place(&mut out),
1927            Err(Error::SharingMinThreshold)
1928        );
1929        assert_eq!(out, IdentifierPrimeField(Scalar::from(99u64)));
1930
1931        assert_eq!(vec![share(1, 7)].combine(), Err(Error::SharingMinThreshold));
1932        assert_eq!(
1933            validate_share_set(&[share(1, 7)]),
1934            Err(Error::SharingMinThreshold)
1935        );
1936        assert_eq!(
1937            vec![share(0, 7), share(2, 7)].combine(),
1938            Err(Error::SharingInvalidIdentifier)
1939        );
1940        assert_eq!(
1941            vec![share(1, 7), share(1, 8)].combine(),
1942            Err(Error::SharingDuplicateIdentifier)
1943        );
1944    }
1945
1946    #[test]
1947    fn feldman_array_backed_sets_expose_generator_and_verifiers() {
1948        let inner = [verifier(9), verifier(1), verifier(2)];
1949        let mut array_set: ArrayFeldmanVerifierSet<TestShare, TestVerifier, 3> = inner.into();
1950        assert_eq!(array_set.generator(), verifier(9));
1951        assert_eq!(array_set.verifiers(), &[verifier(1), verifier(2)]);
1952        array_set.verifiers_mut()[0] = verifier(3);
1953        assert_eq!(<[TestVerifier; 3]>::from(array_set)[1], verifier(3));
1954
1955        let from_ref: ArrayFeldmanVerifierSet<TestShare, TestVerifier, 3> = (&inner).into();
1956        assert_eq!(<[TestVerifier; 3]>::from(&from_ref), inner);
1957
1958        let empty =
1959            ArrayFeldmanVerifierSet::<TestShare, TestVerifier, 3>::with_capacity(2, verifier(4));
1960        assert_eq!(empty.generator(), verifier(4));
1961
1962        let from_verifiers =
1963            ArrayFeldmanVerifierSet::<TestShare, TestVerifier, 3>::with_generator_and_verifiers(
1964                verifier(6),
1965                &[verifier(7), verifier(8)],
1966            );
1967        assert_eq!(from_verifiers.generator(), verifier(6));
1968        assert_eq!(from_verifiers.verifiers(), &[verifier(7), verifier(8)]);
1969    }
1970
1971    #[test]
1972    fn feldman_generic_hybrid_and_vec_sets_round_trip_storage() {
1973        let generic_inner = GenericArray::<TestVerifier, GenericU3>::from_array([
1974            verifier(9),
1975            verifier(1),
1976            verifier(2),
1977        ]);
1978        let generic_set: GenericArrayFeldmanVerifierSet<TestShare, TestVerifier, GenericU3> =
1979            (&generic_inner).into();
1980        assert_eq!(generic_set.generator(), verifier(9));
1981        assert_eq!(
1982            GenericArray::<TestVerifier, GenericU3>::from(generic_set.clone()),
1983            generic_inner
1984        );
1985        assert_eq!(
1986            GenericArray::<TestVerifier, GenericU3>::from(&generic_set),
1987            generic_inner
1988        );
1989
1990        let hybrid_inner = Array::<TestVerifier, HybridU3>::from_fn(|i| verifier(i as u64 + 1));
1991        let hybrid_set: HybridArrayFeldmanVerifierSet<TestShare, TestVerifier, HybridU3> =
1992            (&hybrid_inner).into();
1993        assert_eq!(hybrid_set.generator(), verifier(1));
1994        assert_eq!(
1995            Array::<TestVerifier, HybridU3>::from(&hybrid_set),
1996            hybrid_inner
1997        );
1998
1999        let vec_inner = vec![verifier(9), verifier(1), verifier(2)];
2000        let mut vec_set: VecFeldmanVerifierSet<TestShare, TestVerifier> = (&vec_inner).into();
2001        assert_eq!(vec_set.generator(), verifier(9));
2002        vec_set.verifiers_mut()[1] = verifier(5);
2003        assert_eq!(Vec::<TestVerifier>::from(&vec_set)[2], verifier(5));
2004        assert_eq!(
2005            Vec::<TestVerifier>::from(VecFeldmanVerifierSet::<TestShare, TestVerifier>::from(
2006                vec_inner.clone()
2007            )),
2008            vec_inner
2009        );
2010    }
2011
2012    #[test]
2013    fn pedersen_array_and_vec_sets_expose_generators_and_verifiers() {
2014        let inner = [verifier(9), verifier(8), verifier(1), verifier(2)];
2015        let mut array_set: ArrayPedersenVerifierSet<TestShare, TestVerifier, 4> = inner.into();
2016        assert_eq!(array_set.secret_generator(), verifier(9));
2017        assert_eq!(array_set.blinder_generator(), verifier(8));
2018        assert_eq!(array_set.blind_verifiers(), &[verifier(1), verifier(2)]);
2019        array_set.blind_verifiers_mut()[0] = verifier(3);
2020        assert_eq!(<[TestVerifier; 4]>::from(array_set)[2], verifier(3));
2021        let from_ref: ArrayPedersenVerifierSet<TestShare, TestVerifier, 4> = (&inner).into();
2022        assert_eq!(<[TestVerifier; 4]>::from(&from_ref), inner);
2023
2024        let vec_inner = vec![verifier(9), verifier(8), verifier(1), verifier(2)];
2025        let mut vec_set: VecPedersenVerifierSet<TestShare, TestVerifier> = (&vec_inner).into();
2026        assert_eq!(vec_set.secret_generator(), verifier(9));
2027        assert_eq!(vec_set.blinder_generator(), verifier(8));
2028        vec_set.blind_verifiers_mut()[1] = verifier(6);
2029        assert_eq!(Vec::<TestVerifier>::from(&vec_set)[3], verifier(6));
2030        assert_eq!(
2031            Vec::<TestVerifier>::from(VecPedersenVerifierSet::<TestShare, TestVerifier>::from(
2032                vec_inner.clone()
2033            )),
2034            vec_inner
2035        );
2036    }
2037
2038    #[test]
2039    fn pedersen_generic_and_hybrid_sets_round_trip_storage() {
2040        let generic_inner = GenericArray::<TestVerifier, GenericU4>::from_array([
2041            verifier(9),
2042            verifier(8),
2043            verifier(1),
2044            verifier(2),
2045        ]);
2046        let mut generic_set: GenericArrayPedersenVerifierSet<TestShare, TestVerifier, GenericU4> =
2047            (&generic_inner).into();
2048        assert_eq!(generic_set.secret_generator(), verifier(9));
2049        assert_eq!(generic_set.blinder_generator(), verifier(8));
2050        assert_eq!(generic_set.blind_verifiers(), &[verifier(1), verifier(2)]);
2051        generic_set.blind_verifiers_mut()[0] = verifier(5);
2052        assert_eq!(
2053            GenericArray::<TestVerifier, GenericU4>::from(&generic_set)[2],
2054            verifier(5)
2055        );
2056        assert_eq!(
2057            GenericArray::<TestVerifier, GenericU4>::from(GenericArrayPedersenVerifierSet::<
2058                TestShare,
2059                TestVerifier,
2060                GenericU4,
2061            >::from(generic_inner)),
2062            generic_inner
2063        );
2064        let empty = GenericArrayPedersenVerifierSet::<TestShare, TestVerifier, GenericU4>::empty_pedersen_set_with_capacity(
2065            2,
2066            verifier(7),
2067            verifier(6),
2068        );
2069        assert_eq!(empty.secret_generator(), verifier(7));
2070        assert_eq!(empty.blinder_generator(), verifier(6));
2071
2072        let hybrid_inner = Array::<TestVerifier, HybridU4>::from_fn(|i| verifier(i as u64 + 1));
2073        let mut hybrid_set: HybridArrayPedersenVerifierSet<TestShare, TestVerifier, HybridU4> =
2074            (&hybrid_inner).into();
2075        assert_eq!(hybrid_set.secret_generator(), verifier(1));
2076        assert_eq!(hybrid_set.blinder_generator(), verifier(2));
2077        hybrid_set.blind_verifiers_mut()[1] = verifier(9);
2078        assert_eq!(
2079            Array::<TestVerifier, HybridU4>::from(&hybrid_set)[3],
2080            verifier(9)
2081        );
2082        assert_eq!(
2083            Array::<TestVerifier, HybridU4>::from(HybridArrayPedersenVerifierSet::<
2084                TestShare,
2085                TestVerifier,
2086                HybridU4,
2087            >::from(hybrid_inner)),
2088            hybrid_inner
2089        );
2090        let empty = HybridArrayPedersenVerifierSet::<TestShare, TestVerifier, HybridU4>::empty_pedersen_set_with_capacity(
2091            2,
2092            verifier(5),
2093            verifier(4),
2094        );
2095        assert_eq!(empty.secret_generator(), verifier(5));
2096        assert_eq!(empty.blinder_generator(), verifier(4));
2097    }
2098
2099    #[test]
2100    fn verifier_sets_return_errors_for_invalid_inputs() {
2101        let invalid_share = share(0, 7);
2102        let feldman = VecFeldmanVerifierSet::<TestShare, TestVerifier>::from(vec![
2103            TestVerifier::identity(),
2104            verifier(1),
2105        ]);
2106        assert_eq!(
2107            feldman.verify_share(&invalid_share),
2108            Err(Error::InvalidShare)
2109        );
2110
2111        let invalid_generator = VecFeldmanVerifierSet::<TestShare, TestVerifier>::from(vec![
2112            TestVerifier::identity(),
2113            verifier(1),
2114        ]);
2115        assert_eq!(
2116            invalid_generator.verify_share(&share(1, 7)),
2117            Err(Error::InvalidGenerator("Generator is identity"))
2118        );
2119
2120        let pedersen = VecPedersenVerifierSet::<TestShare, TestVerifier>::from(vec![
2121            TestVerifier::identity(),
2122            verifier(8),
2123            verifier(1),
2124        ]);
2125        assert_eq!(
2126            pedersen.verify_share_and_blinder(&share(1, 7), &share(1, 3)),
2127            Err(Error::InvalidGenerator(
2128                "Generator or Blind generator is an identity"
2129            ))
2130        );
2131    }
2132
2133    #[test]
2134    fn verifier_sets_evaluate_at_identifier() {
2135        let id = IdentifierPrimeField(Scalar::from(3u64));
2136        let feldman = VecFeldmanVerifierSet::<TestShare, TestVerifier>::from(vec![
2137            verifier(1),
2138            verifier(5),
2139            verifier(2),
2140        ]);
2141        assert_eq!(feldman.evaluate_verifier_at(&id), Ok(verifier(11)));
2142        assert_eq!(feldman.evaluate_at(&id), Ok(verifier(11)));
2143        assert_eq!(
2144            feldman.evaluate_verifier_at(&IdentifierPrimeField::zero()),
2145            Err(Error::InvalidShare)
2146        );
2147
2148        let pedersen = VecPedersenVerifierSet::<TestShare, TestVerifier>::from(vec![
2149            verifier(1),
2150            verifier(2),
2151            verifier(5),
2152            verifier(2),
2153        ]);
2154        assert_eq!(pedersen.evaluate_verifier_at(&id), Ok(verifier(11)));
2155        assert_eq!(pedersen.evaluate_at(&id), Ok(verifier(11)));
2156        assert_eq!(
2157            pedersen.evaluate_verifier_at(&IdentifierPrimeField::zero()),
2158            Err(Error::InvalidShare)
2159        );
2160    }
2161
2162    #[test]
2163    fn verifier_set_simplified_constructors_and_verify_alias_work() {
2164        let feldman =
2165            VecFeldmanVerifierSet::<TestShare, TestVerifier>::with_capacity(2, verifier(3));
2166        assert_eq!(feldman.generator(), verifier(3));
2167        assert_eq!(feldman.verifiers(), &[verifier(3), verifier(3)]);
2168
2169        let pedersen =
2170            VecPedersenVerifierSet::<TestShare, TestVerifier>::with_generators_and_verifiers(
2171                verifier(1),
2172                verifier(2),
2173                &[verifier(7), verifier(2)],
2174            );
2175        assert_eq!(pedersen.secret_generator(), verifier(1));
2176        assert_eq!(pedersen.blinder_generator(), verifier(2));
2177        assert_eq!(
2178            pedersen.verify_blinded_share(&share(3, 7), &share(3, 3)),
2179            Ok(())
2180        );
2181
2182        let pedersen = VecPedersenVerifierSet::<TestShare, TestVerifier>::with_capacity(
2183            2,
2184            verifier(4),
2185            verifier(5),
2186        );
2187        assert_eq!(pedersen.secret_generator(), verifier(4));
2188        assert_eq!(pedersen.blinder_generator(), verifier(5));
2189    }
2190}
2191
2192#[test]
2193fn test_feldman_with_generator_and_verifiers() {
2194    type IdK256 = IdentifierPrimeField<k256::Scalar>;
2195    type VK256 = ValuePrimeField<k256::Scalar>;
2196    type ShareVerifierK256 = ShareVerifierGroup<k256::ProjectivePoint>;
2197    type K256Share = (IdK256, VK256);
2198
2199    let set = <[ShareVerifierK256; 8] as FeldmanVerifierSet<K256Share, ShareVerifierK256>>::feldman_set_with_generator_and_verifiers(
2200        ValueGroup(k256::ProjectivePoint::GENERATOR),
2201        &[ValueGroup(k256::ProjectivePoint::IDENTITY); 7]);
2202    assert_eq!(
2203        ValueGroup(k256::ProjectivePoint::GENERATOR),
2204        <[ShareVerifierK256; 8] as FeldmanVerifierSet<K256Share, ShareVerifierK256>>::generator(
2205            &set
2206        )
2207    );
2208    assert_eq!(
2209        [ValueGroup(k256::ProjectivePoint::IDENTITY); 7],
2210        <[ShareVerifierK256; 8] as FeldmanVerifierSet<K256Share, ShareVerifierK256>>::verifiers(
2211            &set
2212        )
2213    );
2214}
vsss_rs/set.rs

vsss_rs/
set.rs
