# 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](/ethscriptions-appchain/protocol-handlers.md)                 | Pluggable system for extending ethscription functionality  |
| [Collections](/ethscriptions-appchain/collections.md)                             | Curated NFT collections with merkle proof enforcement      |
| [Fixed Denomination Tokens](/ethscriptions-appchain/fixed-denomination-tokens.md) | 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](/ethscriptions-appchain/running-a-node.md).

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


---

# Agent Instructions: 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:

```
GET https://docs.ethscriptions.com/ethscriptions-appchain/overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.