feat: app clippy, ignore two warnings because its the simplest soluti…

…on (#17)

* feat: app clippy, ignore two warnings because its the simplest solution

* fix: stop ignoring clippy

.github/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: Rust CI
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        rust:
+          - version: stable
+            profile: minimal
+          - version: beta
+            profile: default
+          - version: nightly
+            profile: default
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        run: |
+          rustup toolchain install ${{ matrix.rust.version }} --profile ${{ matrix.rust.profile }}
+          rustup default ${{ matrix.rust.version }}
+
+      - name: Install protoc
+        run: sudo apt-get install protobuf-compiler
+
+      - name: Cache cargo build
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ runner.os }}-cargo-${{ matrix.rust.version }}-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install dependencies
+        run: cargo fetch
+
+      - name: Add clippy component if not stable
+        if: matrix.rust.version != 'stable'
+        run: rustup component add clippy
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Build project
+        run: cargo build --verbose
+
+      - name: Run tests
+        run: cargo test --verbose 
+
+      - name: Install cargo-audit
+        run: cargo install cargo-audit
+
+      - name: Run cargo audit
+        run: cargo audit

benches/tree_benchmarks.rs

@@ -63,7 +63,7 @@ fn bench_non_membership_proof(c: &mut Criterion) {
         group.bench_with_input(format!("size_{}", size), &size, |b, &size| {
             // Setup: Create the tree and insert nodes once
             let mut tree = IndexedMerkleTree::new_with_size(size).unwrap();
-            for i in 0..size / 2 {
+            for _ in 0..size / 2 {
                 let mut node = Node::new_leaf(
                     true,
                     create_random_test_hash(),

src/tree.rs

@@ -216,15 +216,15 @@ impl IndexedMerkleTree {
     ///
     /// When called, this function expects the passed nodes to be leaf nodes.
     /// It assumes these are the only nodes present in `self.nodes`.
-    fn rehash_inner_nodes(&mut self, current_layer: &[Node]) {
+    fn rehash_inner_nodes(&mut self, current_layer: Vec<Node>) {
         for (index, node) in current_layer.chunks(2).enumerate() {
             let new_node = Node::Inner(InnerNode::new(node[0].clone(), node[1].clone(), index));
             self.nodes.push(new_node);
         }
 
         let remaining = current_layer.len() / 2;
         if remaining > 1 {
-            self.rehash_inner_nodes(&self.nodes[self.nodes.len() - remaining..].to_vec());
+            self.rehash_inner_nodes(self.nodes[self.nodes.len() - remaining..].to_vec());
         }
     }
 
@@ -233,7 +233,7 @@ impl IndexedMerkleTree {
     /// This is done when first initializing the tree, as well as when nodes are updated.
     fn rebuild_tree_from_leaves(&mut self) {
         self.nodes.retain(|node| matches!(node, Node::Leaf(_)));
-        self.rehash_inner_nodes(&self.nodes.clone());
+        self.rehash_inner_nodes(self.nodes.clone());
     }
 
     /// Calculates the root of an IndexedMerkleTree by aggregating the tree's nodes.
@@ -547,7 +547,7 @@ impl IndexedMerkleTree {
         fn write_node(
             f: &mut std::fmt::Formatter<'_>,
             node: &Node,
-            depth: usize,
+            _depth: usize,
             is_last: bool,
             prefix: &str,
         ) -> std::fmt::Result {
@@ -558,8 +558,8 @@ impl IndexedMerkleTree {
                 Node::Inner(inner) => {
                     writeln!(f, "{}Inner Node (Hash: {})", node_prefix, inner.hash)?;
                     let new_prefix = format!("{}{}   ", prefix, if is_last { " " } else { "│" });
-                    write_node(f, &inner.left, depth + 1, false, &new_prefix)?;
-                    write_node(f, &inner.right, depth + 1, true, &new_prefix)?;
+                    write_node(f, &inner.left, _depth + 1, false, &new_prefix)?;
+                    write_node(f, &inner.right, _depth + 1, true, &new_prefix)?;
                 }
                 Node::Leaf(leaf) => {
                     writeln!(