Integrar con el cliente Blobstream

Rollup demo blobstream​

Rollups puede usar Blobstream para DA publicando sus datos en Celestia y luego demostrando que se publicaron en Ethereum. Esto se hace de manera idéntica a cómo cualquier rollup o usuario publicaría datos en Celestia. Luego, se genera una prueba de conocimiento cero de que los validadores de Celestia han llegado a un consenso sobre los encabezados de bloque de Celestia y, posteriormente, se transmiten a Ethereum al contrato inteligente de Blobstream X.

¡Esta implementación de demostración describirá (el esquema no es una implementación! por favor, no espere copiar y pegar este código 🙂) un rollup de Blobstream muy simple para ilustrar a un alto nivel cómo podría ser esto.

Definir una cadena​

El primer paso para iniciar una nueva cadena es definir la estructura de los compromisos en los que consiste cada bloque.

ir

type Block struct {
    // Data is the data of a block that is submitted to Celestia.
    Data `json:"Data"`
    // Header is the set of commitments over a block that is submitted to
    // Ethereum.
    Header `json:"Header"`
}

// Data is the data of a block that is submitted to Celestia.
type Data struct {
    Txs []json.RawMessage `json:"txs"`
}

// Header is the set of commitments over a block that is submitted to Ethereum.
type Header struct {
    Height             uint64    `json:"height"`
    Namespace          []byte    `json:"namespace"`
    PreviousHash       []byte    `json:"previous_hash"`
    Span               Span      `json:"span"`
    SequencerSignature Signature `json:"sequencer_signature,omitempty"`
}

Obsérvese las estructuras específicas de Celestia en el encabezado, como el Namespace y la estructura específica de Blobstream llamada Span. El objetivo de estas estructuras es localizar los datos en el bloque Celestia para que podamos probar la inclusión de los datos a través de Blobstream si es necesario. Leer más en el especificaciones del espacio de nombres, y puedes pensar en esto como una ID de cadena. Aprende más información sobre shares, que son pequeñas piezas del bloque Celestia codificado. Utilizamos la misma codificación aquí para que los compromisos con el bloque de despliegue coincidan con los comprometidos por los validadores en la raíz de datos de Celestia.

El Span podría tomar muchas formas, pero en esta demostración, usaremos lo siguiente:

ir

// Span describes the location of the rollup block data that is posted to
// Celestia. This is important for other nodes to be able to prove that data in
// the Celestia block. This can be thought of as a pointer to some data in the
// Celestia block.
type Span struct {
    // CelestiaHeight is the height of the Celestia block that contains the
    // rollup block data.
    CelestiaHeight uint64 `json:"celestia_height"`
    // DataShareStart is the index of the first share of the rollup block data.
    DataShareStart uint64 `json:"share_start"`
    // DataShareLen is length in shares of the rollup block data. This is used
    // to identify all of the rollup block data in a Celestia block.
    DataShareLen uint64 `json:"share_end"`
}

Luego podemos definir la cadena de bloques como una colección de bloques y alguna información adicional sobre la cadena, como la dirección del secuenciador.

ir

type Blockchain struct {
    Blocks           []Block
    SequencerAddress []byte
    Namespace        []byte
}

Secuenciador rollup​

El secuenciador de rollup es responsable de crear bloques y, en esta demostración, escribir esos datos a Celestia y Ethereum. El nodo completo de rollup es responsable de leer los datos de Celestia y Ethereum y verificar que sigue las reglas de protocolo de ese rollup.

Por lo tanto, podemos comenzar definiendo primero las interacciones de lectura y escritura que los nodos de despliegue tendrán con las redes Celestia y Ethereum. Las implementaciones reales de estas interfaces se dejan como ejercicios para el lector (🤪). Supongamos que esas implementaciones de estas interfaces están verificando la cadena respectiva. Para la conexión a Celestia, esto probablemente significaría conectarse a un nodo de luz Celestia, que puede detectar fallas en el consenso, como datos ocultos. Para la conexión a Ethereum, esto probablemente significaría ejecutar y conectarse a un nodo completo. Se puede encontrar más información sobre el RPC que está expuesto por un nodo de luz Celestia en la documentación de RPC. Además, si necesita más información sobre cómo ejecutar un nodo de luz, puede echa un vistazo a la documentación.

