diff --git a/benches/proof.rs b/benches/proof.rs
index d18e089..14c3602 100644
--- a/benches/proof.rs
+++ b/benches/proof.rs
@@ -12,7 +12,7 @@ use merkle::MerkleTree;
 use rand::RngCore;
 use ring::digest::{Algorithm, SHA512};
 
-static DIGEST: &'static Algorithm = &SHA512;
+static DIGEST: &Algorithm = &SHA512;
 
 fn bench_small_str_tree(c: &mut Criterion) {
     c.bench_function("MerkleTree::from_bec - small", |b| {
@@ -115,7 +115,7 @@ fn bench_big_rnd_iter(c: &mut Criterion) {
             rng.fill_bytes(&mut v);
         }
 
-        let tree = MerkleTree::from_vec(DIGEST, values.clone());
+        let tree = MerkleTree::from_vec(DIGEST, values);
         b.iter(|| {
             for value in &tree {
                 black_box(value);
diff --git a/build.rs b/build.rs
index e5edf70..2b26ec4 100644
--- a/build.rs
+++ b/build.rs
@@ -21,14 +21,12 @@ fn has_right_protoc_version(version: &str) -> bool {
 
 #[cfg(feature = "serialization-protobuf")]
 fn build_protobuf(out_dir: &str, input: &[&str], includes: &[&str]) {
-    use self::protoc_rust::{run, Args};
-    run(Args {
-        out_dir,
-        input,
-        includes,
-        customize: Default::default(),
-    })
-    .expect("protoc");
+    protoc_rust::Codegen::new()
+        .out_dir(out_dir)
+        .inputs(input)
+        .includes(includes)
+        .run()
+        .expect("Running protoc failed");
 }
 
 #[cfg(feature = "serialization-protobuf")]
diff --git a/src/tests.rs b/src/tests.rs
index 93edebc..0d0c26e 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -9,27 +9,26 @@ use crate::hashutils::{HashUtils, Hashable};
 use crate::merkletree::MerkleTree;
 use crate::proof::Positioned;
 
-#[allow(non_upper_case_globals)]
-static digest: &'static Algorithm = &SHA512;
+static DIGEST: &Algorithm = &SHA512;
 
 #[test]
 fn test_from_str_vec() {
     let values = vec!["one", "two", "three", "four"];
 
     let hashes = vec![
-        digest.hash_leaf(&values[0].as_bytes()),
-        digest.hash_leaf(&values[1].as_bytes()),
-        digest.hash_leaf(&values[2].as_bytes()),
-        digest.hash_leaf(&values[3].as_bytes()),
+        DIGEST.hash_leaf(&values[0].as_bytes()),
+        DIGEST.hash_leaf(&values[1].as_bytes()),
+        DIGEST.hash_leaf(&values[2].as_bytes()),
+        DIGEST.hash_leaf(&values[3].as_bytes()),
     ];
 
     let count = values.len();
-    let tree = MerkleTree::from_vec(digest, values);
+    let tree = MerkleTree::from_vec(DIGEST, values);
 
-    let h01 = digest.hash_nodes(&hashes[0], &hashes[1]);
-    let h23 = digest.hash_nodes(&hashes[2], &hashes[3]);
+    let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
+    let h23 = DIGEST.hash_nodes(&hashes[2], &hashes[3]);
 
-    let root_hash = digest.hash_nodes(&h01, &h23);
+    let root_hash = DIGEST.hash_nodes(&h01, &h23);
 
     assert_eq!(tree.count(), count);
     assert_eq!(tree.height(), 2);
@@ -39,8 +38,8 @@ fn test_from_str_vec() {
 #[test]
 fn test_from_vec_empty() {
     let values: Vec<Vec<u8>> = vec![];
-    let tree = MerkleTree::from_vec(digest, values);
-    let empty_hash: Vec<u8> = digest.hash_empty().as_ref().into();
+    let tree = MerkleTree::from_vec(DIGEST, values);
+    let empty_hash: Vec<u8> = DIGEST.hash_empty().as_ref().into();
     let root_hash = tree.root_hash().clone();
 
     assert_eq!(root_hash, empty_hash);
@@ -49,9 +48,9 @@ fn test_from_vec_empty() {
 #[test]
 fn test_from_vec1() {
     let values = vec!["hello, world".to_string()];
-    let tree = MerkleTree::from_vec(digest, values);
+    let tree = MerkleTree::from_vec(DIGEST, values);
 
-    let root_hash = &digest.hash_leaf(b"hello, world");
+    let root_hash = &DIGEST.hash_leaf(b"hello, world");
 
     assert_eq!(tree.count(), 1);
     assert_eq!(tree.height(), 0);
@@ -61,17 +60,17 @@ fn test_from_vec1() {
 #[test]
 fn test_from_vec3() {
     let values = vec![vec![1], vec![2], vec![3]];
-    let tree = MerkleTree::from_vec(digest, values);
+    let tree = MerkleTree::from_vec(DIGEST, values);
 
     let hashes = vec![
-        digest.hash_leaf(&vec![1]),
-        digest.hash_leaf(&vec![2]),
-        digest.hash_leaf(&vec![3]),
+        DIGEST.hash_leaf(&vec![1]),
+        DIGEST.hash_leaf(&vec![2]),
+        DIGEST.hash_leaf(&vec![3]),
     ];
 
-    let h01 = digest.hash_nodes(&hashes[0], &hashes[1]);
+    let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
     let h2 = &hashes[2];
-    let root_hash = &digest.hash_nodes(&h01, h2);
+    let root_hash = &DIGEST.hash_nodes(&h01, h2);
 
     assert_eq!(tree.count(), 3);
     assert_eq!(tree.height(), 2);
@@ -81,23 +80,23 @@ fn test_from_vec3() {
 #[test]
 fn test_from_vec9() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
 
     let hashes = values
         .iter()
-        .map(|v| digest.hash_leaf(v))
+        .map(|v| DIGEST.hash_leaf(v))
         .collect::<Vec<_>>();
 
-    let h01 = digest.hash_nodes(&hashes[0], &hashes[1]);
-    let h23 = digest.hash_nodes(&hashes[2], &hashes[3]);
-    let h45 = digest.hash_nodes(&hashes[4], &hashes[5]);
-    let h67 = digest.hash_nodes(&hashes[6], &hashes[7]);
+    let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
+    let h23 = DIGEST.hash_nodes(&hashes[2], &hashes[3]);
+    let h45 = DIGEST.hash_nodes(&hashes[4], &hashes[5]);
+    let h67 = DIGEST.hash_nodes(&hashes[6], &hashes[7]);
     let h8 = &hashes[8];
-    let h0123 = digest.hash_nodes(&h01, &h23);
-    let h4567 = digest.hash_nodes(&h45, &h67);
-    let h1to7 = digest.hash_nodes(&h0123, &h4567);
+    let h0123 = DIGEST.hash_nodes(&h01, &h23);
+    let h4567 = DIGEST.hash_nodes(&h45, &h67);
+    let h1to7 = DIGEST.hash_nodes(&h0123, &h4567);
 
-    let root_hash = &digest.hash_nodes(&h1to7, h8);
+    let root_hash = &DIGEST.hash_nodes(&h1to7, h8);
 
     assert_eq!(tree.count(), 9);
     assert_eq!(tree.height(), 4);
@@ -107,7 +106,7 @@ fn test_from_vec9() {
 #[test]
 fn test_valid_proof() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
     let root_hash = tree.root_hash();
 
     for value in values {
@@ -121,7 +120,7 @@ fn test_valid_proof() {
 #[test]
 fn test_valid_proof_str() {
     let values = vec!["Hello", "my", "name", "is", "Rusty"];
-    let tree = MerkleTree::from_vec(digest, values);
+    let tree = MerkleTree::from_vec(DIGEST, values);
     let root_hash = tree.root_hash();
 
     let value = "Rusty";
@@ -135,10 +134,10 @@ fn test_valid_proof_str() {
 #[test]
 fn test_wrong_proof() {
     let values1 = vec![vec![1], vec![2], vec![3], vec![4]];
-    let tree1 = MerkleTree::from_vec(digest, values1.clone());
+    let tree1 = MerkleTree::from_vec(DIGEST, values1.clone());
 
     let values2 = vec![vec![4], vec![5], vec![6], vec![7]];
-    let tree2 = MerkleTree::from_vec(digest, values2.clone());
+    let tree2 = MerkleTree::from_vec(DIGEST, values2);
 
     let root_hash = tree2.root_hash();
 
@@ -155,7 +154,7 @@ fn test_nth_proof() {
     // Calculation depends on the total count. Try a few numbers: odd, even, powers of two...
     for &count in &[1, 2, 3, 10, 15, 16, 17, 22] {
         let values = (1..=count).map(|x| vec![x as u8]).collect::<Vec<_>>();
-        let tree = MerkleTree::from_vec(digest, values.clone());
+        let tree = MerkleTree::from_vec(DIGEST, values.clone());
         let root_hash = tree.root_hash();
 
         for i in 0..count {
@@ -173,7 +172,7 @@ fn test_nth_proof() {
 #[test]
 fn test_mutate_proof_first_lemma() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
     let root_hash = tree.root_hash();
 
     for (i, value) in values.into_iter().enumerate() {
@@ -199,7 +198,7 @@ fn test_mutate_proof_first_lemma() {
 #[test]
 fn test_tree_iter() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
     let iter = tree.iter().cloned().collect::<Vec<_>>();
 
     assert_eq!(values, iter);
@@ -208,7 +207,7 @@ fn test_tree_iter() {
 #[test]
 fn test_tree_into_iter() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
     let iter = tree.into_iter().collect::<Vec<_>>();
 
     assert_eq!(values, iter);
@@ -217,7 +216,7 @@ fn test_tree_into_iter() {
 #[test]
 fn test_tree_into_iter_loop() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
 
     let mut collected = Vec::new();
 
@@ -231,7 +230,7 @@ fn test_tree_into_iter_loop() {
 #[test]
 fn test_tree_into_iter_loop_borrow() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
-    let tree = MerkleTree::from_vec(digest, values.clone());
+    let tree = MerkleTree::from_vec(DIGEST, values.clone());
 
     let mut collected = Vec::new();
 
@@ -285,7 +284,7 @@ fn test_custom_hashable_impl() {
         })
         .collect::<Vec<_>>();
 
-    let tree = MerkleTree::from_vec(digest, keys);
+    let tree = MerkleTree::from_vec(DIGEST, keys);
 
     assert_eq!(tree.count(), 10);
     assert_eq!(tree.height(), 4);