diff --git a/src/client.rs b/src/client.rs
index 6cca35f..ccba448 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -87,15 +87,16 @@
     ///
     /// Returns `true` if an update occurred and `false` otherwise.
     pub fn update_remote(&mut self) -> Result<bool> {
-        Ok(
-            Self::update_root(&mut self.tuf, &mut self.remote, &self.config.max_root_size)? ||
-                Self::update_timestamp(
-                    &mut self.tuf,
-                    &mut self.remote,
-                    &self.config.max_timestamp_size,
-                )? || Self::update_snapshot(&mut self.tuf, &mut self.remote)? ||
-                Self::update_targets(&mut self.tuf, &mut self.local)?,
-        )
+        let r = Self::update_root(&mut self.tuf, &mut self.remote, &self.config.max_root_size)?;
+        let ts = Self::update_timestamp(
+            &mut self.tuf,
+            &mut self.remote,
+            &self.config.max_timestamp_size,
+        )?;
+        let sn = Self::update_snapshot(&mut self.tuf, &mut self.remote)?;
+        let ta = Self::update_targets(&mut self.tuf, &mut self.remote)?;
+
+        Ok(r || ts || sn || ta)
     }
 
     /// Returns `true` if an update occurred and `false` otherwise.
@@ -110,7 +111,7 @@
             max_root_size,
             None,
         )?;
