diff --git a/src/client.rs b/src/client.rs
index c8d8ef5..7edea98 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -155,7 +155,7 @@
                 )
             })?;
 
-        let tuf = Tuf::from_root(root)?;
+        let tuf = Tuf::from_root(&root)?;
 
         Ok(Client {
             tuf: tuf,
@@ -302,13 +302,13 @@
                 config.min_bytes_per_second,
                 None,
             )?;
-            if !tuf.update_root(signed)? {
+            if !tuf.update_root(&signed)? {
                 error!("{}", err_msg);
                 return Err(Error::Programming(err_msg.into()));
             }
         }
 
-        if !tuf.update_root(latest_root)? {
+        if !tuf.update_root(&latest_root)? {
             error!("{}", err_msg);
             return Err(Error::Programming(err_msg.into()));
         }
@@ -329,7 +329,7 @@
             config.min_bytes_per_second,
             None,
         )?;
-        tuf.update_timestamp(ts)
+        tuf.update_timestamp(&ts)
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
@@ -364,7 +364,7 @@
             config.min_bytes_per_second,
             Some((alg, value.clone())),
         )?;
-        tuf.update_snapshot(snap)
+        tuf.update_snapshot(&snap)
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
@@ -408,7 +408,7 @@
             config.min_bytes_per_second,
             Some((alg, value.clone())),
         )?;
-        tuf.update_targets(targets)
+        tuf.update_targets(&targets)
     }
 
     /// Fetch a target from the remote repo and write it to the local repo.
@@ -545,7 +545,7 @@
                     }
                 };
 
