Интеграция с EigenDA (Data Availability)

Интеграция с EigenDA (Data Availability)

Data Availability — это не хранение данных. Это гарантия того, что данные были опубликованы и доступны для скачивания в конкретный момент времени. Для rollup это фундаментальное свойство: fraud proof или validity proof бессмысленны, если кто-то не может получить данные транзакций, чтобы верифицировать состояние.

Ethereum Danksharding (EIP-4844) решил эту проблему для Ethereum-based rollup через blobs. EigenDA — альтернатива, построенная на EigenLayer restaking, которая предлагает значительно более высокий throughput и более низкую стоимость ценой иной модели доверия.

Как работает EigenDA: технические детали

Архитектура системы

EigenDA состоит из трёх компонентов:

Операторы (Operators) — нодовладельцы, которые restaked ETH через EigenLayer и предоставляют хранение и bandwidth. Они принимают chunks данных, хранят их, и отвечают на запросы availability.

Disperser — сервис (пока централизованный у EigenLabs, roadmap на децентрализацию), который принимает данные от rollup, делит их на chunks через erasure coding, распределяет по операторам, собирает подписи.

Верификатор on-chain — смарт-контракт на Ethereum, который верифицирует что quorum операторов подписал attestation о получении данных.

Erasure Coding и Data Availability Sampling

EigenDA использует Reed-Solomon erasure coding: данные размером D кодируются в M chunks (M > D), причём любые D из M chunks достаточно для восстановления оригинала. Типичные параметры: если 50% операторов недоступны — данные всё равно восстановимы.

Data Availability Sampling (DAS) — техника, при которой light client может верифицировать доступность данных, скачав только небольшое случайное подмножество chunks. Математически: если скачать 30 случайных chunks и все доступны, с вероятностью >99.9% все данные доступны (при 50% erasure coding).

Blob (данные rollup)
  ↓ Reed-Solomon encoding
Chunks [c0, c1, c2, ..., cn]
  ↓ KZG polynomial commitments
Commitment (короткое доказательство данных)
  ↓ Dispersal к операторам
Операторы хранят chunks + отвечают на sampling запросы

BlobHeader и Certificate

При публикации данных в EigenDA disperser возвращает BlobHeader и BlobCertificate:

type BlobHeader struct {
    Commitment       G1Point        // KZG commitment к данным
    DataLength       uint32         // размер в символах
    BlobQuorumParams []BlobQuorumParam
}

type BlobQuorumParam struct {
    QuorumNumber                 uint8
    AdversaryThresholdPercentage uint8  // максимум злонамеренных операторов
    ConfirmationThresholdPercentage uint8 // минимум подтверждений
    ChunkLength                 uint32
}

type BlobCertificate struct {
    BlobHeader   BlobHeader
    BlobVerificationProof BlobVerificationProof
}

Certificate сохраняется rollup в calldata или blob транзакции на Ethereum — это позволяет верификатору проверить, что данные были действительно опубликованы в EigenDA.

Интеграция rollup с EigenDA

Dispersal: публикация данных

Rollup sequencer (или batch poster) отправляет данные через EigenDA Disperser API:

package main

import (
    "context"
    "github.com/Layr-Labs/eigenda/api/grpc/disperser"
    "google.golang.org/grpc"
)

func disperseBlob(data []byte) (*disperser.BlobInfo, error) {
    conn, err := grpc.Dial("disperser-holesky.eigenda.xyz:443", grpc.WithTransportCredentials(...))
    if err != nil {
        return nil, err
    }
    defer conn.Close()
    
    client := disperser.NewDisperserClient(conn)
    
    reply, err := client.DisperseBlob(context.Background(), &disperser.DisperseBlobRequest{
        Data: data,
        CustomQuorumNumbers: []uint32{}, // использовать default quorum
        AccountId: accountId,            // для rate limiting
    })
    if err != nil {
        return nil, err
    }
    
    // Polling до finalization
    for {
        statusReply, _ := client.GetBlobStatus(context.Background(), &disperser.BlobStatusRequest{
            RequestId: reply.RequestId,
        })
        
        if statusReply.Status == disperser.BlobStatus_CONFIRMED {
            return statusReply.Info, nil
        }
        
        time.Sleep(2 * time.Second)
    }
}

После confirmation — serialized BlobInfo (включая BlobHeader и BlobVerificationProof) постится в Ethereum в calldata вместо или дополнительно к самим данным.

