---
# System prepended metadata

title: Analysis of `execution-spec-tests` in Nitro CI
tags: [EigenDA, Arb Integration]

---

# Analysis of `execution-spec-tests` in Nitro CI

## Overview

This document analyzes the `execution-spec-tests` CI job failures and provides recommendations for the EigenDA integration.

## 1. What is `execution-spec-tests`?

`execution-spec-tests` is an Ethereum Foundation testing framework that validates EVM execution layer compliance. It tests:

- EVM opcodes and instruction execution
- State transitions and storage operations
- Gas calculations
- Transaction processing
- Smart contract behavior across different hard forks (Shanghai, Cancun, Prague, Osaka)

The framework generates JSON test fixtures that verify implementation compliance with the Ethereum Execution Layer Specification.

## 2. Current Setup in Nitro CI

From `.github/workflows/runExecutionSpecTests.sh`:

```bash
# Builds local nitro image
docker build --target nitro-node-dev --tag nitro-local-build .

# Clones nitro-devnode repo
git clone https://github.com/OffchainLabs/nitro-devnode.git

# Starts nitro-devnode with the local build
TARGET_IMAGE=nitro-local-build ./run-dev-node.sh

# Runs execution-spec-tests against RPC endpoint
uv run execute remote --fork=Osaka --rpc-endpoint=http://127.0.0.1:8547 ...
```

The test connects to `http://127.0.0.1:8547` (the nitro-devnode RPC endpoint) and validates that the L2 execution layer behaves according to Ethereum specs.

**CI Configuration**: `.github/workflows/nightly-ci.yml:31`
```yaml
matrix:
  test-mode: [legacychallenge, long, challenge, l3challenge, execution-spec-tests]
```

## 3. Why `nitro-devnode` Exists

`nitro-devnode` is a lightweight development container repository that:

- Spins up a Nitro node in dev mode
- Deploys Stylus-specific contracts (Cache Manager, StylusDeployer)
- Provides a pre-funded account environment
- Targets **v3.7.1** of upstream Nitro (`NITRO_NODE_VERSION=v3.7.1-926f1ab`)

### Version Management Burden

This creates a maintenance concern - `nitro-devnode` hardcodes a specific Nitro version, creating version skew with the current EigenDA fork. Any divergence between:
- The EigenDA Nitro fork version
- The `nitro-devnode` expected version

...will cause compatibility issues and test failures.

## 4. Does EigenDA Integration Affect These Tests?

**Answer: NO, it should NOT affect execution-spec-tests**

### Why EigenDA Doesn't Impact Execution Tests

**EigenDA operates at the Data Availability layer**, NOT the execution layer:

- **What EigenDA does**: Stores and retrieves **batch data** (compressed sequences of transactions)
- **Where it sits**: Between L1 batch posting (`arbnode/batch_poster.go`) and L2 batch ingestion (`arbstate/inbox.go`)
- **What it doesn't touch**: The EVM execution engine, state transitions, or transaction processing

### The Execution Flow

```
┌─────────────┐
│Batch Poster │
└──────┬──────┘
       │
       ├──→ [EigenDA] ──┐
       ├──→ [Blobs]   ──┼──→ L1 Sequencer Inbox
       └──→ [Calldata]──┘
                         │
                         ↓
              Parse Batch (arbstate/inbox.go:54)
                         │
                         ↓
              Decompress & Extract Transactions
                         │
                         ↓
              EVM Execution (arbos/block_processor.go)
                         │
                         ↓
              ← execution-spec-tests validates this layer
```

### Key Code References

**Data Availability Abstraction**: `arbstate/inbox.go:54-99`

The `ParseSequencerMessage` function extracts payload from DA headers **before** execution begins:

```go
// Stage 1: Extract the payload from any data availability header.
if len(payload) > 0 && dapReaders != nil {
    if dapReader, found := dapReaders.GetByHeaderByte(payload[0]); found {
        promise := dapReader.RecoverPayload(batchNum, batchBlockHash, data)
        result, err := promise.Await(ctx)
        // ... error handling ...
        payload = result.Payload
    }
}
```

Once the payload is recovered, execution is **DA-agnostic**. The execution layer doesn't care whether the batch came from:
- Calldata (legacy)
- Blobs (EIP-4844)
- EigenDA (current integration)

**Batch Posting**: `arbnode/batch_poster.go:86-96`

EigenDA is just another DA backend option:
```go
const (
    sequencerBatchPostMethodName                    = "addSequencerL2BatchFromOrigin0"
    sequencerBatchPostWithBlobsMethodName           = "addSequencerL2BatchFromBlobs"
    sequencerBatchPostWithEigendaMethodName         = "addSequencerL2BatchFromEigenDA"
    // ...
)
```

