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,
+        ))
+    }
+}