celestia configurable

Author: chudkowsky

bin/saya/src/any.rs

@@ -1,6 +1,12 @@
 use anyhow::Result;
 use saya_core::{
     block_ingestor::BlockInfo,
+    data_availability::{
+        CelestiaDataAvailabilityBackend, CelestiaDataAvailabilityBackendBuilder,
+        DataAvailabilityBackend, DataAvailabilityBackendBuilder, DataAvailabilityCursor,
+        DataAvailabilityPayload, DataAvailabilityPointer, NoopDataAvailabilityBackend,
+        NoopDataAvailabilityBackendBuilder,
+    },
     prover::{
         AtlanticLayoutBridgeProver, AtlanticLayoutBridgeProverBuilder, MockLayoutBridgeProver,
         MockLayoutBridgeProverBuilder, Prover, ProverBuilder, SnosProof,
@@ -22,6 +28,87 @@ pub enum AnyLayoutBridgeProverBuilder<DB> {
     Mock(MockLayoutBridgeProverBuilder<DB>),
 }
 
+#[derive(Debug)]
+pub enum AnyDataAvailabilityLayer<P> {
+    Celestia(Box<CelestiaDataAvailabilityBackend<P>>),
+    Noop(NoopDataAvailabilityBackend<P>),
+}
+
+#[derive(Debug)]
+pub enum AnyDataAvailabilityLayerBuilder<P> {
+    Celestia(Box<CelestiaDataAvailabilityBackendBuilder<P>>),
+    Noop(NoopDataAvailabilityBackendBuilder<P>),
+}
+
+impl<P> DataAvailabilityBackend for AnyDataAvailabilityLayer<P>
+where
+    P: DataAvailabilityPayload + 'static,
+{
+    type Payload = P;
+}
+
+impl<P> Daemon for AnyDataAvailabilityLayer<P>
+where
+    P: DataAvailabilityPayload + 'static,
+{
+    fn shutdown_handle(&self) -> ShutdownHandle {
+        match self {
+            Self::Celestia(inner) => inner.shutdown_handle(),
+            Self::Noop(inner) => inner.shutdown_handle(),
+        }
+    }
+
+    fn start(self) {
+        match self {
+            Self::Celestia(inner) => inner.start(),
+            Self::Noop(inner) => inner.start(),
+        }
+    }
+}
+
+impl<P> DataAvailabilityBackendBuilder for AnyDataAvailabilityLayerBuilder<P>
+where
+    P: DataAvailabilityPayload + 'static,
+{
+    type Backend = AnyDataAvailabilityLayer<P>;
+
+    fn build(self) -> Result<Self::Backend> {
+        Ok(match self {
+            Self::Celestia(inner) => AnyDataAvailabilityLayer::Celestia(Box::new(inner.build()?)),
+            Self::Noop(inner) => AnyDataAvailabilityLayer::Noop(inner.build()?),
+        })
+    }
+
+    fn last_pointer(self, last_pointer: Option<DataAvailabilityPointer>) -> Self {
+        match self {
+            Self::Celestia(inner) => Self::Celestia(Box::new(inner.last_pointer(last_pointer))),
+            Self::Noop(inner) => Self::Noop(inner.last_pointer(last_pointer)),
+        }
+    }
+
+    fn proof_channel(
+        self,
+        proof_channel: Receiver<<Self::Backend as DataAvailabilityBackend>::Payload>,
+    ) -> Self {
+        match self {
+            Self::Celestia(inner) => Self::Celestia(Box::new(inner.proof_channel(proof_channel))),
+            Self::Noop(inner) => Self::Noop(inner.proof_channel(proof_channel)),
+        }
+    }
+
+    fn cursor_channel(
+        self,
+        cursor_channel: Sender<
+            DataAvailabilityCursor<<Self::Backend as DataAvailabilityBackend>::Payload>,
+        >,
+    ) -> Self {
+        match self {
+            Self::Celestia(inner) => Self::Celestia(Box::new(inner.cursor_channel(cursor_channel))),
+            Self::Noop(inner) => Self::Noop(inner.cursor_channel(cursor_channel)),
+        }
+    }
+}
+
 impl<DB> Prover for AnyLayoutBridgeProver<DB>
 where
     DB: PersistantStorage + Send + Sync + Clone + 'static,

bin/saya/src/persistent.rs

@@ -4,7 +4,9 @@ use anyhow::Result;
 use clap::{Parser, Subcommand};
 use saya_core::{
     block_ingestor::PollingBlockIngestorBuilder,
-    data_availability::CelestiaDataAvailabilityBackendBuilder,
+    data_availability::{
+        CelestiaDataAvailabilityBackendBuilder, NoopDataAvailabilityBackendBuilder,
+    },
     orchestrator::PersistentOrchestratorBuilder,
     prover::{
         AtlanticLayoutBridgeProverBuilder, AtlanticSnosProverBuilder,
@@ -23,7 +25,7 @@ use starknet_types_core::felt::Felt;
 use url::Url;
 
 use crate::{
-    any::AnyLayoutBridgeProverBuilder,
+    any::{AnyDataAvailabilityLayerBuilder, AnyLayoutBridgeProverBuilder},
     common::{calculate_workers_per_stage, NUMBER_OF_STAGES, SAYA_DB_PATH},
     sovereign::validate_non_empty,
 };
@@ -83,12 +85,19 @@ struct Start {
     /// Configuration for OS pie generation
     #[clap(flatten)]
     hints: HintsConfiguration,
+    /// Celestia configuration
+    #[clap(flatten)]
+    celestia: CelestiaConfiguration,
+}
+
+#[derive(Debug, Parser, Clone)]
+struct CelestiaConfiguration {
     /// Celestia RPC endpoint URL
     #[clap(long, env)]
-    celestia_rpc: Url,
+    celestia_rpc: Option<Url>,
     /// Celestia RPC node auth token
     #[clap(long, env)]
-    celestia_token: String,
+    celestia_token: Option<String>,
     /// Celestia key name
     #[clap(long, env)]
     celestia_key_name: Option<String>,
@@ -200,13 +209,22 @@ impl Start {
             ),
             layout_bridge_prover_builder,
         );
-        let da_builder = CelestiaDataAvailabilityBackendBuilder::new(
-            self.celestia_rpc,
-            self.celestia_token,
-            self.celestia_namespace,
-            self.celestia_key_name,
-        )
-        .unwrap();
+
+        let da_builder = if let (Some(celestia_rpc), Some(celestia_token)) =
+            (self.celestia.celestia_rpc, self.celestia.celestia_token)
+        {
+            AnyDataAvailabilityLayerBuilder::Celestia(Box::new(
+                CelestiaDataAvailabilityBackendBuilder::new(
+                    celestia_rpc,
+                    celestia_token,
+                    self.celestia.celestia_namespace,
+                    self.celestia.celestia_key_name,
+                )
+                .unwrap(),
+            ))
+        } else {
+            AnyDataAvailabilityLayerBuilder::Noop(NoopDataAvailabilityBackendBuilder::new())
+        };
 
         let settlement_builder = PiltoverSettlementBackendBuilder::new(
             self.settlement_rpc,