Give your app a boundary for the private part

Compile, configure, submit shares, and receive opened outputs from one application boundary

Get Started with Rust SDK

Schedule a Demo

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 result = Stoffel::compile(source)?
        .parties(5)
        .threshold(1)
        .with_client_input(0, &[42_i64])
        .execute_local()
        .await?;

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

Why use a boundary instead of glue code?

Because private computation needs a clear path in and a clear output coming back

Share before it leaves

Turn sensitive user context into shares before it moves through the workflow.

Compute over shares

MPC parties process shares instead of private details.

Open only the result

Open requested output.

Integration surfaces

Rust SDK workflow

Primary path

Build the application boundary around compilation, shares, network configuration, and outputs.

Python path

Coming next

A higher-level interface for teams that want the same boundary from Python.

Solidity path

Primary path

Coordinate private computation from on-chain applications when the workflow needs it.

How your app uses it

ClientStore.take_share(0, 0)

Create shares before the sensitive value leaves your app boundary.

Send

Stoffel::compile(source)?

.with_client_input(0, &[42_i64])

Run the computation across parties operating on shares.

Rebuild

.execute_local().await?

Combine result pieces locally. Only the final answer gets revealed. The intermediate steps are mathematically destroyed — they never existed as retrievable data. What never existed can't be breached, subpoenaed, or reconstructed — by anyone.