> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stoffelmpc.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MPC Integration

> How Stoffel integrates with MPC backends, secret sharing, client inputs, and backend-specific security models.

Use this page to understand how private client inputs move through Stoffel: input collection, secret sharing, VM execution, openings, and client-output delivery. If you are deciding which backend to use, start with [MPC Backends](../mpc-protocols/overview). If you already chose a backend and need config or runtime details, use [How Backend Selection Works](../mpc-protocols/implementation).

<img src="https://mintcdn.com/stoffellabs/WsJVEVCX73RSUEma/images/diagrams/honeybadger-network.svg?fit=max&auto=format&n=WsJVEVCX73RSUEma&q=85&s=d4a185c53589422d5e091b18a5da7967" alt="HoneyBadger MPC runtime diagram showing client input/output paths, coordinator-managed sessions, preprocessing, and protocol rounds among parties." width="1200" height="675" data-path="images/diagrams/honeybadger-network.svg" />

<img src="https://mintcdn.com/stoffellabs/WsJVEVCX73RSUEma/images/campaign/stoffel-networked-privacy-backend.png?fit=max&auto=format&n=WsJVEVCX73RSUEma&q=85&s=ce93340ce44de6b4039ac1c8a2a8bac4" alt="Campaign-style networked privacy backend diagram showing application clients, coordinator-managed sessions, preprocessing, party mesh communication, and authorized output delivery." width="1800" height="1125" data-path="images/campaign/stoffel-networked-privacy-backend.png" />

## Protocol Architecture

## Protocol architecture

```text theme={null}
StoffelLang program
    │
    ▼
Compiled bytecode manifest
    │
    ├── backend: HoneyBadgerMPC | AVSS
    ├── curve/field metadata
    ├── client input/output schema
    └── preprocessing demand
        │
        ▼
VM + selected MPC backend
```

## Current backend support

| Backend        | Purpose                                                                                      | Developer selector                                    |
| -------------- | -------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| HoneyBadgerMPC | Default asynchronous/robust backend for field-compatible secret application values.          | `honeybadger` / `MpcBackend::HoneyBadger`             |
| AVSS           | AVSS backend for verifiable scalar shares, public commitments, and curve-compatible outputs. | `avss`, `avss:<curve>` / `MpcBackend::Avss { curve }` |

Both backends use the same high-level Stoffel application model, but they are not interchangeable at the cryptographic layer. HoneyBadgerMPC is field-arithmetic oriented. AVSS is group/scalar oriented and is the backend to use when the output boundary needs public commitments, curve-encoded values, or scalar responses that match an external verifier.

## Integration points

### Stoffel VM

* Secret register operations map to backend share operations.
* Clear-to-secret transitions create backend share data.
* Reveal/open operations reconstruct values through the selected backend.
* `Share.random`, `Share.open`, `Share.get_commitment`, and `Mpc.*` builtins route through backend capabilities.

### CLI and bytecode

* `Stoffel.toml` stores `[mpc] backend`, optional `curve`, `parties`, and `threshold`.
* CLI flags such as `--backend`, `--field`, `--parties`, and `--threshold` override project settings.
* `.stflb` bytecode records backend and curve/field metadata so execution can validate the runtime configuration.

### Rust SDK

* `MpcConfig::builder()` configures parties, threshold, instance ID, and backend.
* Program builders accept `.backend(...)` and `.curve(...)`.
* `NetworkDeployment` and off-chain client configs carry backend selection into generated network/client TOML.

## Security model

Each backend has its own threat model and assumptions. Do not treat “MPC backend” as a single security claim.

| Backend        | Security posture                                                                                                                                                                                    |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| HoneyBadgerMPC | Asynchronous, Byzantine-robust, field-based MPC for private computation over application values. Use it when the output boundary is an opened result or client-output shares.                       |
| AVSS           | Asynchronous verifiable secret sharing with Feldman-style commitments. Use it when public commitments, curve-encoded values, or scalar responses are part of the verifier-facing protocol boundary. |

Current Stoffel local/network config validates:

```text theme={null}
parties >= 4 * threshold + 1
```

Use five parties and threshold one for local development unless you are intentionally testing a larger topology.

## Data protection flow

* Inputs become secret shares through ClientStore or direct secret-value paths.
* Computation proceeds over backend share data.
* Intermediate secret values remain secret unless the program opens/reveals them.
* Outputs are returned, opened, or sent to client slots only where the program explicitly does so.

## Performance considerations

| Operation shape                 | Notes                                                                                                         |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| Local share arithmetic          | Addition, subtraction, and scalar operations are usually cheap.                                               |
| Secret multiplication           | Requires backend protocol work and preprocessing.                                                             |
| Opening/reveal                  | Requires reconstruction from enough parties.                                                                  |
| Comparisons and bit-heavy logic | More expensive than field arithmetic because they lower into additional share operations.                     |
| Curve/commitment workflows      | Use AVSS when the output boundary needs public commitments, curve-encoded values, or opened scalar responses. |

## See also

* [MPC Protocols](../mpc-protocols/overview)
* [How Backend Selection Works](../mpc-protocols/implementation)
* [HoneyBadgerMPC](../mpc-protocols/honeybadger-mpc)
* [AVSS](../mpc-protocols/avss)
* [Stoffel VM Overview](../stoffel-vm/overview)
* [Rust SDK API](../rust-sdk/api)