Struct SigningBuilder 

pub struct SigningBuilder<'r, E, L = SecurityLevel128, D = Sha256>
where
    E: Curve,
    L: SecurityLevel,
    D: Digest,
{ /* private fields */ }

Signing entry point

Implementations

impl<'r, E, L, D> SigningBuilder<'r, E, L, D>

where E: Curve, NonZero<Point<E>>: AlwaysHasAffineX<E>, L: SecurityLevel, D: Digest + Clone + 'static,

pub fn new( eid: ExecutionId<'r>, i: PartyIndex, parties_indexes_at_keygen: &'r [PartyIndex], secret_key_share: &'r KeyShare<E, L>, ) -> Self

Construct a signing builder

pub fn set_digest<D2>(self) -> SigningBuilder<'r, E, L, D2>

where D2: Digest,

Specifies another hash function to use

pub fn set_progress_tracer(self, tracer: &'r mut dyn Tracer) -> Self

Specifies a tracer that tracks progress of protocol execution

pub fn enforce_reliable_broadcast(self, v: bool) -> Self

Ensures reliability of broadcast channel by adding one extra communication round

CGGMP24 protocol requires message in the first round to be sent over reliable broadcast channel. We ensure reliability of the broadcast channel by introducing extra communication round (at cost of additional latency). You may disable it, for instance, if your transport layer is reliable by construction (e.g. you use blockchain for communications).

Default: true.

pub fn set_derivation_path<Index>( self, path: impl IntoIterator<Item = Index>, ) -> Result<Self, HdError<<Index as TryInto<NonHardenedIndex>>::Error>>

where Slip10: HdWallet<E>, NonHardenedIndex: TryFrom<Index>,

Available on crate features hd-wallet and hd-slip10 only.

Specifies HD derivation path

Example

Set derivation path to m/1/999

cggmp24::signing(eid, i, &parties_indexes_at_keygen, &key_share)
    .set_derivation_path([1, 999])?

Derivation algorithm

This method uses [hd_wallet::Slip10] derivation algorithm, which can only be used with secp256k1 and secp256r1 curves. If you need to use another one, see set_derivation_path_with_algo

pub fn set_derivation_path_with_algo<Hd: HdWallet<E>, Index>( self, path: impl IntoIterator<Item = Index>, ) -> Result<Self, HdError<<Index as TryInto<NonHardenedIndex>>::Error>>

where NonHardenedIndex: TryFrom<Index>,

Available on crate feature hd-wallet only.

Specifies HD derivation path, using HD derivation algorithm [hd_wallet::HdWallet]

pub async fn generate_presignature<R, M>( self, rng: &mut R, party: M, ) -> Result<(Presignature<E>, PresignaturePublicData<E>), SigningError>

where R: RngCore + CryptoRng, M: Mpc<ProtocolMessage = Msg<E, D>>,

Starts presignature generation protocol

pub fn generate_presignature_sync<R>( self, rng: &'r mut R, ) -> impl StateMachine<Output = Result<(Presignature<E>, PresignaturePublicData<E>), SigningError>, Msg = Msg<E, D>> + 'r

where R: RngCore + CryptoRng,

Available on crate feature state-machine only.

Returns a state machine that can be used to carry out the presignature generation protocol

See [round_based::state_machine] for details on how that can be done.

pub async fn sign<R, M>( self, rng: &mut R, party: M, message_to_sign: &dyn AnyDataToSign<E>, ) -> Result<Signature<E>, SigningError>

where R: RngCore + CryptoRng, M: Mpc<ProtocolMessage = Msg<E, D>>,

Starts signing protocol

message_to_sign can be either DataToSign (original message being signed is known) or PrehashedDataToSign (only hash of the message being signed is known), protocol is secure regardless. However, the best practice is to use DataToSign whenever possible.

pub fn sign_sync<R>( self, rng: &'r mut R, message_to_sign: &'r dyn AnyDataToSign<E>, ) -> impl StateMachine<Output = Result<Signature<E>, SigningError>, Msg = Msg<E, D>> + 'r

where R: RngCore + CryptoRng,

Available on crate feature state-machine only.

Returns a state machine that can be used to carry out the signing protocol

See [round_based::state_machine] for details on how that can be done.

message_to_sign can be either DataToSign (original message being signed is known) or PrehashedDataToSign (only hash of the message being signed is known), protocol is secure regardless. However, the best practice is to use DataToSign whenever possible.