# Overview

## What is the AppChain?

* RPC: [https://mainnet.ethscriptions.com](https://mainnet.ethscriptions.com/)
* Block explorer: [https://explorer.ethscriptions.com](https://explorer.ethscriptions.com/)

The Ethscriptions AppChain is an Ethereum L2 that provides an alternative way to consume and interact with ethscriptions. Instead of relying on an off-chain indexer, the AppChain runs as a derivation pipeline that turns L1 ethscription activity into canonical L2 blocks.

The result is an OP-style "app chain" that keeps Ethscriptions UX unchanged while providing:

* **Merkle state** - Cryptographic proofs for all ethscription data
* **Receipts** - Transaction receipts for every operation
* **EVM compatibility** - Standard tooling works out of the box

## Two Ways to Consume Ethscriptions

| Approach                | Description                                                                      | Best For                                                              |
| ----------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| **Traditional Indexer** | Off-chain service that indexes L1 transactions and maintains state in a database | Simple queries, existing integrations                                 |
| **AppChain**            | On-chain L2 with smart contracts and EVM state                                   | Smart contract interactions, protocol extensions, collections, tokens |

Both approaches read the same L1 data and produce the same canonical ethscription state. The AppChain adds an execution layer that enables advanced features.

## Genesis Block

The AppChain anchors to Ethereum L1 starting at block **17478949**. This is one block before the traditional indexer's genesis block (17478950) because the AppChain includes an L2 block 0 (genesis block) that contains the initial state.

| System              | L1 Genesis Block |
| ------------------- | ---------------- |
| Traditional Indexer | 17478950         |
| AppChain            | 17478949         |

## How It Works

The AppChain runs a derivation pipeline:

1. **Observe** - Watch Ethereum L1 via JSON-RPC for ethscription intents (Data URIs and ESIP events)
2. **Translate** - Convert intents into deposit-style EVM transactions
3. **Execute** - Send transactions to geth via Engine API, producing L2 blocks
4. **Seal** - Geth seals blocks, predeploy contracts mutate state

```
L1 Block → Derivation Node → Engine API → Geth → L2 Block
```

## AppChain-Only Features

The following features are only available on the AppChain:

| Feature                                                                                                      | Description                                                |
| ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------- |
| [Protocol Handlers](https://docs.ethscriptions.com/ethscriptions-appchain/protocol-handlers)                 | Pluggable system for extending ethscription functionality  |
| [Collections](https://docs.ethscriptions.com/ethscriptions-appchain/collections)                             | Curated NFT collections with merkle proof enforcement      |
| [Fixed Denomination Tokens](https://docs.ethscriptions.com/ethscriptions-appchain/fixed-denomination-tokens) | ERC-20 tokens that move in fixed batches tied to NFT notes |

These features require smart contract execution and are not available through the traditional indexer.

## Architecture

The AppChain consists of two main components:

### Derivation Node (Ruby)

* Observes L1 blocks, receipts, and logs
* Parses ethscription intents from calldata and events
* Builds deposit transactions for L2 execution
* Communicates with geth via Engine API

### Execution Client (ethscriptions-geth)

* Modified geth client for the Ethscriptions L2
* Executes deposit transactions
* Maintains EVM state
* Provides standard JSON-RPC interface

## Benefits

### For Users

* Same ethscription experience - create and transfer as before
* Lower costs for complex operations via L2
* Smart contract composability

### For Developers

* Standard EVM tooling (ethers.js, web3.js, Foundry)
* Verifiable state with Merkle proofs
* Build on top of ethscriptions with custom protocols

### For Validators

* Deterministic derivation from L1 data
* Can verify state independently
* Optional validation against reference API

## Getting Started

To run your own AppChain node, see [Running a Node](https://docs.ethscriptions.com/ethscriptions-appchain/running-a-node).

To learn about building protocol extensions, see [Protocol Handlers](https://docs.ethscriptions.com/ethscriptions-appchain/protocol-handlers).