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

chore: add statement and KV metadata to frontend PODs (#117)

Browse source 
* Add statement and KV metadata to frontend PODs

* Code review
This commit is contained in:
Ahmad Afuni 2025-03-07 14:35:25 +10:00 • committed by GitHub
parent 02ec7c311b
commit 6627b46819
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 290 additions and 224 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/backends/plonky2/basetypes.rs
View file

@ -56,7 +56,7 @@ impl Ord for Value {
return Ordering::Greater;
}
}
return Ordering::Equal;
Ordering::Equal
}
}
@ -84,7 +84,7 @@ impl TryInto<i64> for Value {
type Error = Error;
fn try_into(self) -> std::result::Result<i64, Self::Error> {
let value = self.0;
if &value[2..] != &[F::ZERO, F::ZERO]
if value[2..] != [F::ZERO, F::ZERO]
|| value[..2]
.iter()
.all(|x| x.to_canonical_u64() > u32::MAX as u64)
@ -118,7 +118,7 @@ pub fn hash_value(input: &Value) -> Hash {
Hash(PoseidonHash::hash_no_pad(&input.0).elements)
}
pub fn hash_fields(input: &[F]) -> Hash {
Hash(PoseidonHash::hash_no_pad(&input).elements)
Hash(PoseidonHash::hash_no_pad(input).elements)
}
impl From<Value> for Hash {
@ -208,7 +208,7 @@ mod tests {
#[test]
fn test_i64_value_roundtrip() {
let test_cases = vec![
let test_cases = [
0i64,
1,
-1,

39
src/backends/plonky2/mock_main/mod.rs
View file

@ -75,7 +75,7 @@ impl fmt::Display for MockMainPod {
let op = (i >= offset_input_statements)
.then(|| &self.operations[i - offset_input_statements]);
fmt_statement_index(f, &st, op, i)?;
fmt_statement_index(f, st, op, i)?;
}
Ok(())
}
@ -102,7 +102,7 @@ fn fmt_statement_index(
write!(f, "{}", op)?;
}
}
write!(f, "\n")?;
writeln!(f)?;
}
Ok(())
}
@ -151,11 +151,7 @@ impl MockMainPod {
let none_sig_pod: Box<dyn Pod> = Box::new(NonePod {});
assert!(inputs.signed_pods.len() <= params.max_input_signed_pods);
for i in 0..params.max_input_signed_pods {
let pod = inputs
.signed_pods
.get(i)
.map(|p| *p)
.unwrap_or(&none_sig_pod);
let pod = inputs.signed_pods.get(i).copied().unwrap_or(&none_sig_pod);
let sts = pod.pub_statements();
assert!(sts.len() <= params.max_signed_pod_values);
for j in 0..params.max_signed_pod_values {
@ -173,11 +169,7 @@ impl MockMainPod {
let none_main_pod: Box<dyn Pod> = Box::new(NonePod {});
assert!(inputs.main_pods.len() <= params.max_input_main_pods);
for i in 0..params.max_input_main_pods {
let pod = inputs
.main_pods
.get(i)
.map(|p| *p)
.unwrap_or(&none_main_pod);
let pod = inputs.main_pods.get(i).copied().unwrap_or(&none_main_pod);
let sts = pod.pub_statements();
assert!(sts.len() <= params.max_public_statements);
for j in 0..params.max_public_statements {
@ -241,7 +233,10 @@ impl MockMainPod {
(&middleware::Statement::try_from(s.clone()).ok()? == op_arg).then_some(i)
})
.map(OperationArg::Index)
.ok_or(anyhow!("statement not found")),
.ok_or(anyhow!(
"Statement corresponding to op arg {} not found",
op_arg
)),
}
}
@ -347,7 +342,7 @@ impl MockMainPod {
fn statement_none(params: &Params) -> Statement {
let mut args = Vec::with_capacity(params.max_statement_args);
Self::pad_statement_args(&params, &mut args);
Self::pad_statement_args(params, &mut args);
Statement(Predicate::Native(NativePredicate::None), args)
}
@ -368,7 +363,7 @@ impl MockMainPod {
pub fn hash_statements(statements: &[Statement], _params: &Params) -> middleware::Hash {
let field_elems = statements
.into_iter()
.iter()
.flat_map(|statement| statement.clone().to_fields(_params).0)
.collect::<Vec<_>>();
Hash(PoseidonHash::hash_no_pad(&field_elems).elements)
@ -388,7 +383,7 @@ impl Pod for MockMainPod {
.iter()
.find(|s| {
s.0 == Predicate::Native(NativePredicate::ValueOf)
&& s.1.len() > 0
&& !s.1.is_empty()
&& if let StatementArg::Key(AnchoredKey(pod_id, key_hash)) = s.1[0] {
pod_id == SELF && key_hash == hash_str(KEY_TYPE)
} else {
@ -402,7 +397,7 @@ impl Pod for MockMainPod {
// `NewValue` operation.
let value_ofs_unique = {
let key_id_pairs = input_statements
.into_iter()
.iter()
.enumerate()
.map(|(i, s)| {
(
@ -512,9 +507,9 @@ pub mod tests {
println!("{:#}", pod);
assert_eq!(pod.verify(), true); // TODO
// println!("id: {}", pod.id());
// println!("pub_statements: {:?}", pod.pub_statements());
assert!(pod.verify()); // TODO
// println!("id: {}", pod.id());
// println!("pub_statements: {:?}", pod.pub_statements());
Ok(())
}
@ -533,7 +528,7 @@ pub mod tests {
println!("{}", pod);
assert_eq!(pod.verify(), true);
assert!(pod.verify());
Ok(())
}
@ -547,7 +542,7 @@ pub mod tests {
let pod = proof_pod.pod.into_any().downcast::<MockMainPod>().unwrap();
println!("{}", pod);
assert_eq!(pod.verify(), true);
assert!(pod.verify());
Ok(())
}

2
src/backends/plonky2/mock_main/operation.rs
View file

@ -2,7 +2,7 @@ use anyhow::Result;
use std::fmt;
use super::Statement;
use crate::middleware::{self, NativeOperation, OperationType};
use crate::middleware::{self, OperationType};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum OperationArg {

6
src/backends/plonky2/mock_main/statement.rs
View file

@ -50,7 +50,7 @@ impl TryFrom<Statement> for middleware::Statement {
type SA = StatementArg;
let proper_args = s.args();
let args = (
proper_args.get(0).cloned(),
proper_args.first().cloned(),
proper_args.get(1).cloned(),
proper_args.get(2).cloned(),
);
@ -110,11 +110,11 @@ impl From<middleware::Statement> for Statement {
match s.code() {
middleware::Predicate::Native(c) => Statement(
middleware::Predicate::Native(c),
s.args().into_iter().map(|arg| arg).collect(),
s.args().into_iter().collect(),
),
middleware::Predicate::Custom(cpr) => Statement(
middleware::Predicate::Custom(cpr),
s.args().into_iter().map(|arg| arg).collect(),
s.args().into_iter().collect(),
),
middleware::Predicate::BatchSelf(_) => unreachable!(),
}

24
src/backends/plonky2/mock_signed.rs
View file

@ -23,8 +23,8 @@ impl PodSigner for MockSigner {
fn sign(&mut self, _params: &Params, kvs: &HashMap<Hash, 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(hash_str(KEY_SIGNER), pubkey);
kvs.insert(hash_str(KEY_TYPE), Value::from(PodType::MockSigned));
let dict = Dictionary::new(&kvs)?;
let id = PodId(dict.commitment());
@ -47,7 +47,7 @@ pub struct MockSignedPod {
impl Pod for MockSignedPod {
fn verify(&self) -> bool {
// Verify type
let value_at_type = match self.dict.get(&hash_str(&KEY_TYPE).into()) {
let value_at_type = match self.dict.get(&hash_str(KEY_TYPE).into()) {
Ok(v) => v,
Err(_) => return false,
};
@ -73,7 +73,7 @@ impl Pod for MockSignedPod {
}
// Verify signature
let pk_hash = match self.dict.get(&hash_str(&KEY_SIGNER).into()) {
let pk_hash = match self.dict.get(&hash_str(KEY_SIGNER).into()) {
Ok(v) => v,
Err(_) => return false,
};
@ -82,7 +82,7 @@ impl Pod for MockSignedPod {
return false;
}
return true;
true
}
fn id(&self) -> PodId {
@ -124,17 +124,17 @@ pub mod tests {
let pod = pod.sign(&mut signer).unwrap();
let pod = pod.pod.into_any().downcast::<MockSignedPod>().unwrap();
assert_eq!(pod.verify(), true);
assert!(pod.verify());
println!("id: {}", pod.id());
println!("kvs: {:?}", pod.kvs());
let mut bad_pod = pod.clone();
bad_pod.signature = "".into();
assert_eq!(bad_pod.verify(), false);
assert!(!bad_pod.verify());
let mut bad_pod = pod.clone();
bad_pod.id.0 .0[0] = F::ZERO;
assert_eq!(bad_pod.verify(), false);
assert!(!bad_pod.verify());
let mut bad_pod = pod.clone();
let bad_kv = (hash_str(KEY_SIGNER).into(), Value(PodId(NULL).0 .0));
@ -144,9 +144,9 @@ pub mod tests {
.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)?;
let bad_mt = MerkleTree::new(MAX_DEPTH, bad_kvs_mt)?;
bad_pod.dict.mt = bad_mt;
assert_eq!(bad_pod.verify(), false);
assert!(!bad_pod.verify());
let mut bad_pod = pod.clone();
let bad_kv = (hash_str(KEY_TYPE).into(), Value::from(0));
@ -156,9 +156,9 @@ pub mod tests {
.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)?;
let bad_mt = MerkleTree::new(MAX_DEPTH, bad_kvs_mt)?;
bad_pod.dict.mt = bad_mt;
assert_eq!(bad_pod.verify(), false);
assert!(!bad_pod.verify());
Ok(())
}

16
src/backends/plonky2/primitives/merkletree.rs
View file

@ -133,7 +133,7 @@ impl MerkleTree {
let h = proof.compute_root_from_leaf(max_depth, key, Some(*value))?;
if h != root {
return Err(anyhow!("proof of inclusion does not verify"));
Err(anyhow!("proof of inclusion does not verify"))
} else {
Ok(())
}
@ -155,7 +155,7 @@ impl MerkleTree {
let h = proof.compute_root_from_leaf(max_depth, &k, v)?;
if h != root {
return Err(anyhow!("proof of exclusion does not verify"));
Err(anyhow!("proof of exclusion does not verify"))
} else {
Ok(())
}
@ -332,12 +332,12 @@ impl Node {
if let Some(s) = siblings.as_mut() {
s.push(n.left.hash());
}
return n.right.down(lvl + 1, max_depth, path, siblings);
n.right.down(lvl + 1, max_depth, path, siblings)
} else {
if let Some(s) = siblings.as_mut() {
s.push(n.right.hash());
}
return n.left.down(lvl + 1, max_depth, path, siblings);
n.left.down(lvl + 1, max_depth, path, siblings)
}
}
Self::Leaf(Leaf {
@ -345,7 +345,7 @@ impl Node {
value,
path: _p,
hash: _h,
}) => Ok(Some((key.clone(), value.clone()))),
}) => Ok(Some((*key, *value))),
_ => Ok(None),
}
}
@ -549,8 +549,8 @@ impl<'a> Iterator for Iter<'a> {
left,
right,
})) => {
self.state.push(&right);
self.state.push(&left);
self.state.push(right);
self.state.push(left);
self.next()
}
_ => None,
@ -621,7 +621,7 @@ pub mod tests {
match first_unequal_bits {
Some((b1, b2)) => {
if b1 < b2 {
if !b1 & b2 {
Ordering::Less
} else {
Ordering::Greater