feat(plasma): Add PlasmaDataSource

crates/derive/src/sources/ethereum.rs

@@ -1,4 +1,5 @@
-//! Contains a Factory for creating a calldata and blob provider.
+//! Contains the [EthereumDataSource], which is a concrete implementation of the
+//! [DataAvailabilityProvider] trait for the Ethereum protocol.
 
 use crate::{
     sources::{BlobSource, CalldataSource, EthereumDataSourceVariant},

crates/derive/src/sources/mod.rs

@@ -9,5 +9,5 @@ pub use blobs::BlobSource;
 mod calldata;
 pub use calldata::CalldataSource;
 
-mod source;
-pub use source::EthereumDataSourceVariant;
+mod variant;
+pub use variant::EthereumDataSourceVariant;

crates/derive/src/traits/data_sources.rs

@@ -18,15 +18,6 @@ pub trait BlobProvider {
     ) -> Result<Vec<Blob>>;
 }
 
-/// The PlasmaProvider trait specifies the functionality of a data source that can fetch plasma
-/// inputs.
-#[async_trait]
-#[allow(dead_code)]
-pub(crate) trait PlasmaProvider {
-    /// Fetches the plasma input for the given commitment at the given block number.
-    async fn get_input(&self, commitment: &[u8], block_number: u64) -> Result<Bytes>;
-}
-
 /// Describes the functionality of a data source that can provide data availability information.
 #[async_trait]
 pub trait DataAvailabilityProvider {

crates/plasma/src/lib.rs

@@ -6,6 +6,7 @@
 
 extern crate alloc;
 
+pub mod plasma;
 pub mod source;
 pub mod traits;
 pub mod types;

crates/plasma/src/plasma.rs

@@ -0,0 +1,72 @@
+//! Contains the [PlasmaDataSource], which is a concrete implementation of the
+//! [DataAvailabilityProvider] trait for the Plasma protocol. Used as an adapter to the
+//! [kona_derive] crate's derivation pipeline construction.
+//!
+//! [DataAvailabilityProvider]: kona_derive::traits::DataAvailabilityProvider
+
+use crate::{source::PlasmaSource, traits::PlasmaInputFetcher};
+use alloc::{boxed::Box, fmt::Debug};
+use alloy_primitives::{Address, Bytes};
+use anyhow::Result;
+use async_trait::async_trait;
+use kona_derive::{
+    traits::{ChainProvider, DataAvailabilityProvider},
+    types::{BlockInfo, RollupConfig},
+};
+use kona_primitives::BlockID;
+
+/// A factory for creating an Ethereum data source provider.
+#[derive(Debug, Clone, Copy)]
+pub struct PlasmaDataSource<C, PIF, I>
+where
+    C: ChainProvider + Send + Clone,
+    PIF: PlasmaInputFetcher<C> + Clone,
+    I: Iterator<Item = Bytes> + Send + Clone,
+{
+    /// The chain provider to use for the factory.
+    pub chain_provider: C,
+    /// The plasma iterator.
+    pub plasma_source: I,
+    /// The plasma input fetcher.
+    pub plasma_input_fetcher: PIF,
+    /// The L1 Signer.
+    pub signer: Address,
+}
+
+impl<C, PIF, I> PlasmaDataSource<C, PIF, I>
+where
+    C: ChainProvider + Send + Clone + Debug,
+    PIF: PlasmaInputFetcher<C> + Clone,
+    I: Iterator<Item = Bytes> + Send + Clone,
+{
+    /// Creates a new factory.
+    pub fn new(provider: C, pif: PIF, s: I, cfg: &RollupConfig) -> Self {
+        Self {
+            chain_provider: provider,
+            plasma_source: s,
+            plasma_input_fetcher: pif,
+            signer: cfg.genesis.system_config.batcher_addr,
+        }
+    }
+}
+
+#[async_trait]
+impl<C, PIF, I> DataAvailabilityProvider for PlasmaDataSource<C, PIF, I>
+where
+    C: ChainProvider + Send + Clone + Debug + Sync,
+    PIF: PlasmaInputFetcher<C> + Clone + Debug + Send + Sync,
+    I: Iterator<Item = Bytes> + Send + Clone + Debug + Sync,
+{
+    type Item = Bytes;
+    type DataIter = PlasmaSource<C, PIF, I>;
+
+    async fn open_data(&self, block_ref: &BlockInfo, _: Address) -> Result<Self::DataIter> {
+        let id = BlockID { hash: block_ref.hash, number: block_ref.number };
+        Ok(PlasmaSource::new(
+            self.chain_provider.clone(),
+            self.plasma_input_fetcher.clone(),
+            self.plasma_source.clone(),
+            id,
+        ))
+    }
+}

crates/plasma/src/traits.rs

@@ -39,45 +39,3 @@ pub trait PlasmaInputFetcher<CP: ChainProvider + Send> {
     /// Set the engine finalization signal callback.
     fn on_finalized_head_signal(&mut self, callback: FinalizedHeadSignal);
 }
-
-#[async_trait]
-impl<CP: ChainProvider + Send> PlasmaInputFetcher<CP> for () {
-    /// Get the input for the given commitment at the given block number from the DA storage
-    /// service.
-    async fn get_input(
-        &mut self,
-        _fetcher: &CP,
-        _commitment: Bytes,
-        _block: BlockID,
-    ) -> Option<Result<Bytes, PlasmaError>> {
-        unimplemented!()
-    }
-
-    /// Advance the L1 origin to the given block number, syncing the DA challenge events.
-    async fn advance_l1_origin(
-        &mut self,
-        _fetcher: &CP,
-        _block: BlockID,
-    ) -> Option<Result<(), PlasmaError>> {
-        unimplemented!()
-    }
-
-    /// Reset the challenge origin in case of L1 reorg.
-    async fn reset(
-        &mut self,
-        _block_number: BlockInfo,
-        _cfg: SystemConfig,
-    ) -> Option<Result<(), PlasmaError>> {
-        unimplemented!()
-    }
-
-    /// Notify L1 finalized head so plasma finality is always behind L1.
-    async fn finalize(&mut self, _block_number: BlockInfo) -> Option<Result<(), PlasmaError>> {
-        unimplemented!()
-    }
-
-    /// Set the engine finalization signal callback.
-    fn on_finalized_head_signal(&mut self, _callback: FinalizedHeadSignal) {
-        unimplemented!()
-    }
-}