-        let latest_version = D::deserialize::<RootMetadata>(latest_root.unverified_signed())?
+        let latest_version = D::deserialize::<RootMetadata>(latest_root.signed())?
             .version();
 
         if latest_version < tuf.root().version() {
@@ -173,7 +174,7 @@
     {
         let snapshot_description = match tuf.timestamp() {
             Some(ts) => {
-                match ts.meta().get(&MetadataPath::from_role(&Role::Timestamp)) {
+                match ts.meta().get(&MetadataPath::from_role(&Role::Snapshot)) {
                     Some(d) => Ok(d),
                     None => Err(Error::VerificationFailure(
                         "Timestamp metadata did not contain a description of the \
@@ -187,7 +188,7 @@
             .clone();
 
         if snapshot_description.version() <= tuf.snapshot().map(|s| s.version()).unwrap_or(0) {
-            return Ok(false)
+            return Ok(false);
         }
 
         let snap = repo.fetch_metadata(
@@ -221,7 +222,7 @@
             .clone();
 
         if targets_description.version() <= tuf.targets().map(|t| t.version()).unwrap_or(0) {
-            return Ok(false)
+            return Ok(false);
         }
 
         let targets = repo.fetch_metadata(
diff --git a/src/lib.rs b/src/lib.rs
index d1c02d0..0a3d3c9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,7 +19,7 @@
 //! use tuf::Tuf;
 //! use tuf::crypto::KeyId;
 //! use tuf::client::{Client, Config};
-//! use tuf::metadata::{RootMetadata, Unverified, SignedMetadata, Role, MetadataPath,
+//! use tuf::metadata::{RootMetadata, SignedMetadata, Role, MetadataPath,
 //!     MetadataVersion};
 //! use tuf::interchange::JsonDataInterchange;
 //! use tuf::repository::{Repository, FileSystemRepository, HttpRepository};
diff --git a/src/metadata.rs b/src/metadata.rs
index 8fcdcea..406e2ab 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -133,19 +133,6 @@
     Ok(())
 }
 
-/// Trait used to represent whether a piece of data is verified or not.
-pub trait VerificationStatus: Debug + PartialEq {}
-
-/// Type used to represent verified data.
-#[derive(Debug, PartialEq)]
-pub struct Verified {}
-impl VerificationStatus for Verified {}
-
-/// Type used to represent unverified data.
-#[derive(Debug, PartialEq)]
-pub struct Unverified {}
-impl VerificationStatus for Unverified {}
-
 /// The TUF role.
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Role {
@@ -230,11 +217,10 @@
 
 /// A piece of raw metadata with attached signatures.
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct SignedMetadata<D, M, V>
+pub struct SignedMetadata<D, M>
 where
     D: DataInterchange,
     M: Metadata,
-    V: VerificationStatus,
 {
     signatures: Vec<Signature>,
     signed: D::RawData,
@@ -242,22 +228,19 @@
     _interchage: PhantomData<D>,
     #[serde(skip_serializing, skip_deserializing)]
     _metadata: PhantomData<M>,
-    #[serde(skip_serializing, skip_deserializing)]
-    _verification: PhantomData<V>,
 }
 
-impl<D, M, V> SignedMetadata<D, M, V>
+impl<D, M> SignedMetadata<D, M>
 where
     D: DataInterchange,
     M: Metadata,
-    V: VerificationStatus,
 {
     /// Create a new `SignedMetadata`.
     pub fn new(
         metadata: &M,
         private_key: &PrivateKey,
         scheme: SignatureScheme,
-    ) -> Result<SignedMetadata<D, M, Unverified>> {
+    ) -> Result<SignedMetadata<D, M>> {
         let raw = D::serialize(metadata)?;
         let bytes = D::canonicalize(&raw)?;
         let sig = private_key.sign(&bytes, scheme)?;
@@ -266,7 +249,6 @@
             signed: raw,
             _interchage: PhantomData,
             _metadata: PhantomData,
-            _verification: PhantomData,
         })
     }
 
@@ -280,20 +262,18 @@
         &mut self.signatures
     }
 
-    /// An immutable reference to the unverified raw data.
-    ///
-    /// **WARNING**: This data is untrusted.
-    pub fn unverified_signed(&self) -> &D::RawData {
+    /// An immutable reference to the raw data.
+    pub fn signed(&self) -> &D::RawData {
         &self.signed
     }
 
-    /// Verify this metadata and convert its type to `Verified`.
+    /// Verify this metadata.
     pub fn verify(
-        self,
+        &self,
         threshold: u32,
         authorized_key_ids: &HashSet<KeyId>,
         available_keys: &HashMap<KeyId, PublicKey>,
-    ) -> Result<SignedMetadata<D, M, Verified>> {
+    ) -> Result<()> {
         if self.signatures.len() < 1 {
             return Err(Error::VerificationFailure(
                 "The metadata was not signed with any authorized keys."
@@ -344,13 +324,7 @@
         }
 
         if signatures_needed == 0 {
-            Ok(SignedMetadata {
-                signatures: self.signatures,
-                signed: self.signed,
-                _interchage: PhantomData,
-                _metadata: PhantomData,
-                _verification: PhantomData,
-            })
+            Ok(())
         } else {
             Err(Error::VerificationFailure(format!(
                 "Signature threshold not met: {}/{}",
@@ -361,17 +335,6 @@
     }
 }
 
-impl<D, M> SignedMetadata<D, M, Verified>
-where
-    D: DataInterchange,
-    M: Metadata,
-{
-    /// An immutable reference to the verified raw data.
-    pub fn signed(&self) -> &D::RawData {
-        self.unverified_signed()
-    }
-}
-
 /// Metadata for the root role.
 #[derive(Debug, PartialEq)]
 pub struct RootMetadata {
@@ -717,9 +680,7 @@
 
 impl MetadataDescription {
     /// Create a new `MetadataDescription`.
-    pub fn new(
-        version: u32,
-    ) -> Result<Self> {
+    pub fn new(version: u32) -> Result<Self> {
         if version < 1 {
             return Err(Error::IllegalArgument(format!(
                 "Metadata version must be greater than zero. Found: {}",
@@ -727,9 +688,7 @@
             )));
         }
 
-        Ok(MetadataDescription {
-            version: version,
-        })
+        Ok(MetadataDescription { version: version })
     }
 
     /// The version of the described metadata.
@@ -1281,7 +1240,7 @@
 
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
 
-        let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata, Unverified>::new(
+        let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
             &snapshot,
             &key,
             SignatureScheme::Ed25519,
@@ -1309,7 +1268,7 @@
 
         let encoded = json::to_value(&signed).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: SignedMetadata<JsonDataInterchange, SnapshotMetadata, Unverified> =
+        let decoded: SignedMetadata<JsonDataInterchange, SnapshotMetadata> =
             json::from_value(encoded).unwrap();
         assert_eq!(decoded, signed);
     }
diff --git a/src/repository.rs b/src/repository.rs
index bdeab19..04f9d2c 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -15,8 +15,8 @@
 use Result;
 use crypto::{self, HashAlgorithm, HashValue};
 use error::Error;
-use metadata::{SignedMetadata, MetadataVersion, Unverified, Verified, Role, Metadata, TargetPath,
-               TargetDescription, MetadataPath};
+use metadata::{SignedMetadata, MetadataVersion, Role, Metadata, TargetPath, TargetDescription,
+               MetadataPath};
 use interchange::DataInterchange;
 
 /// Top-level trait that represents a TUF repository and contains all the ways it can be interacted
@@ -37,7 +37,7 @@
         role: &Role,
         meta_path: &MetadataPath,
         version: &MetadataVersion,
-        metadata: &SignedMetadata<D, M, Verified>,
+        metadata: &SignedMetadata<D, M>,
     ) -> Result<()>
     where
         M: Metadata;
@@ -50,7 +50,7 @@
         version: &MetadataVersion,
         max_size: &Option<usize>,
         hash_data: Option<(&HashAlgorithm, &HashValue)>,
-    ) -> Result<SignedMetadata<D, M, Unverified>>
+    ) -> Result<SignedMetadata<D, M>>
     where
         M: Metadata;
 
@@ -207,7 +207,7 @@
         role: &Role,
         meta_path: &MetadataPath,
         version: &MetadataVersion,
-        metadata: &SignedMetadata<D, M, Verified>,
+        metadata: &SignedMetadata<D, M>,
     ) -> Result<()>
     where
         M: Metadata,
@@ -236,7 +236,7 @@
         version: &MetadataVersion,
         max_size: &Option<usize>,
         hash_data: Option<(&HashAlgorithm, &HashValue)>,
-    ) -> Result<SignedMetadata<D, M, Unverified>>
+    ) -> Result<SignedMetadata<D, M>>
     where
         M: Metadata,
     {
@@ -366,7 +366,7 @@
         _: &Role,
         _: &MetadataPath,
         _: &MetadataVersion,
-        _: &SignedMetadata<D, M, Verified>,
+        _: &SignedMetadata<D, M>,
     ) -> Result<()>
     where
         M: Metadata,
@@ -383,7 +383,7 @@
         version: &MetadataVersion,
         max_size: &Option<usize>,
         hash_data: Option<(&HashAlgorithm, &HashValue)>,
-    ) -> Result<SignedMetadata<D, M, Unverified>>
+    ) -> Result<SignedMetadata<D, M>>
     where
         M: Metadata,
     {
@@ -451,7 +451,7 @@
         role: &Role,
         meta_path: &MetadataPath,
         version: &MetadataVersion,
-        metadata: &SignedMetadata<D, M, Verified>,
+        metadata: &SignedMetadata<D, M>,
     ) -> Result<()>
     where
         M: Metadata,
@@ -473,7 +473,7 @@
         version: &MetadataVersion,
         max_size: &Option<usize>,
         hash_data: Option<(&HashAlgorithm, &HashValue)>,
-    ) -> Result<SignedMetadata<D, M, Unverified>>
+    ) -> Result<SignedMetadata<D, M>>
     where
         M: Metadata,
     {
diff --git a/src/tuf.rs b/src/tuf.rs
index 5dd3e8e..238f004 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -8,8 +8,8 @@
 use crypto::KeyId;
 use error::Error;
 use interchange::DataInterchange;
-use metadata::{SignedMetadata, RootMetadata, VerificationStatus, TimestampMetadata, Role,
-               SnapshotMetadata, MetadataPath, TargetsMetadata, TargetPath, TargetDescription};
+use metadata::{SignedMetadata, RootMetadata, TimestampMetadata, Role, SnapshotMetadata,
+               MetadataPath, TargetsMetadata, TargetPath, TargetDescription};
 
 /// Contains trusted TUF metadata and can be used to verify other metadata and targets.
 #[derive(Debug)]
@@ -24,13 +24,10 @@
 impl<D: DataInterchange> Tuf<D> {
     /// Create a new `TUF` struct from a known set of pinned root keys that are used to verify the
     /// signed metadata.
-    pub fn from_root_pinned<V>(
-        mut signed_root: SignedMetadata<D, RootMetadata, V>,
+    pub fn from_root_pinned(
+        mut signed_root: SignedMetadata<D, RootMetadata>,
         root_key_ids: &[KeyId],
-    ) -> Result<Self>
-    where
-        V: VerificationStatus,
-    {
+    ) -> Result<Self> {
         signed_root.signatures_mut().retain(|s| {
             root_key_ids.contains(s.key_id())
         });
@@ -41,11 +38,8 @@
     ///
     /// **WARNING**: This is trust-on-first-use (TOFU) and offers weaker security guarantees than
     /// the related method `from_root_pinned`.
-    pub fn from_root<V>(signed_root: SignedMetadata<D, RootMetadata, V>) -> Result<Self>
-    where
-        V: VerificationStatus,
-    {
-        let root = D::deserialize::<RootMetadata>(signed_root.unverified_signed())?;
+    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(),
             root.root().key_ids(),
@@ -93,20 +87,14 @@
     }
 
     /// Verify and update the root metadata.
-    pub fn update_root<V>(
-        &mut self,
-        signed_root: SignedMetadata<D, RootMetadata, V>,
-    ) -> Result<bool>
-    where
-        V: VerificationStatus,
-    {
-        let signed_root = signed_root.verify(
+    pub fn update_root(&mut self, signed_root: SignedMetadata<D, RootMetadata>) -> Result<bool> {
+        signed_root.verify(
             self.root.root().threshold(),
             self.root.root().key_ids(),
             self.root.keys(),
         )?;
 
-        let root = D::deserialize::<RootMetadata>(signed_root.unverified_signed())?;
+        let root = D::deserialize::<RootMetadata>(signed_root.signed())?;
 
         match root.version() {
             x if x == self.root.version() => {
@@ -139,14 +127,11 @@
     }
 
     /// Verify and update the timestamp metadata.
-    pub fn update_timestamp<V>(
+    pub fn update_timestamp(
         &mut self,
-        signed_timestamp: SignedMetadata<D, TimestampMetadata, V>,
-    ) -> Result<bool>
-    where
-        V: VerificationStatus,
-    {
-        let signed_timestamp = signed_timestamp.verify(
+        signed_timestamp: SignedMetadata<D, TimestampMetadata>,
+    ) -> Result<bool> {
+        signed_timestamp.verify(
             self.root.timestamp().threshold(),
             self.root.timestamp().key_ids(),
             self.root.keys(),
@@ -174,13 +159,10 @@
     }
 
     /// Verify and update the snapshot metadata.
-    pub fn update_snapshot<V>(
+    pub fn update_snapshot(
         &mut self,
-        signed_snapshot: SignedMetadata<D, SnapshotMetadata, V>,
-    ) -> Result<bool>
-    where
-        V: VerificationStatus,
-    {
+        signed_snapshot: SignedMetadata<D, SnapshotMetadata>,
+    ) -> Result<bool> {
         let snapshot = {
             let root = self.safe_root_ref()?;
             let timestamp = self.safe_timestamp_ref()?;
@@ -205,7 +187,7 @@
                 return Ok(false);
             }
 
-            let signed_snapshot = signed_snapshot.verify(
+            signed_snapshot.verify(
                 root.snapshot().threshold(),
                 root.snapshot().key_ids(),
                 root.keys(),
@@ -234,13 +216,10 @@
     }
 
     /// Verify and update the targets metadata.
-    pub fn update_targets<V>(
+    pub fn update_targets(
         &mut self,
-        signed_targets: SignedMetadata<D, TargetsMetadata, V>,
-    ) -> Result<bool>
-    where
-        V: VerificationStatus,
-    {
+        signed_targets: SignedMetadata<D, TargetsMetadata>,
+    ) -> Result<bool> {
         let targets = {
             let root = self.safe_root_ref()?;
             let snapshot = self.safe_snapshot_ref()?;
@@ -265,7 +244,7 @@
                 return Ok(false);
             }
 
-            let signed_targets = signed_targets.verify(
+            signed_targets.verify(
                 root.targets().threshold(),
                 root.targets().key_ids(),
                 root.keys(),
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
new file mode 100644
index 0000000..cc8b691
--- /dev/null
+++ b/tests/simple_example.rs
@@ -0,0 +1,199 @@
+extern crate chrono;
+extern crate tuf;
+
+use chrono::prelude::*;
+use chrono::offset::Utc;
+use std::collections::{HashSet, HashMap};
+use tuf::{Tuf, Error};
+use tuf::client::{Client, Config};
+use tuf::crypto::{PrivateKey, SignatureScheme, KeyId};
+use tuf::interchange::JsonDataInterchange;
+use tuf::metadata::{RoleDefinition, RootMetadata, Role, MetadataVersion, MetadataPath,
+                    SignedMetadata, TargetDescription, TargetPath, TargetsMetadata,
+                    MetadataDescription, SnapshotMetadata, TimestampMetadata};
+use tuf::repository::{EphemeralRepository, Repository};
+
+// Ironically, this is far from simple, but it's as simple as it can be made.
+
+const ED25519_1_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-1.pk8.der");
+const ED25519_2_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-2.pk8.der");
+const ED25519_3_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-3.pk8.der");
+const ED25519_4_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-4.pk8.der");
+
+#[test]
+fn main() {
+    let mut remote = EphemeralRepository::<JsonDataInterchange>::new();
+    let root_key_ids = init_server(&mut remote).unwrap();
+    init_client(root_key_ids, remote).unwrap();
+}
+
+fn init_client(
+    root_key_ids: Vec<KeyId>,
+    mut remote: EphemeralRepository<JsonDataInterchange>,
+) -> Result<(), Error> {
+    let local = EphemeralRepository::<JsonDataInterchange>::new();
+    let config = Config::build().finish()?;
+    let root = remote.fetch_metadata(
+        &Role::Root,
+        &MetadataPath::from_role(&Role::Root),
+        &MetadataVersion::None,
+        config.max_root_size(),
+        None,
+    )?;
+
+    let tuf = Tuf::<JsonDataInterchange>::from_root_pinned(root, &root_key_ids)?;
+    let mut client = Client::new(tuf, config, local, remote)?;
+    match client.update_local() {
+        Ok(_) => (),
+        Err(e) => println!("{:?}", e),
+    }
+    let _ = client.update_remote()?;
+    client.fetch_target(&TargetPath::new("grendel".into())?)
+}
+
+fn init_server(remote: &mut EphemeralRepository<JsonDataInterchange>) -> Result<Vec<KeyId>, Error> {
+    // in real life, you wouldn't want these keys on the same machine ever
+    let root_key = PrivateKey::from_pkcs8(ED25519_1_PK8)?;
+    let snapshot_key = PrivateKey::from_pkcs8(ED25519_2_PK8)?;
+    let targets_key = PrivateKey::from_pkcs8(ED25519_3_PK8)?;
+    let timestamp_key = PrivateKey::from_pkcs8(ED25519_4_PK8)?;
+
+    //// build the root ////
+
+    let keys = vec![
+        root_key.public().clone(),
+        snapshot_key.public().clone(),
+        targets_key.public().clone(),
+        timestamp_key.public().clone(),
+    ];
+
+    let mut key_ids = HashSet::new();
+    key_ids.insert(root_key.key_id().clone());
+    let root_def = RoleDefinition::new(1, key_ids)?;
+
+    let mut key_ids = HashSet::new();
+    key_ids.insert(snapshot_key.key_id().clone());
+    let snapshot_def = RoleDefinition::new(1, key_ids)?;
+
+    let mut key_ids = HashSet::new();
+    key_ids.insert(targets_key.key_id().clone());
+    let targets_def = RoleDefinition::new(1, key_ids)?;
+
+    let mut key_ids = HashSet::new();
+    key_ids.insert(timestamp_key.key_id().clone());
+    let timestamp_def = RoleDefinition::new(1, key_ids)?;
+
+    let root = RootMetadata::new(
+        1,
+        Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
+        false,
+        keys,
+        root_def,
+        snapshot_def,
+        targets_def,
+        timestamp_def,
+    )?;
+
+    let signed = SignedMetadata::<JsonDataInterchange, RootMetadata>::new(
+        &root,
+        &root_key,
+        SignatureScheme::Ed25519,
+    )?;
+
+    remote.store_metadata(
+        &Role::Root,
+        &MetadataPath::new("root".into())?,
+        &MetadataVersion::Number(1),
+        &signed,
+    )?;
+    remote.store_metadata(
+        &Role::Root,
+        &MetadataPath::new("root".into())?,
+        &MetadataVersion::None,
+        &signed,
+    )?;
+
+    //// build the targets ////
+
+    let target_file: &[u8] = b"things fade, alternatives exclude";
+    let target_path = TargetPath::new("grendel".into())?;
+    let target_description = TargetDescription::from_reader(target_file)?;
+    let _ = remote.store_target(target_file, &target_path, &target_description);
+
+    let mut target_map = HashMap::new();
+    let _ = target_map.insert(target_path, target_description);
+    let targets = TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map)?;
+
+    let signed = SignedMetadata::<JsonDataInterchange, TargetsMetadata>::new(
+        &targets,
+        &targets_key,
+        SignatureScheme::Ed25519,
+    )?;
+
+    remote.store_metadata(
+        &Role::Targets,
+        &MetadataPath::new("targets".into())?,
+        &MetadataVersion::Number(1),
+        &signed,
+    )?;
+    remote.store_metadata(
+        &Role::Targets,
+        &MetadataPath::new("targets".into())?,
+        &MetadataVersion::None,
+        &signed,
+    )?;
+
+    //// build the snapshot ////
+    let mut meta_map = HashMap::new();
+    let path = MetadataPath::new("targets".into())?;
+    let desc = MetadataDescription::new(1)?;
+    let _ = meta_map.insert(path, desc);
+    let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)?;
+
+    let signed = SignedMetadata::<JsonDataInterchange, SnapshotMetadata>::new(
+        &snapshot,
+        &snapshot_key,
+        SignatureScheme::Ed25519,
+    )?;
+
+    remote.store_metadata(
+        &Role::Snapshot,
+        &MetadataPath::new("snapshot".into())?,
+        &MetadataVersion::Number(1),
+        &signed,
+    )?;
+    remote.store_metadata(
+        &Role::Snapshot,
+        &MetadataPath::new("snapshot".into())?,
+        &MetadataVersion::None,
+        &signed,
+    )?;
+
+    //// build the timestamp ////
+    let mut meta_map = HashMap::new();
+    let path = MetadataPath::new("snapshot".into())?;
+    let desc = MetadataDescription::new(1)?;
+    let _ = meta_map.insert(path, desc);
+    let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)?;
+
+    let signed = SignedMetadata::<JsonDataInterchange, TimestampMetadata>::new(
+        &timestamp,
+        &timestamp_key,
+        SignatureScheme::Ed25519,
+    )?;
+
+    remote.store_metadata(
+        &Role::Timestamp,
+        &MetadataPath::new("timestamp".into())?,
+        &MetadataVersion::Number(1),
+        &signed,
+    )?;
+    remote.store_metadata(
+        &Role::Timestamp,
+        &MetadataPath::new("timestamp".into())?,
+        &MetadataVersion::None,
+        &signed,
+    )?;
+
+    Ok(vec![root_key.key_id().clone()])
+}