No Pod IDs (#394)

- 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

src/backends/plonky2/error.rs

@@ -1,21 +1,15 @@
 use std::{backtrace::Backtrace, fmt::Debug};
 
-use crate::middleware::{PodId, PodType, Value};
+use crate::middleware::Hash;
 
 pub type Result<T, E = Error> = core::result::Result<T, E>;
 
 #[derive(thiserror::Error, Debug)]
 pub enum InnerError {
-    #[error("id does not match, expected {0}, found {1}")]
-    IdNotEqual(PodId, PodId),
-    #[error("type does not match, expected {0}, found {1}")]
-    TypeNotEqual(PodType, Value),
-    #[error("signer public key does not match, expected {0}, found {1}")]
-    SignerNotEqual(Value, Value),
+    #[error("Statements hash does not match, expected {0}, found {1}")]
+    StsHashNotEqual(Hash, Hash),
 
     // POD related
-    #[error("invalid POD ID")]
-    PodIdInvalid,
     #[error("verification failed: POD does not have type statement")]
     NotTypeStatement,
     #[error("repeated ValueOf")]
@@ -85,16 +79,7 @@ impl Error {
     pub fn not_type_statement() -> Self {
         new!(NotTypeStatement)
     }
-    pub fn pod_id_invalid() -> Self {
-        new!(PodIdInvalid)
-    }
-    pub fn id_not_equal(expected: PodId, found: PodId) -> Self {
-        new!(IdNotEqual(expected, found))
-    }
-    pub fn type_not_equal(expected: PodType, found: Value) -> Self {
-        new!(TypeNotEqual(expected, found))
-    }
-    pub(crate) fn signer_not_equal(expected: Value, found: Value) -> Self {
-        new!(SignerNotEqual(expected, found))
+    pub fn statements_hash_not_equal(expected: Hash, found: Hash) -> Self {
+        new!(StsHashNotEqual(expected, found))
     }
 }