fix lint

contracts/mocks/MerkleTreeMock.sol

@@ -7,50 +7,50 @@ import "../utils/structs/MerkleTree.sol";
 contract MerkleTreeMock {
     using MerkleTree for MerkleTree.TreeWithHistory;
 
-    MerkleTree.TreeWithHistory private tree;
+    MerkleTree.TreeWithHistory private _tree;
 
     constructor(uint256 _depth, uint256 _length) {
-        tree.initialize(_depth, _length);
+        _tree.initialize(_depth, _length);
     }
 
     function insert(bytes32 leaf) public returns (uint256) {
-        return tree.insert(leaf);
+        return _tree.insert(leaf);
     }
 
     function getDepth() public view returns (uint256) {
-        return tree.getDepth();
+        return _tree.getDepth();
     }
 
     function getLength() public view returns (uint256) {
-        return tree.getLength();
+        return _tree.getLength();
     }
 
     function getLastRoot() public view returns (bytes32) {
-        return tree.getLastRoot();
+        return _tree.getLastRoot();
     }
 
     function isKnownRoot(bytes32 root) public view returns (bool) {
-        return tree.isKnownRoot(root);
+        return _tree.isKnownRoot(root);
     }
 
     // internal state
     function currentRootIndex() public view returns (uint256) {
-        return tree.currentRootIndex;
+        return _tree.currentRootIndex;
     }
 
     function nextLeafIndex() public view returns (uint256) {
-        return tree.nextLeafIndex;
+        return _tree.nextLeafIndex;
     }
 
     function sides(uint256 i) public view returns (bytes32) {
-        return tree.sides[i];
+        return _tree.sides[i];
     }
 
     function zeros(uint256 i) public view returns (bytes32) {
-        return tree.zeros[i];
+        return _tree.zeros[i];
     }
 
     function roots(uint256 i) public view returns (bytes32) {
-        return tree.roots[i];
+        return _tree.roots[i];
     }
 }

contracts/utils/structs/MerkleTree.sol

@@ -8,7 +8,7 @@ import "../StorageSlot.sol";
 error Full();
 
 library MerkleTree {
-    uint256 private constant MAX_DEPTH = 255;
+    uint256 private constant _MAX_DEPTH = 255;
 
     struct TreeWithHistory {
         uint256 currentRootIndex;
@@ -33,12 +33,12 @@ library MerkleTree {
         bytes32 zero,
         function(bytes32, bytes32) view returns (bytes32) fnHash
     ) internal {
-        require(depth <= MAX_DEPTH);
+        require(depth <= _MAX_DEPTH);
 
         // Store depth & length in the dynamic array
-        setLength(self.sides, depth);
-        setLength(self.zeros, depth);
-        setLength(self.roots, length);
+        _unsafeSetLength(self.sides, depth);
+        _unsafeSetLength(self.zeros, depth);
+        _unsafeSetLength(self.roots, length);
         self.fnHash = fnHash;
 
         // Build the different hashes in a zero-filled complete tree
@@ -142,7 +142,7 @@ library MerkleTree {
     /**
      * @dev Helper to set the length of an dynamic array. Directly writting to `.length` is forbiden.
      */
-    function setLength(bytes32[] storage array, uint256 len) private {
+    function _unsafeSetLength(bytes32[] storage array, uint256 len) private {
         assembly {
             sstore(array.slot, len)
         }