Merge branch 'main' into bridgetree-0.7.0

Author: str4d

.github/workflows/lints-beta.yml

@@ -6,17 +6,22 @@ on: pull_request
 jobs:
   clippy-beta:
     name: Clippy (beta)
-    timeout-minutes: 30
     runs-on: ubuntu-latest
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - uses: dtolnay/rust-toolchain@beta
         id: toolchain
-      - run: rustup override set ${{steps.toolchain.outputs.name}}
+        with:
+          components: clippy
+      - run: rustup override set "${TOOLCHAIN}"
+        shell: sh
+        env:
+          TOOLCHAIN: ${{steps.toolchain.outputs.name}}
       - name: Run Clippy (beta)
         uses: actions-rs/clippy-check@v1
-        continue-on-error: true
         with:
           name: Clippy (beta)
           token: ${{ secrets.GITHUB_TOKEN }}

Cargo.lock

@@ -18,8 +18,8 @@ categories = ["algorithms", "data-structures"]
 
 [workspace.dependencies]
 # Intra-workspace dependencies
-incrementalmerkletree = { version = "0.7", path = "incrementalmerkletree" }
-incrementalmerkletree-testing = { version = "0.1" }
+incrementalmerkletree = { version = "0.8.1", path = "incrementalmerkletree" }
+incrementalmerkletree-testing = { version = "0.3", path = "incrementalmerkletree-testing" }
 
 # Testing
 proptest = "1"

Cargo.toml

@@ -16,5 +16,39 @@ test suite to migrate to later `incrementalmerkletree` versions.
 ### Changed
 - Updated to `incrementalmerkletree 0.8`
 
+## [0.3.0] - 2025-01-30
+
+### Changed
+- Updated to `incrementalmerkletree 0.8`
+
+## [0.2.0] - 2024-10-04
+
+This release includes a significant refactoring and rework of several methods
+of the `incrementalmerkletree_testing::Tree` trait. Please read the notes for
+this release carefully as the semantics of important methods have changed.
+These changes may require changes to example tests that rely on this crate; in
+particular, additional checkpoints may be required in circumstances where
+rewind operations are being applied.
+
+### Changed
+- `incrementalmerkletree_testing::Tree`
+  - Added method `Tree::checkpoint_count`.
+  - `Tree::root` now takes its `checkpoint_depth` argument as `Option<usize>`
+    instead of `usize`. Passing `None` to this method will now compute the root
+    given all of the leaves in the tree; if a `Some` value is passed,
+    implementations of this method must treat the wrapped `usize` as a reverse
+    index into the checkpoints added to the tree, or return `None` if no
+    checkpoint exists at the specified index. This effectively modifies this
+    method to use zero-based indexing instead of a muddled 1-based indexing
+    scheme.
+  - `Tree::rewind` now takes an additional `checkpoint_depth` argument, which
+    is non-optional. Rewinding the tree may now only be performed if there is
+    a checkpoint at the specified depth to rewind to. This depth should be
+    treated as a zero-based reverse index into the checkpoints of the tree.
+    Rewinding no longer removes the checkpoint being rewound to; instead, it
+    removes the effect all state changes to the tree resulting from
+    operations performed since the checkpoint was created, but leaves the
+    checkpoint itself in place.
+
 ## [0.1.0] - 2024-09-25
 Initial release.

incrementalmerkletree-testing/CHANGELOG.md

@@ -1,7 +1,7 @@
 [package]
 name = "incrementalmerkletree-testing"
 description = "Common types, interfaces, and utilities for testing Merkle tree data structures"
-version = "0.2.0-backcompat.0.8"
+version = "0.3.0"
 authors = [
     "Kris Nuttycombe <[email protected]>",
     "Sean Bowe <[email protected]>",
@@ -18,6 +18,6 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-incrementalmerkletree = { version = "0.8", features = ["test-dependencies"] }
+incrementalmerkletree = { workspace = true, features = ["test-dependencies"] }
 
 proptest.workspace = true

incrementalmerkletree-testing/Cargo.toml

@@ -106,7 +106,7 @@ impl<H: Hashable, C: Clone + Ord + core::fmt::Debug, const DEPTH: u8> CompleteTr
                 self.mark();
             }
             Retention::Checkpoint { id, marking } => {
-                let latest_checkpoint = self.checkpoints.keys().rev().next();
+                let latest_checkpoint = self.checkpoints.keys().next_back();
                 if Some(&id) > latest_checkpoint {
                     append(&mut self.leaves, value, DEPTH)?;
                     if marking == Marking::Marked {
@@ -145,7 +145,7 @@ impl<H: Hashable, C: Clone + Ord + core::fmt::Debug, const DEPTH: u8> CompleteTr
             if !self.marks.contains(&pos) {
                 self.marks.insert(pos);
 
-                if let Some(checkpoint) = self.checkpoints.values_mut().rev().next() {
+                if let Some(checkpoint) = self.checkpoints.values_mut().next_back() {
                     checkpoint.marked.insert(pos);
                 }
             }
@@ -156,11 +156,14 @@ impl<H: Hashable, C: Clone + Ord + core::fmt::Debug, const DEPTH: u8> CompleteTr
         }
     }
 
+    // Creates a new checkpoint with the specified identifier and the given tree position; if `pos`
+    // is not provided, the position of the most recently appended leaf is used, or a new
+    // checkpoint of the empty tree is added if appropriate.
     fn checkpoint(&mut self, id: C, pos: Option<Position>) {
         self.checkpoints.insert(
             id,
             Checkpoint::at_length(pos.map_or_else(
-                || 0,
+                || self.leaves.len(),
                 |p| usize::try_from(p).expect(MAX_COMPLETE_SIZE_ERROR) + 1,
             )),
         );
@@ -170,16 +173,12 @@ impl<H: Hashable, C: Clone + Ord + core::fmt::Debug, const DEPTH: u8> CompleteTr
     }
 
     fn leaves_at_checkpoint_depth(&self, checkpoint_depth: usize) -> Option<usize> {
-        if checkpoint_depth == 0 {
-            Some(self.leaves.len())
-        } else {
-            self.checkpoints
-                .iter()
-                .rev()
-                .skip(checkpoint_depth - 1)
-                .map(|(_, c)| c.leaves_len)
-                .next()
-        }
+        self.checkpoints
+            .iter()
+            .rev()
+            .skip(checkpoint_depth)
+            .map(|(_, c)| c.leaves_len)
+            .next()
     }
 
     /// Removes the oldest checkpoint. Returns true if successful and false if
@@ -237,21 +236,20 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
         }
     }
 
