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/mainpod/statement.rs

@@ -74,6 +74,7 @@ impl TryFrom<Statement> for middleware::Statement {
                     S::HashOf(a1.try_into()?, a2.try_into()?, a3.try_into()?)
                 }
                 (NP::PublicKeyOf, &[a1, a2]) => S::PublicKeyOf(a1.try_into()?, a2.try_into()?),
+                (NP::SignedBy, &[a1, a2]) => S::SignedBy(a1.try_into()?, a2.try_into()?),
                 (NP::ContainerInsert, &[a1, a2, a3, a4]) => S::ContainerInsert(
                     a1.try_into()?,
                     a2.try_into()?,
@@ -105,6 +106,17 @@ impl TryFrom<Statement> for middleware::Statement {
                     .collect();
                 S::Custom(cpr, vs)
             }
+            Predicate::Intro(ir) => {
+                let vs: Vec<Value> = proper_args
+                    .into_iter()
+                    .filter_map(|arg| match arg {
+                        SA::None => None,
+                        SA::Literal(v) => Some(v),
+                        _ => unreachable!(),
+                    })
+                    .collect();
+                S::Intro(ir, vs)
+            }
             Predicate::BatchSelf(_) => {
                 unreachable!()
             }
@@ -123,6 +135,10 @@ impl From<middleware::Statement> for Statement {
                 middleware::Predicate::Custom(cpr),
                 s.args().into_iter().collect(),
             ),
+            middleware::Predicate::Intro(ir) => Statement(
+                middleware::Predicate::Intro(ir),
+                s.args().into_iter().collect(),
+            ),
             middleware::Predicate::BatchSelf(_) => unreachable!(),
         }
     }