What a lattice gives you

audience: integrators

A lattice is one end-to-end block-building deployment for one EVM chain. As an external developer you bind into a lattice by pinning its LatticeConfig and opening typed handles on the organism(s) you need. One Arc<Network> serves every organism and every lattice you care about.

This page is the index: what lattices can do for you, which organisms you touch for which use case, and where to go next for code.

Why you might want this

The lattice gives you four things at once, each from a different organism:

• Anonymous submission — a sealed, ordered broadcast channel where nothing in the pipeline can link your transaction to you up to the trust bound of zipnet plus unseal. See Submitting transactions anonymously.
• Sealed-bid auctions — bid on a slot’s unsealed order flow without other searchers learning your bid until the auction commits. See Placing bundle bids.
• Verifiable candidate blocks — read blocks committed by a TDX-attested co-builder committee and verify the committee’s collective signature over them. See Reading built blocks.
• Auditable refund accounting — public tally attestations prove which order flow contributed to which winning block and how the refund is allocated. See Receiving refunds and attributions.

You do not have to use all four. A wallet that only wants anonymous submission can bind to zipnet alone. A searcher that only wants to bid on existing pools can bind to offer alone. A rollup operator that consumes the full pipeline binds to all six.

Who this audience page is for

External Rust developers running their own mosaik agent. You:

• Own your own Arc<Network> and its lifecycle.
• Have read the mosaik book.
• If you care about submission-layer anonymity, have also read the zipnet book.
• Do not operate a lattice; that is a different team whose runbook is For operators.

If you are the team running the lattice, you want Lattice overview instead.

Use case to organism matrix

Pick the row that matches your application; bind the organisms listed.

Each bound organism is one Organism::<D>::verb(&network, &Config) call; you pay for one mosaik endpoint regardless.

What you never touch

• Any organism’s internal consensus — committee Raft, unseal share gossip, atelier’s TDX bundle simulation. Those are operator-managed internals. Your read-side handles give you committed facts; you never need to reason about quorum, apply order, or replica membership.
• Raw mosaik StreamId, StoreId, GroupId values. The Organism::<D>::verb constructors derive everything from the Config fingerprint you compile in.
• The LatticeConfig internals. You receive a LatticeConfig from the operator (either as a literal Rust const in a published crate, or as a hex fingerprint you Config::from_hex); you do not construct one yourself.

What the operator owes you

Three items, same handshake pattern zipnet uses:

1. Universe NetworkId. Almost always the baked-in builder::UNIVERSE constant.
2. Lattice Config. A full LatticeConfig struct (or its serialised hex fingerprint) covering the six organism configs. This is what defines the lattice identity.
3. MR_TDs for every TDX-gated organism in the lattice (unseal, atelier, optionally relay).

Everything else — peer bootstraps, retry policy — you manage locally the same way you manage any mosaik agent. See What you need from the operator.

What happens when a lattice misbehaves

Zero-trust integrations are not currently feasible — the lattice is a permissioned block-building pipeline and integrators accept the operator’s trust model by binding. What the lattice does guarantee:

• Public commit logs. Every organism’s commits are mosaik-replicated and signed by committee members. You can replay them and detect divergence from on-chain reality.
• On-chain settlement enforcement. tally attestations are meant for on-chain verification. A lattice that commits dishonest attestations finds them rejected by the settlement contract.
• Graceful degradation. A lattice whose upstream organism is down still produces valid downstream commits where possible; see the failure table in Composition.

When those are not enough for your use case — e.g. if you need Byzantine liveness guarantees not provided by mosaik’s Raft variant — you either switch to a different lattice or wait for the BFT roadmap item.

Ready to code

Start at Quickstart — submit, bid, read.