diff --git a/interop-tests/src/lib.rs b/interop-tests/src/lib.rs
index e895479..f4d8619 100644
--- a/interop-tests/src/lib.rs
+++ b/interop-tests/src/lib.rs
@@ -9,11 +9,13 @@ use tuf::metadata::{
     MetadataPath, MetadataVersion, Role, SnapshotMetadataBuilder, TargetPath,
     TargetsMetadataBuilder, TimestampMetadataBuilder,
 };
-use tuf::pouf::JsonPretty;
 use tuf::repo_builder::RepoBuilder;
 use tuf::repository::{FileSystemRepository, FileSystemRepositoryBuilder, RepositoryStorage};
 use walkdir::WalkDir;
 
+mod pretty;
+pub use pretty::JsonPretty;
+
 // These structs and functions are necessary to parse keys.json, which contains the keys
 // used by go-tuf to generate the equivalent metadata. We use the same keys to facilitate
 // compatibility testing.
diff --git a/tuf/src/pouf/cjson/pretty.rs b/interop-tests/src/pretty.rs
similarity index 74%
rename from tuf/src/pouf/cjson/pretty.rs
rename to interop-tests/src/pretty.rs
index dae802e..3bc279a 100644
--- a/tuf/src/pouf/cjson/pretty.rs
+++ b/interop-tests/src/pretty.rs
@@ -1,15 +1,17 @@
-use serde::de::DeserializeOwned;
-use serde::ser::Serialize;
-
-use super::Json;
-use crate::pouf::Pouf;
-use crate::Result;
+use {
+    serde::de::DeserializeOwned,
+    serde::ser::Serialize,
+    tuf::{
+        pouf::{Pouf, Pouf1},
+        Result,
+    },
+};
 
 /// Pretty JSON data pouf.
 ///
-/// This is identical to [Json] in all manners except for the `canonicalize` method. Instead of
-/// writing the metadata in the canonical format, it first canonicalizes it, then pretty prints
-/// the metadata.
+/// This is identical to [tuf::pouf::Pouf1] in all manners except for the `canonicalize` method.
+/// Instead of writing the metadata in the canonical format, it first canonicalizes it, then pretty
+/// prints the metadata.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct JsonPretty;
 
@@ -17,16 +19,19 @@ impl Pouf for JsonPretty {
     type RawData = serde_json::Value;
 
     /// ```
-    /// # use tuf::pouf::{Pouf, JsonPretty};
+    /// # use interop_tests::JsonPretty;
+    /// # use tuf::pouf::Pouf;
+    /// #
     /// assert_eq!(JsonPretty::extension(), "json");
     /// ```
     fn extension() -> &'static str {
-        Json::extension()
+        Pouf1::extension()
     }
 
     /// ```
+    /// # use interop_tests::JsonPretty;
     /// # use serde_json::json;
-    /// # use tuf::pouf::{Pouf, JsonPretty};
+    /// # use tuf::pouf::Pouf;
     /// #
     /// let json = json!({
     ///     "o": {
