Spin up a sovereign rollup locally

You can stand up a fully functional L3 appchain boilerplate for sovereign rollups right on your localhost in under five minutes. This quick setup proves the viability of the stack without waiting for testnet approvals or dealing with complex RPC configurations. By running the node locally, you isolate the development environment, ensuring that your smart contracts and backend services interact with a predictable, stateful blockchain instance.

Follow these steps to initialize your local L3 appchain boilerplate. The process leverages pre-configured Docker Compose files and monorepo scripts to handle the heavy lifting of sequencer, batcher, and execution layer orchestration.

1
Clone the boilerplate repository

Start by fetching the latest codebase. This repository contains the pre-built configurations for the L3 stack, including the rollup node, sequencer, and indexer. Use the standard git clone command to pull the project into your local development directory. This ensures you are working with the most recent compatibility layers and security patches.

2
Install project dependencies

Once the repository is cloned, navigate into the project root and install the necessary packages. Run the package manager command (such as yarn install or npm ci) to resolve all JavaScript and TypeScript dependencies. This step prepares the build tools and runtime environments required for the subsequent compilation and deployment phases.

3
Compile and build the contracts

Before launching the node, you must compile the Solidity smart contracts. Execute the build script to generate the ABIs and bytecode for your L3 contracts. This step is critical because the local sequencer expects specific contract interfaces to be available in the build artifacts. A successful build confirms that your code is syntactically correct and compatible with the configured compiler version.

4
Launch the local node environment

Run the local development script to spin up all necessary services. This command typically starts the Ethereum execution layer (e.g., Geth or Nethermind), the consensus layer, the L3 sequencer, and the indexer in parallel via Docker Compose. Wait for the logs to indicate that the sequencer is active and ready to accept transactions. You can verify this by checking the local RPC endpoint, usually running on http://localhost:8545.

5
Deploy contracts to the local instance

With the node running, deploy your smart contracts to the local L3 instance using your preferred deployment tool (such as Hardhat or Foundry). Configure your deployment script to target the local RPC URL. Once deployed, you will have a sovereign rollup environment where you can test transaction throughput, finality times, and contract interactions without any external dependencies.

Configure the L2 settlement layer

Your L3 appchain needs a secure foundation to settle transactions. This section shows how to point your boilerplate to a specific Layer 2 network, such as Base, Starknet, or Arbitrum. The settlement layer handles finality and security, while your L3 manages high-throughput execution.

1. Select your L2 chain

Choose the L2 that best fits your app’s needs. Base offers low fees and strong EVM compatibility, making it ideal for consumer apps. Starknet provides high throughput via STARK proofs, suitable for complex data-heavy dApps. Arbitrum is a mature choice for Ethereum-aligned applications.

2. Update the configuration file

Locate your spire.config.ts or equivalent configuration file. You must specify the L2 chain ID and RPC endpoint. This tells your L3 where to send transaction batches for settlement.

3. Verify connectivity

Before deploying, test the connection. Run a local node check to ensure your L3 can read state from the L2. This prevents costly deployment failures later. You can use tools like spire-cli to simulate the settlement process.

4. Deploy the settlement contract

Once configured, deploy the settlement smart contract on your chosen L2. This contract acts as the bridge between your L3 and the L2. Ensure you have enough native tokens (ETH for Base, ETH for Arbitrum, STRK for Starknet) to cover gas fees.

Bridge the settlement layer

Funding the L3 and linking it to the L2 settlement layer is the final step before your appchain becomes sovereign. This process establishes the liquidity bridge and ensures the L3 can post data and settle transactions back to the L2.

1. Fund the L3 deployment wallet

Your L3 sequencer needs ETH (or the L2 native token) to pay for gas when posting transaction batches and state roots to the L2. Without sufficient funds, the L3 will halt, unable to finalize any user transactions.

Check your deployment wallet balance using a block explorer like Etherscan for Ethereum L2s or Arbiscan for Arbitrum. Transfer a sufficient amount of ETH to cover at least a few days of expected transaction volume. For a testnet deployment, use the faucet provided by your L2 network to obtain test tokens.