-    fn root(&self, checkpoint_depth: usize) -> Option<H> {
-        self.leaves_at_checkpoint_depth(checkpoint_depth)
-            .and_then(|len| root(&self.leaves[0..len], DEPTH))
+    fn root(&self, checkpoint_depth: Option<usize>) -> Option<H> {
+        checkpoint_depth.map_or_else(
+            || root(&self.leaves[..], DEPTH),
+            |depth| {
+                self.leaves_at_checkpoint_depth(depth)
+                    .and_then(|len| root(&self.leaves[0..len], DEPTH))
+            },
+        )
     }
 
     fn witness(&self, position: Position, checkpoint_depth: usize) -> Option<Vec<H>> {
-        if self.marks.contains(&position) && checkpoint_depth <= self.checkpoints.len() {
+        if self.marks.contains(&position) {
             let leaves_len = self.leaves_at_checkpoint_depth(checkpoint_depth)?;
-            let c_idx = self.checkpoints.len() - checkpoint_depth;
-            if self
-                .checkpoints
-                .iter()
-                .skip(c_idx)
-                .any(|(_, c)| c.marked.contains(&position))
-            {
+            if u64::from(position) >= u64::try_from(leaves_len).unwrap() {
                 // The requested position was marked after the checkpoint was created, so we
                 // cannot create a witness.
                 None
@@ -279,7 +277,7 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
 
     fn remove_mark(&mut self, position: Position) -> bool {
         if self.marks.contains(&position) {
-            if let Some(c) = self.checkpoints.values_mut().rev().next() {
+            if let Some(c) = self.checkpoints.values_mut().next_back() {
                 c.forgotten.insert(position);
             } else {
                 self.marks.remove(&position);
@@ -291,22 +289,43 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
     }
 
     fn checkpoint(&mut self, id: C) -> bool {
-        if Some(&id) > self.checkpoints.keys().rev().next() {
+        if Some(&id) > self.checkpoints.keys().next_back() {
             Self::checkpoint(self, id, self.current_position());
             true
         } else {
             false
         }
     }
 
-    fn rewind(&mut self) -> bool {
-        if let Some((id, c)) = self.checkpoints.iter().rev().next() {
-            self.leaves.truncate(c.leaves_len);
-            for pos in c.marked.iter() {
-                self.marks.remove(pos);
+    fn checkpoint_count(&self) -> usize {
+        self.checkpoints.len()
+    }
+
+    fn rewind(&mut self, depth: usize) -> bool {
+        if self.checkpoints.len() > depth {
+            let mut to_delete = vec![];
+            for (idx, (id, c)) in self
+                .checkpoints
+                .iter_mut()
+                .rev()
+                .enumerate()
+                .take(depth + 1)
+            {
+                for pos in c.marked.iter() {
+                    self.marks.remove(pos);
+                }
+                if idx < depth {
+                    to_delete.push(id.clone());
+                } else {
+                    self.leaves.truncate(c.leaves_len);
+                    c.marked.clear();
+                    c.forgotten.clear();
+                }
             }
-            let id = id.clone(); // needed to avoid mutable/immutable borrow conflict
-            self.checkpoints.remove(&id);
+            for cid in to_delete.iter() {
+                self.checkpoints.remove(cid);
+            }
+
             true
         } else {
             false
@@ -316,8 +335,6 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
 
 #[cfg(test)]
 mod tests {
-    use std::convert::TryFrom;
-
     use super::CompleteTree;
     use crate::{
         check_append, check_checkpoint_rewind, check_rewind_remove_mark, check_root_hashes,
@@ -334,7 +351,7 @@ mod tests {
         }
 
         let tree = CompleteTree::<SipHashable, (), DEPTH>::new(100);
-        assert_eq!(tree.root(0).unwrap(), expected);
+        assert_eq!(tree.root(None), Some(expected));
     }
 
     #[test]
@@ -362,7 +379,7 @@ mod tests {
             ),
         );
 
-        assert_eq!(tree.root(0).unwrap(), expected);
+        assert_eq!(tree.root(None), Some(expected));
     }
 
     #[test]
@@ -408,10 +425,12 @@ mod tests {
             ),
         );
 
-        assert_eq!(tree.root(0).unwrap(), expected);
+        assert_eq!(tree.root(None), Some(expected.clone()));
+        tree.checkpoint((), None);
+        assert_eq!(tree.root(Some(0)), Some(expected.clone()));
 
         for i in 0u64..(1 << DEPTH) {
-            let position = Position::try_from(i).unwrap();
+            let position = Position::from(i);
             let path = tree.witness(position, 0).unwrap();
             assert_eq!(
                 compute_root_from_witness(SipHashable(i), position, &path),