ir

// CelestiaLightNodeClient summarizes the actions that a rollup that uses
// Blobstream for DA would need from a Celestia light node. Note that the actual
// connection to this light node is arbitrary, but would likely involve an RPC
// connection to a Celestia light node.
type CelestiaLightNodeClient interface {
    GetBlockData(Span) (Data, error)
    SubmitBlockData(Data) (Span, error)
}

// EthereumClient summarizes the actions that a rollup that uses Blobstream for
// DA would need from an Ethereum client.
type EthereumClient interface {
    // GetLatestRollupHeight returns the height of the latest rollup block by
    // querying the appropriate contract on Ethereum.
    LatestRollupHeight() (uint64, error)
    // GetHeader returns the rollup header of a specific height.
    GetHeader(uint64) (Header, error)
    // SubmitHeader submits a header to the rollup bridge contract on Ethereum.
    SubmitHeader(Header) error
}

Tenga en cuenta que aquí estamos esperando que la cabeza se publique en Ethereum, sin embargo, probablemente sería mejor simplemente descargar ese encabezado de la red p2p o directamente del secuenciador.

Para los fines de esta demostración, utilizaremos un único secuenciador centralizado, que se puede definir simplemente envolviendo el nodo completo para aislar la lógica para crear bloques.

Un nodo completo en rollup consistirá en una representación de una cadena de bloques junto con clientes para leer con Celestia y Ethereum.

ir

type Fullnode struct {
    Blockchain
    CelestiaLightNodeClient
    EthereumClient
}

// Sequencer wraps the demo Fullnode struct to add specific functionality for
// producing blocks.
type Sequencer struct {
    Fullnode
}

Comprometerse con los datos​

Las cadenas de bloques típicas se comprometen con las transacciones incluidas en cada bloque utilizando una raíz Merkle. Los rollups que usan Blobstream para DA deben usar los compromisos que se transmiten a los contratos de Blobstream.

Para rollups optimistas, esto podría ser tan simple como hacer referencia a los datos en el bloque Celestia, no muy diferente de usar un puntero en la memoria. Esto es lo que se hace a continuación a través de un Span en el creando bloques sección. Hacemos un seguimiento de dónde se encuentran los datos en el bloque Celestia y los signos del secuenciador sobre esa ubicación en el encabezado. Si el secuenciador se compromete con datos inexistentes o una raíz de estado no válida, primero se demuestra que la transacción no válida se incluye en el Span antes de que se siga el resto del proceso de prueba de fraude. Encuentra más información en la documentación de pruebas de inclusión.

Para los rollups de zk, esto implicaría crear una prueba de inclusión en la raíz de tupla de raíz de datos en los contratos de Blobstream y luego verificar esa prueba en la prueba de zk utilizada para verificar el estado. Encuentra más información en el documentación de prueba de inclusión de raíz de datos.

Además, vea la documentación para el diseño cuadrado de datos y el acciones del bloque Celestia para ver cómo se codifican los datos en Celestia.

Creación de bloques​

El primer paso para crear un bloque es publicar los datos del bloque en Celestia. Tras la confirmación de que los datos se incluyen en un bloque, se puede determinar la ubicación real de los datos en Celestia. Estos datos se utilizan para crear un Span que está incluido en el encabezado y firmado por el secuenciador. Esto Span puede ser utilizado por contratos en Ethereum que utilizan los contratos de Blobstream para demostrar que se incluyeron algunos datos específicos.

ir

func (s *Sequencer) ProduceBlock(txs []json.RawMessage) (Block, error) {
    data := Data{Txs: txs}

    span, err := s.CelestiaLightNodeClient.SubmitBlockData(data)
    if err != nil {
        return Block{}, err
    }

    var lastBlock Block
    if len(s.Blocks) > 0 {
        lastBlock = s.Blocks[len(s.Blocks)-1]
    }

    header := Header{
        Height:       uint64(len(s.Blocks) + 1),
        PreviousHash: lastBlock.Header.Hash(),
        Namespce:     s.Namespace,
        Span: span,
    }

    signature := s.key.Sign(header.SignBytes())

    header.SequencerSignature = signature

    block := Block{
        Data:   data,
        Header: header,
    }

    s.AddBlock(block)

    return block, nil
}