2. Configure the bridge contracts

The bridge contracts act as the communication channel between the L3 and the L2. You need to deploy these contracts on both layers and configure the L3 to recognize the L2 bridge address.

For most L3 boilerplates, this involves setting the L2BridgeAddress and L2SequencerAddress in the L3 configuration file. Ensure the bridge contract on the L2 is verified and that the L3 contract has permission to call the bridge functions.

3. Verify the bridge connection

Once the contracts are deployed and funded, verify the connection by sending a small test transaction through the L3. Monitor the L2 block explorer to ensure the transaction batch is posted and the state root is updated.

If the transaction fails to post, check the L3 logs for any gas estimation errors or bridge contract reverts. Ensure the L3 sequencer is running and connected to the correct RPC endpoint.

4. Monitor settlement latency

After the initial setup, monitor the settlement latency to ensure the L3 is syncing correctly with the L2. This involves checking the time it takes for L3 blocks to be finalized on the L2.

Use the L3 dashboard to track the number of blocks pending settlement. If the latency is unusually high, consider adjusting the batch size or the frequency of batch submissions to optimize for your specific use case.

Integrate DevRel kits for adoption

Treat this step as a welfare screen for Deploy L3 Appchain Boilerplates. Compare the source, the animal's visible condition, the seller's care knowledge, the paperwork, and the transport plan before you commit. A good purchase path should make the dragon's health easier to verify, not harder. Pause before paying if any part of the chain is unclear. Confirm the exact animal, pickup or shipping timing, heat-pack plan when relevant, return policy, and the supplies you need at home for the first week.

Use the checklist as a welfare screen: verify the source, health signs, enclosure readiness, paperwork, and transport plan before paying.

Verify RPC endpoints and sync

Before connecting a frontend, confirm the node is reachable and the chain is syncing. This step isolates infrastructure issues from application bugs.

Check local RPC availability

Run a health check against the default endpoint. If the node is running correctly, it should return a JSON-RPC response.

Shell
curl -X POST http://localhost:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

A successful response returns a hex-encoded block number. If you receive a connection refused error, verify that the geth or nethermind process is active and listening on port 8545.

Confirm chain synchronization

An L3 appchain must sync with its underlying Layer 2 or Layer 1 source to maintain state validity. Check the sync status to ensure the node is not stuck.

Shell
curl -X POST http://localhost:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}'

If the response is false, the node is fully synced. If it returns an object with currentBlock, highestBlock, and startedHeaders, the node is still catching up. Wait until the response is false before proceeding with frontend integration.

Common l3 deployment: what to check next

Building a sovereign rollup involves specific technical trade-offs. Here are answers to the most frequent questions about cost, customization, and compatibility when using L3 appchain boilerplates.

How much does it cost to deploy an L3?

Deployment costs vary based on the underlying L2 and data availability layer. Using a boilerplate reduces initial engineering overhead, but you still pay for L2 gas fees when posting proof data. For example, deploying on Base involves ETH gas costs, while other L2s like Arbitrum or Optimism have their own fee structures. Always calculate the expected transaction volume to estimate monthly data availability costs before going live.

Can I customize the L3 to fit my specific dApp?

Yes. L3 appchains are designed for high customizability, allowing you to control the execution logic and state transitions [6]. You can modify the sequencer settings, adjust gas limits, and integrate specific precompiles. The boilerplate provides a modular foundation, so you can swap out components like the consensus engine or data availability client without rebuilding the entire stack from scratch.

Do L3 appchains work with existing L2 tooling?

Most L3s settle on an L2, meaning they inherit the security and tooling ecosystem of that parent chain [3]. If you build on Base, your L3 can interact with Base’s existing bridges, wallets, and explorers. However, you may need to configure cross-chain messaging protocols to ensure seamless communication between your L3 and the broader L2 ecosystem. Testing this interoperability locally before mainnet deployment is critical.