Eduard S.
0e2f7b756e
- middleware:
- Add `Statement::Intro`
- Add `SignedBy` native predicate and operation. The signature is auxiliary data to the operation
- Rename `PodSigner` to `Signer` with a new API (just for signing `RawValue`)
- Removed `NewEntry` operation. Use `ContainsFromEntries` instead
- Remove `KEY_SIGNER` and `KEY_TYPE` which are no longer used
- Merge `RecursivePod` and `Pod` traits
- Change the `Pod::deserialize_data` method to use `Self` instead of `Box<dyn Pod>`
- Extend `Pod` trait with these methods:
- `is_main`: when the pod is Main, in a (recursive) verification its vk will be checked to exist in the vd_set but not if it's intro pod
- `is_mock`: skip some verifications in the recursive mock MainPod verification
- `verifier_data_hash`
- `pod_id` renamed to `statements_hash`
- AnchoredKeys are now a pair of dictionary root and key
- Entry statements are now defined as Contains with literal arguments
- Operations that take Entries now use Contains statements with literal arguments
- frontend:
- Rename `SignedPod` to `SignedDict` (which now contains the dict, public key and signature, and can still `verify(self)`ed)
- The `SignedDict` keeps the method `get_statement` for convenience but now it returns a `Contains` statement that proves the existence of the key in the dict
- The `MainPodBuilder` automatically inserts a `Contains` statement when an operation is added that uses an entry as argument that was not yet "opened".
- Removed the `literal` methods from the `MainPodBuilder` that were loading literals to anchored keys: that was no longer needed after we introduced literal arguments
- backend
- Only verify inclusion of the verifying key into the vd_set if the pod is MainPod. A pod is not MainPod if the first statement is Intro.
- Reject intro pods that have non-intro statements
- Empty pod now returns an intro statement
- Don't insert a type statement automatically in MainPod and MockMainPod. We get rid of the type entry.
- Implement `SignedBy` operation, which uses the muxed table to store signature verifications
- Rename `PodId` to `statements_hash` or `sts_hash` for short. Now this is only used as a hash of the statements for the circuits public inputs.
- Refactor normalization of `self` statements:
- Before: replace values that contain `SELF` by the given pod_id
- After: place the verifying key hash into the Intro predicates
85 lines
2.3 KiB
Rust
85 lines
2.3 KiB
Rust
use std::{backtrace::Backtrace, fmt::Debug};
|
|
|
|
use crate::middleware::Hash;
|
|
|
|
pub type Result<T, E = Error> = core::result::Result<T, E>;
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum InnerError {
|
|
#[error("Statements hash does not match, expected {0}, found {1}")]
|
|
StsHashNotEqual(Hash, Hash),
|
|
|
|
// POD related
|
|
#[error("verification failed: POD does not have type statement")]
|
|
NotTypeStatement,
|
|
#[error("repeated ValueOf")]
|
|
RepeatedValueOf,
|
|
#[error("Statement did not check")]
|
|
StatementNotCheck,
|
|
#[error("Key not found")]
|
|
KeyNotFound,
|
|
|
|
// Other
|
|
#[error("{0}")]
|
|
Custom(String),
|
|
}
|
|
|
|
#[derive(thiserror::Error)]
|
|
pub enum Error {
|
|
#[error("Inner: {inner}\n{backtrace}")]
|
|
Inner {
|
|
inner: Box<InnerError>,
|
|
backtrace: Box<Backtrace>,
|
|
},
|
|
#[error("anyhow::Error: {0}")]
|
|
Anyhow(#[from] anyhow::Error),
|
|
#[error("Plonky2 proof failed to verify {0}: {1}")]
|
|
Plonky2ProofFail(String, anyhow::Error),
|
|
#[error("base64::DecodeError: {0}")]
|
|
Base64Decode(#[from] base64::DecodeError),
|
|
#[error("serde_json::Error: {0}")]
|
|
SerdeJson(#[from] serde_json::Error),
|
|
#[error(transparent)]
|
|
Tree(#[from] crate::backends::plonky2::primitives::merkletree::error::TreeError),
|
|
#[error(transparent)]
|
|
Middleware(#[from] crate::middleware::Error),
|
|
}
|
|
|
|
impl Debug for Error {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
std::fmt::Display::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
macro_rules! new {
|
|
($inner:expr) => {
|
|
Error::Inner {
|
|
inner: Box::new($inner),
|
|
backtrace: Box::new(Backtrace::capture()),
|
|
}
|
|
};
|
|
}
|
|
use InnerError::*;
|
|
impl Error {
|
|
pub fn custom(s: String) -> Self {
|
|
new!(Custom(s))
|
|
}
|
|
pub fn plonky2_proof_fail(context: impl Into<String>, e: anyhow::Error) -> Self {
|
|
Self::Plonky2ProofFail(context.into(), e)
|
|
}
|
|
pub fn key_not_found() -> Self {
|
|
new!(KeyNotFound)
|
|
}
|
|
pub fn statement_not_check() -> Self {
|
|
new!(StatementNotCheck)
|
|
}
|
|
pub fn repeated_value_of() -> Self {
|
|
new!(RepeatedValueOf)
|
|
}
|
|
pub fn not_type_statement() -> Self {
|
|
new!(NotTypeStatement)
|
|
}
|
|
pub fn statements_hash_not_equal(expected: Hash, found: Hash) -> Self {
|
|
new!(StsHashNotEqual(expected, found))
|
|
}
|
|
}
|