From 7e548e68888063fbe89053d1eb42a7a6d1ffd048 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ole=20Kr=C3=BCger?= <ole.kruger@trili.tech>
Date: Fri, 27 Mar 2026 15:49:54 +0000
Subject: [PATCH] feat(vector): add CloneState implementation

---
 data/src/clone.rs             |  6 ++++
 data/src/components/vector.rs | 55 +++++++++++++++++++++++++++++++----
 data/src/partial_vec.rs       | 19 ++++++++++++
 3 files changed, 74 insertions(+), 6 deletions(-)

diff --git a/data/src/clone.rs b/data/src/clone.rs
index 7c588f56b09..f1c5072d1d5 100644
--- a/data/src/clone.rs
+++ b/data/src/clone.rs
@@ -51,6 +51,12 @@ impl<T: CloneState> CloneState for Box<[T]> {
     }
 }
 
+impl<T: CloneState> CloneState for Vec<T> {
+    fn clone_state(&self) -> Self {
+        self.iter().map(CloneState::clone_state).collect()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::CloneState;
diff --git a/data/src/components/vector.rs b/data/src/components/vector.rs
index a72cd5e18ef..2197c015dea 100644
--- a/data/src/components/vector.rs
+++ b/data/src/components/vector.rs
@@ -124,12 +124,6 @@ impl<T, M: VectorMode> Default for Vector<T, M> {
     }
 }
 
-impl<T: Clone, M: CloneVectorMode> CloneState for Vector<T, M> {
-    fn clone_state(&self) -> Self {
-        M::clone(self)
-    }
-}
-
 impl<T: Foldable<HashFold>> Foldable<HashFold> for Vector<T, Normal> {
     fn fold(&self, builder: HashFold) -> Hash {
         let mut node = builder.into_node_fold();
@@ -341,6 +335,12 @@ impl<T: Clone, M: CloneVectorMode> Clone for Vector<T, M> {
     }
 }
 
+impl<T: CloneState, M: CloneVectorMode> CloneState for Vector<T, M> {
+    fn clone_state(&self) -> Self {
+        M::clone_state(self)
+    }
+}
+
 impl<T: Encode, M: EncodeVectorMode> Encode for Vector<T, M> {
     fn encode<E: bincode::enc::Encoder>(
         &self,
@@ -588,6 +588,9 @@ pub trait CloneVectorMode: Mode {
     /// This clones the entire component, not just the internal value. Consider this when cloning
     /// components in [`crate::mode::Prove`] mode.
     fn clone<T: Clone>(this: &Vector<T, Self>) -> Vector<T, Self>;
+
+    /// Like [`Self::clone`] but uses `CloneState` instead.
+    fn clone_state<T: CloneState>(this: &Vector<T, Self>) -> Vector<T, Self>;
 }
 
 impl CloneVectorMode for Normal {
@@ -596,6 +599,12 @@ impl CloneVectorMode for Normal {
             vector: this.vector.clone(),
         }
     }
+
+    fn clone_state<T: CloneState>(this: &Vector<T, Self>) -> Vector<T, Self> {
+        Vector {
+            vector: this.vector.clone_state(),
+        }
+    }
 }
 
 impl CloneVectorMode for Prove<'_> {
@@ -604,6 +613,12 @@ impl CloneVectorMode for Prove<'_> {
             vector: this.vector.clone(),
         }
     }
+
+    fn clone_state<T: CloneState>(this: &Vector<T, Self>) -> Vector<T, Self> {
+        Vector {
+            vector: this.vector.clone_state(),
+        }
+    }
 }
 
 impl CloneVectorMode for Verify {
@@ -612,6 +627,12 @@ impl CloneVectorMode for Verify {
             vector: this.vector.clone(),
         }
     }
+
+    fn clone_state<T: CloneState>(this: &Vector<T, Self>) -> Vector<T, Self> {
+        Vector {
+            vector: this.vector.clone_state(),
+        }
+    }
 }
 
 /// Mode types that implement this trait support encoding of the [`Vector`] component.
@@ -721,6 +742,18 @@ impl<T> ProveImpl<T> {
     }
 }
 
+impl<T: CloneState> CloneState for ProveImpl<T> {
+    fn clone_state(&self) -> Self {
+        Self {
+            previous: self.previous.clone_state(),
+            active_previous: self.active_previous,
+            accessed_indices: self.accessed_indices.clone(),
+            appended: self.appended.clone_state(),
+            read_length: self.read_length.clone(),
+        }
+    }
+}
+
 /// [`crate::mode::Verify`] mode implementation for the [`Vector`] component
 #[perfect_derive(Clone)]
 struct VerifyImpl<T> {
@@ -744,6 +777,16 @@ impl<T> VerifyImpl<T> {
     }
 }
 
+impl<T: CloneState> CloneState for VerifyImpl<T> {
+    fn clone_state(&self) -> Self {
+        Self {
+            original_length: self.original_length.clone(),
+            length: self.length.clone(),
+            items: self.items.clone_state(),
+        }
+    }
+}
+
 /// Arity of internal nodes in the Merkle tree
 const NODE_ARITY: usize = 4;
 
diff --git a/data/src/partial_vec.rs b/data/src/partial_vec.rs
index ebec5240db6..266a153b61a 100644
--- a/data/src/partial_vec.rs
+++ b/data/src/partial_vec.rs
@@ -31,6 +31,8 @@ use std::ops::Range;
 
 use perfect_derive::perfect_derive;
 
+use crate::clone::CloneState;
+
 /// Entry in the partial vector that represents a defined data range
 #[perfect_derive(Debug, Clone, Default)]
 struct DefinedEntry<T> {
@@ -48,6 +50,15 @@ impl<T> DefinedEntry<T> {
     }
 }
 
+impl<T: CloneState> CloneState for DefinedEntry<T> {
+    fn clone_state(&self) -> Self {
+        Self {
+            start: self.start,
+            data: self.data.clone_state(),
+        }
+    }
+}
+
 /// Partial vector that may not be defined for certain ranges
 ///
 /// This data type can be seen as an alternative to `BTreeMap<usize, T>` which provides a more
@@ -371,6 +382,14 @@ impl<T> From<Vec<T>> for PartialVec<T> {
     }
 }
 
+impl<T: CloneState> CloneState for PartialVec<T> {
+    fn clone_state(&self) -> Self {
+        Self {
+            entries: self.entries.clone_state(),
+        }
+    }
+}
+
 /// Entry within a partial vector
 #[derive(Debug, Clone)]
 pub enum RangeEntry<'a, T> {