> 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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.espressosys.com/network/developer/rollup-developers.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.