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

Refactor frontend/middleware types (#194)

Browse source 
* unify fe/be NativeOp and NativePred

* remove Origin in favour of PodId

* Combine string and hash in Key

* use middleware::AnchoredKey in frontend

* merge frontend/middleware types

* refactor custom predicates

* clean up a bit

* fix middleware custom tests

* clean up

* clean up 2

* add acronyms in typos list
This commit is contained in:
Eduard S. 2025-04-16 11:59:30 +02:00 • committed by GitHub
parent 9e860ef262
commit c232c8dae5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
33 changed files with 1985 additions and 2800 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -7,8 +7,8 @@ use crate::{
backends::plonky2::primitives::merkletree::MerkleTree,
constants::MAX_DEPTH,
middleware::{
containers::Dictionary, hash_str, AnchoredKey, Hash, Params, Pod, PodId, PodSigner,
PodType, Statement, Value, KEY_SIGNER, KEY_TYPE,
containers::Dictionary, hash_str, AnchoredKey, Hash, Key, Params, Pod, PodId, PodSigner,
PodType, RawValue, Statement, Value, KEY_SIGNER, KEY_TYPE,
},
};
@ -17,26 +17,22 @@ pub struct MockSigner {
}
impl MockSigner {
pub fn pubkey(&self) -> Value {
Value(hash_str(&self.pk).0)
pub fn pubkey(&self) -> Hash {
hash_str(&self.pk)
}
}
impl PodSigner for MockSigner {
fn sign(&mut self, _params: &Params, kvs: &HashMap<Hash, Value>) -> Result<Box<dyn Pod>> {
fn sign(&mut self, _params: &Params, kvs: &HashMap<Key, Value>) -> Result<Box<dyn Pod>> {
let mut kvs = kvs.clone();
let pubkey = self.pubkey();
kvs.insert(hash_str(KEY_SIGNER), pubkey);
kvs.insert(hash_str(KEY_TYPE), Value::from(PodType::MockSigned));
kvs.insert(Key::from(KEY_SIGNER), Value::from(pubkey));
kvs.insert(Key::from(KEY_TYPE), Value::from(PodType::MockSigned));
let dict = Dictionary::new(&kvs)?;
let dict = Dictionary::new(kvs.clone())?;
let id = PodId(dict.commitment());
let signature = format!("{}_signed_by_{}", id, pubkey);
Ok(Box::new(MockSignedPod {
dict,
id,
signature,
}))
Ok(Box::new(MockSignedPod { id, signature, kvs }))
}
}
@ -44,18 +40,18 @@ impl PodSigner for MockSigner {
pub struct MockSignedPod {
id: PodId,
signature: String,
dict: Dictionary,
kvs: HashMap<Key, Value>,
}
impl MockSignedPod {
pub fn deserialize(id: PodId, signature: String, dict: Dictionary) -> Self {
Self {
id,
signature,
dict,
}
}
}
// impl MockSignedPod {
// pub fn deserialize(id: PodId, signature: String, dict: Dictionary) -> Self {
// Self {
// id,
// signature,
// dict,
// }
// }
// }
impl Pod for MockSignedPod {
fn verify(&self) -> Result<()> {
@ -63,10 +59,10 @@ impl Pod for MockSignedPod {
let mt = MerkleTree::new(
MAX_DEPTH,
&self
.dict
.kvs
.iter()
.map(|(&k, &v)| (k, v))
.collect::<HashMap<Value, Value>>(),
.map(|(k, v)| (k.raw(), v.raw()))
.collect::<HashMap<RawValue, RawValue>>(),
)?;
let id = PodId(mt.root());
if id != self.id {
@ -78,8 +74,11 @@ impl Pod for MockSignedPod {
}
// 2. Verify type
let value_at_type = self.dict.get(&hash_str(KEY_TYPE).into())?;
if Value::from(PodType::MockSigned) != value_at_type {
let value_at_type = self
.kvs
.get(&Key::from(KEY_TYPE))
.ok_or(anyhow!("key not found"))?;
if &Value::from(PodType::MockSigned) != value_at_type {
return Err(anyhow!(
"type does not match, expected MockSigned ({}), found {}",
PodType::MockSigned,
@ -88,7 +87,10 @@ impl Pod for MockSignedPod {
}
// 3. Verify signature
let pk_hash = self.dict.get(&hash_str(KEY_SIGNER).into())?;
let pk_hash = self
.kvs
.get(&Key::from(KEY_SIGNER))
.ok_or(anyhow!("key not found"))?;
let signature = format!("{}_signed_by_{}", id, pk_hash);
if signature != self.signature {
return Err(anyhow!(
@ -108,15 +110,15 @@ impl Pod for MockSignedPod {
fn pub_statements(&self) -> Vec<Statement> {
let id = self.id();
// By convention we put the KEY_TYPE first and KEY_SIGNER second
let mut kvs: HashMap<_, _> = self.dict.iter().collect();
let key_type = Value::from(hash_str(KEY_TYPE));
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 = Value::from(hash_str(KEY_SIGNER));
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)]
[(key_type, value_type), (key_signer, value_signer)]
.into_iter()
.chain(kvs.into_iter().sorted_by_key(|kv| kv.0))
.map(|(k, v)| Statement::ValueOf(AnchoredKey(id, Hash(k.0)), *v))
.chain(kvs.into_iter().sorted_by_key(|kv| kv.0.hash()))
.map(|(k, v)| Statement::ValueOf(AnchoredKey::from((id, k)), v))
.collect()
}
@ -140,9 +142,8 @@ pub mod tests {
use super::*;
use crate::{
constants::MAX_DEPTH,
frontend,
middleware::{self, EMPTY_HASH, F},
middleware::{self, EMPTY_VALUE, F},
};
#[test]
@ -170,27 +171,25 @@ pub mod tests {
assert!(bad_pod.verify().is_err());
let mut bad_pod = pod.clone();
let bad_kv = (hash_str(KEY_SIGNER).into(), Value(PodId(EMPTY_HASH).0 .0));
let bad_kvs_mt = &bad_pod
.kvs()
let bad_kv = (Key::from(KEY_SIGNER), Value::from(EMPTY_VALUE));
let bad_kvs = bad_pod
.kvs
.clone()
.into_iter()
.map(|(AnchoredKey(_, k), v)| (Value(k.0), v))
.chain(iter::once(bad_kv))
.collect::<HashMap<Value, Value>>();
let bad_mt = MerkleTree::new(MAX_DEPTH, bad_kvs_mt)?;
bad_pod.dict.mt = bad_mt;
.collect::<HashMap<Key, Value>>();
bad_pod.kvs = bad_kvs;
assert!(bad_pod.verify().is_err());
let mut bad_pod = pod.clone();
let bad_kv = (hash_str(KEY_TYPE).into(), Value::from(0));
let bad_kvs_mt = &bad_pod
.kvs()
let bad_kv = (Key::from(KEY_TYPE), Value::from(0));
let bad_kvs = bad_pod
.kvs
.clone()
.into_iter()
.map(|(AnchoredKey(_, k), v)| (Value(k.0), v))
.chain(iter::once(bad_kv))
.collect::<HashMap<Value, Value>>();
let bad_mt = MerkleTree::new(MAX_DEPTH, bad_kvs_mt)?;
bad_pod.dict.mt = bad_mt;
.collect::<HashMap<Key, Value>>();
bad_pod.kvs = bad_kvs;
assert!(bad_pod.verify().is_err());
Ok(())