mpvss-rs 2.0.0

A Simple Publicly Verifiable Secret Sharing Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// Copyright 2020-2026 MathxH Chen.
//
// Code is licensed under MIT Apache Dual License

#![allow(non_snake_case)]

use num_bigint::BigInt;
use num_traits::identities::Zero;
use std::collections::HashMap;
use std::vec::Vec;

use crate::group::Group;

// ============================================================================
// Generic ShareBox Types for 1.0.0 API
// ============================================================================

/// Generic share box for any cryptographic group.
///
/// Used to store a decrypted share along with its DLEQ proof.
#[derive(Debug, Clone)]
pub struct GenericShareBox<G: Group> {
    pub publickey: G::Element,
    pub share: G::Element,
    pub challenge: G::Scalar,
    pub response: G::Scalar,
}

impl<G: Group> Default for GenericShareBox<G>
where
    G::Element: Default,
    G::Scalar: Default,
{
    fn default() -> Self {
        GenericShareBox {
            publickey: Default::default(),
            share: Default::default(),
            challenge: Default::default(),
            response: Default::default(),
        }
    }
}

impl<G: Group> GenericShareBox<G> {
    pub fn new() -> Self
    where
        G::Element: Default,
        G::Scalar: Default,
    {
        Self::default()
    }

    pub fn init(
        &mut self,
        publickey: G::Element,
        share: G::Element,
        challenge: G::Scalar,
        response: G::Scalar,
    ) {
        self.publickey = publickey;
        self.share = share;
        self.challenge = challenge;
        self.response = response;
    }
}

/// Generic distribution shares box for any cryptographic group.
///
/// Used to store all encrypted shares with commitments and proofs.
///
/// Note: Uses HashMap with Vec<u8> keys (serialized elements) instead of
/// G::Element directly, to support group elements that don't implement Hash
/// (e.g., EC points like AffinePoint).
#[derive(Debug, Clone)]
pub struct GenericDistributionSharesBox<G: Group> {
    pub commitments: Vec<G::Element>,
    /// Maps serialized element bytes to position
    pub positions: HashMap<Vec<u8>, i64>,
    /// Maps serialized element bytes to encrypted share
    pub shares: HashMap<Vec<u8>, G::Element>,
    pub publickeys: Vec<G::Element>,
    pub challenge: G::Scalar,
    /// Maps serialized element bytes to response
    pub responses: HashMap<Vec<u8>, G::Scalar>,
    pub U: BigInt, // Secret encoded as BigInt for cross-group compatibility
}

impl<G: Group> Default for GenericDistributionSharesBox<G>
where
    G::Scalar: Default,
{
    fn default() -> Self {
        GenericDistributionSharesBox {
            commitments: Vec::new(),
            positions: HashMap::new(),
            shares: HashMap::new(),
            publickeys: Vec::new(),
            challenge: Default::default(),
            responses: HashMap::new(),
            U: BigInt::zero(),
        }
    }
}

impl<G: Group> GenericDistributionSharesBox<G> {
    pub fn new() -> Self
    where
        G::Scalar: Default,
    {
        Self::default()
    }

    /// Initialize the distribution shares box.
    ///
    /// Note: positions, shares, and responses should use Vec<u8> keys (serialized elements).
    #[allow(clippy::too_many_arguments)]
    pub fn init(
        &mut self,
        commitments: &[G::Element],
        positions: HashMap<Vec<u8>, i64>,
        shares: HashMap<Vec<u8>, G::Element>,
        publickeys: &[G::Element],
        challenge: &G::Scalar,
        responses: HashMap<Vec<u8>, G::Scalar>,
        U: &BigInt,
    ) {
        self.commitments = commitments.to_vec();
        self.positions = positions;
        self.shares = shares;
        self.publickeys = publickeys.to_vec();
        self.challenge = challenge.clone();
        self.responses = responses;
        self.U = U.clone();
    }
}

// ============================================================================
// Type Aliases (Primary API)
// ============================================================================

/// Type alias for the generic ShareBox - primary API for 1.0.0
/// Replaces the old non-generic ShareBox struct
pub type ShareBox<G> = GenericShareBox<G>;

/// Type alias for the generic DistributionSharesBox - primary API for 1.0.0
/// Replaces the old non-generic DistributionSharesBox struct
pub type DistributionSharesBox<G> = GenericDistributionSharesBox<G>;