Examples

cd /path/to/stoffel
cargo run -p stoffel-rust-sdk --example quickstart
cargo run -p stoffel-rust-sdk --example local_mpc_named_inputs
cargo run -p stoffel-rust-sdk --example local_mpc_client_input

use stoffel::prelude::*;

fn main() -> stoffel::Result<()> {
    let result = Stoffel::compile("def main(a: int64, b: int64) -> int64:\n  return a + b")?
        .with_inputs(&[("a", 42_i64), ("b", 58_i64)])
        .execute_clear()?;

    println!("Result: {}", result[0]);
    Ok(())
}

Result: 100

use stoffel::prelude::*;

#[tokio::main]
async fn main() -> stoffel::Result<()> {
    let result = Stoffel::compile(
        "def main(a: secret int64, b: secret int64) -> secret int64:\n  return a + b",
    )?
    .parties(5)
    .threshold(1)
    .with_inputs(&[("a", 42_i64), ("b", 58_i64)])
    .execute_local()
    .await;

    match result {
        Ok(values) => println!("Private result: {}", values[0]),
        Err(stoffel::Error::Unsupported(message)) => println!("Local MPC unavailable: {message}"),
        Err(error) => return Err(error),
    }

    Ok(())
}

use stoffel::prelude::*;

#[tokio::main]
async fn main() -> stoffel::Result<()> {
    let source = r#"
def add_private_values(a: Share, b: Share) -> int64:
  var sum = Share.add(a, b)
  return sum.open()
"#;

    match Stoffel::compile(source)?
        .parties(5)
        .threshold(1)
        .with_inputs(&[("a", 42_i64), ("b", 58_i64)])
        .execute_local_function("add_private_values")
        .await
    {
        Ok(result) => println!("Local MPC named-input result: {}", result[0]),
        Err(stoffel::Error::Unsupported(message)) => println!("Local MPC unavailable: {message}"),
        Err(error) => return Err(error),
    }

    Ok(())
}

use stoffel::prelude::*;

#[tokio::main]
async fn main() -> stoffel::Result<()> {
    let source = r#"
def main() -> int64:
  var share = ClientStore.take_share(0, 0)
  var opened: int64 = share.open()
  return opened + 5
"#;

    let runtime = Stoffel::compile(source)?.parties(5).threshold(1).build()?;
    let client = runtime.program().client(0).expect("client slot 0");
    println!(
        "Program expects {} input(s) from client slot {}",
        client.input_count(),
        client.client_slot()
    );

    match Stoffel::load(&runtime.program().to_bytecode()?)?
        .parties(5)
        .threshold(1)
        .with_client_input(0, &[42_i64])
        .execute_local()
        .await
    {
        Ok(result) => println!("Local MPC result: {}", result[0]),
        Err(stoffel::Error::Unsupported(message)) => println!("Local MPC unavailable: {message}"),
        Err(error) => return Err(error),
    }

    Ok(())
}

use std::time::{SystemTime, UNIX_EPOCH};

use stoffel::prelude::*;

fn main() -> stoffel::Result<()> {
    let source = "def main(a: int64, b: int64) -> int64:\n  return a * b";
    let runtime = Stoffel::compile(source)?.build()?;

    let bytecode_path = std::env::temp_dir().join(format!(
        "stoffel-sdk-bytecode-{}-{}.stflb",
        std::process::id(),
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map(|duration| duration.as_nanos())
            .unwrap_or_default()
    ));
    runtime.save_bytecode(&bytecode_path)?;
    let summary = runtime.bytecode_summary()?;

    let result = Stoffel::load_file(&bytecode_path)?
        .with_inputs(&[("a", 6_i64), ("b", 7_i64)])
        .execute_clear()?;

    let _ = std::fs::remove_file(&bytecode_path);
    println!(
        "Bytecode round-trip result: {} ({} bytes, {} function(s))",
        result[0], summary.byte_len, summary.program.function_count
    );
    Ok(())
}

use stoffel::prelude::*;

fn main() -> stoffel::Result<()> {
    let deployment = NetworkDeployment::builder([
        "127.0.0.1:19200",
        "127.0.0.1:19201",
        "127.0.0.1:19202",
        "127.0.0.1:19203",
        "127.0.0.1:19204",
    ])
    .expected_clients(1)
    .threshold(1)
    .backend(MpcBackend::HoneyBadger)
    .preprocessing(1000, 500)
    .build()?;

    let config_dir = std::env::temp_dir().join("stoffel-sdk-network-configs");
    let paths = deployment.save_toml_files(&config_dir)?;
    let reparsed = NetworkConfig::from_toml_file(&paths[0])?;
    let _ = std::fs::remove_dir_all(&config_dir);

    let server = StoffelServer::builder(0)
        .network_deployment(&deployment)
        .build()?;
    let client = StoffelClient::builder().network_config(&reparsed).build()?;

    println!(
        "Configured party {} on {} with {} peer(s); client sees {} server(s)",
        server.party_id(),
        server.bind_addr(),
        server.peers().len(),
        client.servers().len()
    );
    Ok(())
}

use std::time::Duration;

use stoffel::prelude::*;
use tracing::Level;

fn main() -> stoffel::Result<()> {
    let tracing = TracingConfig::builder()
        .service_name("stoffel-observability-example")
        .max_level(Level::INFO)
        .ansi(false)
        .build();

    let server = StoffelServer::builder(0)
        .bind("127.0.0.1:19400")
        .with_preprocessing(100, 50)
        .build()?;

    server.metrics().record_connected_peers(4);
    server.metrics().record_connected_clients(1);
    server.metrics().record_preprocessing_remaining(80, 40);
    server
        .metrics()
        .record_computation_latency(Duration::from_millis(25));
    server.metrics().increment_computations_completed();

    let snapshot = server.metrics().snapshot();
    println!(
        "health={} peers={} completed={}",
        server.health(),
        snapshot.connected_peers,
        snapshot.computations_completed
    );

    let error = Error::Preprocessing("not enough triples".to_owned());
    println!(
        "error_category={} recoverable={} hint={:?}",
        error.category(),
        error.is_recoverable(),
        error.recovery_hint()
    );

    println!("Tracing summary: {:?}", tracing.summary());
    Ok(())
}