using vec<u8> instead of a wrapper DaPayload

Author: KimiWu123

crates/common/da/src/column.rs

@@ -2,27 +2,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::id::DaColumnId;
 
-/// Opaque, scheme-specific encoding of a DA column payload together with its
-/// availability evidence.
-///
-/// The DA core never interprets these bytes. 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.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct DaPayload(Vec<u8>);
-
-impl DaPayload {
-    pub fn new(bytes: Vec<u8>) -> Self {
-        Self(bytes)
-    }
-
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.0
-    }
-}
-
 /// Consensus-derived context attached to a candidate column.
 ///
 /// Only plain data crosses this boundary; no beacon runtime handles.
@@ -42,7 +21,13 @@ pub struct DaContext {
 pub struct CandidateColumn {
     pub id: DaColumnId,
     pub context: DaContext,
-    pub payload: DaPayload,
+    /// 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.
@@ -54,12 +39,12 @@ pub struct CandidateColumn {
 pub struct VerifiedColumn {
     id: DaColumnId,
     context: DaContext,
-    payload: DaPayload,
+    payload: Vec<u8>,
 }
 
 impl VerifiedColumn {
     /// Construct a verified column without running verification.
-    pub fn new_unchecked(id: DaColumnId, context: DaContext, payload: DaPayload) -> Self {
+    pub fn new_unchecked(id: DaColumnId, context: DaContext, payload: Vec<u8>) -> Self {
         Self {
             id,
             context,
@@ -75,11 +60,11 @@ impl VerifiedColumn {
         self.context
     }
 
-    pub fn payload(&self) -> &DaPayload {
+    pub fn payload(&self) -> &[u8] {
         &self.payload
     }
 
-    pub fn into_payload(self) -> DaPayload {
+    pub fn into_payload(self) -> Vec<u8> {
         self.payload
     }
 }

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

@@ -70,7 +70,7 @@ impl KzgVerifier {
 
 impl DaVerifier for KzgVerifier {
     fn verify(&self, candidate: CandidateColumn) -> Result<VerifiedColumn, ValidationError> {
-        let sidecar = self.decode(candidate.payload.as_bytes())?;
+        let sidecar = self.decode(&candidate.payload)?;
 
         // Identifier consistency: the id is derived from the sidecar's own signed
         // header, so a candidate cannot claim a (block root, column) its payload
@@ -136,7 +136,7 @@ mod tests {
         polynomial_commitments::{kzg_commitment::KZGCommitment, kzg_proof::KZGProof},
     };
     use ream_da::{
-        column::{CandidateColumn, DaContext, DaPayload},
+        column::{CandidateColumn, DaContext},
         error::ValidationError,
         id::DaColumnId,
         verifier::DaVerifier,
@@ -172,8 +172,8 @@ mod tests {
         }
     }
 
-    fn payload_of(sidecar: &DataColumnSidecar) -> DaPayload {
-        DaPayload::new(sidecar.as_ssz_bytes())
+    fn payload_of(sidecar: &DataColumnSidecar) -> Vec<u8> {
+        sidecar.as_ssz_bytes()
     }
 
     /// An honest candidate whose id is derived from the sidecar's own header.
@@ -247,15 +247,15 @@ mod tests {
             .expect("a KZG-valid sidecar is accepted");
 
         assert_eq!(verified.id().index(), sidecar.index);
-        assert_eq!(verified.payload().as_bytes(), sidecar.as_ssz_bytes());
+        assert_eq!(verified.payload(), sidecar.as_ssz_bytes());
     }
 
     #[test]
     fn rejects_malformed_payload() {
         let candidate = CandidateColumn {
             id: DaColumnId::new(B256::ZERO, 0).expect("valid index"),
             context: DaContext::default(),
-            payload: DaPayload::new(vec![0xde, 0xad, 0xbe, 0xef]),
+            payload: vec![0xde, 0xad, 0xbe, 0xef],
         };
         assert!(matches!(
             verifier().verify(candidate),

crates/common/da_node/src/service.rs

@@ -169,7 +169,7 @@ mod tests {
 
     use alloy_primitives::B256;
     use ream_da::{
-        column::{CandidateColumn, DaContext, DaPayload, VerifiedColumn},
+        column::{CandidateColumn, DaContext, VerifiedColumn},
         error::ValidationError,
         id::DaColumnId,
         store::DaReadStore,
@@ -217,7 +217,7 @@ mod tests {
         CandidateColumn {
             id: DaColumnId::new(block_root, index).expect("index within range"),
             context: DaContext { slot },
-            payload: DaPayload::new(payload.to_vec()),
+            payload: payload.to_vec(),
         }
     }
 
@@ -255,7 +255,7 @@ mod tests {
                     .get(&candidate.id)
                     .expect("get succeeds")
                     .expect("column is present");
-                assert_eq!(stored.payload().as_bytes(), candidate.payload.as_bytes());
+                assert_eq!(stored.payload(), candidate.payload);
             }
         });
 

crates/common/da_node/src/store.rs

@@ -10,7 +10,7 @@ use std::{
 use alloy_primitives::B256;
 use ream_da::{
     availability::DaAvailability,
-    column::{DaContext, DaPayload, VerifiedColumn},
+    column::{DaContext, VerifiedColumn},
     error::DaStoreError,
     id::{ALL_COLUMNS_MASK, DaColumnId, NUMBER_OF_COLUMNS, column_indices},
     store::{DaReadStore, DaWriteStore, InsertOutcome},
@@ -248,7 +248,7 @@ impl DaReadStore for DaFileStore {
         Ok(Some(VerifiedColumn::new_unchecked(
             *id,
             DaContext { slot: entry.slot },
-            DaPayload::new(bytes),
+            bytes,
         )))
     }
 
@@ -294,7 +294,7 @@ impl DaWriteStore for DaFileStore {
         let path = self.column_path(&id, slot);
         let tmp_path = path.with_extension("tmp");
         let mut file = fs::File::create(&tmp_path)?;
-        file.write_all(column.payload().as_bytes())?;
+        file.write_all(column.payload())?;
         file.sync_all()?;
         fs::rename(&tmp_path, &path)?;
 
@@ -328,7 +328,7 @@ mod tests {
 
     use alloy_primitives::B256;
     use ream_da::{
-        column::{DaContext, DaPayload, VerifiedColumn},
+        column::{DaContext, VerifiedColumn},
         id::DaColumnId,
         store::{DaReadStore, DaWriteStore, InsertOutcome},
     };
@@ -347,7 +347,7 @@ mod tests {
 
     fn sample_column(block_root: B256, index: u64, slot: u64, payload: &[u8]) -> VerifiedColumn {
         let id = DaColumnId::new(block_root, index).expect("index within range");
-        VerifiedColumn::new_unchecked(id, DaContext { slot }, DaPayload::new(payload.to_vec()))
+        VerifiedColumn::new_unchecked(id, DaContext { slot }, payload.to_vec())
     }
 
     #[test]
@@ -424,7 +424,7 @@ mod tests {
 
         // The originally stored column is untouched...
         let fetched = store.get(&id).expect("get succeeds").expect("present");
-        assert_eq!(fetched.payload().as_bytes(), b"original");
+        assert_eq!(fetched.payload(), b"original");
         assert_eq!(fetched.context().slot, 10);
         // ...and the ignored slot left no orphan file behind.
         assert!(!store.column_path(&id, 11).exists());

crates/rpc/da/src/handlers/column.rs

@@ -14,7 +14,7 @@ use crate::handlers::block_root_from_id;
 /// JSON view of a stored column.
 ///
 /// The payload travels as a `0x`-hex string, symmetric with the
-/// ingest envelope, instead of `DaPayload`'s raw byte array.
+/// ingest envelope, instead of the raw payload bytes.
 ///
 /// TODO: this hex-JSON form is the dev/debug interface, not the final wire
 /// format. The serving path's real consumer is the local beacon, which wants the
@@ -36,7 +36,7 @@ impl From<VerifiedColumn> for ColumnResponse {
             block_root: id.block_root(),
             index: id.index(),
             slot: column.context().slot,
-            payload: alloy_primitives::hex::encode_prefixed(column.payload().as_bytes()),
+            payload: alloy_primitives::hex::encode_prefixed(column.payload()),
         }
     }
 }

crates/rpc/da/src/handlers/ingest.rs

@@ -5,7 +5,7 @@ use actix_web::{
 use alloy_primitives::B256;
 use ream_api_types_common::error::ApiError;
 use ream_da::{
-    column::{CandidateColumn, DaContext, DaPayload},
+    column::{CandidateColumn, DaContext},
     id::DaColumnId,
 };
 use ream_da_node::{error::IngestionError, ingest::DaIngestHandle};
@@ -33,7 +33,7 @@ impl IngestRequest {
         Ok(CandidateColumn {
             id,
             context: DaContext { slot: self.slot },
-            payload: DaPayload::new(payload),
+            payload,
         })
     }
 }

crates/rpc/da/src/handlers/retention.rs

@@ -28,9 +28,9 @@ pub async fn post_retention(
         .map_err(|err| match err {
             // Mirrors `/ingest`: transient overload is a retryable 503, a closed
             // service is an internal fault (500).
-            IngestionError::Overloaded => {
-                ApiError::ServiceUnavailable("verification queue is full; retry shortly".to_string())
-            }
+            IngestionError::Overloaded => ApiError::ServiceUnavailable(
+                "verification queue is full; retry shortly".to_string(),
+            ),
             IngestionError::Closed => {
                 ApiError::InternalError("verification service is unavailable".to_string())
             }

crates/rpc/da/src/tests.rs

@@ -12,7 +12,7 @@ use std::{
 use actix_web::{App, http::StatusCode, test, web::Data};
 use alloy_primitives::B256;
 use ream_da::{
-    column::{DaContext, DaPayload, VerifiedColumn},
+    column::{DaContext, VerifiedColumn},
     id::DaColumnId,
     store::{DaReadStore, DaWriteStore},
 };
@@ -47,7 +47,7 @@ impl TempStore {
             .put(VerifiedColumn::new_unchecked(
                 id,
                 DaContext { slot },
-                DaPayload::new(payload.to_vec()),
+                payload.to_vec(),
             ))
             .expect("put");
     }
@@ -72,9 +72,7 @@ async fn health_reports_ok() {
     // No app_data needed: the probe touches neither store nor ingest handle.
     let app = test::init_service(App::new().configure(register_routers)).await;
 
-    let req = test::TestRequest::get()
-        .uri("/da/v0/health")
-        .to_request();
+    let req = test::TestRequest::get().uri("/da/v0/health").to_request();
     let resp = test::call_service(&app, req).await;
     assert_eq!(resp.status(), StatusCode::OK);
 
@@ -116,7 +114,7 @@ async fn ingest_accepts_valid_candidate() {
             assert_eq!(candidate.id.block_root(), root);
             assert_eq!(candidate.id.index(), 3);
             assert_eq!(candidate.context.slot, 42);
-            assert_eq!(candidate.payload.as_bytes(), &[0xde, 0xad, 0xbe, 0xef]);
+            assert_eq!(candidate.payload, [0xde, 0xad, 0xbe, 0xef]);
         }
         other => panic!("expected a candidate, got {other:?}"),
     }