> For the complete documentation index, see [llms.txt](https://docs.espressosys.com/network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.espressosys.com/network/developer/rollup-developers.md).

# Integrate a Chain

Use these guides if you are building a stablecoin, tokenized asset platform, exchange, payment network, or other application that needs dedicated chain infrastructure with decentralized settlement.

***

## The Espresso stack

When you integrate a chain or application with Espresso, your environment is composed of four layers. Understanding how they fit together will help you choose the right integration path.

### 1. Execution environment

Your application runs its own execution environment. This is where transactions are executed and state is derived. Espresso does not execute transactions and does not dictate what VM or logic your environment uses.

Supported execution clients include:

* **Besu** and other EVM clients
* **OP Stack** execution environments
* **Nitro / Orbit** execution environments
* Custom VMs

Your execution environment defines its own rules for fees, ordering policy, compliance checks, and asset support.

### 2. Sequencer

Each application environment has a dedicated sequencer. The sequencer is responsible for ordering incoming transactions and streaming blocks to Espresso. Blocks can be encrypted before submission to preserve transaction privacy.

The sequencer is operated by you or your designated operator. It is separate from Espresso's validator network.

### 3. Espresso

Espresso finalizes the blocks produced by your sequencer through decentralized Proof of Stake consensus. Once Espresso finalizes a block, it cannot be reordered or removed without consensus-level corruption.

Espresso provides:

* **Finality**: decentralized Proof of Stake consensus across a permissionless validator set
* **Scalable throughput**: the ability to scale to millions of transactions per second across parallel environments
* **Crosschain readability**: State finalized by Espresso can be verified by other chains and applications
* **Optional data availability**

Espresso does not execute transactions. It finalizes the transaction stream your sequencer produces.

### 4. RPC nodes and provers

Authorized clients read the finalized transaction stream from Espresso via RPC nodes. They execute the deterministic application logic against that stream to derive state. For private applications, this includes decrypting blocks using access keys they hold.

For crosschain coordination, coordination servers generate zero-knowledge proofs that allow destination environments to verify message correctness without re-executing the source logic.

***

## Choose your integration path

| Starting point                    | Guide                                                                                                                                                   |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Private permissioned Besu network | [From Private Besu to an Espresso Application Chain](https://github.com/EspressoSystems/gitbook/blob/main/guides/rollup-developers/besu-to-espresso.md) |
| New Nitro / Orbit chain           | [Deploy a New Orbit Chain](/network/developer/rollup-developers/nitro/deploy-a-new-orbit-chain.md)                                                      |
| Existing Nitro / Orbit chain      | [Migrate an Existing Orbit Chain to Espresso](/network/developer/rollup-developers/nitro/migrate-orbit-chains-to-espresso.md)                           |
| OP Stack chain                    | [OP Stack Integration](/network/developer/rollup-developers/op/op-stack-integration.md)                                                                 |

Not sure which path fits? [Contact Espresso](https://form.typeform.com/to/KgayxNsX?typeform-source=www.espressosys.com) to schedule an architecture review.

***

## Integration stages

All integration paths follow the same four stages:

1. **Internal deployment**: deploy and validate against your own test environment (3 to 4 days)
2. **Devnet**: validate against a shared Espresso development network
3. **Testnet**: minimum 5 to 7 day clean run required before proceeding
4. **Mainnet**: go live on Espresso Mainnet with 24/7 monitoring

Espresso provides a kick-off call, devops assistance, async support, and monitoring throughout.