On-chain верификация

Для rollup с fraud proofs нужно верифицировать on-chain, что данные были действительно доступны:

interface IEigenDAServiceManager {
    function confirmBatch(
        BatchHeader calldata batchHeader,
        OperatorStakesAndSignature calldata operatorStakesAndSignature
    ) external;
    
    function verifyBlob(
        BlobHeader calldata blobHeader,
        BlobVerificationProof calldata blobVerificationProof
    ) external view;
}

contract RollupWithEigenDA {
    IEigenDAServiceManager public eigenDA;
    
    function submitBatch(
        bytes calldata batchData,
        BlobHeader calldata eigenDABlobHeader,
        BlobVerificationProof calldata eigenDAProof
    ) external {
        // Верифицируем что данные действительно были в EigenDA
        eigenDA.verifyBlob(eigenDABlobHeader, eigenDAProof);
        
        // Дальше обычная логика rollup
        bytes32 batchRoot = keccak256(batchData);
        _submitBatchRoot(batchRoot);
    }
}

Интеграция с OP Stack через EigenDA Proxy

Для rollup на базе OP Stack есть готовый EigenDA Proxy — sidecar сервис, который реализует OP Stack alt-DA интерфейс и транслирует запросы в EigenDA:

# docker-compose.yml для EigenDA Proxy
eigenda-proxy:
  image: ghcr.io/layr-labs/eigenda-proxy:latest
  environment:
    - EIGENDA_PROXY_ADDR=0.0.0.0
    - EIGENDA_PROXY_PORT=4242
    - EIGENDA_PROXY_EIGENDA_DISPERSER_RPC=disperser-holesky.eigenda.xyz:443
    - EIGENDA_PROXY_G1_PATH=/data/g1.point
    - EIGENDA_PROXY_G2_POWER_OF_TAU_PATH=/data/g2.point.powerOf2
  volumes:
    - ./data:/data

OP Stack batch poster конфигурируется с --altda.da-service=true и указывает на proxy. Все остальное прозрачно — proxy сам обрабатывает dispersal, polling, сохранение certificate.

Аналогичный паттерн для Arbitrum Orbit через AnyTrust: EigenDA может выступать как Data Availability Committee (DAC) альтернатива.

Сравнение с альтернативами

EigenDA выигрывает по throughput и стоимости для высоконагруженных rollup. Компромисс — дополнительная зависимость от EigenLayer и пока частичная централизация disperser-а.

Операционные соображения

Latency характеристики

Dispersal в EigenDA занимает 10–15 секунд до confirmation (зависит от quorum и network conditions). Это нужно учитывать в архитектуре sequencer: batch posting может быть асинхронным.

Retry и fallback логика

Disperser может быть недоступен. Нужна fallback стратегия:

func postBatchWithFallback(batchData []byte) error {
    // Пробуем EigenDA
    blobInfo, err := disperseToEigenDA(batchData)
    if err == nil {
        return postToEthereumWithEigenDARef(blobInfo)
    }
    
    log.Warn("EigenDA dispersal failed, falling back to calldata", "err", err)
    
    // Fallback: постим данные напрямую в calldata Ethereum
    // Дороже, но гарантирует liveness
    return postToEthereumCalldata(batchData)
}

Это паттерн из OP Stack AltDA spec: если DA layer недоступен — rollup может упасть обратно на Ethereum calldata, сохраняя liveness ценой большего gas.

Мониторинг

• Dispersal latency: алерт если >30 секунд
• Quorum thresholds: мониторинг процента ответивших операторов
• Certificate validity: все сертификаты в Ethereum должны проходить on-chain верификацию

Сроки интеграции

Интеграция OP Stack rollup с EigenDA через proxy: 2–3 недели (настройка инфраструктуры, тестирование на Holesky, мониторинг).

Кастомный rollup с нативной EigenDA интеграцией: 4–8 недель (имплементация dispersal логики, on-chain верификатор, fallback механизм, аудит контрактов).

Разработка кастомного DA layer на основе EigenDA: 3–4 месяца (собственные quorum параметры, кастомный ServiceManager контракт, интеграция в EigenLayer).

Интеграция EigenDA предполагает работу с testnet (Holesky) минимум 2–3 недели до mainnet деплоя — слишком много движущихся частей для immediate production.