Struct Party 

pub struct Party<C>
where
    C: DklsCurve,
{
    pub parameters: Parameters,
    pub party_index: PartyIndex,
    pub session_id: Vec<u8>,
    pub poly_point: <C as CurveArithmetic>::Scalar,
    pub pk: <C as CurveArithmetic>::AffinePoint,
    pub zero_share: ZeroShare,
    pub mul_senders: BTreeMap<PartyIndex, MulSender<C>>,
    pub mul_receivers: BTreeMap<PartyIndex, MulReceiver<C>>,
    pub derivation_data: DerivData<C>,
    pub address: String,
}

Represents a party after key generation ready to sign a message.

Fields

parameters: Parameters

party_index: PartyIndex

session_id: Vec<u8>

poly_point: <C as CurveArithmetic>::Scalar

Behaves as the secret key share.

pk: <C as CurveArithmetic>::AffinePoint

Public key.

zero_share: ZeroShare

Used for computing shares of zero during signing.

mul_senders: BTreeMap<PartyIndex, MulSender<C>>

Initializations for two-party multiplication. The key in the BTreeMap represents the other party.

mul_receivers: BTreeMap<PartyIndex, MulReceiver<C>>

derivation_data: DerivData<C>

Data for BIP-32 derivation.

address: String

Address calculated from the public key.

Implementations

impl<C> Party<C>

where C: DklsCurve,

Implementations related to BIP-32 derivation (read more).

pub fn derive_child( &self, child_number: u32, address_fn: impl Fn(&<C as CurveArithmetic>::AffinePoint) -> String, ) -> Result<Party<C>, ErrorDeriv>

Derives an instance of Party given a child number.

The address_fn parameter computes the address from the derived public key.

Errors

Will return Err if the DerivData::derive_child fails.

pub fn derive_from_path( &self, path: &str, address_fn: impl Fn(&<C as CurveArithmetic>::AffinePoint) -> String, ) -> Result<Party<C>, ErrorDeriv>

Derives an instance of Party following a path on the “key tree”.

See https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki for the description of a possible path (and don’t forget that hardened derivations are not implemented).

Errors

Will return Err if the DerivData::derive_from_path fails.

impl<C> Party<C>

where C: DklsCurve,

Implementations related to refresh protocols (read more).

pub fn refresh_complete_phase1(&self) -> Vec<<C as CurveArithmetic>::Scalar>

Works as Phase 1 in DKG, but with the alterations needed for the refresh protocol.

The output should be dealt in the same way.

pub fn refresh_complete_phase2( &self, refresh_sid: &[u8], poly_fragments: &[<C as CurveArithmetic>::Scalar], ) -> (<C as CurveArithmetic>::Scalar, ProofCommitment<C>, BTreeMap<PartyIndex, KeepInitZeroSharePhase2to3>, Vec<TransmitInitZeroSharePhase2to4>)

Works as Phase 2 in DKG, but the derivation part is omitted.

The output should be dealt in the same way. The only difference is that we will refer to the scalarpoly_point as correction_value.

pub fn refresh_complete_phase3( &self, refresh_sid: &[u8], zero_kept: &BTreeMap<PartyIndex, KeepInitZeroSharePhase2to3>, ) -> (BTreeMap<PartyIndex, KeepInitZeroSharePhase3to4>, Vec<TransmitInitZeroSharePhase3to4>, BTreeMap<PartyIndex, KeepInitMulPhase3to4<C>>, Vec<TransmitInitMulPhase3to4<C>>)

Works as Phase 3 in DKG, but the derivation part is omitted.

The output should be dealt in the same way.

pub fn refresh_complete_phase4( &self, refresh_sid: &[u8], correction_value: &<C as CurveArithmetic>::Scalar, proofs_commitments: &[ProofCommitment<C>], zero_kept: &BTreeMap<PartyIndex, KeepInitZeroSharePhase3to4>, zero_received_phase2: &[TransmitInitZeroSharePhase2to4], zero_received_phase3: &[TransmitInitZeroSharePhase3to4], mul_kept: &BTreeMap<PartyIndex, KeepInitMulPhase3to4<C>>, mul_received: &[TransmitInitMulPhase3to4<C>], ) -> Result<Party<C>, Abort>

Works as Phase 4 in DKG, but the derivation part is omitted. Moreover, the variable poly_point is now called correction_value.

The output is a new instance of Party which is the previous one refreshed.

Errors

Will return Err if the verifying public key is not trivial, if a message is not meant for the party, if the zero shares protocol fails when verifying the seeds or if the multiplication protocol fails.

pub fn refresh_phase1(&self) -> Vec<<C as CurveArithmetic>::Scalar>

Works as Phase 1 in DKG, but with the alterations needed for the refresh protocol.

The output should be dealt in the same way.

pub fn refresh_phase2( &self, refresh_sid: &[u8], poly_fragments: &[<C as CurveArithmetic>::Scalar], ) -> (<C as CurveArithmetic>::Scalar, ProofCommitment<C>, BTreeMap<PartyIndex, KeepRefreshPhase2to3>, Vec<TransmitRefreshPhase2to4>)

Works as Phase 2 in DKG, but the derivation part is omitted.

The output should be dealt in the same way. The only difference is that we will refer to the scalarpoly_point as correction_value.

