fix comments

Author: ColoCarletti

crypto/crypto/src/merkle_tree/merkle.rs

@@ -255,9 +255,9 @@ where
     /// Merkle tree
     pub fn get_proof_by_pos(&self, pos: usize) -> Option<Proof<B::Node>> {
         // A root only tree (from `from_root`) has no nodes to walk. Callers must
-        // gather paths from the device resident copy instead. Catch the misuse
-        // early in debug builds rather than returning a misleading None.
-        debug_assert!(
+        // gather paths from the device resident copy instead. Fail loudly in all
+        // builds rather than returning a misleading empty path.
+        assert!(
             !self.nodes.is_empty(),
             "get_proof_by_pos called on a root-only MerkleTree (no nodes)"
         );

crypto/math-cuda/src/merkle.rs

@@ -378,16 +378,11 @@ pub fn gather_merkle_paths_dev(
     Ok(host)
 }
 
-/// Row-pair Keccak leaf + Merkle tree build for R2 composition-polynomial
-/// commit. `parts_interleaved` is `num_parts` slices, each holding an ext3
-/// LDE column interleaved as `[a0,a1,a2, b0,b1,b2, ...]` of length `3*lde_size`.
-///
-/// Returns `(2*(lde_size/2) - 1) * 32` bytes of tree nodes in the standard
-/// layout (root at byte offset 0, leaves in the tail).
-/// Build the composition Merkle tree on device. Leaves hash row pairs, so
+/// Build the composition Merkle tree on device. `parts_interleaved` is
+/// `num_parts` slices, each an ext3 LDE column interleaved as
+/// `[a0,a1,a2, b0,b1,b2, ...]` of length `3*lde_size`. Leaves hash row pairs, so
 /// `num_leaves = lde_size / 2`. Returns the device node buffer, the leaf count,
-/// and the stream it was built on. Shared by the host copy and device keep
-/// wrappers below.
+/// and the stream it was built on. Used by the device keep wrapper below.
 fn build_comp_poly_tree_nodes_dev(
     parts_interleaved: &[&[u64]],
 ) -> Result<(CudaSlice<u8>, usize, Arc<CudaStream>)> {

crypto/stark/src/gpu_lde.rs

@@ -1446,6 +1446,12 @@ pub(crate) fn gather_proofs_dev(
     if positions.is_empty() {
         return Some(Vec::new());
     }
+    // Positions index an LDE that `assert_u32_domain` keeps within u32; guard the
+    // cast so any future relaxation fails loudly instead of wrapping silently.
+    debug_assert!(
+        positions.iter().all(|&p| p <= u32::MAX as usize),
+        "gather_proofs_dev: position exceeds u32 range"
+    );
     let positions_u32: Vec<u32> = positions.iter().map(|&p| p as u32).collect();
     let bytes = math_cuda::merkle::gather_merkle_paths_dev(
         &tree.nodes,
@@ -1698,8 +1704,17 @@ where
     // The GPU FRI commit sets `gpu_tree` on every layer as a group; the CPU
     // commit sets none. Host trees fall back to the host walk. When the layers
     // are device resident the host trees are root only, so the gather below must
-    // succeed (a failure is a hard abort, not a silent walk).
-    if fri_layers[0].gpu_tree.is_none() {
+    // succeed (a failure is a hard abort, not a silent walk). The residency is
+    // all or nothing; assert it so a future partial-build can never route a
+    // root-only layer through the host walk and ship empty proofs.
+    let first_resident = fri_layers[0].gpu_tree.is_some();
+    debug_assert!(
+        fri_layers
+            .iter()
+            .all(|l| l.gpu_tree.is_some() == first_resident),
+        "FRI layer residency must be all or nothing"
+    );
+    if !first_resident {
         return None;
     }
     let stream = math_cuda::device::backend()