@@ -57,17 +62,18 @@ impl Pouf for JsonPretty {
     /// }"#);
     /// ```
     fn canonicalize(raw_data: &Self::RawData) -> Result<Vec<u8>> {
-        let bytes = Json::canonicalize(raw_data)?;
+        let bytes = Pouf1::canonicalize(raw_data)?;
         Ok(serde_json::to_vec_pretty(&Self::from_slice::<
             Self::RawData,
         >(&bytes)?)?)
     }
 
     /// ```
+    /// # use interop_tests::JsonPretty;
     /// # use serde_derive::Deserialize;
     /// # use serde_json::json;
     /// # use std::collections::HashMap;
-    /// # use tuf::pouf::{Pouf, JsonPretty};
+    /// # use tuf::pouf::Pouf;
     /// #
     /// #[derive(Deserialize, Debug, PartialEq)]
     /// struct Thing {
@@ -84,14 +90,15 @@ impl Pouf for JsonPretty {
     where
         T: DeserializeOwned,
     {
-        Json::deserialize(raw_data)
+        Pouf1::deserialize(raw_data)
     }
 
     /// ```
+    /// # use interop_tests::JsonPretty;
     /// # use serde_derive::Serialize;
     /// # use serde_json::json;
     /// # use std::collections::HashMap;
-    /// # use tuf::pouf::{Pouf, JsonPretty};
+    /// # use tuf::pouf::Pouf;
     /// #
     /// #[derive(Serialize)]
     /// struct Thing {
@@ -108,12 +115,14 @@ impl Pouf for JsonPretty {
     where
         T: Serialize,
     {
-        Json::serialize(data)
+        Pouf1::serialize(data)
     }
 
     /// ```
-    /// # use tuf::pouf::{Pouf, JsonPretty};
+    /// # use interop_tests::JsonPretty;
     /// # use std::collections::HashMap;
+    /// # use tuf::pouf::Pouf;
+    /// #
     /// let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
     /// let _: HashMap<String, String> = JsonPretty::from_slice(&jsn).unwrap();
     /// ```
@@ -121,6 +130,6 @@ impl Pouf for JsonPretty {
     where
         T: DeserializeOwned,
     {
-        Json::from_slice(slice)
+        Pouf1::from_slice(slice)
     }
 }
diff --git a/interop-tests/tests/test.rs b/interop-tests/tests/test.rs
index dfb3a12..772af39 100644
--- a/interop-tests/tests/test.rs
+++ b/interop-tests/tests/test.rs
@@ -37,20 +37,21 @@
 use assert_matches::assert_matches;
 use futures_executor::block_on;
 use futures_util::io::AsyncReadExt;
+use interop_tests::JsonPretty;
 use pretty_assertions::assert_eq;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 use tuf::client::{Client, Config};
 use tuf::crypto::PublicKey;
 use tuf::metadata::{MetadataPath, MetadataVersion, RawSignedMetadata, RootMetadata, TargetPath};
-use tuf::pouf::{Json, JsonPretty, Pouf};
+use tuf::pouf::{Pouf, Pouf1};
 use tuf::repository::{
     EphemeralRepository, FileSystemRepository, FileSystemRepositoryBuilder, RepositoryProvider,
 };
 
 #[test]
 fn fuchsia_go_tuf_consistent_snapshot_false() {
-    test_key_rotation::<Json>(
+    test_key_rotation::<Pouf1>(
         Path::new("tests")
             .join("fuchsia-go-tuf-5527fe")
             .join("consistent-snapshot-false"),
@@ -59,7 +60,7 @@ fn fuchsia_go_tuf_consistent_snapshot_false() {
 
 #[test]
 fn fuchsia_go_tuf_consistent_snapshot_true() {
-    test_key_rotation::<Json>(
+    test_key_rotation::<Pouf1>(
         Path::new("tests")
             .join("fuchsia-go-tuf-5527fe")
             .join("consistent-snapshot-true"),
@@ -68,7 +69,7 @@ fn fuchsia_go_tuf_consistent_snapshot_true() {
 
 #[test]
 fn fuchsia_go_tuf_transition_m4_consistent_snapshot_false() {
-    test_key_rotation::<Json>(
+    test_key_rotation::<Pouf1>(
         Path::new("tests")
             .join("fuchsia-go-tuf-transition-M4")
             .join("consistent-snapshot-false"),
@@ -77,7 +78,7 @@ fn fuchsia_go_tuf_transition_m4_consistent_snapshot_false() {
 
 #[test]
 fn fuchsia_go_tuf_transition_m4_consistent_snapshot_true() {
-    test_key_rotation::<Json>(
+    test_key_rotation::<Pouf1>(
         Path::new("tests")
             .join("fuchsia-go-tuf-transition-M4")
             .join("consistent-snapshot-true"),
diff --git a/tuf/src/client.rs b/tuf/src/client.rs
index 78f1252..1e2a052 100644
--- a/tuf/src/client.rs
+++ b/tuf/src/client.rs
@@ -11,7 +11,7 @@
 //! # use tuf::crypto::PublicKey;
 //! # use tuf::client::{Client, Config};
 //! # use tuf::metadata::{RootMetadata, Role, MetadataPath, MetadataVersion};
-//! # use tuf::pouf::Json;
+//! # use tuf::pouf::Pouf1;
 //! # use tuf::repository::{FileSystemRepository, HttpRepositoryBuilder};
 //! #
 //! # const PUBLIC_KEY: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-1.pub");
@@ -23,7 +23,7 @@
 //! # fn main() -> Result<()> {
 //! # block_on(async {
 //! let root_public_keys = load_root_public_keys();
-//! let local = FileSystemRepository::<Json>::new(PathBuf::from("~/.rustup"));
+//! let local = FileSystemRepository::<Pouf1>::new(PathBuf::from("~/.rustup"));
 //!
 //! let remote = HttpRepositoryBuilder::new_with_uri(
 //!     "https://static.rust-lang.org/".parse::<http::Uri>().unwrap(),
@@ -98,7 +98,7 @@ where
     /// # use futures_executor::block_on;
     /// # use tuf::{
     /// #     Error,
-    /// #     pouf::Json,
+    /// #     pouf::Pouf1,
     /// #     client::{Client, Config},
     /// #     crypto::{Ed25519PrivateKey, PrivateKey, SignatureScheme},
     /// #     metadata::{MetadataPath, MetadataVersion, Role, RootMetadataBuilder},
@@ -110,8 +110,8 @@ where
     /// #     &Ed25519PrivateKey::pkcs8()?,
     /// # )?;
     /// # let public_key = private_key.public().clone();
-    /// let mut local = EphemeralRepository::<Json>::new();
-    /// let remote = EphemeralRepository::<Json>::new();
+    /// let mut local = EphemeralRepository::<Pouf1>::new();
+    /// let remote = EphemeralRepository::<Pouf1>::new();
     ///
     /// let root_version = 1;
     /// let root = RootMetadataBuilder::new()
@@ -121,7 +121,7 @@ where
     ///     .snapshot_key(public_key.clone())
     ///     .targets_key(public_key.clone())
     ///     .timestamp_key(public_key.clone())
-    ///     .signed::<Json>(&private_key)?;
+    ///     .signed::<Pouf1>(&private_key)?;
     ///
     /// let root_path = MetadataPath::root();
     /// let root_version = MetadataVersion::Number(root_version);
@@ -166,7 +166,7 @@ where
     /// # use futures_executor::block_on;
     /// # use tuf::{
     /// #     Error,
-    /// #     pouf::Json,
+    /// #     pouf::Pouf1,
     /// #     client::{Client, Config},
     /// #     crypto::{Ed25519PrivateKey, KeyType, PrivateKey, SignatureScheme},
     /// #     metadata::{MetadataPath, MetadataVersion, Role, RootMetadataBuilder},
@@ -178,8 +178,8 @@ where
     /// #     &Ed25519PrivateKey::pkcs8()?,
     /// # )?;
     /// # let public_key = private_key.public().clone();
-    /// let local = EphemeralRepository::<Json>::new();
-    /// let remote = EphemeralRepository::<Json>::new();
+    /// let local = EphemeralRepository::<Pouf1>::new();
+    /// let remote = EphemeralRepository::<Pouf1>::new();
     ///
     /// let root_version = 1;
     /// let root_threshold = 1;
@@ -191,7 +191,7 @@ where
     ///     .snapshot_key(public_key.clone())
     ///     .targets_key(public_key.clone())
     ///     .timestamp_key(public_key.clone())
-    ///     .signed::<Json>(&private_key)
+    ///     .signed::<Pouf1>(&private_key)
     ///     .unwrap()
     ///     .to_raw()
     ///     .unwrap();
@@ -229,7 +229,7 @@ where
     /// # use std::iter::once;
     /// # use tuf::{
     /// #     Error,
-    /// #     pouf::Json,
+    /// #     pouf::Pouf1,
     /// #     client::{Client, Config},
     /// #     crypto::{Ed25519PrivateKey, KeyType, PrivateKey, SignatureScheme},
     /// #     metadata::{MetadataPath, MetadataVersion, Role, RootMetadataBuilder},
@@ -241,8 +241,8 @@ where
     /// #     &Ed25519PrivateKey::pkcs8()?,
     /// # )?;
     /// # let public_key = private_key.public().clone();
-    /// let local = EphemeralRepository::<Json>::new();
-    /// let mut remote = EphemeralRepository::<Json>::new();
+    /// let local = EphemeralRepository::<Pouf1>::new();
+    /// let mut remote = EphemeralRepository::<Pouf1>::new();
     ///
     /// let root_version = 1;
     /// let root_threshold = 1;
@@ -254,7 +254,7 @@ where
     ///     .snapshot_key(public_key.clone())
     ///     .targets_key(public_key.clone())
     ///     .timestamp_key(public_key.clone())
-    ///     .signed::<Json>(&private_key)?;
+    ///     .signed::<Pouf1>(&private_key)?;
     ///
     /// let root_path = MetadataPath::root();
     /// let root_version = MetadataVersion::Number(root_version);
@@ -1297,7 +1297,7 @@ mod test {
         MetadataDescription, MetadataPath, MetadataVersion, RootMetadataBuilder,
         SnapshotMetadataBuilder, TargetsMetadataBuilder, TimestampMetadataBuilder,
     };
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use crate::repo_builder::RepoBuilder;
     use crate::repository::{
         fetch_metadata_to_string, EphemeralRepository, ErrorRepository, Track, TrackRepository,
@@ -1339,8 +1339,8 @@ mod test {
     #[test]
     fn client_constructors_err_with_not_found() {
         block_on(async {
-            let mut local = EphemeralRepository::<Json>::new();
-            let remote = EphemeralRepository::<Json>::new();
+            let mut local = EphemeralRepository::<Pouf1>::new();
+            let remote = EphemeralRepository::<Pouf1>::new();
 
             let private_key =
                 Ed25519PrivateKey::from_pkcs8(&Ed25519PrivateKey::pkcs8().unwrap()).unwrap();
@@ -1371,7 +1371,7 @@ mod test {
     #[test]
     fn client_constructors_err_with_invalid_keys() {
         block_on(async {
-            let mut remote = EphemeralRepository::<Json>::new();
+            let mut remote = EphemeralRepository::<Pouf1>::new();
 
             let good_private_key = &KEYS[0];
             let bad_private_key = &KEYS[1];
@@ -1431,7 +1431,7 @@ mod test {
 
     async fn constructors_load_metadata_from_local_repo(constructor_mode: ConstructorMode) {
         // Store an expired root in the local store.
-        let mut local = EphemeralRepository::<Json>::new();
+        let mut local = EphemeralRepository::<Pouf1>::new();
         let metadata1 = RepoBuilder::create(&mut local)
             .current_time(Utc.timestamp(0, 0))
             .trusted_root_keys(&[&KEYS[0]])
@@ -1445,7 +1445,7 @@ mod test {
             .unwrap();
 
         // Remote repo has unexpired metadata.
-        let mut remote = EphemeralRepository::<Json>::new();
+        let mut remote = EphemeralRepository::<Pouf1>::new();
         let metadata2 = RepoBuilder::create(&mut remote)
             .trusted_root_keys(&[&KEYS[0]])
             .trusted_targets_keys(&[&KEYS[0]])
@@ -1591,8 +1591,8 @@ mod test {
     #[test]
     fn constructor_succeeds_with_missing_metadata() {
         block_on(async {
-            let mut local = EphemeralRepository::<Json>::new();
-            let remote = EphemeralRepository::<Json>::new();
+            let mut local = EphemeralRepository::<Pouf1>::new();
+            let remote = EphemeralRepository::<Pouf1>::new();
 
             // Store only a root in the local store.
             let metadata1 = RepoBuilder::create(&mut local)
@@ -1693,8 +1693,8 @@ mod test {
     #[test]
     fn constructor_succeeds_with_expired_metadata() {
         block_on(async {
-            let mut local = EphemeralRepository::<Json>::new();
-            let remote = EphemeralRepository::<Json>::new();
+            let mut local = EphemeralRepository::<Pouf1>::new();
+            let remote = EphemeralRepository::<Pouf1>::new();
 
             // Store an expired root in the local store.
             let metadata1 = RepoBuilder::create(&mut local)
@@ -1788,7 +1788,7 @@ mod test {
     fn constructor_succeeds_with_malformed_metadata() {
         block_on(async {
             // Store a malformed timestamp in the local repository.
-            let local = EphemeralRepository::<Json>::new();
+            let local = EphemeralRepository::<Pouf1>::new();
             let junk_timestamp = "junk timestamp";
 
             local
@@ -1801,7 +1801,7 @@ mod test {
                 .unwrap();
 
             // Create a normal repository on the remote server.
-            let mut remote = EphemeralRepository::<Json>::new();
+            let mut remote = EphemeralRepository::<Pouf1>::new();
             let metadata1 = RepoBuilder::create(&mut remote)
                 .trusted_root_keys(&[&KEYS[0]])
                 .trusted_targets_keys(&[&KEYS[0]])
@@ -1859,7 +1859,7 @@ mod test {
     }
 
     async fn root_chain_update(consistent_snapshot: bool) {
-        let mut repo = EphemeralRepository::<Json>::new();
+        let mut repo = EphemeralRepository::<Pouf1>::new();
 
         // First, create the initial metadata. We want to use the same non-root
         // metadata, so sign it with all the keys.
@@ -2083,7 +2083,7 @@ mod test {
 
     async fn test_fetch_target_description(path: String, expected_description: TargetDescription) {
         // Generate an ephemeral repository with a single target.
-        let mut remote = EphemeralRepository::<Json>::new();
+        let mut remote = EphemeralRepository::<Pouf1>::new();
 
         let metadata = RepoBuilder::create(&mut remote)
             .trusted_root_keys(&[&KEYS[0]])
@@ -2127,7 +2127,7 @@ mod test {
     #[test]
     fn update_eventually_succeeds_if_cannot_write_to_repo() {
         block_on(async {
-            let mut remote = EphemeralRepository::<Json>::new();
+            let mut remote = EphemeralRepository::<Pouf1>::new();
 
             // First, create the metadata.
             let _ = RepoBuilder::create(&mut remote)
@@ -2225,8 +2225,8 @@ mod test {
     #[test]
     fn test_local_and_remote_repo_methods() {
         block_on(async {
-            let local = EphemeralRepository::<Json>::new();
-            let mut remote = EphemeralRepository::<Json>::new();
+            let local = EphemeralRepository::<Pouf1>::new();
+            let mut remote = EphemeralRepository::<Pouf1>::new();
 
             let metadata1 = RepoBuilder::create(&mut remote)
                 .trusted_root_keys(&[&KEYS[0]])
@@ -2258,7 +2258,7 @@ mod test {
 
             // Generate some new metadata.
             let metadata2 = RepoBuilder::from_database(
-                &mut EphemeralRepository::<Json>::new(),
+                &mut EphemeralRepository::<Pouf1>::new(),
                 client.database(),
             )
             .trusted_root_keys(&[&KEYS[0]])
@@ -2330,7 +2330,7 @@ mod test {
     #[test]
     fn client_can_update_with_unknown_len_and_hashes() {
         block_on(async {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             let root = RootMetadataBuilder::new()
                 .consistent_snapshot(true)
@@ -2338,7 +2338,7 @@ mod test {
                 .targets_key(KEYS[1].public().clone())
                 .snapshot_key(KEYS[2].public().clone())
                 .timestamp_key(KEYS[3].public().clone())
-                .signed::<Json>(&KEYS[0])
+                .signed::<Pouf1>(&KEYS[0])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -2352,7 +2352,7 @@ mod test {
             .unwrap();
 
             let targets = TargetsMetadataBuilder::new()
-                .signed::<Json>(&KEYS[1])
+                .signed::<Pouf1>(&KEYS[1])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -2371,7 +2371,7 @@ mod test {
 
             let snapshot = SnapshotMetadataBuilder::new()
                 .insert_metadata_description(MetadataPath::targets(), targets_description)
-                .signed::<Json>(&KEYS[2])
+                .signed::<Pouf1>(&KEYS[2])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -2390,7 +2390,7 @@ mod test {
 
             let timestamp =
                 TimestampMetadataBuilder::from_metadata_description(snapshot_description)
-                    .signed::<Json>(&KEYS[3])
+                    .signed::<Pouf1>(&KEYS[3])
                     .unwrap()
                     .to_raw()
                     .unwrap();
diff --git a/tuf/src/crypto.rs b/tuf/src/crypto.rs
index 9d669ca..c901652 100644
--- a/tuf/src/crypto.rs
+++ b/tuf/src/crypto.rs
@@ -41,7 +41,7 @@ use {
 
 use crate::error::{derp_error_to_error, Error, Result};
 use crate::metadata::MetadataPath;
-use crate::pouf::cjson::shims;
+use crate::pouf::pouf1::shims;
 
 const HASH_ALG_PREFS: &[HashAlgorithm] = &[HashAlgorithm::Sha512, HashAlgorithm::Sha256];
 
@@ -236,7 +236,7 @@ fn calculate_key_id(
     keyid_hash_algorithms: &Option<Vec<String>>,
     public_key: &[u8],
 ) -> Result<KeyId> {
-    use crate::pouf::{Json, Pouf};
+    use crate::pouf::{Pouf, Pouf1};
 
     let public_key = shim_public_key(
         key_type,
@@ -244,7 +244,7 @@ fn calculate_key_id(
         keyid_hash_algorithms,
         public_key,
     )?;
-    let public_key = Json::canonicalize(&Json::serialize(&public_key)?)?;
+    let public_key = Pouf1::canonicalize(&Pouf1::serialize(&public_key)?)?;
     let mut context = digest::Context::new(&SHA256);
     context.update(&public_key);
 
diff --git a/tuf/src/database.rs b/tuf/src/database.rs
index eddee13..b390cbe 100644
--- a/tuf/src/database.rs
+++ b/tuf/src/database.rs
@@ -1062,7 +1062,7 @@ mod test {
         RawSignedMetadataSetBuilder, RootMetadataBuilder, SnapshotMetadataBuilder,
         TargetsMetadataBuilder, TimestampMetadataBuilder,
     };
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use assert_matches::assert_matches;
     use lazy_static::lazy_static;
     use std::iter::once;
@@ -1090,7 +1090,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap();
         let raw_root = root.to_raw().unwrap();
 
@@ -1107,7 +1107,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap();
         let raw_root = root.to_raw().unwrap();
 
@@ -1129,7 +1129,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1146,7 +1146,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1171,7 +1171,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1191,7 +1191,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1216,7 +1216,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1229,7 +1229,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[1].public().clone())
             .timestamp_key(KEYS[1].public().clone())
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
 
         // add the original key's signature to make it cross signed
@@ -1253,7 +1253,7 @@ mod test {
             .snapshot_key(KEYS[0].public().clone())
             .targets_key(KEYS[0].public().clone())
             .timestamp_key(KEYS[0].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1265,7 +1265,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[1].public().clone())
             .timestamp_key(KEYS[1].public().clone())
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1282,7 +1282,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[1].public().clone())
             .timestamp_key(KEYS[1].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1290,13 +1290,13 @@ mod test {
         let mut tuf = Database::from_trusted_root(&raw_root).unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
 
         let timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[1])
+                .signed::<Pouf1>(&KEYS[1])
                 .unwrap();
         let raw_timestamp = timestamp.to_raw().unwrap();
 
@@ -1318,7 +1318,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[1].public().clone())
             .timestamp_key(KEYS[1].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1326,14 +1326,14 @@ mod test {
         let mut tuf = Database::from_trusted_root(&raw_root).unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
 
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
                 // sign it with the root key
-                .signed::<Json>(&KEYS[0])
+                .signed::<Pouf1>(&KEYS[0])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1350,7 +1350,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[2].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1363,7 +1363,7 @@ mod test {
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[2])
+                .signed::<Pouf1>(&KEYS[2])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1385,7 +1385,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[2].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1393,7 +1393,7 @@ mod test {
         let mut tuf = Database::from_trusted_root(&raw_root).unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_snapshot = snapshot.to_raw().unwrap();
 
@@ -1401,7 +1401,7 @@ mod test {
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
                 // sign it with the targets key
-                .signed::<Json>(&KEYS[2])
+                .signed::<Pouf1>(&KEYS[2])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1420,7 +1420,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[2].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1429,13 +1429,13 @@ mod test {
 
         let snapshot = SnapshotMetadataBuilder::new()
             .version(2)
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
 
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[2])
+                .signed::<Pouf1>(&KEYS[2])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1444,7 +1444,7 @@ mod test {
 
         let raw_snapshot = SnapshotMetadataBuilder::new()
             .version(1)
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1461,7 +1461,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1469,21 +1469,21 @@ mod test {
         let mut tuf = Database::from_trusted_root(&raw_root).unwrap();
 
         let signed_targets = TargetsMetadataBuilder::new()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_targets = signed_targets.to_raw().unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
             .insert_metadata(&signed_targets, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_snapshot = snapshot.to_raw().unwrap();
 
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1506,7 +1506,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1515,21 +1515,21 @@ mod test {
 
         let signed_targets = TargetsMetadataBuilder::new()
             // sign it with the timestamp key
-            .signed::<Json>(&KEYS[3])
+            .signed::<Pouf1>(&KEYS[3])
             .unwrap();
         let raw_targets = signed_targets.to_raw().unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
             .insert_metadata(&signed_targets, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_snapshot = snapshot.to_raw().unwrap();
 
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1549,7 +1549,7 @@ mod test {
             .snapshot_key(KEYS[1].public().clone())
             .targets_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1558,20 +1558,20 @@ mod test {
 
         let signed_targets = TargetsMetadataBuilder::new()
             .version(2)
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
             .insert_metadata(&signed_targets, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_snapshot = snapshot.to_raw().unwrap();
 
         let raw_timestamp =
             TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1581,7 +1581,7 @@ mod test {
 
         let raw_targets = TargetsMetadataBuilder::new()
             .version(1)
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap()
             .to_raw()
             .unwrap();
@@ -1596,27 +1596,27 @@ mod test {
             .targets_key(KEYS[1].public().clone())
             .snapshot_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
 
         let signed_targets1 = TargetsMetadataBuilder::new()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_targets1 = signed_targets1.to_raw().unwrap();
 
         let snapshot1 = SnapshotMetadataBuilder::new()
             .insert_metadata(&signed_targets1, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_snapshot1 = snapshot1.to_raw().unwrap();
 
         let raw_timestamp1 =
             TimestampMetadataBuilder::from_snapshot(&snapshot1, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1636,14 +1636,14 @@ mod test {
             .targets_key(KEYS[1].public().clone())
             .snapshot_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
 
         let signed_targets2 = TargetsMetadataBuilder::new()
             .version(2)
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_targets2 = signed_targets2.to_raw().unwrap();
 
@@ -1651,7 +1651,7 @@ mod test {
             .version(2)
             .insert_metadata(&signed_targets2, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_snapshot2 = snapshot2.to_raw().unwrap();
 
@@ -1659,7 +1659,7 @@ mod test {
             TimestampMetadataBuilder::from_snapshot(&snapshot2, &[HashAlgorithm::Sha256])
                 .unwrap()
                 .version(2)
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1681,27 +1681,27 @@ mod test {
             .targets_key(KEYS[1].public().clone())
             .snapshot_key(KEYS[2].public().clone())
             .timestamp_key(KEYS[3].public().clone())
-            .signed::<Json>(&KEYS[0])
+            .signed::<Pouf1>(&KEYS[0])
             .unwrap()
             .to_raw()
             .unwrap();
 
         let signed_targets1 = TargetsMetadataBuilder::new()
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_targets1 = signed_targets1.to_raw().unwrap();
 
         let snapshot1 = SnapshotMetadataBuilder::new()
             .insert_metadata(&signed_targets1, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_snapshot1 = snapshot1.to_raw().unwrap();
 
         let raw_timestamp1 =
             TimestampMetadataBuilder::from_snapshot(&snapshot1, &[HashAlgorithm::Sha256])
                 .unwrap()
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
@@ -1721,14 +1721,14 @@ mod test {
             .targets_key(KEYS[2].public().clone())
             .snapshot_key(KEYS[3].public().clone())
             .timestamp_key(KEYS[4].public().clone())
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap()
             .to_raw()
             .unwrap();
 
         let signed_targets2 = TargetsMetadataBuilder::new()
             .version(2)
-            .signed::<Json>(&KEYS[1])
+            .signed::<Pouf1>(&KEYS[1])
             .unwrap();
         let raw_targets2 = signed_targets2.to_raw().unwrap();
 
@@ -1736,7 +1736,7 @@ mod test {
             .version(2)
             .insert_metadata(&signed_targets2, &[HashAlgorithm::Sha256])
             .unwrap()
-            .signed::<Json>(&KEYS[2])
+            .signed::<Pouf1>(&KEYS[2])
             .unwrap();
         let raw_snapshot2 = snapshot2.to_raw().unwrap();
 
@@ -1744,7 +1744,7 @@ mod test {
             TimestampMetadataBuilder::from_snapshot(&snapshot2, &[HashAlgorithm::Sha256])
                 .unwrap()
                 .version(2)
-                .signed::<Json>(&KEYS[3])
+                .signed::<Pouf1>(&KEYS[3])
                 .unwrap()
                 .to_raw()
                 .unwrap();
diff --git a/tuf/src/metadata.rs b/tuf/src/metadata.rs
index 1cde85c..f8044f4 100644
--- a/tuf/src/metadata.rs
+++ b/tuf/src/metadata.rs
@@ -14,7 +14,7 @@ use std::str;
 
 use crate::crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
 use crate::error::Error;
-use crate::pouf::cjson::shims;
+use crate::pouf::pouf1::shims;
 use crate::pouf::Pouf;
 use crate::Result;
 
@@ -459,14 +459,14 @@ where
     /// ```
     /// # use chrono::prelude::*;
     /// # use tuf::crypto::{Ed25519PrivateKey, PrivateKey, SignatureScheme, HashAlgorithm};
-    /// # use tuf::pouf::Json;
+    /// # use tuf::pouf::Pouf1;
     /// # use tuf::metadata::{SignedMetadata, SnapshotMetadataBuilder};
     /// #
     /// # let key: &[u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
     /// let key = Ed25519PrivateKey::from_pkcs8(&key).unwrap();
     ///
     /// let snapshot = SnapshotMetadataBuilder::new().build().unwrap();
-    /// SignedMetadata::<Json, _>::new(&snapshot, &key).unwrap();
+    /// SignedMetadata::<Pouf1, _>::new(&snapshot, &key).unwrap();
     /// ```
     pub fn new(metadata: &M, private_key: &dyn PrivateKey) -> Result<Self> {
         let raw = D::serialize(metadata)?;
@@ -507,7 +507,7 @@ where
     /// ```
     /// # use chrono::prelude::*;
     /// # use tuf::crypto::{Ed25519PrivateKey, PrivateKey, SignatureScheme, HashAlgorithm};
-    /// # use tuf::pouf::Json;
+    /// # use tuf::pouf::Pouf1;
     /// # use tuf::metadata::{SignedMetadata, SnapshotMetadataBuilder};
     /// #
     /// let key_1: &[u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
@@ -519,7 +519,7 @@ where
     /// let key_2 = Ed25519PrivateKey::from_pkcs8(&key_2).unwrap();
     ///
     /// let snapshot = SnapshotMetadataBuilder::new().build().unwrap();
-    /// let mut snapshot = SignedMetadata::<Json, _>::new(&snapshot, &key_1).unwrap();
+    /// let mut snapshot = SignedMetadata::<Pouf1, _>::new(&snapshot, &key_1).unwrap();
     ///
     /// snapshot.add_signature(&key_2).unwrap();
     /// assert_eq!(snapshot.signatures().len(), 2);
@@ -1025,13 +1025,13 @@ impl MetadataPath {
     ///
     /// ```
     /// # use tuf::crypto::HashValue;
-    /// # use tuf::pouf::Json;
+    /// # use tuf::pouf::Pouf1;
     /// # use tuf::metadata::{MetadataPath, MetadataVersion};
     /// #
     /// let path = MetadataPath::new("foo/bar").unwrap();
-    /// assert_eq!(path.components::<Json>(MetadataVersion::None),
+    /// assert_eq!(path.components::<Pouf1>(MetadataVersion::None),
     ///            ["foo".to_string(), "bar.json".to_string()]);
-    /// assert_eq!(path.components::<Json>(MetadataVersion::Number(1)),
+    /// assert_eq!(path.components::<Pouf1>(MetadataVersion::Number(1)),
     ///            ["foo".to_string(), "1.bar.json".to_string()]);
     /// ```
     pub fn components<D>(&self, version: MetadataVersion) -> Vec<String>
@@ -2282,7 +2282,7 @@ impl DelegationBuilder {
 mod test {
     use super::*;
     use crate::crypto::Ed25519PrivateKey;
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use crate::verify::verify_signatures;
     use assert_matches::assert_matches;
     use chrono::prelude::*;
@@ -2614,7 +2614,7 @@ mod test {
     #[test]
     fn de_ser_root_metadata_wrong_key_id() {
         let jsn = jsn_root_metadata_without_keyid_hash_algos();
-        let mut jsn_str = str::from_utf8(&Json::canonicalize(&jsn).unwrap())
+        let mut jsn_str = str::from_utf8(&Pouf1::canonicalize(&jsn).unwrap())
             .unwrap()
             .to_owned();
         // Replace the key id to something else.
@@ -2632,7 +2632,7 @@ mod test {
         let root_key = Ed25519PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
         let decoded: RootMetadata = serde_json::from_value(jsn).unwrap();
 
-        let signed: SignedMetadata<crate::pouf::cjson::Json, _> =
+        let signed: SignedMetadata<crate::pouf::pouf1::Pouf1, _> =
             SignedMetadata::new(&decoded, &root_key).unwrap();
         let raw_root = signed.to_raw().unwrap();
 
@@ -2657,7 +2657,7 @@ mod test {
             "signed": jsn_root_metadata_without_keyid_hash_algos()
         });
         let root_key = Ed25519PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
-        let decoded: SignedMetadata<crate::pouf::cjson::Json, RootMetadata> =
+        let decoded: SignedMetadata<crate::pouf::pouf1::Pouf1, RootMetadata> =
             serde_json::from_value(jsn).unwrap();
         let raw_root = decoded.to_raw().unwrap();
 
@@ -2686,7 +2686,7 @@ mod test {
             "signed": jsn_root_metadata_without_keyid_hash_algos()
         });
         let root_key = Ed25519PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
-        let decoded: SignedMetadata<crate::pouf::cjson::Json, RootMetadata> =
+        let decoded: SignedMetadata<crate::pouf::pouf1::Pouf1, RootMetadata> =
             serde_json::from_value(jsn).unwrap();
         let raw_root = decoded.to_raw().unwrap();
         assert_matches!(
@@ -2716,7 +2716,7 @@ mod test {
         let key = Ed25519PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
         let public_keys = vec![key.public().clone()];
 
-        let mut standard = SignedMetadataBuilder::<Json, M>::from_raw_metadata(metadata.clone())
+        let mut standard = SignedMetadataBuilder::<Pouf1, M>::from_raw_metadata(metadata.clone())
             .unwrap()
             .sign(&key)
             .unwrap()
@@ -2733,7 +2733,7 @@ mod test {
                 "this-too": 42,
             }),
         );
-        let mut custom = SignedMetadataBuilder::<Json, M>::from_raw_metadata(metadata)
+        let mut custom = SignedMetadataBuilder::<Pouf1, M>::from_raw_metadata(metadata)
             .unwrap()
             .sign(&key)
             .unwrap()
@@ -3157,7 +3157,7 @@ mod test {
 
         let key = Ed25519PrivateKey::from_pkcs8(ED25519_1_PK8).unwrap();
 
-        let signed = SignedMetadata::<Json, _>::new(&snapshot, &key).unwrap();
+        let signed = SignedMetadata::<Pouf1, _>::new(&snapshot, &key).unwrap();
 
         let jsn = json!({
             "signatures": [
@@ -3187,7 +3187,7 @@ mod test {
 
         let encoded = serde_json::to_value(&signed).unwrap();
         assert_eq!(encoded, jsn, "{:#?} != {:#?}", encoded, jsn);
-        let decoded: SignedMetadata<Json, SnapshotMetadata> =
+        let decoded: SignedMetadata<Pouf1, SnapshotMetadata> =
             serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, signed);
     }
diff --git a/tuf/src/pouf/mod.rs b/tuf/src/pouf/mod.rs
index 4fa5bb1..4ff8db7 100644
--- a/tuf/src/pouf/mod.rs
+++ b/tuf/src/pouf/mod.rs
@@ -1,7 +1,7 @@
 //! Structures and functions to aid in various TUF data pouf formats.
 
-pub(crate) mod cjson;
-pub use cjson::{Json, JsonPretty};
+pub(crate) mod pouf1;
+pub use pouf1::Pouf1;
 
 use serde::de::DeserializeOwned;
 use serde::ser::Serialize;
diff --git a/tuf/src/pouf/cjson/mod.rs b/tuf/src/pouf/pouf1/mod.rs
similarity index 92%
rename from tuf/src/pouf/cjson/mod.rs
rename to tuf/src/pouf/pouf1/mod.rs
index 9557aba..758ce92 100644
--- a/tuf/src/pouf/cjson/mod.rs
+++ b/tuf/src/pouf/pouf1/mod.rs
@@ -6,18 +6,12 @@ use crate::error::Error;
 use crate::pouf::Pouf;
 use crate::Result;
 
-pub(crate) mod pretty;
 pub(crate) mod shims;
 
-pub use pretty::JsonPretty;
-
-/// JSON data pouf.
+/// TUF POUF-1 implementation.
 ///
 /// # Schema
 ///
-/// This doesn't use JSON Schema because that specification language is rage inducing. Here's
-/// something else instead.
-///
 /// ## Common Entities
 ///
 /// `NATURAL_NUMBER` is an integer in the range `[1, 2**32)`.
@@ -182,25 +176,25 @@ pub use pretty::JsonPretty;
 /// }
 /// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Json;
+pub struct Pouf1;
 
-impl Pouf for Json {
+impl Pouf for Pouf1 {
     type RawData = serde_json::Value;
 
     /// ```
-    /// # use tuf::pouf::{Pouf, Json};
-    /// assert_eq!(Json::extension(), "json");
+    /// # use tuf::pouf::{Pouf, Pouf1};
+    /// assert_eq!(Pouf1::extension(), "json");
     /// ```
     fn extension() -> &'static str {
         "json"
     }
 
     /// ```
-    /// # use tuf::pouf::{Pouf, Json};
+    /// # use tuf::pouf::{Pouf, Pouf1};
     /// # use std::collections::HashMap;
     /// let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
-    /// let raw = Json::from_slice(jsn).unwrap();
-    /// let out = Json::canonicalize(&raw).unwrap();
+    /// let raw = Pouf1::from_slice(jsn).unwrap();
+    /// let out = Pouf1::canonicalize(&raw).unwrap();
     /// assert_eq!(out, br#"{"baz":"quux","foo":"bar"}"#);
     /// ```
     fn canonicalize(raw_data: &Self::RawData) -> Result<Vec<u8>> {
@@ -211,7 +205,7 @@ impl Pouf for Json {
     /// # use serde_derive::Deserialize;
     /// # use serde_json::json;
     /// # use std::collections::HashMap;
-    /// # use tuf::pouf::{Pouf, Json};
+    /// # use tuf::pouf::{Pouf, Pouf1};
     /// #
     /// #[derive(Deserialize, Debug, PartialEq)]
     /// struct Thing {
@@ -221,7 +215,7 @@ impl Pouf for Json {
     ///
     /// let jsn = json!({"foo": "wat", "bar": "lol"});
     /// let thing = Thing { foo: "wat".into(), bar: "lol".into() };
-    /// let de: Thing = Json::deserialize(&jsn).unwrap();
+    /// let de: Thing = Pouf1::deserialize(&jsn).unwrap();
     /// assert_eq!(de, thing);
     /// ```
     fn deserialize<T>(raw_data: &Self::RawData) -> Result<T>
@@ -235,7 +229,7 @@ impl Pouf for Json {
     /// # use serde_derive::Serialize;
     /// # use serde_json::json;
     /// # use std::collections::HashMap;
-    /// # use tuf::pouf::{Pouf, Json};
+    /// # use tuf::pouf::{Pouf, Pouf1};
     /// #
     /// #[derive(Serialize)]
     /// struct Thing {
@@ -245,7 +239,7 @@ impl Pouf for Json {
     ///
     /// let jsn = json!({"foo": "wat", "bar": "lol"});
     /// let thing = Thing { foo: "wat".into(), bar: "lol".into() };
-    /// let se: serde_json::Value = Json::serialize(&thing).unwrap();
+    /// let se: serde_json::Value = Pouf1::serialize(&thing).unwrap();
     /// assert_eq!(se, jsn);
     /// ```
     fn serialize<T>(data: &T) -> Result<Self::RawData>
@@ -256,10 +250,10 @@ impl Pouf for Json {
     }
 
     /// ```
-    /// # use tuf::pouf::{Pouf, Json};
+    /// # use tuf::pouf::{Pouf, Pouf1};
     /// # use std::collections::HashMap;
     /// let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
-    /// let _: HashMap<String, String> = Json::from_slice(&jsn).unwrap();
+    /// let _: HashMap<String, String> = Pouf1::from_slice(&jsn).unwrap();
     /// ```
     fn from_slice<T>(slice: &[u8]) -> Result<T>
     where
diff --git a/tuf/src/pouf/cjson/shims.rs b/tuf/src/pouf/pouf1/shims.rs
similarity index 100%
rename from tuf/src/pouf/cjson/shims.rs
rename to tuf/src/pouf/pouf1/shims.rs
diff --git a/tuf/src/repo_builder.rs b/tuf/src/repo_builder.rs
index 7ef37cf..4bb713a 100644
--- a/tuf/src/repo_builder.rs
+++ b/tuf/src/repo_builder.rs
@@ -382,7 +382,7 @@ where
     /// # use {
     /// #     futures_executor::block_on,
     /// #     tuf::{
-    /// #         pouf::Json,
+    /// #         pouf::Pouf1,
     /// #         crypto::Ed25519PrivateKey,
     /// #         repo_builder::RepoBuilder,
     /// #         repository::EphemeralRepository,
@@ -394,7 +394,7 @@ where
     /// # ).unwrap();
     /// #
     /// # block_on(async {
-    /// let mut repo = EphemeralRepository::<Json>::new();
+    /// let mut repo = EphemeralRepository::<Pouf1>::new();
     /// let _metadata = RepoBuilder::create(&mut repo)
     ///     .trusted_root_keys(&[&key])
     ///     .trusted_targets_keys(&[&key])
@@ -448,7 +448,7 @@ where
     /// #     tuf::{
     /// #         database::Database,
     /// #         crypto::Ed25519PrivateKey,
-    /// #         pouf::Json,
+    /// #         pouf::Pouf1,
     /// #         repo_builder::RepoBuilder,
     /// #         repository::EphemeralRepository,
     /// #     },
@@ -459,7 +459,7 @@ where
     /// # ).unwrap();
     /// #
     /// # block_on(async {
-    ///  let mut repo = EphemeralRepository::<Json>::new();
+    ///  let mut repo = EphemeralRepository::<Pouf1>::new();
     ///  let metadata1 = RepoBuilder::create(&mut repo)
     ///     .trusted_root_keys(&[&key])
     ///     .trusted_targets_keys(&[&key])
@@ -1576,7 +1576,7 @@ mod tests {
             client::{Client, Config},
             crypto::Ed25519PrivateKey,
             metadata::SignedMetadata,
-            pouf::Json,
+            pouf::Pouf1,
             repository::{EphemeralRepository, RepositoryProvider},
         },
         assert_matches::assert_matches,
@@ -1612,7 +1612,7 @@ mod tests {
         version: u32,
         consistent_snapshot: bool,
         expires: DateTime<Utc>,
-    ) -> SignedMetadata<Json, RootMetadata> {
+    ) -> SignedMetadata<Pouf1, RootMetadata> {
         let root = RootMetadataBuilder::new()
             .version(version)
             .consistent_snapshot(consistent_snapshot)
@@ -1650,13 +1650,13 @@ mod tests {
     fn create_targets(
         version: u32,
         expires: DateTime<Utc>,
-    ) -> SignedMetadata<Json, TargetsMetadata> {
+    ) -> SignedMetadata<Pouf1, TargetsMetadata> {
         let targets = TargetsMetadataBuilder::new()
             .version(version)
             .expires(expires)
             .build()
             .unwrap();
-        SignedMetadataBuilder::<Json, _>::from_metadata(&targets)
+        SignedMetadataBuilder::<Pouf1, _>::from_metadata(&targets)
             .unwrap()
             .sign(&KEYS[1])
             .unwrap()
@@ -1670,9 +1670,9 @@ mod tests {
     fn create_snapshot(
         version: u32,
         expires: DateTime<Utc>,
-        targets: &SignedMetadata<Json, TargetsMetadata>,
+        targets: &SignedMetadata<Pouf1, TargetsMetadata>,
         include_length_and_hashes: bool,
-    ) -> SignedMetadata<Json, SnapshotMetadata> {
+    ) -> SignedMetadata<Pouf1, SnapshotMetadata> {
         let description = if include_length_and_hashes {
             let raw_targets = targets.to_raw().unwrap();
             let hashes = crypto::calculate_hashes_from_slice(
@@ -1692,7 +1692,7 @@ mod tests {
             .expires(expires)
             .build()
             .unwrap();
-        SignedMetadataBuilder::<Json, _>::from_metadata(&snapshot)
+        SignedMetadataBuilder::<Pouf1, _>::from_metadata(&snapshot)
             .unwrap()
             .sign(&KEYS[2])
             .unwrap()
@@ -1706,9 +1706,9 @@ mod tests {
     fn create_timestamp(
         version: u32,
         expires: DateTime<Utc>,
-        snapshot: &SignedMetadata<Json, SnapshotMetadata>,
+        snapshot: &SignedMetadata<Pouf1, SnapshotMetadata>,
         include_length_and_hashes: bool,
-    ) -> SignedMetadata<Json, TimestampMetadata> {
+    ) -> SignedMetadata<Pouf1, TimestampMetadata> {
         let description = if include_length_and_hashes {
             let raw_snapshot = snapshot.to_raw().unwrap();
             let hashes = crypto::calculate_hashes_from_slice(
@@ -1727,7 +1727,7 @@ mod tests {
             .expires(expires)
             .build()
             .unwrap();
-        SignedMetadataBuilder::<Json, _>::from_metadata(&timestamp)
+        SignedMetadataBuilder::<Pouf1, _>::from_metadata(&timestamp)
             .unwrap()
             .sign(&KEYS[3])
             .unwrap()
@@ -1739,11 +1739,11 @@ mod tests {
     }
 
     fn assert_metadata(
-        metadata: &RawSignedMetadataSet<Json>,
-        expected_root: Option<&RawSignedMetadata<Json, RootMetadata>>,
-        expected_targets: Option<&RawSignedMetadata<Json, TargetsMetadata>>,
-        expected_snapshot: Option<&RawSignedMetadata<Json, SnapshotMetadata>>,
-        expected_timestamp: Option<&RawSignedMetadata<Json, TimestampMetadata>>,
+        metadata: &RawSignedMetadataSet<Pouf1>,
+        expected_root: Option<&RawSignedMetadata<Pouf1, RootMetadata>>,
+        expected_targets: Option<&RawSignedMetadata<Pouf1, TargetsMetadata>>,
+        expected_snapshot: Option<&RawSignedMetadata<Pouf1, SnapshotMetadata>>,
+        expected_timestamp: Option<&RawSignedMetadata<Pouf1, TimestampMetadata>>,
     ) {
         assert_eq!(
             metadata.root().map(|m| m.parse_untrusted().unwrap()),
@@ -1764,7 +1764,7 @@ mod tests {
     }
 
     fn assert_repo(
-        repo: &EphemeralRepository<Json>,
+        repo: &EphemeralRepository<Pouf1>,
         expected_metadata: &BTreeMap<(MetadataPath, MetadataVersion), &[u8]>,
     ) {
         let actual_metadata = repo
@@ -1797,7 +1797,7 @@ mod tests {
 
     async fn check_stage_and_update_repo(consistent_snapshot: bool) {
         // We'll write all the metadata to this remote repository.
-        let mut remote = EphemeralRepository::<Json>::new();
+        let mut remote = EphemeralRepository::<Pouf1>::new();
 
         // First, create the metadata.
         let expires1 = Utc.ymd(2038, 1, 1).and_hms(0, 0, 0);
@@ -2028,7 +2028,7 @@ mod tests {
     }
 
     async fn commit_does_nothing_if_nothing_changed(consistent_snapshot: bool) {
-        let mut repo = EphemeralRepository::<Json>::new();
+        let mut repo = EphemeralRepository::<Pouf1>::new();
         let metadata1 = RepoBuilder::create(&mut repo)
             .trusted_root_keys(&[&KEYS[0]])
             .trusted_targets_keys(&[&KEYS[0]])
@@ -2082,7 +2082,7 @@ mod tests {
     }
 
     async fn check_root_chain_update(consistent_snapshot: bool) {
-        let mut repo = EphemeralRepository::<Json>::new();
+        let mut repo = EphemeralRepository::<Pouf1>::new();
 
         // First, create the initial metadata. We initially sign the root
         // metadata with key 1.
@@ -2189,7 +2189,7 @@ mod tests {
     #[test]
     fn test_from_database_root_must_be_one_after_the_last() {
         block_on(async {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
             let metadata = RepoBuilder::create(&mut repo)
                 .trusted_root_keys(&[&KEYS[0]])
                 .trusted_targets_keys(&[&KEYS[0]])
@@ -2224,7 +2224,7 @@ mod tests {
     #[test]
     fn test_add_target_not_consistent_snapshot() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let hash_algs = &[HashAlgorithm::Sha256, HashAlgorithm::Sha512];
 
@@ -2318,7 +2318,7 @@ mod tests {
     #[test]
     fn test_add_target_consistent_snapshot() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let hash_algs = &[HashAlgorithm::Sha256, HashAlgorithm::Sha512];
 
@@ -2415,7 +2415,7 @@ mod tests {
     #[test]
     fn test_do_not_require_all_keys_to_be_online() {
         block_on(async {
-            let mut remote = EphemeralRepository::<Json>::new();
+            let mut remote = EphemeralRepository::<Pouf1>::new();
 
             // First, write some metadata to the repo.
             let expires1 = Utc.ymd(2038, 1, 1).and_hms(0, 0, 0);
@@ -2612,7 +2612,7 @@ mod tests {
     #[test]
     fn test_builder_inherits_from_trusted_targets() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let expires = Utc.ymd(2038, 1, 4).and_hms(0, 0, 0);
             let hash_algs = &[HashAlgorithm::Sha256, HashAlgorithm::Sha512];
@@ -2638,7 +2638,7 @@ mod tests {
                     &[HashAlgorithm::Sha256],
                 )
                 .unwrap()
-                .signed::<Json>(delegation_key)
+                .signed::<Pouf1>(delegation_key)
                 .unwrap();
             let raw_delegated_targets = delegated_targets1.to_raw().unwrap();
 
@@ -2696,7 +2696,7 @@ mod tests {
                     &[HashAlgorithm::Sha256],
                 )
                 .unwrap()
-                .signed::<Json>(delegation_key)
+                .signed::<Pouf1>(delegation_key)
                 .unwrap();
             let raw_delegated_targets = delegated_targets2.to_raw().unwrap();
 
@@ -2758,7 +2758,7 @@ mod tests {
     #[test]
     fn test_builder_rotating_keys_refreshes_metadata() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let metadata1 = RepoBuilder::create(&mut repo)
                 .trusted_root_keys(&[&KEYS[0]])
@@ -2872,7 +2872,7 @@ mod tests {
     #[test]
     fn test_builder_expired_metadata_refreshes_metadata() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let epoch = Utc.timestamp(0, 0);
             let root_expires = Duration::seconds(40);
@@ -3008,7 +3008,7 @@ mod tests {
     #[test]
     fn test_adding_target_refreshes_metadata() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let metadata1 = RepoBuilder::create(&mut repo)
                 .trusted_root_keys(&[&KEYS[0]])
@@ -3053,7 +3053,7 @@ mod tests {
     #[test]
     fn test_time_versioning() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             let current_time = Utc.timestamp(5, 0);
             let metadata = RepoBuilder::create(&mut repo)
@@ -3130,7 +3130,7 @@ mod tests {
     #[test]
     fn test_time_versioning_falls_back_to_monotonic() {
         block_on(async move {
-            let mut repo = EphemeralRepository::<Json>::new();
+            let mut repo = EphemeralRepository::<Pouf1>::new();
 
             // zero timestamp should initialize to 1.
             let current_time = Utc.timestamp(0, 0);
@@ -3183,7 +3183,7 @@ mod tests {
     #[test]
     fn test_builder_errs_if_no_keys() {
         block_on(async move {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             let metadata = RepoBuilder::create(&repo)
                 .trusted_root_keys(&[&KEYS[0]])
diff --git a/tuf/src/repository.rs b/tuf/src/repository.rs
index 0be5d5f..177c497 100644
--- a/tuf/src/repository.rs
+++ b/tuf/src/repository.rs
@@ -379,7 +379,7 @@ where
 mod test {
     use super::*;
     use crate::metadata::{MetadataPath, MetadataVersion, RootMetadata, SnapshotMetadata};
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use crate::repository::EphemeralRepository;
     use assert_matches::assert_matches;
     use futures_executor::block_on;
@@ -387,7 +387,7 @@ mod test {
     #[test]
     fn repository_forwards_not_found_error() {
         block_on(async {
-            let repo = Repository::<_, Json>::new(EphemeralRepository::new());
+            let repo = Repository::<_, Pouf1>::new(EphemeralRepository::new());
 
             assert_matches!(
                 repo.fetch_metadata::<RootMetadata>(
@@ -406,8 +406,8 @@ mod test {
     #[test]
     fn repository_rejects_mismatched_path() {
         block_on(async {
-            let mut repo = Repository::<_, Json>::new(EphemeralRepository::new());
-            let fake_metadata = RawSignedMetadata::<Json, RootMetadata>::new(vec![]);
+            let mut repo = Repository::<_, Pouf1>::new(EphemeralRepository::new());
+            let fake_metadata = RawSignedMetadata::<Pouf1, RootMetadata>::new(vec![]);
 
             repo.store_metadata(&MetadataPath::root(), MetadataVersion::None, &fake_metadata)
                 .await
@@ -442,7 +442,7 @@ mod test {
             let path = MetadataPath::root();
             let version = MetadataVersion::None;
             let data: &[u8] = b"valid metadata";
-            let _metadata = RawSignedMetadata::<Json, RootMetadata>::new(data.to_vec());
+            let _metadata = RawSignedMetadata::<Pouf1, RootMetadata>::new(data.to_vec());
             let data_hash = crypto::calculate_hash(data, &HashAlgorithm::Sha256);
 
             let repo = EphemeralRepository::new();
@@ -450,7 +450,7 @@ mod test {
                 .await
                 .unwrap();
 
-            let client = Repository::<_, Json>::new(repo);
+            let client = Repository::<_, Pouf1>::new(repo);
 
             assert_matches!(
                 client
@@ -478,7 +478,7 @@ mod test {
                 .await
                 .unwrap();
 
-            let client = Repository::<_, Json>::new(repo);
+            let client = Repository::<_, Pouf1>::new(repo);
 
             assert_matches!(
                 client
@@ -500,14 +500,14 @@ mod test {
             let path = MetadataPath::root();
             let version = MetadataVersion::None;
             let data: &[u8] = b"reasonably sized metadata";
-            let _metadata = RawSignedMetadata::<Json, RootMetadata>::new(data.to_vec());
+            let _metadata = RawSignedMetadata::<Pouf1, RootMetadata>::new(data.to_vec());
 
             let repo = EphemeralRepository::new();
             repo.store_metadata(&path, version, &mut &*data)
                 .await
                 .unwrap();
 
-            let client = Repository::<_, Json>::new(repo);
+            let client = Repository::<_, Pouf1>::new(repo);
 
             assert_matches!(
                 client
@@ -530,7 +530,7 @@ mod test {
                 .await
                 .unwrap();
 
-            let client = Repository::<_, Json>::new(repo);
+            let client = Repository::<_, Pouf1>::new(repo);
 
             assert_matches!(
                 client
@@ -545,7 +545,7 @@ mod test {
     fn repository_rejects_corrupt_targets() {
         block_on(async {
             let repo = EphemeralRepository::new();
-            let mut client = Repository::<_, Json>::new(repo);
+            let mut client = Repository::<_, Pouf1>::new(repo);
 
             let data: &[u8] = b"like tears in the rain";
             let target_description =
@@ -575,9 +575,9 @@ mod test {
     #[test]
     fn repository_takes_trait_objects() {
         block_on(async {
-            let repo: Box<dyn RepositoryStorageProvider<Json>> =
+            let repo: Box<dyn RepositoryStorageProvider<Pouf1>> =
                 Box::new(EphemeralRepository::new());
-            let mut client = Repository::<_, Json>::new(repo);
+            let mut client = Repository::<_, Pouf1>::new(repo);
 
             let data: &[u8] = b"like tears in the rain";
             let target_description =
@@ -599,11 +599,11 @@ mod test {
     fn repository_dyn_impls_repository_traits() {
         let mut repo = EphemeralRepository::new();
 
-        fn storage<T: RepositoryStorage<Json>>(_t: T) {}
-        fn provider<T: RepositoryProvider<Json>>(_t: T) {}
+        fn storage<T: RepositoryStorage<Pouf1>>(_t: T) {}
+        fn provider<T: RepositoryProvider<Pouf1>>(_t: T) {}
 
-        provider(&repo as &dyn RepositoryProvider<Json>);
-        provider(&mut repo as &mut dyn RepositoryProvider<Json>);
-        storage(&mut repo as &mut dyn RepositoryStorage<Json>);
+        provider(&repo as &dyn RepositoryProvider<Pouf1>);
+        provider(&mut repo as &mut dyn RepositoryProvider<Pouf1>);
+        storage(&mut repo as &mut dyn RepositoryStorage<Pouf1>);
     }
 }
diff --git a/tuf/src/repository/ephemeral.rs b/tuf/src/repository/ephemeral.rs
index 55fa354..3929f10 100644
--- a/tuf/src/repository/ephemeral.rs
+++ b/tuf/src/repository/ephemeral.rs
@@ -308,7 +308,7 @@ async fn bytes_to_reader<'a>(
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use crate::repository::{fetch_metadata_to_string, fetch_target_to_string};
     use assert_matches::assert_matches;
     use futures_executor::block_on;
@@ -316,7 +316,7 @@ mod test {
     #[test]
     fn ephemeral_repo_targets() {
         block_on(async {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             let path = TargetPath::new("batty").unwrap();
             if let Err(err) = repo.fetch_target(&path).await {
@@ -348,7 +348,7 @@ mod test {
     #[test]
     fn ephemeral_repo_batch_update() {
         block_on(async {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             let meta_path = MetadataPath::new("meta").unwrap();
             let meta_version = MetadataVersion::None;
@@ -449,7 +449,7 @@ mod test {
     #[test]
     fn ephemeral_repo_batch_commit_fails_with_metadata_conflicts() {
         block_on(async {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             // commit() fails if we did nothing to the batch, but the repo changed.
             let batch = repo.batch_update();
@@ -491,7 +491,7 @@ mod test {
     #[test]
     fn ephemeral_repo_batch_commit_fails_with_target_conflicts() {
         block_on(async {
-            let repo = EphemeralRepository::<Json>::new();
+            let repo = EphemeralRepository::<Pouf1>::new();
 
             // commit() fails if we did nothing to the batch, but the repo changed.
             let batch = repo.batch_update();
diff --git a/tuf/src/repository/file_system.rs b/tuf/src/repository/file_system.rs
index 4ec86c5..29f4e2e 100644
--- a/tuf/src/repository/file_system.rs
+++ b/tuf/src/repository/file_system.rs
@@ -491,7 +491,7 @@ mod test {
     use super::*;
     use crate::error::Error;
     use crate::metadata::RootMetadata;
-    use crate::pouf::Json;
+    use crate::pouf::Pouf1;
     use crate::repository::{fetch_metadata_to_string, fetch_target_to_string, Repository};
     use assert_matches::assert_matches;
     use futures_executor::block_on;
@@ -508,7 +508,7 @@ mod test {
             let repo = FileSystemRepositoryBuilder::new(temp_dir.path()).build();
 
             assert_matches!(
-                Repository::<_, Json>::new(repo)
+                Repository::<_, Pouf1>::new(repo)
                     .fetch_metadata::<RootMetadata>(
                         &MetadataPath::root(),
                         MetadataVersion::None,
@@ -532,7 +532,7 @@ mod test {
                 .prefix("rust-tuf")
                 .tempdir()
                 .unwrap();
-            let repo = FileSystemRepositoryBuilder::<Json>::new(temp_dir.path().to_path_buf())
+            let repo = FileSystemRepositoryBuilder::<Pouf1>::new(temp_dir.path().to_path_buf())
                 .metadata_prefix("meta")
                 .targets_prefix("targs")
                 .build();
@@ -577,7 +577,7 @@ mod test {
                 .tempdir()
                 .unwrap();
 
-            let repo = FileSystemRepositoryBuilder::<Json>::new(temp_dir.path().to_path_buf())
+            let repo = FileSystemRepositoryBuilder::<Pouf1>::new(temp_dir.path().to_path_buf())
                 .metadata_prefix("meta")
                 .targets_prefix("targs")
                 .build();
@@ -685,7 +685,7 @@ mod test {
                 .tempdir()
                 .unwrap();
 
-            let repo = FileSystemRepository::<Json>::new(temp_dir.path().to_path_buf());
+            let repo = FileSystemRepository::<Pouf1>::new(temp_dir.path().to_path_buf());
 
             // commit() fails if we did nothing to the batch, but the repo changed.
             let batch = repo.batch_update();
@@ -732,7 +732,7 @@ mod test {
                 .tempdir()
                 .unwrap();
 
-            let repo = FileSystemRepository::<Json>::new(temp_dir.path().to_path_buf());
+            let repo = FileSystemRepository::<Pouf1>::new(temp_dir.path().to_path_buf());
 
             // commit() fails if we did nothing to the batch, but the repo changed.
             let batch = repo.batch_update();
diff --git a/tuf/src/verify.rs b/tuf/src/verify.rs
index 07fdebc..904b464 100644
--- a/tuf/src/verify.rs
+++ b/tuf/src/verify.rs
@@ -36,7 +36,7 @@ impl<T> std::ops::Deref for Verified<T> {
 /// ```
 /// # use chrono::prelude::*;
 /// # use tuf::crypto::{Ed25519PrivateKey, PrivateKey, SignatureScheme, HashAlgorithm};
-/// # use tuf::pouf::Json;
+/// # use tuf::pouf::Pouf1;
 /// # use tuf::metadata::{MetadataPath, SnapshotMetadataBuilder, SignedMetadata};
 /// # use tuf::verify::verify_signatures;
 ///
@@ -47,7 +47,7 @@ impl<T> std::ops::Deref for Verified<T> {
 /// let key_2 = Ed25519PrivateKey::from_pkcs8(&key_2).unwrap();
 ///
 /// let raw_snapshot = SnapshotMetadataBuilder::new()
-///     .signed::<Json>(&key_1)
+///     .signed::<Pouf1>(&key_1)
 ///     .unwrap()
 ///     .to_raw()
 ///     .unwrap();
diff --git a/tuf/tests/integration.rs b/tuf/tests/integration.rs
index 64c4d01..2895c28 100644
--- a/tuf/tests/integration.rs
+++ b/tuf/tests/integration.rs
@@ -5,7 +5,7 @@ use tuf::crypto::{Ed25519PrivateKey, HashAlgorithm, PrivateKey};
 use tuf::metadata::{
     Delegation, Delegations, MetadataDescription, MetadataPath, TargetPath, TargetsMetadataBuilder,
 };
-use tuf::pouf::Json;
+use tuf::pouf::Pouf1;
 use tuf::repo_builder::RepoBuilder;
 use tuf::repository::EphemeralRepository;
 use tuf::Database;
@@ -58,7 +58,7 @@ fn simple_delegation() {
             .await
             .unwrap();
 
-        let mut tuf = Database::<Json>::from_trusted_metadata(&metadata).unwrap();
+        let mut tuf = Database::<Pouf1>::from_trusted_metadata(&metadata).unwrap();
 
         //// build the targets ////
         //// build the delegation ////
@@ -70,7 +70,7 @@ fn simple_delegation() {
                 &[HashAlgorithm::Sha256],
             )
             .unwrap()
-            .signed::<Json>(&delegation_key)
+            .signed::<Pouf1>(&delegation_key)
             .unwrap();
         let raw_delegation = delegation.to_raw().unwrap();
 
@@ -136,7 +136,7 @@ fn nested_delegation() {
             .await
             .unwrap();
 
-        let mut tuf = Database::<Json>::from_trusted_metadata(&metadata).unwrap();
+        let mut tuf = Database::<Pouf1>::from_trusted_metadata(&metadata).unwrap();
 
         //// build delegation B ////
 
@@ -154,7 +154,7 @@ fn nested_delegation() {
 
         let delegation = TargetsMetadataBuilder::new()
             .delegations(delegations)
-            .signed::<Json>(&delegation_a_key)
+            .signed::<Pouf1>(&delegation_a_key)
             .unwrap();
         let raw_delegation = delegation.to_raw().unwrap();
 
@@ -177,7 +177,7 @@ fn nested_delegation() {
                 &[HashAlgorithm::Sha256],
             )
             .unwrap()
-            .signed::<Json>(&delegation_b_key)
+            .signed::<Pouf1>(&delegation_b_key)
             .unwrap();
         let raw_delegation = delegation.to_raw().unwrap();
 
@@ -236,7 +236,7 @@ fn rejects_bad_delegation_signatures() {
             .await
             .unwrap();
 
-        let mut tuf = Database::<Json>::from_trusted_metadata(&metadata).unwrap();
+        let mut tuf = Database::<Pouf1>::from_trusted_metadata(&metadata).unwrap();
 
         //// build the delegation ////
         let target_file: &[u8] = b"bar";
@@ -247,7 +247,7 @@ fn rejects_bad_delegation_signatures() {
                 &[HashAlgorithm::Sha256],
             )
             .unwrap()
-            .signed::<Json>(&bad_delegation_key)
+            .signed::<Pouf1>(&bad_delegation_key)
             .unwrap();
         let raw_delegation = delegation.to_raw().unwrap();
 
@@ -317,7 +317,7 @@ fn diamond_delegation() {
 
         let delegation_a = TargetsMetadataBuilder::new()
             .delegations(delegations_a)
-            .signed::<Json>(&delegation_a_key)
+            .signed::<Pouf1>(&delegation_a_key)
             .unwrap();
         let raw_delegation_a = delegation_a.to_raw().unwrap();
 
@@ -338,7 +338,7 @@ fn diamond_delegation() {
 
         let delegation_b = TargetsMetadataBuilder::new()
             .delegations(delegations_b)
-            .signed::<Json>(&delegation_b_key)
+            .signed::<Pouf1>(&delegation_b_key)
             .unwrap();
         let raw_delegation_b = delegation_b.to_raw().unwrap();
 
@@ -360,7 +360,7 @@ fn diamond_delegation() {
                 &[HashAlgorithm::Sha256],
             )
             .unwrap()
-            .signed::<Json>(&delegation_c_key)
+            .signed::<Pouf1>(&delegation_c_key)
             .unwrap();
         let raw_delegation_c = delegation_c.to_raw().unwrap();
 
@@ -427,7 +427,7 @@ fn diamond_delegation() {
             .await
             .unwrap();
 
-        let mut tuf = Database::<Json>::from_trusted_metadata(&metadata).unwrap();
+        let mut tuf = Database::<Pouf1>::from_trusted_metadata(&metadata).unwrap();
 
         //// Verify we can trust delegation-a and delegation-b..
 
diff --git a/tuf/tests/simple_example.rs b/tuf/tests/simple_example.rs
index b697113..8f324d5 100644
--- a/tuf/tests/simple_example.rs
+++ b/tuf/tests/simple_example.rs
@@ -3,7 +3,7 @@ use futures_util::io::Cursor;
 use tuf::client::{Client, Config};
 use tuf::crypto::{Ed25519PrivateKey, PrivateKey, PublicKey};
 use tuf::metadata::{MetadataVersion, TargetPath};
-use tuf::pouf::Json;
+use tuf::pouf::Pouf1;
 use tuf::repo_builder::RepoBuilder;
 use tuf::repository::EphemeralRepository;
 use tuf::Result;
@@ -46,7 +46,7 @@ async fn run_tests(config: Config, consistent_snapshots: bool) {
 
 async fn init_client(
     root_public_keys: &[PublicKey],
-    remote: EphemeralRepository<Json>,
+    remote: EphemeralRepository<Pouf1>,
     config: Config,
 ) -> Result<()> {
     let local = EphemeralRepository::new();
@@ -65,7 +65,7 @@ async fn init_client(
 }
 
 async fn init_server(
-    remote: &mut EphemeralRepository<Json>,
+    remote: &mut EphemeralRepository<Pouf1>,
     consistent_snapshot: bool,
 ) -> Result<Vec<PublicKey>> {
     // in real life, you wouldn't want these keys on the same machine ever