M src/hash/rpo/mod.rs → src/hash/rpo/mod.rs

@@ -166,7 +166,7 @@ });
 
         // if we absorbed some elements but didn't apply a permutation to them (would happen when
         // the number of elements is not a multiple of RATE_WIDTH), apply the RPO permutation. we
-        // don't need to apply any extra padding because the first capacity element containts a
+        // don't need to apply any extra padding because the first capacity element contains a
         // flag indicating whether the input is evenly divisible by the rate.
         if i != 0 {
             state[RATE_RANGE.start + i..RATE_RANGE.end].fill(ZERO);

M src/merkle/mmr/mod.rs → src/merkle/mmr/mod.rs

@@ -41,7 +41,7 @@ // - each bit in the forest is a unique tree and the bit position its power-of-two size
         // - each tree owns a consecutive range of positions equal to its size from left-to-right
         // - this means the first tree owns from `0` up to the `2^k_0` first positions, where `k_0`
         // is the highest true bit position, the second tree from `2^k_0 + 1` up to `2^k_1` where
-        // `k_1` is the second higest bit, so on.
+        // `k_1` is the second highest bit, so on.
         // - this means the highest bits work as a category marker, and the position is owned by
         // the first tree which doesn't share a high bit with the position
         let before = forest & pos;

M src/merkle/store/tests.rs → src/merkle/store/tests.rs

@@ -841,7 +841,7 @@ check_mstore_subtree(&substore, &subtree2);
     check_mstore_subtree(&substore, &subtree3);
 
     // --- extract subtrees 1 and 3 -------------------------------------------
-    // this should give the same result as above as subtree2 is nested withing subtree1
+    // this should give the same result as above as subtree2 is nested within subtree1
 
     let substore = store.subset([subtree1.root(), subtree3.root()].iter());
 

M src/merkle/tiered_smt/mod.rs → src/merkle/tiered_smt/mod.rs

@@ -208,7 +208,7 @@ // returned index points to a leaf at the bottom tier
             let node = self.build_leaf_node(index, key, value);
             self.nodes.update_leaf_node(index, node)
         } else if leaf_exists {
-            // returned index pointes to a leaf for a different key with the same prefix
+            // returned index points to a leaf for a different key with the same prefix
 
             // get the key-value pair for the key with the same prefix; since the key-value
             // pair has already been inserted into the value store, we need to filter it out