eddsa-threshold 0.2.0__py3-none-any.whl

eddsa_threshold/frost/participant.py

@@ -0,0 +1,140 @@
+import os
+from typing import Final, Tuple
+
+from eddsa_threshold.eddsa.curves.base.edwards_curve import EdwardsCurve
+from eddsa_threshold.frost.core.base.frost_hashing import FrostHashing
+from eddsa_threshold.frost.core.frost_types import GroupInfo, NonceCommitment, ParticipantId, SecretShare, SecretValue, SessionId, SigningPackage, VSSCommitment
+from eddsa_threshold.frost.core.polynomial import derive_interpolating_value
+from eddsa_threshold.frost.core.util import binding_factor_for_participant, compute_binding_factors, compute_group_commitment, derive_group_info
+
+
+class FrostParticipant:
+    """
+    Participant-side implementation for a 2-round FROST signing flow.
+
+    The participant owns one long-term secret key share and ephemeral nonces.
+    """
+
+    # EdwardsCurve for now, because this project only implements FROST for EdDSA, but this can be made more generic if needed.
+    def __init__(self, participant_id: ParticipantId, threshold: int, max_participants: int, hashing: FrostHashing, curve: EdwardsCurve):
+        self.PARTICIPANT_ID: Final[ParticipantId] = participant_id
+        self.THRESHOLD: Final[int] = threshold
+        self.MAX_PARTICIPANTS: Final[int] = max_participants
+
+        self._HASHING: Final[FrostHashing] = hashing
+        self._CURVE: Final[EdwardsCurve] = curve
+        
+        self._dealer_info_set: bool = False
+
+        self._nonce_pair: dict[SessionId, Tuple[int, int]] = dict()  # store nonce pairs for active signing sessions, cleared after signing is complete
+
+    def set_and_verify_dealer_info(self, secret_share: SecretShare, vss_commitment: list[VSSCommitment]) -> None:
+        """
+        Set the participant's secret share and group info after receiving and verifying them from the trusted dealer.
+        """
+        
+        if not self._vss_verify(secret_share, vss_commitment):
+            raise ValueError(f"VSS verification failed for the received secret share and VSS commitment for participant {self.PARTICIPANT_ID}")
+
+        if self._dealer_info_set:
+            raise ValueError(f"Participant {self.PARTICIPANT_ID} has already set their dealer info")
+
+        self._SECRET_SHARE = secret_share
+        self._GROUP_INFO = derive_group_info(self.THRESHOLD, self.MAX_PARTICIPANTS, vss_commitment, self._CURVE)
+        self._dealer_info_set = True
+
+    def round_one_commit(self, session_id: SessionId) -> NonceCommitment:
+        """
+        Round 1 of FROST signing: generates a nonce pair and returns the corresponding commitment.
+        """
+
+        if not self._dealer_info_set:
+            raise ValueError(f"Participant {self.PARTICIPANT_ID} has not set their dealer info")
+
+        if session_id in self._nonce_pair:
+            raise ValueError(f"participant {self.PARTICIPANT_ID} has already committed to this signing session")
+
+        nonce_pair, commitment = self._commit()
+        self._nonce_pair[session_id] = nonce_pair
+
+        return commitment
+
+    def round_two_sign(self, signing_package: SigningPackage) -> SecretValue:
+        """
+        Round 2 of FROST signing: takes the signing package from the coordinator and returns the signature share.
+        """
+
+        if signing_package.session_id not in self._nonce_pair:
+            raise ValueError(f"participant {self.PARTICIPANT_ID} must commit to this signing session before signing")
+
+        nonce_pair = self._nonce_pair[signing_package.session_id]
+        signature_share = self._sign(signing_package.session_id, signing_package.message, list(signing_package.commitments.values()))
+
+        self._nonce_pair.pop(signing_package.session_id)  # clear nonce pair for this session since signing is complete
+
+        return signature_share
+
+    def _commit(self) -> Tuple[Tuple[int, int], NonceCommitment]:
+        """
+        Generates a nonce pair and the corresponding commitment for round 1 of FROST signing.
+        """
+        
+        encoded_secret_share = self._CURVE.encoding.encode_scalar(self._SECRET_SHARE.value)
+        hiding_nonce = self._generate_nonce(encoded_secret_share)
+        binding_nonce = self._generate_nonce(encoded_secret_share)
+
+        hiding_nonce_commitment = self._CURVE.extended_to_affine(self._CURVE.scalar_mult(hiding_nonce, None))  # None means base point
+        binding_nonce_commitment = self._CURVE.extended_to_affine(self._CURVE.scalar_mult(binding_nonce, None))
+
+        return (hiding_nonce, binding_nonce), NonceCommitment(self._SECRET_SHARE.index, hiding_nonce_commitment, binding_nonce_commitment)
+
+    def _sign(self, session_id: SessionId, message: bytes, commitments: list[NonceCommitment]) -> SecretValue:
+        """
+        Generates a signature share for round 2 of FROST signing given the signing package from the coordinator.
+        """
+        
+        nonce_pair = self._nonce_pair[session_id]
+
+        binding_factors = compute_binding_factors(self._GROUP_INFO.group_public_key, commitments, message, self._HASHING, self._CURVE.encoding)
+        binding_factor = binding_factor_for_participant(self._SECRET_SHARE.index, binding_factors)
+
+        group_commitment = compute_group_commitment(commitments, binding_factors, self._CURVE)
+
+        participants = list(commitment.participant_id for commitment in commitments)
+        # Potentially implemenet reuse logic
+        lambda_i = derive_interpolating_value(participants, self._SECRET_SHARE.index, 0, self._CURVE.scalar_ops)
+
+        challenge = self._compute_challenge(group_commitment, message)
+
+        hiding_nonce, binding_nonce = nonce_pair
+        signature_share = hiding_nonce + (binding_nonce * binding_factor) + (lambda_i * self._SECRET_SHARE.value * challenge)
+
+        return self._CURVE.scalar_ops.reduce(signature_share)
+
+    def _vss_verify(self, secret_share: SecretShare, vss_commitment: list[VSSCommitment]) -> bool:
+        """
+        Verify a participant's secret share against the VSS commitment.
+        """
+
+        S = self._CURVE.scalar_mult(secret_share.value, None)
+        S_ = (0, 1, 1, 0)  # identity point in extended coordinates
+        for i in range(0, self.THRESHOLD):
+            S_ = self._CURVE.add(S_, self._CURVE.scalar_mult(pow(secret_share.index, i), vss_commitment[i]))
+
+        return self._CURVE.extended_to_affine(S) == self._CURVE.extended_to_affine(S_)
+
+    def _generate_nonce(self, secret: bytes) -> int:
+        """
+        Generates a nonce using the participant's secret share and a random value.
+        """
+        
+        random = os.urandom(32)
+        return self._HASHING.h3(random + secret)
+    
+    def _compute_challenge(self, group_commitment: Tuple, message: bytes) -> int:
+        """
+        Computes the signing challenge c = H(R || A || m) where R is the group commitment, A is the group public key, and m is the message.
+        """
+        
+        challenge_input = self._CURVE.encoding.encode_point(group_commitment) + self._GROUP_INFO.group_public_key + message
+        return self._HASHING.h2(challenge_input)

