remove redundant comment and function

Author: KimiWu123

bin/ream/src/cli/mod.rs

@@ -211,7 +211,6 @@ mod tests {
 
     #[test]
     fn test_cli_da_node_command() {
-        // Explicit flags parse through to the config.
         let cli = Cli::parse_from([
             "program",
             "--verbosity",
@@ -234,7 +233,6 @@ mod tests {
             _ => unreachable!("This test should only validate the da node cli"),
         }
 
-        // Omitting --http-port falls back to DEFAULT_DATA_AVAILABILITY_HTTP_PORT.
         let cli = Cli::parse_from(["program", "da_node"]);
 
         match cli.command {

bin/ream/src/main.rs

@@ -660,9 +660,8 @@ pub async fn run_data_availability_node(
 
     set_beacon_network_spec(config.network.clone());
 
-    // The DA RPC is a private, same-host channel to the local beacon, not a public
-    // service. Refuse to start if bound anywhere reachable beyond this
-    // machine, which would expose unauthenticated write/prune/read to the network.
+    // The DA RPC is unauthenticated; it must never be reachable beyond
+    // localhost.
     if !config.http_address.is_loopback() {
         error!(
             "refusing to start DA node: http address {} is not loopback; \
@@ -678,7 +677,6 @@ pub async fn run_data_availability_node(
         config.http_allow_origin,
     );
 
-    // Filesystem-backed store, rooted at the node's data directory.
     let store = Arc::new(DaFileStore::new(data_dir).expect("failed to open DA store"));
     let max_blobs_per_block =
         NonZeroUsize::new(beacon_network_spec().max_blobs_per_block_electra as usize)
@@ -693,9 +691,8 @@ pub async fn run_data_availability_node(
         ream_rpc_da::server::start(server_config, ingest_handle, store).await
     }));
 
-    // The KZG trusted setup is lazily loaded and expensive (seconds). Warm it up
-    // now, off the async workers, so the first column to arrive doesn't pay that
-    // cost mid-verification.
+    // Warm the trusted setup (multi-second) off the async workers before the
+    // first column arrives.
     if let Err(err) = executor
         .spawn_blocking(KzgVerifier::warm_up_trusted_setup)
         .await

crates/common/da/src/availability.rs

@@ -1,13 +1,9 @@
 use crate::id::{NUMBER_OF_COLUMNS, column_indices};
 
-/// Which of a block's columns this node holds, against the set it is responsible
-/// for.
-///
-/// Both fields are 128-bit presence bitmaps — bit `i` set ⇔ column index `i`:
-/// - `held`: columns actually stored here.
-/// - `expected`: columns this node is responsible for (its custody set). For the full-custody MVP
-///   the store stamps every value with `ALL_COLUMNS_MASK`; once custody groups land it stamps the
-///   node's actual custody set instead, and the query methods below keep working unchanged.
+/// Which of a block's columns this node holds (`held`) against the set it is
+/// responsible for (`expected`). Both are 128-bit presence bitmaps: bit `i`
+/// set ⇔ column `i`. The full-custody MVP stamps `expected` with
+/// `ALL_COLUMNS_MASK`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct DaAvailability {
     held: u128,
@@ -29,26 +25,17 @@ impl DaAvailability {
         u64::from(self.held.count_ones())
     }
 
-    /// Whether column `index` is physically held, regardless of custody.
-    ///
-    /// A pure bitmap probe — this is the cheap presence check for callers that
-    /// would otherwise fetch a whole column just to see if it exists. An
-    /// out-of-range index is never held.
+    /// Whether column `index` is held; an out-of-range index is never held.
     pub fn holds(&self, index: u64) -> bool {
         index < NUMBER_OF_COLUMNS && self.held & (1u128 << index) != 0
     }
 
-    /// Column indices this node is responsible for but does not yet hold, in
-    /// ascending order.
-    ///
-    /// This is the list a fetcher turns into a request for the missing columns
+    /// Column indices expected but not held, ascending.
     pub fn missing_indices(&self) -> Vec<u64> {
         column_indices(self.expected & !self.held)
     }
 
-    /// Column indices physically held, ascending — the list a serving node walks
-    /// to return every column it has for a block. Includes any held outside the
-    /// custody set.
+    /// Column indices held (including any outside custody), ascending.
     pub fn held_indices(&self) -> Vec<u64> {
         column_indices(self.held)
     }
@@ -58,14 +45,10 @@ impl DaAvailability {
 mod tests {
     use super::DaAvailability;
 
-    /// A small custody set — columns {0, 1, 2, 3} — keeps the expectations
-    /// readable while still exercising partial/complete logic.
     const EXPECTED_FOUR: u128 = 0b1111;
 
     #[test]
     fn holds_probes_single_columns() {
-        // Held {0, 2}: bit probes answer per column, and an out-of-range index
-        // (>= NUMBER_OF_COLUMNS) is never held.
         let availability = DaAvailability::new(0b0101, EXPECTED_FOUR);
         assert!(availability.holds(0));
         assert!(!availability.holds(1));
@@ -92,7 +75,6 @@ mod tests {
 
     #[test]
     fn partial_reports_only_the_gaps() {
-        // Holds columns 0 and 2 of the four expected.
         let availability = DaAvailability::new(0b0101, EXPECTED_FOUR);
         assert!(!availability.is_complete());
         assert_eq!(availability.held_count(), 2);
@@ -101,8 +83,6 @@ mod tests {
 
     #[test]
     fn extra_columns_beyond_custody_still_complete() {
-        // Holds column 4 on top of the expected four: a superset, still complete,
-        // and column 4 is never reported as missing.
         let availability = DaAvailability::new(0b11111, EXPECTED_FOUR);
         assert!(availability.is_complete());
         assert_eq!(availability.held_count(), 5);
@@ -111,8 +91,6 @@ mod tests {
 
     #[test]
     fn sparse_custody_follows_the_bits_not_the_count() {
-        // Custody indices {5, 70, 99}, plus a held column (9) that lies
-        // OUTSIDE custody.
         let expected = (1u128 << 5) | (1u128 << 70) | (1u128 << 99);
         let held = (1u128 << 5) | (1u128 << 9);
         let availability = DaAvailability::new(held, expected);
@@ -124,10 +102,8 @@ mod tests {
 
     #[test]
     fn held_indices_lists_every_stored_column_in_order() {
-        // Held {0, 2} within custody plus {9} outside it — all count as held.
         let availability = DaAvailability::new((1 << 0) | (1 << 2) | (1 << 9), EXPECTED_FOUR);
         assert_eq!(availability.held_indices(), vec![0, 2, 9]);
-        // Nothing held -> empty list.
         assert!(
             DaAvailability::new(0, EXPECTED_FOUR)
                 .held_indices()

crates/common/da/src/column.rs

@@ -3,38 +3,22 @@ use serde::{Deserialize, Serialize};
 use crate::id::DaColumnId;
 
 /// Consensus-derived context attached to a candidate column.
-///
-/// Only plain data crosses this boundary; no beacon runtime handles.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct DaContext {
-    /// Slot of the block the column belongs to. Used for retention decisions,
-    /// never for fork choice.
+    /// Slot of the block the column belongs to; used for retention only.
     pub slot: u64,
 }
 
 /// A candidate column submitted for verification.
-///
-/// Candidates may come from a consensus data source, the dev-mode ingest API,
-/// or (in the future) peers. All of them pass through the same verification
-/// pipeline before they can be stored or served.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CandidateColumn {
     pub id: DaColumnId,
     pub context: DaContext,
-    /// Opaque, scheme-specific payload bytes carrying the column and its
-    /// availability evidence. The DA core never interprets them: for the
-    /// PeerDAS backend they are an SSZ-encoded `DataColumnSidecar` (cells, KZG
-    /// commitments, KZG proofs, signed block header, and commitments inclusion
-    /// proof); a future non-KZG backend can encode different evidence without
-    /// changing storage, API, or serving logic.
     pub payload: Vec<u8>,
 }
 
-/// A column that passed verification.
-///
-/// This is the only type accepted by `DaWriteStore`. It must only be
-/// constructed by `DaVerifier` implementations; everything downstream of the
-/// verifier relies on this to avoid re-verifying on the serving path.
+/// A column that passed verification — the only type accepted by
+/// `DaWriteStore`, and only constructed by `DaVerifier` implementations.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct VerifiedColumn {
     id: DaColumnId,
@@ -43,7 +27,6 @@ pub struct VerifiedColumn {
 }
 
 impl VerifiedColumn {
-    /// Construct a verified column without running verification.
     pub fn new_unchecked(id: DaColumnId, context: DaContext, payload: Vec<u8>) -> Self {
         Self {
             id,
@@ -63,8 +46,4 @@ impl VerifiedColumn {
     pub fn payload(&self) -> &[u8] {
         &self.payload
     }
-
-    pub fn into_payload(self) -> Vec<u8> {
-        self.payload
-    }
 }

crates/common/da/src/error.rs

@@ -46,8 +46,7 @@ pub enum ValidationError {
 
 #[derive(Debug, Error)]
 pub enum DaStoreError {
-    /// Underlying storage failure: filesystem I/O, a missing backing file, or
-    /// corruption. Not a normal "not found" answer — that is `Ok(None)`.
+    /// Underlying storage failure; "not found" is `Ok(None)`, not an error.
     #[error("storage I/O failure: {0}")]
     Io(#[from] io::Error),
 }

crates/common/da/src/id.rs

@@ -3,20 +3,15 @@ use serde::{Deserialize, Serialize};
 
 use crate::error::ValidationError;
 
-/// Number of data columns per block in the PeerDAS MVP.
-///
-/// The MVP custodies and serves the full column set.
-///
-/// This MUST stay equal to the spec's `NUMBER_OF_COLUMNS`
+/// MUST stay equal to the spec's `NUMBER_OF_COLUMNS`
 /// (<https://ethereum.github.io/consensus-specs/fulu/das-core/>).
 pub const NUMBER_OF_COLUMNS: u64 = 128;
 
-/// Bitmask for full custody, serve the full column set.
+/// Bitmask for full custody.
 pub const ALL_COLUMNS_MASK: u128 = u128::MAX;
 
 /// Ascending column indices set in a 128-bit presence bitmap (bit `i` ⇔ column
-/// `i`). Expands a bitmap into concrete indices for callers that need them — the
-/// missing-column set, or the columns to delete when pruning a block.
+/// `i`).
 pub fn column_indices(mut bitmap: u128) -> Vec<u64> {
     let mut indices = Vec::new();
     while bitmap != 0 {

crates/common/da/src/lib.rs

@@ -1,23 +1,3 @@
-//! DA core for `ream da-node`: the storage-and-verification half of a PeerDAS
-//! data-availability node.
-//!
-//! # Division of labor: beacon node vs. DA node
-//!
-//! A beacon node and a DA node run as two separate OS processes, and the split
-//! of responsibility is deliberate:
-//!
-//! - The **beacon node** owns the consensus business logic — gossip, peer scoring, fork choice,
-//!   which blocks are canonical, which columns this node is custodian of. It drives the DA node
-//!   over HTTP/RPC.
-//! - The **DA node** (this code) only *stores* data columns and *verifies* them in a self-contained
-//!   way: SSZ structure, the commitments inclusion proof, and the KZG cell proofs. It has no P2P
-//!   stack and no view of the chain — it cannot tell "canonical" from "orphaned". Everything it
-//!   needs arrives as an opaque payload plus a small context across the RPC boundary.
-//!
-//! This crate is intentionally free of beacon, KZG, and execution
-//! dependencies. A concrete proof system enters only through an adapter (see
-//! `ream-da-verifier-kzg`) behind the [`verifier::DaVerifier`] trait, so the
-//! core stays reusable by a future non-KZG or post-quantum scheme.
 pub mod availability;
 pub mod column;
 pub mod error;

crates/common/da/src/store.rs

@@ -7,35 +7,23 @@ use crate::{
 /// Outcome of inserting a verified column.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum InsertOutcome {
-    /// The column was newly persisted.
     Inserted,
-    /// A column was already stored for this identifier; the insert is a no-op
-    /// idempotent success and the existing value is kept.
+    /// A column was already stored for this id; the insert is an idempotent
+    /// no-op and the existing column is kept.
     Duplicated,
 }
 
-/// Read-only storage handle.
-///
-/// This is the only storage capability handed to the local API and to P2P
-/// serving. Serving does not re-verify on the output path because the store
-/// only ever contains verified data.
+/// Read-only storage handle. Serving never re-verifies on the output path
+/// because the store only ever contains verified data.
 pub trait DaReadStore: Send + Sync {
     fn get(&self, id: &DaColumnId) -> Result<Option<VerifiedColumn>, DaStoreError>;
     fn availability(&self, block_root: B256) -> Result<DaAvailability, DaStoreError>;
 }
 
-/// Write-capable storage handle.
-///
-/// Handed to the verification service only. Accepting [`VerifiedColumn`] (not
-/// candidates) makes "unverified data is never stored" a type-level rule.
+/// Write-capable storage handle, handed to the verification service only.
+/// Accepting [`VerifiedColumn`] (not candidates) makes "unverified data is
+/// never stored" a type-level rule.
 pub trait DaWriteStore: DaReadStore {
-    /// Store a verified column.
-    ///
-    /// Columns are keyed by [`DaColumnId`]. If a column is already stored for
-    /// this id, the call is an idempotent [`InsertOutcome::Duplicated`]: the
-    /// incoming column is ignored and the stored one is kept, never
-    /// overwritten. Otherwise the column is persisted and
-    /// [`InsertOutcome::Inserted`] is returned.
     fn put(&self, column: VerifiedColumn) -> Result<InsertOutcome, DaStoreError>;
 
     fn prune_below_slot(&self, slot: u64) -> Result<usize, DaStoreError>;

crates/common/da_adapters/kzg_verifier/src/lib.rs

@@ -1,11 +1,3 @@
-//! PeerDAS/KZG verifier adapter for the DA core.
-//!
-//! This is the scheme boundary made concrete: the only DA crate that depends on
-//! both beacon types (`DataColumnSidecar`) and a concrete commitment scheme
-//! (KZG over BLS12-381). Isolating those dependencies here lets `ream-da` stay
-//! free of beacon and KZG code while still getting real verification, plugged
-//! in through the [`ream_da::verifier::DaVerifier`] trait.
-
 pub mod verifier;
 
 pub use verifier::KzgVerifier;