Refactor frontend/middleware types (#194)
* 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:
GitHub
parent
9e860ef262
commit
c232c8dae5
33 changed files with 1985 additions and 2800 deletions
|
|
@ -1,14 +1,14 @@
|
|||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
/// This file implements the types defined at
|
||||
/// https://0xparc.github.io/pod2/values.html#dictionary-array-set .
|
||||
use anyhow::Result;
|
||||
use anyhow::{anyhow, Result};
|
||||
|
||||
#[cfg(feature = "backend_plonky2")]
|
||||
use crate::backends::plonky2::primitives::merkletree::{Iter as TreeIter, MerkleProof, MerkleTree};
|
||||
use crate::backends::plonky2::primitives::merkletree::{MerkleProof, MerkleTree};
|
||||
use crate::{
|
||||
constants::MAX_DEPTH,
|
||||
middleware::basetypes::{hash_value, Hash, Value, EMPTY_VALUE},
|
||||
middleware::{hash_value, Hash, Key, RawValue, Value, EMPTY_VALUE},
|
||||
};
|
||||
|
||||
/// Dictionary: the user original keys and values are hashed to be used in the leaf.
|
||||
|
|
@ -16,47 +16,58 @@ use crate::{
|
|||
/// leaf.value=hash(original_value)
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Dictionary {
|
||||
// exposed with pub(crate) so that it can be modified at tests
|
||||
pub(crate) mt: MerkleTree,
|
||||
mt: MerkleTree,
|
||||
kvs: HashMap<Key, Value>,
|
||||
}
|
||||
|
||||
impl Dictionary {
|
||||
pub fn new(kvs: &HashMap<Hash, Value>) -> Result<Self> {
|
||||
let kvs: HashMap<Value, Value> = kvs.iter().map(|(&k, &v)| (Value(k.0), v)).collect();
|
||||
pub fn new(kvs: HashMap<Key, Value>) -> Result<Self> {
|
||||
let kvs_raw: HashMap<RawValue, RawValue> = kvs
|
||||
.iter()
|
||||
.map(|(k, v)| (RawValue(k.hash().0), v.raw()))
|
||||
.collect();
|
||||
Ok(Self {
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs)?,
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs_raw)?,
|
||||
kvs,
|
||||
})
|
||||
}
|
||||
pub fn commitment(&self) -> Hash {
|
||||
self.mt.root()
|
||||
}
|
||||
pub fn get(&self, key: &Value) -> Result<Value> {
|
||||
self.mt.get(key)
|
||||
pub fn get(&self, key: &Key) -> Result<&Value> {
|
||||
self.kvs
|
||||
.get(key)
|
||||
.ok_or_else(|| anyhow!("key \"{}\" not found", key.name()))
|
||||
}
|
||||
pub fn prove(&self, key: &Value) -> Result<(Value, MerkleProof)> {
|
||||
self.mt.prove(key)
|
||||
pub fn prove(&self, key: &Key) -> Result<(&Value, MerkleProof)> {
|
||||
let (_, mtp) = self.mt.prove(&RawValue(key.hash().0))?;
|
||||
let value = self.kvs.get(key).expect("key exists");
|
||||
Ok((value, mtp))
|
||||
}
|
||||
pub fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
|
||||
self.mt.prove_nonexistence(key)
|
||||
pub fn prove_nonexistence(&self, key: &Key) -> Result<MerkleProof> {
|
||||
self.mt.prove_nonexistence(&RawValue(key.hash().0))
|
||||
}
|
||||
pub fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
|
||||
MerkleTree::verify(MAX_DEPTH, root, proof, key, value)
|
||||
pub fn verify(root: Hash, proof: &MerkleProof, key: &Key, value: &Value) -> Result<()> {
|
||||
let key = RawValue(key.hash().0);
|
||||
MerkleTree::verify(MAX_DEPTH, root, proof, &key, &value.raw())
|
||||
}
|
||||
pub fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Value) -> Result<()> {
|
||||
MerkleTree::verify_nonexistence(MAX_DEPTH, root, proof, key)
|
||||
pub fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Key) -> Result<()> {
|
||||
let key = RawValue(key.hash().0);
|
||||
MerkleTree::verify_nonexistence(MAX_DEPTH, root, proof, &key)
|
||||
}
|
||||
pub fn iter(&self) -> TreeIter {
|
||||
self.mt.iter()
|
||||
}
|
||||
}
|
||||
impl<'a> IntoIterator for &'a Dictionary {
|
||||
type Item = (&'a Value, &'a Value);
|
||||
type IntoIter = TreeIter<'a>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
self.mt.iter()
|
||||
// TODO: Rename to dict to be consistent maybe?
|
||||
pub fn kvs(&self) -> &HashMap<Key, Value> {
|
||||
&self.kvs
|
||||
}
|
||||
}
|
||||
// impl<'a> IntoIterator for &'a Dictionary {
|
||||
// type Item = (&'a RawValue, &'a RawValue);
|
||||
// type IntoIter = TreeIter<'a>;
|
||||
//
|
||||
// fn into_iter(self) -> Self::IntoIter {
|
||||
// self.mt.iter()
|
||||
// }
|
||||
// }
|
||||
|
||||
impl PartialEq for Dictionary {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
|
|
@ -71,42 +82,48 @@ impl Eq for Dictionary {}
|
|||
#[derive(Clone, Debug)]
|
||||
pub struct Set {
|
||||
mt: MerkleTree,
|
||||
set: HashSet<Value>,
|
||||
}
|
||||
|
||||
impl Set {
|
||||
pub fn new(set: &[Value]) -> Result<Self> {
|
||||
let kvs: HashMap<Value, Value> = set
|
||||
pub fn new(set: HashSet<Value>) -> Result<Self> {
|
||||
let kvs_raw: HashMap<RawValue, RawValue> = set
|
||||
.iter()
|
||||
.map(|e| {
|
||||
let h = hash_value(e);
|
||||
(Value::from(h), EMPTY_VALUE)
|
||||
let h = hash_value(&e.raw());
|
||||
(RawValue::from(h), EMPTY_VALUE)
|
||||
})
|
||||
.collect();
|
||||
Ok(Self {
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs)?,
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs_raw)?,
|
||||
set,
|
||||
})
|
||||
}
|
||||
pub fn commitment(&self) -> Hash {
|
||||
self.mt.root()
|
||||
}
|
||||
pub fn contains(&self, value: &Value) -> Result<bool> {
|
||||
self.mt.contains(value)
|
||||
pub fn contains(&self, value: &Value) -> bool {
|
||||
self.set.contains(value)
|
||||
}
|
||||
pub fn prove(&self, value: &Value) -> Result<MerkleProof> {
|
||||
let (_, proof) = self.mt.prove(value)?;
|
||||
let h = hash_value(&value.raw());
|
||||
let (_, proof) = self.mt.prove(&RawValue::from(h))?;
|
||||
Ok(proof)
|
||||
}
|
||||
pub fn prove_nonexistence(&self, value: &Value) -> Result<MerkleProof> {
|
||||
self.mt.prove_nonexistence(value)
|
||||
let h = hash_value(&value.raw());
|
||||
self.mt.prove_nonexistence(&RawValue::from(h))
|
||||
}
|
||||
pub fn verify(root: Hash, proof: &MerkleProof, value: &Value) -> Result<()> {
|
||||
MerkleTree::verify(MAX_DEPTH, root, proof, value, &EMPTY_VALUE)
|
||||
let h = hash_value(&value.raw());
|
||||
MerkleTree::verify(MAX_DEPTH, root, proof, &RawValue::from(h), &EMPTY_VALUE)
|
||||
}
|
||||
pub fn verify_nonexistence(root: Hash, proof: &MerkleProof, value: &Value) -> Result<()> {
|
||||
MerkleTree::verify_nonexistence(MAX_DEPTH, root, proof, value)
|
||||
let h = hash_value(&value.raw());
|
||||
MerkleTree::verify_nonexistence(MAX_DEPTH, root, proof, &RawValue::from(h))
|
||||
}
|
||||
pub fn iter(&self) -> TreeIter {
|
||||
self.mt.iter()
|
||||
pub fn set(&self) -> &HashSet<Value> {
|
||||
&self.set
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -124,34 +141,46 @@ impl Eq for Set {}
|
|||
#[derive(Clone, Debug)]
|
||||
pub struct Array {
|
||||
mt: MerkleTree,
|
||||
array: Vec<Value>,
|
||||
}
|
||||
|
||||
impl Array {
|
||||
pub fn new(array: &[Value]) -> Result<Self> {
|
||||
let kvs: HashMap<Value, Value> = array
|
||||
pub fn new(array: Vec<Value>) -> Result<Self> {
|
||||
let kvs_raw: HashMap<RawValue, RawValue> = array
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &e)| (Value::from(i as i64), e))
|
||||
.map(|(i, e)| (RawValue::from(i as i64), e.raw()))
|
||||
.collect();
|
||||
|
||||
Ok(Self {
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs)?,
|
||||
mt: MerkleTree::new(MAX_DEPTH, &kvs_raw)?,
|
||||
array,
|
||||
})
|
||||
}
|
||||
pub fn commitment(&self) -> Hash {
|
||||
self.mt.root()
|
||||
}
|
||||
pub fn get(&self, i: usize) -> Result<Value> {
|
||||
self.mt.get(&Value::from(i as i64))
|
||||
pub fn get(&self, i: usize) -> Result<&Value> {
|
||||
self.array
|
||||
.get(i)
|
||||
.ok_or_else(|| anyhow!("index {} out of bounds 0..{}", i, self.array.len()))
|
||||
}
|
||||
pub fn prove(&self, i: usize) -> Result<(Value, MerkleProof)> {
|
||||
self.mt.prove(&Value::from(i as i64))
|
||||
pub fn prove(&self, i: usize) -> Result<(&Value, MerkleProof)> {
|
||||
let (_, mtp) = self.mt.prove(&RawValue::from(i as i64))?;
|
||||
let value = self.array.get(i).expect("valid index");
|
||||
Ok((value, mtp))
|
||||
}
|
||||
pub fn verify(root: Hash, proof: &MerkleProof, i: usize, value: &Value) -> Result<()> {
|
||||
MerkleTree::verify(MAX_DEPTH, root, proof, &Value::from(i as i64), value)
|
||||
MerkleTree::verify(
|
||||
MAX_DEPTH,
|
||||
root,
|
||||
proof,
|
||||
&RawValue::from(i as i64),
|
||||
&value.raw(),
|
||||
)
|
||||
}
|
||||
pub fn iter(&self) -> TreeIter {
|
||||
self.mt.iter()
|
||||
pub fn array(&self) -> &[Value] {
|
||||
&self.array
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue