diff --git a/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.rs b/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.rs
deleted file mode 100644
index 612e5c9fcf..0000000000
--- a/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.rs
+++ /dev/null
@@ -1,516 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetBlockCommitmentStreamRequest {}
-impl ::prost::Name for GetBlockCommitmentStreamRequest {
-    const NAME: &'static str = "GetBlockCommitmentStreamRequest";
-    const PACKAGE: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1";
-    fn full_name() -> ::prost::alloc::string::String {
-        ::prost::alloc::format!(
-            "astria.sequencerblock.optimisticblock.v1alpha1.{}", Self::NAME
-        )
-    }
-}
-/// Identifying metadata for blocks that have been successfully committed in the Sequencer.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SequencerBlockCommit {
-    /// Height of the sequencer block that was committed.
-    #[prost(uint64, tag = "1")]
-    pub height: u64,
-    /// Hash of the sequencer block that was committed.
-    #[prost(bytes = "bytes", tag = "2")]
-    pub block_hash: ::prost::bytes::Bytes,
-}
-impl ::prost::Name for SequencerBlockCommit {
-    const NAME: &'static str = "SequencerBlockCommit";
-    const PACKAGE: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1";
-    fn full_name() -> ::prost::alloc::string::String {
-        ::prost::alloc::format!(
-            "astria.sequencerblock.optimisticblock.v1alpha1.{}", Self::NAME
-        )
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetBlockCommitmentStreamResponse {
-    #[prost(message, optional, tag = "1")]
-    pub commitment: ::core::option::Option<SequencerBlockCommit>,
-}
-impl ::prost::Name for GetBlockCommitmentStreamResponse {
-    const NAME: &'static str = "GetBlockCommitmentStreamResponse";
-    const PACKAGE: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1";
-    fn full_name() -> ::prost::alloc::string::String {
-        ::prost::alloc::format!(
-            "astria.sequencerblock.optimisticblock.v1alpha1.{}", Self::NAME
-        )
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetOptimisticBlockStreamRequest {
-    /// The rollup id for which the Sequencer block is being streamed.
-    #[prost(message, optional, tag = "1")]
-    pub rollup_id: ::core::option::Option<super::super::super::primitive::v1::RollupId>,
-}
-impl ::prost::Name for GetOptimisticBlockStreamRequest {
-    const NAME: &'static str = "GetOptimisticBlockStreamRequest";
-    const PACKAGE: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1";
-    fn full_name() -> ::prost::alloc::string::String {
-        ::prost::alloc::format!(
-            "astria.sequencerblock.optimisticblock.v1alpha1.{}", Self::NAME
-        )
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetOptimisticBlockStreamResponse {
-    /// The optimistic Sequencer block that is being streamed, filtered for the provided rollup id.
-    #[prost(message, optional, tag = "1")]
-    pub block: ::core::option::Option<super::super::v1::FilteredSequencerBlock>,
-}
-impl ::prost::Name for GetOptimisticBlockStreamResponse {
-    const NAME: &'static str = "GetOptimisticBlockStreamResponse";
-    const PACKAGE: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1";
-    fn full_name() -> ::prost::alloc::string::String {
-        ::prost::alloc::format!(
-            "astria.sequencerblock.optimisticblock.v1alpha1.{}", Self::NAME
-        )
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "client")]
-pub mod optimistic_block_service_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    /// The Sequencer will serve this to the aucitoneer
-    #[derive(Debug, Clone)]
-    pub struct OptimisticBlockServiceClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl OptimisticBlockServiceClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> OptimisticBlockServiceClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> OptimisticBlockServiceClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
-        {
-            OptimisticBlockServiceClient::new(
-                InterceptedService::new(inner, interceptor),
-            )
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        /// The Sequencer will stream the optimistic Sequencer block (filtered for the provided
-        /// rollup id) to the Auctioneer.
-        pub async fn get_optimistic_block_stream(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetOptimisticBlockStreamRequest>,
-        ) -> std::result::Result<
-            tonic::Response<
-                tonic::codec::Streaming<super::GetOptimisticBlockStreamResponse>,
-            >,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService/GetOptimisticBlockStream",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService",
-                        "GetOptimisticBlockStream",
-                    ),
-                );
-            self.inner.server_streaming(req, path, codec).await
-        }
-        /// The Sequencer will stream the block commits to the Auctioneer.
-        pub async fn get_block_commitment_stream(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetBlockCommitmentStreamRequest>,
-        ) -> std::result::Result<
-            tonic::Response<
-                tonic::codec::Streaming<super::GetBlockCommitmentStreamResponse>,
-            >,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService/GetBlockCommitmentStream",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService",
-                        "GetBlockCommitmentStream",
-                    ),
-                );
-            self.inner.server_streaming(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-#[cfg(feature = "server")]
-pub mod optimistic_block_service_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with OptimisticBlockServiceServer.
-    #[async_trait]
-    pub trait OptimisticBlockService: Send + Sync + 'static {
-        /// Server streaming response type for the GetOptimisticBlockStream method.
-        type GetOptimisticBlockStreamStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOptimisticBlockStreamResponse,
-                    tonic::Status,
-                >,
-            >
-            + Send
-            + 'static;
-        /// The Sequencer will stream the optimistic Sequencer block (filtered for the provided
-        /// rollup id) to the Auctioneer.
-        async fn get_optimistic_block_stream(
-            self: std::sync::Arc<Self>,
-            request: tonic::Request<super::GetOptimisticBlockStreamRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetOptimisticBlockStreamStream>,
-            tonic::Status,
-        >;
-        /// Server streaming response type for the GetBlockCommitmentStream method.
-        type GetBlockCommitmentStreamStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetBlockCommitmentStreamResponse,
-                    tonic::Status,
-                >,
-            >
-            + Send
-            + 'static;
-        /// The Sequencer will stream the block commits to the Auctioneer.
-        async fn get_block_commitment_stream(
-            self: std::sync::Arc<Self>,
-            request: tonic::Request<super::GetBlockCommitmentStreamRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetBlockCommitmentStreamStream>,
-            tonic::Status,
-        >;
-    }
-    /// The Sequencer will serve this to the aucitoneer
-    #[derive(Debug)]
-    pub struct OptimisticBlockServiceServer<T: OptimisticBlockService> {
-        inner: _Inner<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    struct _Inner<T>(Arc<T>);
-    impl<T: OptimisticBlockService> OptimisticBlockServiceServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            let inner = _Inner(inner);
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>>
-    for OptimisticBlockServiceServer<T>
-    where
-        T: OptimisticBlockService,
-        B: Body + Send + 'static,
-        B::Error: Into<StdError> + Send + 'static,
-    {
-        type Response = http::Response<tonic::body::BoxBody>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            let inner = self.inner.clone();
-            match req.uri().path() {
-                "/astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService/GetOptimisticBlockStream" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetOptimisticBlockStreamSvc<T: OptimisticBlockService>(
-                        pub Arc<T>,
-                    );
-                    impl<
-                        T: OptimisticBlockService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOptimisticBlockStreamRequest,
-                    > for GetOptimisticBlockStreamSvc<T> {
-                        type Response = super::GetOptimisticBlockStreamResponse;
-                        type ResponseStream = T::GetOptimisticBlockStreamStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<
-                                super::GetOptimisticBlockStreamRequest,
-                            >,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as OptimisticBlockService>::get_optimistic_block_stream(
-                                        inner,
-                                        request,
-                                    )
-                                    .await
-                            };
-                            Box::pin(fut)
-                        }
-                    }
-                    let accept_compression_encodings = self.accept_compression_encodings;
-                    let send_compression_encodings = self.send_compression_encodings;
-                    let max_decoding_message_size = self.max_decoding_message_size;
-                    let max_encoding_message_size = self.max_encoding_message_size;
-                    let inner = self.inner.clone();
-                    let fut = async move {
-                        let inner = inner.0;
-                        let method = GetOptimisticBlockStreamSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
-                        let mut grpc = tonic::server::Grpc::new(codec)
-                            .apply_compression_config(
-                                accept_compression_encodings,
-                                send_compression_encodings,
-                            )
-                            .apply_max_message_size_config(
-                                max_decoding_message_size,
-                                max_encoding_message_size,
-                            );
-                        let res = grpc.server_streaming(method, req).await;
-                        Ok(res)
-                    };
-                    Box::pin(fut)
-                }
-                "/astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService/GetBlockCommitmentStream" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetBlockCommitmentStreamSvc<T: OptimisticBlockService>(
-                        pub Arc<T>,
-                    );
-                    impl<
-                        T: OptimisticBlockService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetBlockCommitmentStreamRequest,
-                    > for GetBlockCommitmentStreamSvc<T> {
-                        type Response = super::GetBlockCommitmentStreamResponse;
-                        type ResponseStream = T::GetBlockCommitmentStreamStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<
-                                super::GetBlockCommitmentStreamRequest,
-                            >,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as OptimisticBlockService>::get_block_commitment_stream(
-                                        inner,
-                                        request,
-                                    )
-                                    .await
-                            };
-                            Box::pin(fut)
-                        }
-                    }
-                    let accept_compression_encodings = self.accept_compression_encodings;
-                    let send_compression_encodings = self.send_compression_encodings;
-                    let max_decoding_message_size = self.max_decoding_message_size;
-                    let max_encoding_message_size = self.max_encoding_message_size;
-                    let inner = self.inner.clone();
-                    let fut = async move {
-                        let inner = inner.0;
-                        let method = GetBlockCommitmentStreamSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
-                        let mut grpc = tonic::server::Grpc::new(codec)
-                            .apply_compression_config(
-                                accept_compression_encodings,
-                                send_compression_encodings,
-                            )
-                            .apply_max_message_size_config(
-                                max_decoding_message_size,
-                                max_encoding_message_size,
-                            );
-                        let res = grpc.server_streaming(method, req).await;
-                        Ok(res)
-                    };
-                    Box::pin(fut)
-                }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
-            }
-        }
-    }
-    impl<T: OptimisticBlockService> Clone for OptimisticBlockServiceServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    impl<T: OptimisticBlockService> Clone for _Inner<T> {
-        fn clone(&self) -> Self {
-            Self(Arc::clone(&self.0))
-        }
-    }
-    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{:?}", self.0)
-        }
-    }
-    impl<T: OptimisticBlockService> tonic::server::NamedService
-    for OptimisticBlockServiceServer<T> {
-        const NAME: &'static str = "astria.sequencerblock.optimisticblock.v1alpha1.OptimisticBlockService";
-    }
-}
diff --git a/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.serde.rs b/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.serde.rs
deleted file mode 100644
index bc159c576f..0000000000
--- a/crates/astria-core/src/generated/astria.sequencerblock.optimisticblock.v1alpha1.serde.rs
+++ /dev/null
@@ -1,460 +0,0 @@
-impl serde::Serialize for GetBlockCommitmentStreamRequest {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let len = 0;
-        let struct_ser = serializer.serialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamRequest", len)?;
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GetBlockCommitmentStreamRequest {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                            Err(serde::de::Error::unknown_field(value, FIELDS))
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GetBlockCommitmentStreamRequest;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamRequest")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetBlockCommitmentStreamRequest, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                while map_.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
-                }
-                Ok(GetBlockCommitmentStreamRequest {
-                })
-            }
-        }
-        deserializer.deserialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamRequest", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GetBlockCommitmentStreamResponse {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.commitment.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamResponse", len)?;
-        if let Some(v) = self.commitment.as_ref() {
-            struct_ser.serialize_field("commitment", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GetBlockCommitmentStreamResponse {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "commitment",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Commitment,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "commitment" => Ok(GeneratedField::Commitment),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GetBlockCommitmentStreamResponse;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamResponse")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetBlockCommitmentStreamResponse, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut commitment__ = None;
-                while let Some(k) = map_.next_key()? {
-                    match k {
-                        GeneratedField::Commitment => {
-                            if commitment__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("commitment"));
-                            }
-                            commitment__ = map_.next_value()?;
-                        }
-                    }
-                }
-                Ok(GetBlockCommitmentStreamResponse {
-                    commitment: commitment__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetBlockCommitmentStreamResponse", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GetOptimisticBlockStreamRequest {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.rollup_id.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamRequest", len)?;
-        if let Some(v) = self.rollup_id.as_ref() {
-            struct_ser.serialize_field("rollupId", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GetOptimisticBlockStreamRequest {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "rollup_id",
-            "rollupId",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            RollupId,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "rollupId" | "rollup_id" => Ok(GeneratedField::RollupId),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GetOptimisticBlockStreamRequest;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamRequest")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetOptimisticBlockStreamRequest, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut rollup_id__ = None;
-                while let Some(k) = map_.next_key()? {
-                    match k {
-                        GeneratedField::RollupId => {
-                            if rollup_id__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("rollupId"));
-                            }
-                            rollup_id__ = map_.next_value()?;
-                        }
-                    }
-                }
-                Ok(GetOptimisticBlockStreamRequest {
-                    rollup_id: rollup_id__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamRequest", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GetOptimisticBlockStreamResponse {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.block.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamResponse", len)?;
-        if let Some(v) = self.block.as_ref() {
-            struct_ser.serialize_field("block", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GetOptimisticBlockStreamResponse {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "block",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Block,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "block" => Ok(GeneratedField::Block),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GetOptimisticBlockStreamResponse;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamResponse")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetOptimisticBlockStreamResponse, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut block__ = None;
-                while let Some(k) = map_.next_key()? {
-                    match k {
-                        GeneratedField::Block => {
-                            if block__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("block"));
-                            }
-                            block__ = map_.next_value()?;
-                        }
-                    }
-                }
-                Ok(GetOptimisticBlockStreamResponse {
-                    block: block__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.GetOptimisticBlockStreamResponse", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SequencerBlockCommit {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.height != 0 {
-            len += 1;
-        }
-        if !self.block_hash.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.SequencerBlockCommit", len)?;
-        if self.height != 0 {
-            #[allow(clippy::needless_borrow)]
-            struct_ser.serialize_field("height", ToString::to_string(&self.height).as_str())?;
-        }
-        if !self.block_hash.is_empty() {
-            #[allow(clippy::needless_borrow)]
-            struct_ser.serialize_field("blockHash", pbjson::private::base64::encode(&self.block_hash).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SequencerBlockCommit {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "height",
-            "block_hash",
-            "blockHash",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Height,
-            BlockHash,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "height" => Ok(GeneratedField::Height),
-                            "blockHash" | "block_hash" => Ok(GeneratedField::BlockHash),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SequencerBlockCommit;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct astria.sequencerblock.optimisticblock.v1alpha1.SequencerBlockCommit")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SequencerBlockCommit, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut height__ = None;
-                let mut block_hash__ = None;
-                while let Some(k) = map_.next_key()? {
-                    match k {
-                        GeneratedField::Height => {
-                            if height__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("height"));
-                            }
-                            height__ = 
-                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::BlockHash => {
-                            if block_hash__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("blockHash"));
-                            }
-                            block_hash__ = 
-                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(SequencerBlockCommit {
-                    height: height__.unwrap_or_default(),
-                    block_hash: block_hash__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("astria.sequencerblock.optimisticblock.v1alpha1.SequencerBlockCommit", FIELDS, GeneratedVisitor)
-    }
-}
diff --git a/crates/astria-core/src/generated/mod.rs b/crates/astria-core/src/generated/mod.rs
index 963dd5bbe3..3f46ae855a 100644
--- a/crates/astria-core/src/generated/mod.rs
+++ b/crates/astria-core/src/generated/mod.rs
@@ -166,14 +166,14 @@ pub mod sequencerblock {
         }
     }
 
-    pub mod optimisticblock {
+    pub mod optimistic {
         pub mod v1alpha1 {
-            include!("astria.sequencerblock.optimisticblock.v1alpha1.rs");
+            include!("astria.sequencerblock.optimistic.v1alpha1.rs");
 
             #[cfg(feature = "serde")]
             mod _serde_impl {
                 use super::*;
-                include!("astria.sequencerblock.optimisticblock.v1alpha1.serde.rs");
+                include!("astria.sequencerblock.optimistic.v1alpha1.serde.rs");
             }
         }
     }