**EigenDA Implementation**: `eigenda/eigenda.go`

The EigenDA integration only handles blob storage and retrieval:
```go
// QueryBlob retrieves a blob from EigenDA using the provided EigenDAV1Cert
func (e *EigenDA) QueryBlob(ctx context.Context, cert *EigenDAV1Cert) ([]byte, error)

// Store disperses a blob to EigenDA and returns the appropriate EigenDAV1Cert
func (e *EigenDA) Store(ctx context.Context, data []byte) (*EigenDAV1Cert, error)
```

No execution-layer code is modified.

## 5. Root Cause of Test Failures

The test failures are likely due to **version incompatibility**:

1. `nitro-devnode` expects Nitro v3.7.1-926f1ab
2. The EigenDA fork is based on a different version with additional patches
3. Docker build incompatibilities or API changes cause the devnode setup to fail
4. Even if the node starts, it may not have the EigenDA proxy configured

## 6. Recommendations

### Option A: Skip These Tests (RECOMMENDED)

**Rationale:**
- These tests validate L2 geth execution semantics, which the EigenDA integration doesn't modify
- The maintenance burden (tracking `nitro-devnode` versions) outweighs the value
- Already running the full `system_tests` suite which tests the integrated system
- The CI failure is due to version incompatibility, not actual functional issues

**Action:**

1. Edit `.github/workflows/nightly-ci.yml:31`:
```yaml
matrix:
  fail-fast: false
  test-mode: [legacychallenge, long, challenge, l3challenge]
  # execution-spec-tests removed - see execution-spec-tests-analysis.md
```

2. Add explanatory comment:
```yaml
# Note: execution-spec-tests validates EVM execution layer compliance.
# EigenDA integration only affects the batch DA layer (before execution),
# so these tests provide no additional coverage for our changes.
# Removed to avoid maintenance burden of nitro-devnode version tracking.
# See: execution-spec-tests-analysis.md
```

**Coverage Impact**: None - the `system_tests` suite already validates:
- Batch posting via EigenDA
- Batch retrieval and parsing
- Transaction execution
- End-to-end L2 functionality

Reference: `CLAUDE.md:45-48`
```bash
# EigenDA integration tests
./scripts/start-eigenda-proxy.sh
go test -timeout 600s -run ^TestEigenDAIntegration$ github.com/offchainlabs/nitro/system_tests
```

### Option B: Fix and Maintain (NOT RECOMMENDED)

If you really want to support this, you would need to:

**Issues to resolve:**
1. **Version mismatch**: `nitro-devnode` expects v3.7.1, but the fork is on a later version
2. **Docker build**: The local build may not match `nitro-devnode` expectations
3. **EigenDA proxy requirement**: The test needs EigenDA proxy running, but `nitro-devnode` doesn't initialize it

**What you'd need to do:**
- Fork `nitro-devnode` into Layr-Labs org
- Update it to match the current Nitro fork version
- Add EigenDA proxy initialization to the setup script
- Maintain this fork alongside the Nitro fork (2x version management burden)
- Update both repositories for every upstream merge

**Why this is not recommended:**
- Creates **2x version management burden** (Nitro + nitro-devnode)
- Adds CI flakiness due to Docker/version coordination issues
- Provides **minimal testing value** (execution layer unchanged)
- Diverts maintenance effort from actual EigenDA integration work

## 7. Decision Matrix

| Factor | Skip Tests | Maintain Tests |
|--------|-----------|----------------|
| **Coverage value** | Low (already covered by system_tests) | Low (tests unrelated layer) |
| **Maintenance burden** | None | High (2 repos to sync) |
| **CI reliability** | High | Low (version drift risks) |
| **EigenDA relevance** | N/A (tests unrelated layer) | N/A (tests unrelated layer) |
| **Implementation effort** | Trivial (1 line change) | High (fork + maintain repo) |
| **Recommendation** | ✅ **DO THIS** | ❌ Avoid |

## 8. Conclusion

**Recommendation: Skip these tests.**

They validate a layer of the stack (EVM execution) that the EigenDA integration doesn't touch. The maintenance cost of keeping `nitro-devnode` synchronized significantly exceeds the benefit, especially given that:

1. The EigenDA integration is purely at the DA layer
2. System tests already validate end-to-end functionality including DA + execution
3. The test failures are infrastructure issues, not functional regressions
4. No execution layer code is modified by the EigenDA integration

## References

- CI Configuration: `.github/workflows/nightly-ci.yml`
- Test Script: `.github/workflows/runExecutionSpecTests.sh`
- Batch Posting: `arbnode/batch_poster.go`
- Message Parsing: `arbstate/inbox.go`
- EigenDA Implementation: `eigenda/eigenda.go`
- System Tests Documentation: `CLAUDE.md:45-48`