eddsa_threshold/frost/trusted_dealer.py

@@ -0,0 +1,72 @@
+from typing import Callable, Final
+
+from eddsa_threshold.eddsa.curves.base.edwards_curve import EdwardsCurve
+from eddsa_threshold.frost.core.base.frost_hashing import FrostHashing
+from eddsa_threshold.frost.core.secrets.shamir_secret_sharing import ShamirSecretSharing
+from eddsa_threshold.frost.core.frost_types import ParticipantId, SecretShare, VSSCommitment
+from eddsa_threshold.frost.core.util import check_participant_bounds
+
+
+class FrostTrustedDealer:
+    
+    def __init__(self, seed: int, threshold: int, participant_ids: list[ParticipantId], participant_connections: dict[ParticipantId, Callable[[SecretShare, list[VSSCommitment]], None]], coordinator_connection: Callable[[list[VSSCommitment]], None], curve: EdwardsCurve) -> None:
+        if seed < 0 or seed >= curve.scalar_ops.order:
+            raise ValueError("seed must be a valid scalar value for the curve")
+        
+        check_participant_bounds(threshold, participant_ids, curve.scalar_ops)
+        
+        self._seed = seed
+        self.PARTICIPANT_IDS: Final[list[ParticipantId]] = participant_ids
+        self._PARTICIPANT_CONNECTIONS: Final[dict[ParticipantId, Callable[[SecretShare, list[VSSCommitment]], None]]] = participant_connections
+        self._COORDINATOR_CONNECTION: Final[Callable[[list[VSSCommitment]], None]] = coordinator_connection
+        self._CURVE: Final[EdwardsCurve] = curve
+        
+        # In the future, we may want to support other secret sharing schemes
+        self._SECRET_SHARING: Final[ShamirSecretSharing] = ShamirSecretSharing(threshold, len(self.PARTICIPANT_IDS), self._CURVE.scalar_ops)
+
+    def keygen(self):
+        """
+        Trusted dealer key generation.
+        """
+
+        shares, coeffs = self._SECRET_SHARING.split(self._seed)
+
+        vss_commitment = self._vss_commit(coeffs)
+        
+        for participant_id, share in zip(self.PARTICIPANT_IDS, shares):
+            if participant_id in self._PARTICIPANT_CONNECTIONS:
+                self._PARTICIPANT_CONNECTIONS[participant_id](share, vss_commitment)
+            else:
+                raise ValueError(f"No connection provided for participant {participant_id}")
+            
+        if self._COORDINATOR_CONNECTION:
+            self._COORDINATOR_CONNECTION(vss_commitment)
+            
+        # clear seed, shares, coeffs from memory after key generation, MUST not be reused for another keygen session
+        self._seed = -1
+        shares.clear()
+        coeffs.clear()
+    
+    @classmethod
+    def from_private_bytes(cls, seed: int, threshold: int, participant_ids: list[ParticipantId], participant_connections: dict[ParticipantId, Callable[[SecretShare, list[VSSCommitment]], None]], coordinator_connection: Callable[[list[VSSCommitment]], None], curve: EdwardsCurve) -> FrostTrustedDealer: 
+        """Create a dealer instance from the given private seed bytes."""
+        return cls(seed, threshold, participant_ids, participant_connections, coordinator_connection, curve)
+
+    @classmethod
+    def generate(cls, threshold: int, participant_ids: list[ParticipantId], participant_connections: dict[ParticipantId, Callable[[SecretShare, list[VSSCommitment]], None]], coordinator_connection: Callable[[list[VSSCommitment]], None], curve: EdwardsCurve) -> FrostTrustedDealer: 
+        """Generate a new dealer instance with a fresh secret."""
+        seed = curve.scalar_ops.random_scalar()
+        return cls(seed, threshold, participant_ids, participant_connections, coordinator_connection, curve)
+    
+    def _vss_commit(self, coeffs: list[int]) -> list[VSSCommitment]:
+        """
+        Generates a VSS commitment from the given polynomial coefficients.
+        """
+        
+        vss_commitment = []
+        
+        for coeff in coeffs:
+            vss_i = self._CURVE.scalar_mult(coeff, None) 
+            vss_commitment.append(vss_i)
+            
+        return vss_commitment