-                match tuf.update_delegation(delegation.role(), signed_meta.clone()) {
+                match tuf.update_delegation(delegation.role(), &signed_meta) {
                     Ok(_) => {
                         match local.store_metadata(
                             &Role::Targets,
diff --git a/src/error.rs b/src/error.rs
index 11dddbf..4cfc435 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -78,7 +78,7 @@
 
 impl Error {
     /// Helper to include the path that causd the error for FS I/O errors.
-    pub fn from_io(err: io::Error, path: &Path) -> Error {
+    pub fn from_io(err: &io::Error, path: &Path) -> Error {
         Error::Opaque(format!("Path {:?} : {:?}", path, err))
     }
 }
diff --git a/src/metadata.rs b/src/metadata.rs
index 7c349d0..dd782fe 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -1308,7 +1308,7 @@
     // TODO check all keys are used
     // TODO check all roles have their ID in the set of keys
     /// Create a new `Delegations` wrapper from the given set of trusted keys and roles.
-    pub fn new(keys: HashSet<PublicKey>, roles: Vec<Delegation>) -> Result<Self> {
+    pub fn new(keys: &HashSet<PublicKey>, roles: Vec<Delegation>) -> Result<Self> {
         if keys.is_empty() {
             return Err(Error::IllegalArgument("Keys cannot be empty.".into()));
         }
@@ -1787,7 +1787,7 @@
     fn serde_targets_with_delegations_metadata() {
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
         let delegations = Delegations::new(
-            hashset![key.public().clone()],
+            &hashset![key.public().clone()],
             vec![Delegation::new(
                 MetadataPath::new("foo/bar".into()).unwrap(),
                 false,
@@ -1988,7 +1988,7 @@
             .public()
             .clone();
         let delegations = Delegations::new(
-            hashset![key.clone()],
+            &hashset![key.clone()],
             vec![Delegation::new(
                 MetadataPath::new("foo".into()).unwrap(),
                 false,
@@ -2328,7 +2328,7 @@
             .public()
             .clone();
         let delegations = Delegations::new(
-            hashset!(key.clone()),
+            &hashset!(key.clone()),
             vec![Delegation::new(
                 MetadataPath::new("foo".into()).unwrap(),
                 false,
diff --git a/src/shims.rs b/src/shims.rs
index e252aec..a4842c8 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -343,7 +343,7 @@
         if keys.len() != keys_len {
             return Err(Error::Encoding("Cannot have duplicate keys".into()));
         }
-        metadata::Delegations::new(keys, self.roles)
+        metadata::Delegations::new(&keys, self.roles)
     }
 }
 
diff --git a/src/tuf.rs b/src/tuf.rs
index eea3eec..a13d5c6 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -37,14 +37,14 @@
         signed_root.signatures_mut().retain(|s| {
             root_key_ids.contains(s.key_id())
         });
-        Self::from_root(signed_root)
+        Self::from_root(&signed_root)
     }
 
     /// Create a new `TUF` struct from a piece of metadata that is assumed to be trusted.
     ///
     /// **WARNING**: This is trust-on-first-use (TOFU) and offers weaker security guarantees than
     /// the related method `from_root_pinned`.
-    pub fn from_root(signed_root: SignedMetadata<D, RootMetadata>) -> Result<Self> {
+    pub fn from_root(signed_root: &SignedMetadata<D, RootMetadata>) -> Result<Self> {
         let root = D::deserialize::<RootMetadata>(signed_root.signed())?;
         let _ = signed_root.verify(
             root.root().threshold(),
@@ -95,7 +95,7 @@
     }
 
     /// Verify and update the root metadata.
-    pub fn update_root(&mut self, signed_root: SignedMetadata<D, RootMetadata>) -> Result<bool> {
+    pub fn update_root(&mut self, signed_root: &SignedMetadata<D, RootMetadata>) -> Result<bool> {
         signed_root.verify(
             self.root.root().threshold(),
             self.root.keys().iter().filter_map(|(k, v)| {
@@ -150,7 +150,7 @@
     /// Verify and update the timestamp metadata.
     pub fn update_timestamp(
         &mut self,
-        signed_timestamp: SignedMetadata<D, TimestampMetadata>,
+        signed_timestamp: &SignedMetadata<D, TimestampMetadata>,
     ) -> Result<bool> {
         signed_timestamp.verify(
             self.root.timestamp().threshold(),
@@ -196,7 +196,7 @@
     /// Verify and update the snapshot metadata.
     pub fn update_snapshot(
         &mut self,
-        signed_snapshot: SignedMetadata<D, SnapshotMetadata>,
+        signed_snapshot: &SignedMetadata<D, SnapshotMetadata>,
     ) -> Result<bool> {
         let snapshot = {
             let root = self.safe_root_ref()?;
@@ -289,7 +289,7 @@
     /// Verify and update the targets metadata.
     pub fn update_targets(
         &mut self,
-        signed_targets: SignedMetadata<D, TargetsMetadata>,
+        signed_targets: &SignedMetadata<D, TargetsMetadata>,
     ) -> Result<bool> {
         let targets = {
             let root = self.safe_root_ref()?;
@@ -351,7 +351,7 @@
     pub fn update_delegation(
         &mut self,
         role: &MetadataPath,
-        signed: SignedMetadata<D, TargetsMetadata>,
+        signed: &SignedMetadata<D, TargetsMetadata>,
     ) -> Result<bool> {
         let delegation = {
             let _ = self.safe_root_ref()?;
@@ -458,7 +458,7 @@
             current_depth: u32,
             target_path: &VirtualTargetPath,
             delegations: &Delegations,
-            parents: Vec<HashSet<VirtualTargetPath>>,
+            parents: &[HashSet<VirtualTargetPath>],
             visited: &mut HashSet<MetadataPath>,
         ) -> (bool, Option<TargetDescription>) {
             for delegation in delegations.roles() {
@@ -467,7 +467,7 @@
                 }
                 let _ = visited.insert(delegation.role().clone());
 
-                let mut new_parents = parents.clone();
+                let mut new_parents = parents.to_owned();
                 new_parents.push(delegation.paths().clone());
 
                 if current_depth > 0 && !target_path.matches_chain(&parents) {
@@ -496,7 +496,7 @@
                         current_depth + 1,
                         target_path,
                         d,
-                        new_parents,
+                        &new_parents,
                         visited,
                     );
                     if term {
@@ -512,7 +512,7 @@
         match targets.delegations() {
             Some(d) => {
                 let mut visited = HashSet::new();
-                lookup(self, false, 0, target_path, d, vec![], &mut visited)
+                lookup(self, false, 0, target_path, d, &[], &mut visited)
                     .1
                     .ok_or_else(|| Error::TargetUnavailable)
             }
@@ -645,7 +645,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let root = RootMetadata::new(
             2,
@@ -663,10 +663,10 @@
         // add the original key's signature to make it cross signed
         root.add_signature(&KEYS[0]).unwrap();
 
-        assert_eq!(tuf.update_root(root.clone()), Ok(true));
+        assert_eq!(tuf.update_root(&root), Ok(true));
 
         // second update should do nothing
-        assert_eq!(tuf.update_root(root), Ok(false));
+        assert_eq!(tuf.update_root(&root), Ok(false));
     }
 
     #[test]
@@ -684,7 +684,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let root = RootMetadata::new(
             2,
@@ -700,7 +700,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[1])
             .unwrap();
 
-        assert!(tuf.update_root(root).is_err());
+        assert!(tuf.update_root(&root).is_err());
     }
 
     #[test]
@@ -718,7 +718,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -729,10 +729,10 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[1]).unwrap();
 
-        assert_eq!(tuf.update_timestamp(timestamp.clone()), Ok(true));
+        assert_eq!(tuf.update_timestamp(&timestamp), Ok(true));
 
         // second update should do nothing
-        assert_eq!(tuf.update_timestamp(timestamp), Ok(false))
+        assert_eq!(tuf.update_timestamp(&timestamp), Ok(false))
     }
 
     #[test]
@@ -750,7 +750,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -763,7 +763,7 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[0]).unwrap();
 
-        assert!(tuf.update_timestamp(timestamp).is_err())
+        assert!(tuf.update_timestamp(&timestamp).is_err())
     }
 
     #[test]
@@ -785,7 +785,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -796,17 +796,17 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
-        assert_eq!(tuf.update_snapshot(snapshot.clone()), Ok(true));
+        assert_eq!(tuf.update_snapshot(&snapshot), Ok(true));
 
         // second update should do nothing
-        assert_eq!(tuf.update_snapshot(snapshot), Ok(false));
+        assert_eq!(tuf.update_snapshot(&snapshot), Ok(false));
     }
 
     #[test]
@@ -828,7 +828,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -839,14 +839,14 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[2]).unwrap();
 
-        assert!(tuf.update_snapshot(snapshot.clone()).is_err());
+        assert!(tuf.update_snapshot(&snapshot).is_err());
     }
 
     #[test]
@@ -868,7 +868,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -879,14 +879,14 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
             .unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
-        assert!(tuf.update_snapshot(snapshot).is_err());
+        assert!(tuf.update_snapshot(&snapshot).is_err());
     }
 
     #[test]
@@ -909,7 +909,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -920,7 +920,7 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let meta_map =
             hashmap!(
@@ -932,7 +932,7 @@
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
-        tuf.update_snapshot(snapshot).unwrap();
+        tuf.update_snapshot(&snapshot).unwrap();
 
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
@@ -940,10 +940,10 @@
         let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[2]).unwrap();
 
-        assert_eq!(tuf.update_targets(targets.clone()), Ok(true));
+        assert_eq!(tuf.update_targets(&targets), Ok(true));
 
         // second update should do nothing
-        assert_eq!(tuf.update_targets(targets), Ok(false));
+        assert_eq!(tuf.update_targets(&targets), Ok(false));
     }
 
     #[test]
@@ -966,7 +966,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -977,7 +977,7 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let meta_map =
             hashmap!(
@@ -989,7 +989,7 @@
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
-        tuf.update_snapshot(snapshot).unwrap();
+        tuf.update_snapshot(&snapshot).unwrap();
 
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
@@ -997,7 +997,7 @@
         let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[3]).unwrap();
 
-        assert!(tuf.update_targets(targets).is_err());
+        assert!(tuf.update_targets(&targets).is_err());
     }
 
     #[test]
@@ -1020,7 +1020,7 @@
         let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
             .unwrap();
 
-        let mut tuf = Tuf::from_root(root).unwrap();
+        let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
@@ -1031,7 +1031,7 @@
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
-        tuf.update_timestamp(timestamp).unwrap();
+        tuf.update_timestamp(&timestamp).unwrap();
 
         let meta_map =
             hashmap!(
@@ -1043,7 +1043,7 @@
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
-        tuf.update_snapshot(snapshot).unwrap();
+        tuf.update_snapshot(&snapshot).unwrap();
 
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
@@ -1051,6 +1051,6 @@
         let targets: SignedMetadata<Json, TargetsMetadata> =
             SignedMetadata::new(&targets, &KEYS[2]).unwrap();
 
-        assert!(tuf.update_targets(targets).is_err());
+        assert!(tuf.update_targets(&targets).is_err());
     }
 }
diff --git a/tests/integration.rs b/tests/integration.rs
index 4f46a83..4a7fd3c 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -63,7 +63,7 @@
     let signed = SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key)
         .unwrap();
 
-    tuf.update_timestamp(signed).unwrap();
+    tuf.update_timestamp(&signed).unwrap();
 
     //// build the snapshot ////
     let meta_map =
@@ -78,11 +78,11 @@
 
     let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
-    tuf.update_snapshot(signed).unwrap();
+    tuf.update_snapshot(&signed).unwrap();
 
     //// build the targets ////
     let delegations = Delegations::new(
-        hashset![delegation_key.public().clone()],
+        &hashset![delegation_key.public().clone()],
         vec![
             Delegation::new(
                 MetadataPath::new("delegation".into()).unwrap(),
@@ -108,7 +108,7 @@
 
     let signed = SignedMetadata::<Json, TargetsMetadata>::new(&targets, &targets_key).unwrap();
 
-    tuf.update_targets(signed).unwrap();
+    tuf.update_targets(&signed).unwrap();
 
     //// build the delegation ////
     let target_file: &[u8] = b"bar";
@@ -123,7 +123,7 @@
     let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_key)
         .unwrap();
 
-    tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), signed)
+    tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), &signed)
         .unwrap();
 
     assert!(
@@ -176,7 +176,7 @@
     let signed = SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key)
         .unwrap();
 
-    tuf.update_timestamp(signed).unwrap();
+    tuf.update_timestamp(&signed).unwrap();
 
     //// build the snapshot ////
     let meta_map =
@@ -193,11 +193,11 @@
 
     let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
-    tuf.update_snapshot(signed).unwrap();
+    tuf.update_snapshot(&signed).unwrap();
 
     //// build the targets ////
     let delegations = Delegations::new(
-        hashset![delegation_a_key.public().clone()],
+        &hashset![delegation_a_key.public().clone()],
         vec![
             Delegation::new(
                 MetadataPath::new("delegation-a".into()).unwrap(),
@@ -223,11 +223,11 @@
 
     let signed = SignedMetadata::<Json, TargetsMetadata>::new(&targets, &targets_key).unwrap();
 
-    tuf.update_targets(signed).unwrap();
+    tuf.update_targets(&signed).unwrap();
 
     //// build delegation A ////
     let delegations = Delegations::new(
-        hashset![delegation_b_key.public().clone()],
+        &hashset![delegation_b_key.public().clone()],
         vec![
             Delegation::new(
                 MetadataPath::new("delegation-b".into()).unwrap(),
@@ -254,7 +254,7 @@
     let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_a_key)
         .unwrap();
 
-    tuf.update_delegation(&MetadataPath::new("delegation-a".into()).unwrap(), signed)
+    tuf.update_delegation(&MetadataPath::new("delegation-a".into()).unwrap(), &signed)
         .unwrap();
 
     //// build delegation B ////
@@ -271,7 +271,7 @@
     let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_b_key)
         .unwrap();
 
-    tuf.update_delegation(&MetadataPath::new("delegation-b".into()).unwrap(), signed)
+    tuf.update_delegation(&MetadataPath::new("delegation-b".into()).unwrap(), &signed)
         .unwrap();
 
     assert!(