pub fn refresh_phase3( &self, kept: &BTreeMap<PartyIndex, KeepRefreshPhase2to3>, ) -> (BTreeMap<PartyIndex, KeepRefreshPhase3to4>, Vec<TransmitRefreshPhase3to4>)

Works as Phase 3 in DKG, but the multiplication and derivation parts are omitted.

The output should be dealt in the same way.

pub fn refresh_phase4( &self, refresh_sid: &[u8], correction_value: &<C as CurveArithmetic>::Scalar, proofs_commitments: &[ProofCommitment<C>], kept: &BTreeMap<PartyIndex, KeepRefreshPhase3to4>, received_phase2: &[TransmitRefreshPhase2to4], received_phase3: &[TransmitRefreshPhase3to4], ) -> Result<Party<C>, Abort>

Works as Phase 4 in DKG, but the multiplication and derivation parts are omitted. Moreover, the variable poly_point is now called correction_value.

The output is a new instance of Party which is the previous one refreshed.

Errors

Will return Err if the verifying public key is not trivial, if a message is not meant for the party or if the zero shares protocol fails when verifying the seeds.

Panics

Will panic if the indices of the parties are different from the ones used in DKG.

impl<C> Party<C>

where C: DklsCurve,

Implementations related to the DKLs23 signing protocol (read more).

pub fn sign_phase1( &self, data: &SignData, ) -> Result<(UniqueKeep1to2<C>, BTreeMap<PartyIndex, KeepPhase1to2<C>>, Vec<TransmitPhase1to2>), Abort>

Phase 1 for signing: Steps 4, 5 and 6 from Protocol 3.6 in https://eprint.iacr.org/2023/765.pdf.

The outputs should be kept or transmitted according to the conventions here.

Errors

Will return Err if the number of counterparties is wrong, if any party index is out of range, or if the counterparty list contains our own index.

pub fn sign_phase2( &self, data: &SignData, unique_kept: &UniqueKeep1to2<C>, kept: &BTreeMap<PartyIndex, KeepPhase1to2<C>>, received: &[TransmitPhase1to2], ) -> Result<(UniqueKeep2to3<C>, BTreeMap<PartyIndex, KeepPhase2to3<C>>, Vec<TransmitPhase2to3<C>>), Abort>

Phase 2 for signing: Step 7 from Protocol 3.6 in https://eprint.iacr.org/2023/765.pdf.

The inputs come from the previous phase. The messages received should be gathered in a vector (in any order).

The outputs should be kept or transmitted according to the conventions here.

Errors

Will return Err if the multiplication protocol fails.

Panics

Will panic if the list of keys in the BTreeMap’s are incompatible with the party indices in the vector received.

pub fn sign_phase3( &self, data: &SignData, unique_kept: &UniqueKeep2to3<C>, kept: &BTreeMap<PartyIndex, KeepPhase2to3<C>>, received: &[TransmitPhase2to3<C>], ) -> Result<(String, Broadcast3to4<C>), Abort>

Phase 3 for signing: Steps 8 and 9 from Protocol 3.6 in https://eprint.iacr.org/2023/765.pdf.

The inputs come from the previous phase. The messages received should be gathered in a vector (in any order).

The first output is already the value r from the ECDSA signature. The second output should be broadcasted according to the conventions here.

Errors

Will return Err if some commitment doesn’t verify, if the multiplication protocol fails or if one of the consistency checks is false. The error will also happen if the total instance point is trivial (very unlikely).

Panics

Will panic if the list of keys in the BTreeMap’s are incompatible with the party indices in the vector received.

pub fn sign_phase4( &self, data: &SignData, x_coord: &str, received: &[Broadcast3to4<C>], normalize: bool, ) -> Result<(String, u8), Abort>

Phase 4 for signing: Step 10 from Protocol 3.6 in https://eprint.iacr.org/2023/765.pdf.

The inputs come from the previous phase. The messages received should be gathered in a vector (in any order). Note that our broadcasted message from the previous round should also appear here.

The first output is the value s from the ECDSA signature. The second output is the recovery id from the ECDSA signature. Note that the parameter ‘v’ isn’t this value, but it is used to compute it. To know how to compute it, check the EIP which standardizes the transaction format that you’re using. For example: EIP-155, EIP-2930, EIP-1559.

Errors

Will return Err if the final ECDSA signature is invalid or if the denominator in signature assembly is zero.

Trait Implementations

impl<C> Clone for Party<C>

where C: Clone + DklsCurve, <C as CurveArithmetic>::Scalar: Clone, <C as CurveArithmetic>::AffinePoint: Clone,

fn clone(&self) -> Party<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Debug for Party<C>

where C: Debug + DklsCurve, <C as CurveArithmetic>::Scalar: Debug, <C as CurveArithmetic>::AffinePoint: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for Party<C>

where C: DklsCurve, <C as CurveArithmetic>::AffinePoint: Deserialize<'de>, <C as CurveArithmetic>::Scalar: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Party<C>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Drop for Party<C>

where C: DklsCurve,

fn drop(&mut self)

Executes the destructor for this type.

impl<C> Serialize for Party<C>

where C: DklsCurve, <C as CurveArithmetic>::AffinePoint: Serialize, <C as CurveArithmetic>::Scalar: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Zeroize for Party<C>

where C: DklsCurve,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.