ed255/pod2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove MockSignedPod (#339)

Browse source 
- breaking change: Removal of MockSignedPod.  Use SignedPod instead.
- breaking change: Redefinition of numerical id for values of PodType.
This commit is contained in:
Eduard S. 2025-07-15 11:19:19 +02:00 • committed by GitHub
parent 06b84e8dca
commit b5e0d97cb6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
14 changed files with 79 additions and 358 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/backends/plonky2/circuits/common.rs
View file

@ -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 =

9
src/backends/plonky2/mainpod/mod.rs
View file

@ -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> =
if mock || inputs.signed_pods.len() == params.max_input_signed_pods {
Box::new(MockSignedPod::dummy())
} else {
Box::new(SignedPod::dummy())
};
let dummy_signed_pod_box: Box<dyn Pod> = 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 {

19
src/backends/plonky2/mock/mainpod.rs
View file

@ -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 {
pk: "ZooGov".into(),
};
let mut signer = Signer(SecretKey(1u32.into()));
let gov_id_pod = gov_id_builder.sign(&mut signer)?;
let mut signer = MockSigner {
pk: "ZooDeel".into(),
};
let mut signer = Signer(SecretKey(2u32.into()));
let pay_stub_pod = pay_stub_builder.sign(&mut signer)?;
let mut signer = MockSigner {
pk: "ZooOFAC".into(),
};
let mut signer = Signer(SecretKey(3u32.into()));
let sanction_list_pod = sanction_list_builder.sign(&mut signer)?;
let kyc_builder = zu_kyc_pod_builder(
&params,

1
src/backends/plonky2/mock/mod.rs
View file

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

233
src/backends/plonky2/mock/signedpod.rs
View file

@ -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(())
}
}

4
src/backends/plonky2/signedpod.rs
View file

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

11
src/examples/custom.rs
View file

@ -18,12 +18,7 @@ macro_rules! render {
}
/// Instantiates an ETHDos batch
pub fn eth_dos_batch(params: &Params, mock: bool) -> Result<Arc<CustomPredicateBatch>> {
let pod_type = Value::from(if mock {
PodType::MockSigned
} else {
PodType::Signed
});
pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
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();
}
}

69
src/examples/mod.rs
View file

@ -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 {
PodType::MockSigned
} else {
PodType::Signed
}),
&Value::from(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 = MockSigner {
pk: good_boy_issuers[0].into(),
};
let mut macrosoft_signer = MockSigner {
pk: good_boy_issuers[1].into(),
};
let mut faebook_signer = MockSigner {
pk: good_boy_issuers[2].into(),
};
let bob = "Bob";
let charlie = "Charlie";
let alice = "Alice";
let mut bob_signer = MockSigner { pk: bob.into() };
let mut charlie_signer = MockSigner { pk: charlie.into() };
let mut giggles_signer = Signer(SecretKey(1u32.into()));
let mut macrosoft_signer = Signer(SecretKey(2u32.into()));
let mut faebook_signer = Signer(SecretKey(3u32.into()));
let good_boy_issuers =
[&giggles_signer, &macrosoft_signer, &faebook_signer].map(|s| s.0.public_key());
let mut bob_signer = Signer(SecretKey(11u32.into()));
let mut charlie_signer = Signer(SecretKey(12u32.into()));
let alice_signer = Signer(SecretKey(13u32.into()));
let bob = bob_signer.public_key();
let charlie = charlie_signer.public_key();
let alice = alice_signer.public_key();
// 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,

2
src/frontend/custom.rs
View file

@ -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();

37
src/frontend/mod.rs
View file

@ -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 {
pk: "ZooGov".into(),
};
let mut signer = Signer(SecretKey(1u32.into()));
let gov_id = gov_id.sign(&mut signer)?;
check_kvs(&gov_id)?;
println!("{}", gov_id);
let mut signer = MockSigner {
pk: "ZooDeel".into(),
};
let mut signer = Signer(SecretKey(2u32.into()));
let pay_stub = pay_stub.sign(&mut signer)?;
check_kvs(&pay_stub)?;
println!("{}", pay_stub);
let mut signer = MockSigner {
pk: "ZooOFAC".into(),
};
let mut signer = Signer(SecretKey(3u32.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 bob = MockSigner { pk: "Bob".into() };
let mut charlie = MockSigner {
pk: "Charlie".into(),
};
let david = MockSigner { pk: "David".into() };
let mut alice = Signer(SecretKey(1u32.into()));
let mut bob = Signer(SecretKey(2u32.into()));
let mut charlie = Signer(SecretKey(3u32.into()));
let david = Signer(SecretKey(4u32.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 = MockSigner {
pk: "signer".into(),
};
let mut signer = Signer(SecretKey(1u32.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 {
pk: "signer".into(),
};
let mut signer = Signer(SecretKey(1u32.into()));
let pod = builder.sign(&mut signer).unwrap();
let mut builder = MainPodBuilder::new(&params, &vd_set);

28
src/frontend/serialization.rs
View file

@ -107,9 +107,7 @@ mod tests {
use super::*;
use crate::{
backends::plonky2::{
mainpod::Prover,
mock::{mainpod::MockProver, signedpod::MockSigner},
primitives::ec::schnorr::SecretKey,
mainpod::Prover, mock::mainpod::MockProver, 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 {
pk: "ZooGov".into(),
};
let mut signer = Signer(SecretKey(1u32.into()));
let gov_id_pod = gov_id_builder.sign(&mut signer).unwrap();
let mut signer = MockSigner {
pk: "ZooDeel".into(),
};
let mut signer = Signer(SecretKey(2u32.into()));
let pay_stub_pod = pay_stub_builder.sign(&mut signer).unwrap();
let mut signer = MockSigner {
pk: "ZooOFAC".into(),
};
let mut signer = Signer(SecretKey(3u32.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 bob = MockSigner { pk: "Bob".into() };
let charlie = MockSigner {
pk: "Charlie".into(),
};
let mut alice = Signer(SecretKey(1u32.into()));
let mut bob = Signer(SecretKey(2u32.into()));
let charlie = Signer(SecretKey(3u32.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();

2
src/lang/mod.rs
View file

@ -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 {

12
src/middleware/mod.rs
View file

@ -618,18 +618,16 @@ impl ToFields for PodId {
#[derive(Clone, Copy, Debug, PartialEq, Eq, FromRepr, Serialize, Deserialize, JsonSchema)]
pub enum PodType {
MockSigned = 1,
MockMain = 2,
MockEmpty = 3,
Signed = 4,
Main = 5,
Empty = 6,
Signed = 1,
Main = 2,
Empty = 3,
MockMain = 102,
MockEmpty = 103,
}
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"),

6
src/middleware/pod_deserialization.rs
View file

@ -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 {
MockSignedPod::deserialize(id, data)
} else if pod_type == PodType::Signed as usize {
if pod_type == PodType::Signed as usize {
SignedPod::deserialize(id, data)
} else {
Err(BackendError::custom(format!(