remove raw

Author: patrick-ogrady

chain/src/lib.rs

@@ -756,7 +756,7 @@ mod tests {
                     .block_upload_started
                     .load(std::sync::atomic::Ordering::SeqCst),
                 0,
-                "raw block uploads should stay idle when certified uploads succeed",
+                "block uploads should stay idle when certified uploads succeed",
             );
         });
     }
@@ -796,7 +796,7 @@ mod tests {
             link_validators(&mut oracle, &participants, link, None).await;
 
             // Reject certificate uploads so the only way blocks can reach the
-            // indexer is through the durable raw block consumer.
+            // indexer is through the durable block consumer.
 
             let indexer = mocks::Client::new().with_fail_certs();
 
@@ -824,7 +824,7 @@ mod tests {
             assert!(!indexer
                 .finalization_seen
                 .load(std::sync::atomic::Ordering::Relaxed));
-            // The durable consumer should compensate by uploading raw blocks.
+            // The durable consumer should compensate by uploading blocks.
             for _ in 0..10 {
                 if indexer
                     .block_upload_completed
@@ -878,7 +878,7 @@ mod tests {
 
             // Hold the first few certificate uploads open so finalized queue
             // rows exist while a certificate path for the same digest is still
-            // in flight. The raw consumer should wait instead of racing them.
+            // in flight. The block consumer should wait instead of racing them.
             let mut cert_upload_senders = Vec::new();
             let mut cert_upload_waiters = Vec::new();
             for _ in 0..8 {
@@ -932,11 +932,11 @@ mod tests {
                     .block_upload_started
                     .load(std::sync::atomic::Ordering::SeqCst),
                 0,
-                "raw block uploads should wait while certificate uploads are still in flight",
+                "block uploads should wait while certificate uploads are still in flight",
             );
 
             // Release the blocked certificate uploads and confirm the
-            // certificate-bearing paths finish without the raw consumer ever
+            // certificate-bearing paths finish without the block consumer ever
             // needing to step in.
             drop(cert_upload_senders);
             for _ in 0..10 {
@@ -957,7 +957,7 @@ mod tests {
                     .block_upload_started
                     .load(std::sync::atomic::Ordering::SeqCst),
                 0,
-                "raw block uploads should remain idle when certificate uploads eventually succeed",
+                "block uploads should remain idle when certificate uploads eventually succeed",
             );
         });
     }
@@ -995,7 +995,7 @@ mod tests {
             };
             link_validators(&mut oracle, &participants, link, None).await;
 
-            // Hold the first two raw block uploads open so we can observe the
+            // Hold the first two block uploads open so we can observe the
             // consumer's parallelism before any upload completes.
             let (release_first, wait_first) = oneshot::channel();
             let (release_second, wait_second) = oneshot::channel();
@@ -1135,8 +1135,8 @@ mod tests {
             blocked_waiters.push(receiver);
         }
 
-        // Use one mock that keeps raw uploads blocked during the first run, and
-        // a second mock that still rejects cert uploads but lets replayed raw
+        // Use one mock that keeps block uploads blocked during the first run, and
+        // a second mock that still rejects cert uploads but lets replayed block
         // uploads complete during recovery.
         let blocked_indexer = mocks::Client::new()
             .with_fail_certs()
@@ -1290,7 +1290,7 @@ mod tests {
             let mut registrations = register_validators(&mut oracle, &participants).await;
             let participants_set = Set::from_iter_dedup(participants.clone());
 
-            // Do not relink validators on restart. Any successful raw block
+            // Do not relink validators on restart. Any successful block
             // uploads in this run must therefore come from replaying the
             // durable queue and restored marshal state.
             for (signer, scheme) in private_keys.into_iter().zip(schemes) {

client/src/consensus.rs

@@ -31,13 +31,13 @@ fn finalization_get_path(base: String, query: &IndexQuery) -> String {
     format!("{base}/finalization/{}", query.serialize())
 }
 
-/// Raw block backfill endpoint used by the chain backfiller.
+/// Block backfill endpoint used by the chain backfiller.
 fn block_upload_path(base: String) -> String {
     format!("{base}/block")
 }
 
 /// Block reads still go through this path. `Latest` and `Index` return certified
-/// data; digest lookups may return a raw block body recovered by the backfiller.
+/// data; digest lookups may return a block body recovered by the backfiller.
 fn block_get_path(base: String, query: &Query) -> String {
     format!("{base}/block/{}", query.serialize())
 }
@@ -188,7 +188,7 @@ impl<S: Strategy> Client<S> {
     }
 
     pub async fn block_upload(&self, block: Block) -> Result<(), Error> {
-        // Upload the raw block body without a notarization/finalization wrapper.
+        // Upload the block body without a notarization/finalization wrapper.
         let result = self
             .http_client
             .post(block_upload_path(self.uri.clone()))

indexer/src/lib.rs

@@ -171,7 +171,7 @@ impl<S: Strategy> Indexer<S> {
         }
     }
 
-    /// Resolve canonical chain queries by finalized height/latest, or raw block
+    /// Resolve canonical chain queries by finalized height/latest, or block
     /// fallback queries by digest.
     pub fn get_block(&self, query: &str) -> Option<BlockResult> {
         let state = self.state.read().unwrap();
@@ -193,7 +193,7 @@ impl<S: Strategy> Indexer<S> {
                         .map(|f| BlockResult::Finalized(f.clone()))
                 })
             } else if raw.len() == Digest::SIZE {
-                // Raw block uploads are keyed by digest and are not restricted
+                // Block uploads are keyed by digest and are not restricted
                 // to the canonical finalized chain.
                 let digest = Digest::decode(raw.as_slice()).ok()?;
                 state
@@ -208,7 +208,7 @@ impl<S: Strategy> Indexer<S> {
         }
     }
 
-    /// Store a raw block body for digest lookups used by the backfiller.
+    /// Store a block body for digest lookups used by the backfiller.
     pub fn submit_block(&self, block: Block) {
         let mut state = self.state.write().unwrap();
         // These uploads are not certificate-bearing; verified certificate data