remove MockSignedPod (#339)

- breaking change: Removal of MockSignedPod.  Use SignedPod instead.
- breaking change: Redefinition of numerical id for values of PodType.

src/backends/plonky2/circuits/common.rs

@@ -1477,7 +1477,7 @@ pub(crate) mod tests {
         let params = Params::default();
         let config = CircuitConfig::standard_recursion_config();
 
-        let custom_predicate_batch = eth_dos_batch(&params, false)?;
+        let custom_predicate_batch = eth_dos_batch(&params)?;
 
         for (i, cp) in custom_predicate_batch.predicates().iter().enumerate() {
             let mut builder = CircuitBuilder::<F, D>::new(config.clone());
@@ -1540,7 +1540,7 @@ pub(crate) mod tests {
         helper_custom_predicate_batch_target_id(&params, &custom_predicate_batch).unwrap();
 
         // Some cases from the examples
-        let custom_predicate_batch = eth_dos_batch(&params, false)?;
+        let custom_predicate_batch = eth_dos_batch(&params)?;
         helper_custom_predicate_batch_target_id(&params, &custom_predicate_batch).unwrap();
 
         let custom_predicate_batch =

src/backends/plonky2/mainpod/mod.rs

@@ -18,7 +18,7 @@ use crate::{
         deserialize_proof,
         emptypod::EmptyPod,
         error::{Error, Result},
-        mock::{emptypod::MockEmptyPod, signedpod::MockSignedPod},
+        mock::emptypod::MockEmptyPod,
         primitives::merkletree::MerkleClaimAndProof,
         recursion::{hash_verifier_data, RecursiveCircuit, RecursiveParams},
         serialize_proof,
@@ -267,12 +267,7 @@ pub(crate) fn layout_statements(
     statements.push(middleware::Statement::None.into());
 
     // Input signed pods region
-    let dummy_signed_pod_box: Box<dyn Pod> =
+    let dummy_signed_pod_box: Box<dyn Pod> = Box::new(SignedPod::dummy());
-        if mock || inputs.signed_pods.len() == params.max_input_signed_pods {
-            Box::new(MockSignedPod::dummy())
-        } else {
-            Box::new(SignedPod::dummy())
-        };
     let dummy_signed_pod = dummy_signed_pod_box.as_ref();
     assert!(inputs.signed_pods.len() <= params.max_input_signed_pods);
     for i in 0..params.max_input_signed_pods {

src/backends/plonky2/mock/mainpod.rs

@@ -16,9 +16,10 @@ use crate::{
             process_private_statements_operations, process_public_statements_operations, Operation,
             Statement,
         },
-        mock::{emptypod::MockEmptyPod, signedpod::MockSignedPod},
+        mock::emptypod::MockEmptyPod,
         primitives::merkletree::MerkleClaimAndProof,
         recursion::hash_verifier_data,
+        signedpod::SignedPod,
     },
     middleware::{
         self, deserialize_pod, deserialize_signed_pod, hash_str, AnchoredKey, Hash, MainPodInputs,
@@ -187,7 +188,7 @@ impl MockMainPod {
         // get the id out of the public statements
         let id: PodId = PodId(calculate_id(&public_statements, params));
 
-        let pad_signed_pod: Box<dyn Pod> = Box::new(MockSignedPod::dummy());
+        let pad_signed_pod: Box<dyn Pod> = Box::new(SignedPod::dummy());
         let input_signed_pods: Vec<Box<dyn Pod>> = inputs
             .signed_pods
             .iter()
@@ -425,7 +426,7 @@ pub mod tests {
 
     use super::*;
     use crate::{
-        backends::plonky2::mock::signedpod::MockSigner,
+        backends::plonky2::{primitives::ec::schnorr::SecretKey, signedpod::Signer},
         examples::{
             great_boy_pod_full_flow, tickets_pod_full_flow, zu_kyc_pod_builder,
             zu_kyc_sign_pod_builders, MOCK_VD_SET,
@@ -440,17 +441,11 @@ pub mod tests {
         let vd_set = &*MOCK_VD_SET;
         let (gov_id_builder, pay_stub_builder, sanction_list_builder) =
             zu_kyc_sign_pod_builders(&params);
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(1u32.into()));
-            pk: "ZooGov".into(),
-        };
         let gov_id_pod = gov_id_builder.sign(&mut signer)?;
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(2u32.into()));
-            pk: "ZooDeel".into(),
-        };
         let pay_stub_pod = pay_stub_builder.sign(&mut signer)?;
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(3u32.into()));
-            pk: "ZooOFAC".into(),
-        };
         let sanction_list_pod = sanction_list_builder.sign(&mut signer)?;
         let kyc_builder = zu_kyc_pod_builder(
             &params,

src/backends/plonky2/mock/mod.rs

@@ -1,3 +1,2 @@
 pub mod emptypod;
 pub mod mainpod;
-pub mod signedpod;

src/backends/plonky2/mock/signedpod.rs

@@ -1,233 +0,0 @@
-use std::collections::HashMap;
-
-use itertools::Itertools;
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    backends::plonky2::{
-        error::{Error, Result},
-        primitives::merkletree::MerkleTree,
-    },
-    middleware::{
-        containers::Dictionary, hash_str, serialization::ordered_map, AnchoredKey, Key, Params,
-        Pod, PodId, PodSigner, PodType, RawValue, Statement, Value, KEY_SIGNER, KEY_TYPE, SELF,
-    },
-};
-
-pub struct MockSigner {
-    pub pk: String,
-}
-
-impl MockSigner {
-    pub fn public_key(&self) -> Value {
-        Value::from(hash_str(&self.pk))
-    }
-}
-
-impl MockSigner {
-    fn _sign(&mut self, params: &Params, kvs: &HashMap<Key, Value>) -> Result<MockSignedPod> {
-        let mut kvs = kvs.clone();
-        let pubkey = self.public_key();
-        kvs.insert(Key::from(KEY_SIGNER), pubkey.clone());
-        kvs.insert(Key::from(KEY_TYPE), Value::from(PodType::MockSigned));
-
-        let dict = Dictionary::new(params.max_depth_mt_containers, kvs.clone())?;
-        let id = PodId(dict.commitment());
-        let signature = format!("{}_signed_by_{}", id, pubkey);
-        Ok(MockSignedPod {
-            mt_max_depth: params.max_depth_mt_containers,
-            id,
-            signature,
-            kvs,
-        })
-    }
-}
-
-impl PodSigner for MockSigner {
-    fn sign(&mut self, params: &Params, kvs: &HashMap<Key, Value>) -> Result<Box<dyn Pod>> {
-        Ok(self._sign(params, kvs).map(Box::new)?)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MockSignedPod {
-    mt_max_depth: usize,
-    id: PodId,
-    signature: String,
-    kvs: HashMap<Key, Value>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct Data {
-    mt_max_depth: usize,
-    signature: String,
-    #[serde(serialize_with = "ordered_map")]
-    kvs: HashMap<Key, Value>,
-}
-
-impl MockSignedPod {
-    pub fn signature(&self) -> String {
-        self.signature.clone()
-    }
-
-    pub(crate) fn deserialize(id: PodId, data: serde_json::Value) -> Result<Box<dyn Pod>> {
-        let data: Data = serde_json::from_value(data)?;
-        Ok(Box::new(Self {
-            mt_max_depth: data.mt_max_depth,
-            id,
-            signature: data.signature,
-            kvs: data.kvs,
-        }))
-    }
-    /// Generate a valid MockSignedPod with a public deterministic public key and no other
-    /// key-values than the default ones.  This is used for padding.
-    pub fn dummy() -> MockSignedPod {
-        MockSigner {
-            pk: "dummy".to_string(),
-        }
-        ._sign(&Params::default(), &HashMap::new())
-        .expect("valid")
-    }
-}
-
-impl Pod for MockSignedPod {
-    fn params(&self) -> &Params {
-        panic!("MockSignedPod doesn't have params");
-    }
-    fn verify(&self) -> Result<()> {
-        // 1. Verify id
-        let mt = MerkleTree::new(
-            self.mt_max_depth,
-            &self
-                .kvs
-                .iter()
-                .map(|(k, v)| (k.raw(), v.raw()))
-                .collect::<HashMap<RawValue, RawValue>>(),
-        )?;
-        let id = PodId(mt.root());
-        if id != self.id {
-            return Err(Error::id_not_equal(self.id, id));
-        }
-
-        // 2. Verify type
-        let value_at_type = self
-            .kvs
-            .get(&Key::from(KEY_TYPE))
-            .ok_or(Error::key_not_found())?;
-        if &Value::from(PodType::MockSigned) != value_at_type {
-            return Err(Error::type_not_equal(
-                PodType::MockSigned,
-                value_at_type.clone(),
-            ));
-        }
-
-        // 3. Verify signature
-        let pk_hash = self
-            .kvs
-            .get(&Key::from(KEY_SIGNER))
-            .ok_or(Error::key_not_found())?;
-        let signature = format!("{}_signed_by_{}", id, pk_hash);
-        if signature != self.signature {
-            return Err(Error::custom(format!(
-                "signature does not match, expected {}, computed {}",
-                self.id, id
-            )));
-        }
-
-        Ok(())
-    }
-
-    fn id(&self) -> PodId {
-        self.id
-    }
-    fn pod_type(&self) -> (usize, &'static str) {
-        (PodType::MockSigned as usize, "MockSigned")
-    }
-
-    fn pub_self_statements(&self) -> Vec<Statement> {
-        // By convention we put the KEY_TYPE first and KEY_SIGNER second
-        let mut kvs = self.kvs.clone();
-        let key_type = Key::from(KEY_TYPE);
-        let value_type = kvs.remove(&key_type).expect("KEY_TYPE");
-        let key_signer = Key::from(KEY_SIGNER);
-        let value_signer = kvs.remove(&key_signer).expect("KEY_SIGNER");
-        [(key_type, value_type), (key_signer, value_signer)]
-            .into_iter()
-            .chain(kvs.into_iter().sorted_by_key(|kv| kv.0.hash()))
-            .map(|(k, v)| Statement::equal(AnchoredKey::from((SELF, k)), v))
-            .collect()
-    }
-
-    fn serialize_data(&self) -> serde_json::Value {
-        serde_json::to_value(Data {
-            mt_max_depth: self.mt_max_depth,
-            signature: self.signature.clone(),
-            kvs: self.kvs.clone(),
-        })
-        .expect("serialization to json")
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use std::{any::Any, iter};
-
-    use plonky2::field::types::Field;
-
-    use super::*;
-    use crate::{
-        frontend,
-        middleware::{self, EMPTY_VALUE, F},
-    };
-
-    #[test]
-    fn test_mock_signed_0() -> Result<()> {
-        let params = middleware::Params::default();
-        let mut pod = frontend::SignedPodBuilder::new(&params);
-        pod.insert("idNumber", "4242424242");
-        pod.insert("dateOfBirth", 1169909384);
-        pod.insert("socialSecurityNumber", "G2121210");
-
-        let mut signer = MockSigner { pk: "Molly".into() };
-        let pod = pod.sign(&mut signer).unwrap();
-        let pod = (pod.pod as Box<dyn Any>)
-            .downcast::<MockSignedPod>()
-            .unwrap();
-
-        pod.verify()?;
-        println!("id: {}", pod.id());
-        println!("kvs: {:?}", pod.kvs());
-
-        let mut bad_pod = pod.clone();
-        bad_pod.signature = "".into();
-        assert!(bad_pod.verify().is_err());
-
-        let mut bad_pod = pod.clone();
-        bad_pod.id.0 .0[0] = F::ZERO;
-        assert!(bad_pod.verify().is_err());
-
-        let mut bad_pod = pod.clone();
-        let bad_kv = (Key::from(KEY_SIGNER), Value::from(EMPTY_VALUE));
-        let bad_kvs = bad_pod
-            .kvs
-            .clone()
-            .into_iter()
-            .chain(iter::once(bad_kv))
-            .collect::<HashMap<Key, Value>>();
-        bad_pod.kvs = bad_kvs;
-        assert!(bad_pod.verify().is_err());
-
-        let mut bad_pod = pod.clone();
-        let bad_kv = (Key::from(KEY_TYPE), Value::from(0));
-        let bad_kvs = bad_pod
-            .kvs
-            .clone()
-            .into_iter()
-            .chain(iter::once(bad_kv))
-            .collect::<HashMap<Key, Value>>();
-        bad_pod.kvs = bad_kvs;
-        assert!(bad_pod.verify().is_err());
-
-        Ok(())
-    }
-}

src/backends/plonky2/signedpod.rs

@@ -53,8 +53,8 @@ impl Signer {
         self.sign_with_nonce(params, nonce, kvs)
     }
 
-    pub fn public_key(&self) -> Point {
+    pub fn public_key(&self) -> Value {
-        self.0.public_key()
+        Value::from(self.0.public_key())
     }
 }
 

src/examples/custom.rs

@@ -18,12 +18,7 @@ macro_rules! render {
 }
 
 /// Instantiates an ETHDos batch
-pub fn eth_dos_batch(params: &Params, mock: bool) -> Result<Arc<CustomPredicateBatch>> {
+pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
-    let pod_type = Value::from(if mock {
-        PodType::MockSigned
-    } else {
-        PodType::Signed
-    });
     let input = render!(
         r#"
         eth_friend(src, dst, private: attestation_pod) = AND(
@@ -48,7 +43,7 @@ pub fn eth_dos_batch(params: &Params, mock: bool) -> Result<Arc<CustomPredicateB
             eth_dos_ind(?src, ?dst, ?distance)
         )
         "#,
-        pod_type = pod_type,
+        pod_type = Value::from(PodType::Signed),
     );
     let batch = parse(&input, params, &[]).expect("lang parse").custom_batch;
     println!("a.0. {}", batch.predicates[0]);
@@ -65,6 +60,6 @@ mod tests {
     #[test]
     fn test_eth_friend_batch() {
         let params = Params::default();
-        eth_dos_batch(&params, true).unwrap();
+        eth_dos_batch(&params).unwrap();
     }
 }

src/examples/mod.rs

@@ -7,7 +7,7 @@ use custom::eth_dos_batch;
 pub const MOCK_VD_SET: LazyLock<VDSet> = LazyLock::new(|| VDSet::new(6, &[]).unwrap());
 
 use crate::{
-    backends::plonky2::mock::signedpod::MockSigner,
+    backends::plonky2::{primitives::ec::schnorr::SecretKey, signedpod::Signer},
     frontend::{MainPod, MainPodBuilder, Result, SignedPod, SignedPodBuilder},
     middleware::{
         containers::Set, CustomPredicateRef, Params, PodSigner, PodType, Predicate, Statement,
@@ -92,7 +92,7 @@ pub struct EthDosHelper {
 
 impl EthDosHelper {
     pub fn new(params: &Params, vd_set: &VDSet, mock: bool, src: Value) -> Result<Self> {
-        let eth_dos_batch = eth_dos_batch(params, mock)?;
+        let eth_dos_batch = eth_dos_batch(params)?;
         let eth_friend = eth_dos_batch.predicate_ref_by_name("eth_friend").unwrap();
         let eth_dos_base = eth_dos_batch.predicate_ref_by_name("eth_dos_base").unwrap();
         let eth_dos_ind = eth_dos_batch.predicate_ref_by_name("eth_dos_ind").unwrap();
@@ -196,11 +196,7 @@ impl EthDosHelper {
         n: i64,
     ) -> Result<()> {
         assert_eq!(
-            &Value::from(if self.mock {
+            &Value::from(PodType::Signed),
-                PodType::MockSigned
-            } else {
-                PodType::Signed
-            }),
             int_attestation.get(KEY_TYPE).expect("get KEY_TYPE")
         );
 
@@ -238,17 +234,17 @@ impl EthDosHelper {
 
 // GreatBoy
 
-pub fn good_boy_sign_pod_builder(params: &Params, user: &str, age: i64) -> SignedPodBuilder {
+pub fn good_boy_sign_pod_builder(params: &Params, user: &Value, age: i64) -> SignedPodBuilder {
     let mut good_boy = SignedPodBuilder::new(params);
-    good_boy.insert("user", user);
+    good_boy.insert("user", user.clone());
     good_boy.insert("age", age);
 
     good_boy
 }
 
-pub fn friend_sign_pod_builder(params: &Params, friend: &str) -> SignedPodBuilder {
+pub fn friend_sign_pod_builder(params: &Params, friend: &Value) -> SignedPodBuilder {
     let mut friend_pod = SignedPodBuilder::new(params);
-    friend_pod.insert("friend", friend);
+    friend_pod.insert("friend", friend.clone());
 
     friend_pod
 }
@@ -259,7 +255,7 @@ pub fn great_boy_pod_builder(
     good_boy_pods: [&SignedPod; 4],
     friend_pods: [&SignedPod; 2],
     good_boy_issuers: &Value,
-    receiver: &str,
+    receiver: &Value,
 ) -> Result<MainPodBuilder> {
     // Attestment chain (issuer -> good boy -> great boy):
     // issuer 0 -> good_boy_pods[0] => good boy 0
@@ -282,14 +278,14 @@ pub fn great_boy_pod_builder(
         great_boy.pub_op(op!(
             eq,
             (friend_pods[good_boy_idx], KEY_TYPE),
-            PodType::MockSigned as i64
+            PodType::Signed as i64
         ))?;
         for issuer_idx in 0..2 {
             // Type check
             great_boy.pub_op(op!(
                 eq,
                 (good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_TYPE),
-                PodType::MockSigned as i64
+                PodType::Signed as i64
             ))?;
             // Each good boy POD comes from a valid issuer
             great_boy.pub_op(op!(
@@ -311,7 +307,11 @@ pub fn great_boy_pod_builder(
             (good_boy_pods[good_boy_idx * 2 + 1], KEY_SIGNER)
         ))?;
         // Each good boy is receivers' friend
-        great_boy.pub_op(op!(eq, (friend_pods[good_boy_idx], "friend"), receiver))?;
+        great_boy.pub_op(op!(
+            eq,
+            (friend_pods[good_boy_idx], "friend"),
+            receiver.clone()
+        ))?;
     }
     // The two good boys are different
     great_boy.pub_op(op!(
@@ -334,44 +334,38 @@ pub fn great_boy_pod_full_flow() -> Result<(Params, MainPodBuilder)> {
     };
     let vd_set = &*MOCK_VD_SET;
 
-    let good_boy_issuers = ["Giggles", "Macrosoft", "FaeBook"];
+    let mut giggles_signer = Signer(SecretKey(1u32.into()));
-    let mut giggles_signer = MockSigner {
+    let mut macrosoft_signer = Signer(SecretKey(2u32.into()));
-        pk: good_boy_issuers[0].into(),
+    let mut faebook_signer = Signer(SecretKey(3u32.into()));
-    };
+    let good_boy_issuers =
-    let mut macrosoft_signer = MockSigner {
+        [&giggles_signer, &macrosoft_signer, &faebook_signer].map(|s| s.0.public_key());
-        pk: good_boy_issuers[1].into(),
+    let mut bob_signer = Signer(SecretKey(11u32.into()));
-    };
+    let mut charlie_signer = Signer(SecretKey(12u32.into()));
-    let mut faebook_signer = MockSigner {
+    let alice_signer = Signer(SecretKey(13u32.into()));
-        pk: good_boy_issuers[2].into(),
+    let bob = bob_signer.public_key();
-    };
+    let charlie = charlie_signer.public_key();
-    let bob = "Bob";
+    let alice = alice_signer.public_key();
-    let charlie = "Charlie";
-    let alice = "Alice";
-    let mut bob_signer = MockSigner { pk: bob.into() };
-    let mut charlie_signer = MockSigner { pk: charlie.into() };
 
     // Bob receives two good_boy pods from Giggles and Macrosoft.
 
-    let bob = "Bob";
     let mut bob_good_boys = Vec::new();
 
-    let good_boy = good_boy_sign_pod_builder(&params, bob, 36);
+    let good_boy = good_boy_sign_pod_builder(&params, &bob, 36);
     bob_good_boys.push(good_boy.sign(&mut giggles_signer).unwrap());
     bob_good_boys.push(good_boy.sign(&mut macrosoft_signer).unwrap());
 
     // Charlie receives two good_boy pods from Macrosoft and Faebook
 
-    let charlie = "Charlie";
     let mut charlie_good_boys = Vec::new();
 
-    let good_boy = good_boy_sign_pod_builder(&params, charlie, 27);
+    let good_boy = good_boy_sign_pod_builder(&params, &charlie, 27);
     charlie_good_boys.push(good_boy.sign(&mut macrosoft_signer).unwrap());
     charlie_good_boys.push(good_boy.sign(&mut faebook_signer).unwrap());
 
     // Bob and Charlie send Alice a Friend POD
 
     let mut alice_friend_pods = Vec::new();
-    let friend = friend_sign_pod_builder(&params, alice);
+    let friend = friend_sign_pod_builder(&params, &alice);
     alice_friend_pods.push(friend.sign(&mut bob_signer).unwrap());
     alice_friend_pods.push(friend.sign(&mut charlie_signer).unwrap());
 
@@ -391,7 +385,7 @@ pub fn great_boy_pod_full_flow() -> Result<(Params, MainPodBuilder)> {
         ],
         [&alice_friend_pods[0], &alice_friend_pods[1]],
         &good_boy_issuers,
-        alice,
+        &alice,
     )?;
 
     Ok((params, builder))
@@ -438,7 +432,8 @@ pub fn tickets_pod_full_flow() -> Result<MainPodBuilder> {
     let params = Params::default();
     let vd_set = &*MOCK_VD_SET;
     let builder = tickets_sign_pod_builder(&params);
-    let signed_pod = builder.sign(&mut MockSigner { pk: "test".into() }).unwrap();
+
+    let signed_pod = builder.sign(&mut Signer(SecretKey(1u32.into()))).unwrap();
     tickets_pod_builder(
         &params,
         vd_set,

src/frontend/custom.rs

@@ -255,7 +255,7 @@ mod tests {
         params.print_serialized_sizes();
 
         // ETH friend custom predicate batch
-        let eth_dos_batch = eth_dos_batch(&params, true)?;
+        let eth_dos_batch = eth_dos_batch(&params)?;
 
         // This batch only has 1 predicate, so we pick it already for convenience
         let eth_friend = eth_dos_batch.predicate_ref_by_name("eth_friend").unwrap();

src/frontend/mod.rs

@@ -831,7 +831,9 @@ pub mod tests {
 
     use super::*;
     use crate::{
-        backends::plonky2::mock::{mainpod::MockProver, signedpod::MockSigner},
+        backends::plonky2::{
+            mock::mainpod::MockProver, primitives::ec::schnorr::SecretKey, signedpod::Signer,
+        },
         examples::{
             attest_eth_friend, great_boy_pod_full_flow, tickets_pod_full_flow, zu_kyc_pod_builder,
             zu_kyc_sign_pod_builders, EthDosHelper, MOCK_VD_SET,
@@ -877,23 +879,17 @@ pub mod tests {
         println!("{}", gov_id);
         println!("{}", pay_stub);
 
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(1u32.into()));
-            pk: "ZooGov".into(),
-        };
         let gov_id = gov_id.sign(&mut signer)?;
         check_kvs(&gov_id)?;
         println!("{}", gov_id);
 
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(2u32.into()));
-            pk: "ZooDeel".into(),
-        };
         let pay_stub = pay_stub.sign(&mut signer)?;
         check_kvs(&pay_stub)?;
         println!("{}", pay_stub);
 
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(3u32.into()));
-            pk: "ZooOFAC".into(),
-        };
         let sanction_list = sanction_list.sign(&mut signer)?;
         check_kvs(&sanction_list)?;
         println!("{}", sanction_list);
@@ -920,12 +916,10 @@ pub mod tests {
         };
         let vd_set = &*MOCK_VD_SET;
 
-        let mut alice = MockSigner { pk: "Alice".into() };
+        let mut alice = Signer(SecretKey(1u32.into()));
-        let mut bob = MockSigner { pk: "Bob".into() };
+        let mut bob = Signer(SecretKey(2u32.into()));
-        let mut charlie = MockSigner {
+        let mut charlie = Signer(SecretKey(3u32.into()));
-            pk: "Charlie".into(),
+        let david = Signer(SecretKey(4u32.into()));
-        };
-        let david = MockSigner { pk: "David".into() };
 
         let helper = EthDosHelper::new(&params, vd_set, true, alice.public_key())?;
 
@@ -980,7 +974,7 @@ pub mod tests {
         let mut signed_builder = SignedPodBuilder::new(&params);
         signed_builder.insert("a", 1);
         signed_builder.insert("b", 1);
-        let mut signer = MockSigner { pk: "key".into() };
+        let mut signer = Signer(SecretKey(1u32.into()));
         let signed_pod = signed_builder.sign(&mut signer).unwrap();
 
         let mut builder = MainPodBuilder::new(&params, &vd_set);
@@ -1031,10 +1025,7 @@ pub mod tests {
         let mut builder = SignedPodBuilder::new(&params);
 
         builder.insert("num", 2);
-
+        let mut signer = Signer(SecretKey(1u32.into()));
-        let mut signer = MockSigner {
-            pk: "signer".into(),
-        };
         let pod = builder.sign(&mut signer).unwrap();
 
         println!("{}", pod);
@@ -1066,9 +1057,7 @@ pub mod tests {
         let dict_root = Value::from(dict.clone());
         builder.insert("dict", dict_root);
 
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(1u32.into()));
-            pk: "signer".into(),
-        };
         let pod = builder.sign(&mut signer).unwrap();
 
         let mut builder = MainPodBuilder::new(&params, &vd_set);

src/frontend/serialization.rs

@@ -107,9 +107,7 @@ mod tests {
     use super::*;
     use crate::{
         backends::plonky2::{
-            mainpod::Prover,
+            mainpod::Prover, mock::mainpod::MockProver, primitives::ec::schnorr::SecretKey,
-            mock::{mainpod::MockProver, signedpod::MockSigner},
-            primitives::ec::schnorr::SecretKey,
             signedpod::Signer,
         },
         examples::{
@@ -242,7 +240,7 @@ mod tests {
     #[test]
     fn test_mock_signed_pod_serialization() {
         let builder = signed_pod_builder();
-        let mut signer = MockSigner { pk: "test".into() };
+        let mut signer = Signer(SecretKey(1u32.into()));
         let pod = builder.sign(&mut signer).unwrap();
 
         let serialized = serde_json::to_string_pretty(&pod).unwrap();
@@ -263,17 +261,11 @@ mod tests {
 
         let (gov_id_builder, pay_stub_builder, sanction_list_builder) =
             zu_kyc_sign_pod_builders(&params);
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(1u32.into()));
-            pk: "ZooGov".into(),
-        };
         let gov_id_pod = gov_id_builder.sign(&mut signer).unwrap();
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(2u32.into()));
-            pk: "ZooDeel".into(),
-        };
         let pay_stub_pod = pay_stub_builder.sign(&mut signer).unwrap();
-        let mut signer = MockSigner {
+        let mut signer = Signer(SecretKey(3u32.into()));
-            pk: "ZooOFAC".into(),
-        };
         let sanction_list_pod = sanction_list_builder.sign(&mut signer).unwrap();
         let kyc_builder = zu_kyc_pod_builder(
             &params,
@@ -356,11 +348,9 @@ mod tests {
         };
         let vd_set = &*MOCK_VD_SET;
 
-        let mut alice = MockSigner { pk: "Alice".into() };
+        let mut alice = Signer(SecretKey(1u32.into()));
-        let mut bob = MockSigner { pk: "Bob".into() };
+        let mut bob = Signer(SecretKey(2u32.into()));
-        let charlie = MockSigner {
+        let charlie = Signer(SecretKey(3u32.into()));
-            pk: "Charlie".into(),
-        };
 
         // Alice attests that she is ETH friends with Bob and Bob
         // attests that he is ETH friends with Charlie.
@@ -390,7 +380,7 @@ mod tests {
 
         let kyc_pod = build_mock_zukyc_pod().unwrap();
         let signed_pod = signed_pod_builder()
-            .sign(&mut MockSigner { pk: "test".into() })
+            .sign(&mut Signer(SecretKey(1u32.into())))
             .unwrap();
         let ethdos_pod = build_ethdos_pod().unwrap();
         let mainpod_schema_value = serde_json::to_value(&mainpod_schema).unwrap();

src/lang/mod.rs

@@ -543,7 +543,7 @@ mod tests {
                 pred: Predicate::Native(NativePredicate::Equal),
                 args: vec![
                     sta_ak(("attestation_pod", 2), "_type"), // Pub(0-1), Priv(2)
-                    sta_lit(PodType::MockSigned),
+                    sta_lit(PodType::Signed),
                 ],
             },
             StatementTmpl {

src/middleware/mod.rs

@@ -618,18 +618,16 @@ impl ToFields for PodId {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, FromRepr, Serialize, Deserialize, JsonSchema)]
 pub enum PodType {
-    MockSigned = 1,
+    Signed = 1,
-    MockMain = 2,
+    Main = 2,
-    MockEmpty = 3,
+    Empty = 3,
-    Signed = 4,
+    MockMain = 102,
-    Main = 5,
+    MockEmpty = 103,
-    Empty = 6,
 }
 
 impl fmt::Display for PodType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            PodType::MockSigned => write!(f, "MockSigned"),
             PodType::MockMain => write!(f, "MockMain"),
             PodType::MockEmpty => write!(f, "MockEmpty"),
             PodType::Signed => write!(f, "Signed"),

src/middleware/pod_deserialization.rs

@@ -56,7 +56,7 @@ mod backend {
     use crate::backends::plonky2::{
         emptypod::EmptyPod,
         mainpod::MainPod,
-        mock::{emptypod::MockEmptyPod, mainpod::MockMainPod, signedpod::MockSignedPod},
+        mock::{emptypod::MockEmptyPod, mainpod::MockMainPod},
         signedpod::SignedPod,
     };
 
@@ -74,9 +74,7 @@ mod backend {
         id: PodId,
         data: serde_json::Value,
     ) -> Result<Box<dyn Pod>, BackendError> {
-        if pod_type == PodType::MockSigned as usize {
+        if pod_type == PodType::Signed as usize {
-            MockSignedPod::deserialize(id, data)
-        } else if pod_type == PodType::Signed as usize {
             SignedPod::deserialize(id, data)
         } else {
             Err(BackendError::custom(format!(