Module state_machine 

Available on crate feature state-machine only.

Wraps the protocol defined as async function and provides sync API to execute it

In round_based framework, MPC protocols are defined as async function. However, sometimes it may not be possible/desirable to have async runtime which drives the futures until completion. For such use-cases, we provide wrap_protocol function that wraps an MPC protocol defined as async function and returns the StateMachine that exposes sync API to carry out the protocol.

Example

use anyhow::{Result, Error, Context as _};

// Any MPC protocol
pub async fn protocol_of_random_generation<M>(
    party: M,
    i: u16,
    n: u16
) -> Result<Randomness>
where
    M: round_based::Mpc<Msg = Msg>
{
    // ...
}

// `state` implements `round_based::state_machine::StateMachine` trait.
// Its methods can be used to advance protocol until completion.
let mut state = round_based::state_machine::wrap_protocol(
    |party| protocol_of_random_generation(party, 0, 3)
);

fn send(msg: round_based::Outgoing<Msg>) -> Result<()> {
    // sends outgoing message...
}
fn recv() -> Result<round_based::Incoming<Msg>> {
    // receives incoming message...
}

use round_based::state_machine::{StateMachine as _, ProceedResult};
let output = loop {
    match state.proceed() {
        ProceedResult::SendMsg(msg) => {
            send(msg)?
        }
        ProceedResult::NeedsOneMoreMessage => {
            let msg = recv()?;
            state.received_msg(msg)
                .map_err(|_| anyhow::format_err!("state machine rejected received message"))?;
        }
        ProceedResult::Yielded => {},
        ProceedResult::Output(out) => break Ok(out),
        ProceedResult::Error(err) => break Err(err),
    }
};

Structs

Delivery

Provides a stream of incoming and sink for outgoing messages

DeliveryErr

Error returned by Delivery

ExecutionError

Error type which indicates that state machine failed to carry out the protocol

Runtime

State machine runtime

YieldNow

Future returned by runtime.yield_now()

Enums

ProceedResult

Tells why protocol execution stopped

Traits

StateMachine

Provides interface to execute the protocol

Functions

wrap_protocol

Wraps the protocol and provides sync API to execute it

Type Aliases

MpcParty

MpcParty instantiated with state machine implementation of delivery and async runtime