eddsa_threshold-0.2.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: eddsa-threshold
+Version: 0.2.0
+Summary: Educational EdDSA and FROST implementations
+Author-email: Maximilian <23641084+xfallme@users.noreply.github.com>
+License-Expression: 0BSD
+Project-URL: Homepage, https://github.com/xfallme/EdDSA-Threshold
+Project-URL: Repository, https://github.com/xfallme/EdDSA-Threshold
+Project-URL: Issues, https://github.com/xfallme/EdDSA-Threshold/issues
+Keywords: cryptography,threshold,eddsa,frost
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: black>=26.5; extra == "dev"
+Requires-Dist: mypy>=2.1; extra == "dev"
+Requires-Dist: pytest==9.0.3; extra == "dev"
+Requires-Dist: pytest-cases==3.10.1; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Requires-Dist: pynacl>=1.6.2; extra == "dev"
+Dynamic: license-file
+
+# EdDSA (Threshold)
+
+> [!CAUTION]
+> This project is a strictly educational implementation of the EdDSA standard and FROST algorithm. This means it is NOT PRODUCTION READY at the moment. 
+> And will likely never be.
+
+This repository contains two different but linked implementations. The first is a "normal" single- party DSA, in this case EdDSA. The second is a multi-party threshold signature scheme, namely FROST.
+
+## EdDSA
+
+Although this implementation is strictly educational, it follows the standard for EdDSA as specified in [RFC 8032](https://datatracker.ietf.org/doc/html/rfc8032).
+
+## FROST
+
+FROST is a bit different, there is no standard (yet) and the [RFC 9591](https://datatracker.ietf.org/doc/html/rfc9591) is strictly informational. 
+Also, the RFC defines multiple instantiations for FROST, however this package only implements the version compatible with [Ed25519](https://datatracker.ietf.org/doc/html/rfc9591#name-frosted25519-sha-512) and [Ed448](https://datatracker.ietf.org/doc/html/rfc9591#name-frosted448-shake256) since the focus of the corresponding Master Thesis is on backwards compatibility in regards to the verification.

eddsa_threshold-0.2.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+eddsa_threshold/__init__.py,sha256=lfKASrNz00_628laptQbdv7sb118Ltk-7n9xu3xsVHk,30
+eddsa_threshold/eddsa/__init__.py,sha256=8n4W6uj_mIwQyz4TXVbvDVtuOEE07EP_Xu6hWaJeYsk,23
+eddsa_threshold/eddsa/algorithms/__init__.py,sha256=OgSLr3-cQJ1findSBT_K0XjwQp7vc448RZwEGtQKqeA,31
+eddsa_threshold/eddsa/algorithms/ed25519.py,sha256=FjG6ADGPlRD_VO51F9k5uAJcHRhcLPwHsqgaWqnODmI,3179
+eddsa_threshold/eddsa/algorithms/ed25519ctx.py,sha256=psIu67FKXCuyLMt4Ww58UIQTn9-gJgTKwyBDwp5vjUs,1034
+eddsa_threshold/eddsa/algorithms/ed25519ph.py,sha256=kB8dnedMRvn2AZP7cPDyFrHsi9Kp6ORf-Gjx8lUfpdk,1065
+eddsa_threshold/eddsa/algorithms/ed448.py,sha256=eussmwjgoGWYRbJdIABOJNQHJBgNA28FSRsqhUQkG-E,3232
+eddsa_threshold/eddsa/algorithms/ed448ph.py,sha256=0VgopcxQ3af98I1tzPZHwO6cRWgnnPfOmgsZccwm8-c,957
+eddsa_threshold/eddsa/curves/__init__.py,sha256=IK7ljKkfDzfkCDEP4EFJtMT1-gInReCqjUG01pPgFRk,28
+eddsa_threshold/eddsa/curves/base/__init__.py,sha256=n9Lvy8LC7DEFjp1fMlF6GkJRKx-TNR0sa7Hqz2vfvw8,30
+eddsa_threshold/eddsa/curves/base/edwards_curve.py,sha256=RUqMF7Vc5Qriovq733FqIMoswwzFj0zw0FpT92zCrgw,2927
+eddsa_threshold/eddsa/curves/base/encoding.py,sha256=TXogRKFEGHItftu-H2Wx3UyyvF7L23osTWzBY2ZpxS8,1635
+eddsa_threshold/eddsa/curves/base/field_ops.py,sha256=EJAA6iY7rw0ZUjh2-_--5fqWIY8qz3_jiDUB3uAHLvo,1350
+eddsa_threshold/eddsa/curves/base/scalar_ops.py,sha256=4tgrqPs4zDSyyIkZXabNJ1bvBWBspXCxE5XewKi8m2c,956
+eddsa_threshold/eddsa/curves/ed25519/__init__.py,sha256=EMBoAt4lBb-KykLhy1UZ8zXCEO5O8iCVQbMwW26loTc,35
+eddsa_threshold/eddsa/curves/ed25519/constants.py,sha256=LvXshRDSA3FE4O4qbw8yQap8WnEkUHxxBlUrSxgeapU,923
+eddsa_threshold/eddsa/curves/ed25519/ed25519_curve.py,sha256=UrvAF85zumOiBFr7JJCEPr7iIWylUA6zK2SUd5G3TOg,2029
+eddsa_threshold/eddsa/curves/ed25519/encoding.py,sha256=TLJJVi7C7-aqyd-JJFJ1r0ty7q6l61d4e8mTz9WiOeQ,2484
+eddsa_threshold/eddsa/curves/ed25519/field_ops.py,sha256=LcQQEHPutCP6xGf95_u005Nj8F70BgxA20Ins56Q9i4,270
+eddsa_threshold/eddsa/curves/ed25519/scalar_ops.py,sha256=9Ormd6XeCDuEMoluz6XZBtnr5Ff-RC_hAVa8UDiWbBI,268
+eddsa_threshold/eddsa/curves/ed448/__init__.py,sha256=9FnwT1eOBgcskwR0H9GES_wNofjt2YTlm6qTxcw00dI,33
+eddsa_threshold/eddsa/curves/ed448/constants.py,sha256=KuG2fwz4Vo6l_lrZ8CpS243H5KyXXIrVdJ5IyLMb-zU,1006
+eddsa_threshold/eddsa/curves/ed448/ed448_curve.py,sha256=vE_UmOnK7nt0yTKaGKXWBq-zaNtZAJrFcXyWDJ73xks,1912
+eddsa_threshold/eddsa/curves/ed448/encoding.py,sha256=oaTE56rgxQr96AJTlhY0dEwvsqbpqBKu935FW6aEs7s,2325
+eddsa_threshold/eddsa/curves/ed448/field_ops.py,sha256=8MhjocTHJifeMJaTqRgYIRXeu6AyxTh29nWJOv80_Tg,273
+eddsa_threshold/eddsa/curves/ed448/scalar_ops.py,sha256=AH2vUnaeyt1v22Ui18sG_ty327p0oTVJx2FOgB8Na0M,261
+eddsa_threshold/eddsa/keys/__init__.py,sha256=OVoWR2WgDoEkOW2IpRRTWemWd4d3CVyrQVv4adGefSg,22
+eddsa_threshold/eddsa/keys/ed25519_keypair.py,sha256=fTbCB1t6wcQ4gonFNiLQVXPpSTAuP8UwwfSCW4Rq8p4,1561
+eddsa_threshold/eddsa/keys/ed448_keypair.py,sha256=gJm6CWhOA7ShqSm-PrJgYFN63mQHzv-wSctxr10VGmg,1554
+eddsa_threshold/eddsa/keys/keypair.py,sha256=myvBx7qNMFVVhi30EVwtejhZwA83swvN4U2Rrqg0nEQ,1623
+eddsa_threshold/eddsa/util/__init__.py,sha256=wFHlAEsRLfuekGImWHqi-_1OzvPYfDcbiRbSANgDuIM,22
+eddsa_threshold/eddsa/util/dom.py,sha256=kqU7e0axroO2AZ2deh0qcuUPgltMfDJ6VqZdsloQ688,663
+eddsa_threshold/eddsa/util/hash_bindings.py,sha256=KcKkMENtCLSMx118BBsFuMvZgPefOLEnic0wKivrZ60,349
+eddsa_threshold/frost/__init__.py,sha256=iK_XjyEK_4ApFFNN6MRTYpH0Cpxqyy7axinGj3Q_aWs,36
+eddsa_threshold/frost/coordinator.py,sha256=74JLPw7MntKmvjpiOGAcLEM-ceqsJJ_FC5fjKZOv0dI,7744
+eddsa_threshold/frost/participant.py,sha256=jiS_XeVWV3to6UQsqKnzQgt-68OFO1JTyjxOh4RBgI4,6943
+eddsa_threshold/frost/trusted_dealer.py,sha256=ndfwPyAiHE1D33z_4GUqwPEB0xagLNlUGTkFsWFJQfI,3878
+eddsa_threshold/frost/core/__init__.py,sha256=1KX1Z_tlMEkLpDH6skCl_tb3rGjvhJ6VQOLBI8Oq5qo,28
+eddsa_threshold/frost/core/frost_types.py,sha256=LYiowaolZn6yw-T3VJ-ho35vvuXvlkhkxWqBHah06yg,1253
+eddsa_threshold/frost/core/polynomial.py,sha256=Hi4D7p4VBIYNcZe7nos-fgKy3eCQeKf6IZLKikweqZM,1132
+eddsa_threshold/frost/core/util.py,sha256=o4O1x0lLGlgqprH52i_EdO1pRVKg_uV0haW-Fd9hQ5w,4924
+eddsa_threshold/frost/core/base/__init__.py,sha256=0eFoCkRPKQ-l6UhQbp1y9w57QlemTj6XKfDXcDDdbtg,28
+eddsa_threshold/frost/core/base/frost_hashing.py,sha256=qboXjQr36J0BVUg2SGpkLFzAl7Th2Dsw2peX0zRXgog,658
+eddsa_threshold/frost/core/ed25519/__init__.py,sha256=A6MxasKrHxcl-dv1pu-YH8FhrjZI2Pvs7FgOm6cVJlU,37
+eddsa_threshold/frost/core/ed25519/frost_hashing.py,sha256=zvvdrhyvAxQipkvOs5dUJcz3cNwE7iH2HmCCI8hQxbw,919
+eddsa_threshold/frost/core/ed448/__init__.py,sha256=LePiRkQccNcBfHY8vve7jwZHNSyUbh65H7QJOhc2jDk,35
+eddsa_threshold/frost/core/ed448/frost_hashing.py,sha256=sQpan2t6RI70lfkhT2NK8CZMY4O5M2cbj2J3lP07E6I,1078
+eddsa_threshold/frost/core/secrets/__init__.py,sha256=QI-UHdD9Pyhhbd6mRwa2UX-8qBPlBtRTQ42seqc8wWw,29
+eddsa_threshold/frost/core/secrets/secret_sharing.py,sha256=8YbTWSbO76DaBHymRvT8Ej3CVIVrTvxC8vtndF91BfE,854
+eddsa_threshold/frost/core/secrets/shamir_secret_sharing.py,sha256=ntx1iPjPamTE_bWvWfEc2juVYHsTc4o9zrAgPdYgTJI,1767
+eddsa_threshold-0.2.0.dist-info/licenses/LICENSE,sha256=GnTcxvPvk1nKBdI6c2txhYiKrz6d12VBluN9qN59_1w,660
+eddsa_threshold-0.2.0.dist-info/METADATA,sha256=UrqBi1bH36ZGF1cl1nNnqcHNGRM8D9fqRmrqKiXFJJo,2054
+eddsa_threshold-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+eddsa_threshold-0.2.0.dist-info/top_level.txt,sha256=iLKoOwo1o3ZOWfN1iZSY_M-Gr8kzE_Yc4v8K6wB9j0w,16
+eddsa_threshold-0.2.0.dist-info/RECORD,,

eddsa_threshold-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eddsa_threshold-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,14 @@
+BSD Zero Clause License
+
+Copyright (c) 2026 xfallme
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

eddsa_threshold-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eddsa_threshold