Tenga en cuenta que el secuenciador aquí aún no está publicando encabezados en Ethereum. Esto se debe a que el secuenciador está esperando que los compromisos del conjunto de validadores Celestia (las raíces de tupla raíz de datos) se transmitan a los contratos. Una vez que se actualizan los contratos, el secuenciador puede publicar el encabezado en Ethereum.

ir

func (s *Sequencer) UpdateHeaders() error {
    latestRollupHeight, err := s.EthereumClient.LatestRollupHeight()
    if err != nil {
        return err
    }

    for i := latestRollupHeight; i <= uint64(len(s.Blocks)+1); i++ {
        err := s.EthereumClient.SubmitHeader(s.Blocks[i].Header)
        if err != nil {
            return err
        }
    }

    return nil
}

Rollup nodo completo​

Descargando el bloque​

Hay algunos mecanismos diferentes que podrían usarse para descargar bloques. La solución más simple y lo que se describe anteriormente es para Fullnodes para esperar hasta que los bloques y los encabezados se publiquen en las cadenas respectivas, y luego descargue cada uno a medida que se publican. También sería posible cotillear los encabezados con anticipación y descargar los bloques desplegables de Celestia en lugar de esperar a que los encabezados se publiquen en Ethereum. También es posible descargar los encabezados y los datos de bloque como una cadena de bloques normal a través de una red de chismes y solo volver a descargar los datos y encabezados de Celestia y Ethereum si el la red de chismes no está disponible o el secuenciador es malicioso.

ir

func (f *Fullnode) AddBlock(b Block) error {
    // Perform validation of the block
    if b.Header.Height != uint64(len(f.Blocks)+1) {
        return fmt.Errorf("failure to add block: expected block height %d, got %d", len(f.Blocks)+1, b.Header.Height)
    }
    // Check the sequencer's signature
    if !b.Header.SequencerSignature.IsValid(f.SequencerAddress) {
        return fmt.Errorf("failure to add block: invalid sequencer signature")
    }

    f.Blocks = append(f.Blocks, b)
    return nil
}

func (f *Fullnode) GetLatestBlock() error {
    nextHeight := uint64(len(f.Blocks) + 1)

    // Download the next header from etheruem before we download the block data
    // from Celestia. Note that we could alternatievely download the header
    // directly from the sequencer instead of waiting.
    header, err := f.EthereumClient.GetHeader(nextHeight)
    if err != nil {
        return err
    }

    data, err := f.CelestiaLightNodeClient.GetBlockData(header.Span)
    if err != nil {
        return err
    }

    return f.AddBlock(
        Block{
            Data:   data,
            Header: header,
        },
    )
}

Este esquema de un rollup de Blobstream no está haciendo transiciones de ejecución o estado inducidas por las transacciones, sin embargo, ese paso ocurriría aquí. Si se detecta fraude, comenzará el proceso de prueba de fraude. La única diferencia entre el proceso de prueba de fraude de un rollup optimista normal y un rollup que usa Blobstream para DA es que el nodo completo primero probaría que la transacción fraudulenta estaba comprometida por el secuenciador usando el Span en el encabezado y antes de continuar con el proceso normal.

Más documentación​

Demostrar inclusión a través de Blobstream​

Documentos a prueba de inclusión de blobstream y el ayudante verificador contratos.

Envío de datos de bloque a Celestia a través del nodo de luz​

Como se ha vinculado anteriormente, utilice el Celestia nodo de luz RPC para enviar los datos a Celestia.

Publicar encabezados a Ethereum​

La forma en que se publican los encabezados en Ethereum depende completamente de cómo funcionan los contratos de clientes de luz desplegable. Para ver ejemplos de interacción con la cadena de bloques Ethereum programáticamente, consulte el libro go-ethereum o uno de los muchos otros recursos para envío de transacciones o redacción de contratos.