migrate from anyhow to thiserror (#197)

* migrate from anyhow to thiserror (#190). pending polish error msgs

* Add backtrace and compartmentalize errors

- Include backtraces in the errors we generate.  To get this we can't
  just return a literal enum, because the backtrace requires a call.
- Related to the previous point: add methods to create errors so
  we can include the backtrace conveniently without changing too much
  the syntax.  So instead of `Err(Error::KeyNotFound(key))` (literal
  enum) it will be `Err(Error::key_not_found(key))` (method call)
- Each error should be local to its scope, and each scope should
  only return its own error.
  - The merkle tree should return `TreeError` and not Error
  - The middleware should return `MiddlewareError` and not Error
- With a global Error we can't easily include backend/frontend types in
  the error fields, so declare a `BackendError` and a `FrontendError`
  and follow the pattern from the previous point
- The Pod traits should be able to return backend errors and will be
  used in the frontend; for that we change them to use trait object
  Error: `dyn std::error::Error`

* fix error

* apply suggestions from @arnaucube

* rename XError and XResult to Error and Result

* reorg signature

* make frontend custom error more ergonomic

* remove unnecessary feature

---------

Co-authored-by: Eduard S. <eduardsanou@posteo.net>

src/backends/plonky2/error.rs

@@ -0,0 +1,93 @@
+use std::{backtrace::Backtrace, fmt::Debug};
+
+use crate::middleware::{PodId, PodType, Value};
+
+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),
+
+    // POD related
+    #[error("invalid POD ID")]
+    PodIdInvalid,
+    #[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}")]
+    Plonky2ProofFail(anyhow::Error),
+    #[error("base64::DecodeError: {0}")]
+    Base64Decode(#[from] base64::DecodeError),
+    #[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(crate) fn custom(s: String) -> Self {
+        new!(Custom(s))
+    }
+    pub(crate) fn plonky2_proof_fail(e: anyhow::Error) -> Self {
+        Self::Plonky2ProofFail(e)
+    }
+    pub(crate) fn key_not_found() -> Self {
+        new!(KeyNotFound)
+    }
+    pub(crate) fn statement_not_check() -> Self {
+        new!(StatementNotCheck)
+    }
+    pub(crate) fn repeated_value_of() -> Self {
+        new!(RepeatedValueOf)
+    }
+    pub(crate) fn not_type_statement() -> Self {
+        new!(NotTypeStatement)
+    }
+    pub(crate) fn pod_id_invalid() -> Self {
+        new!(PodIdInvalid)
+    }
+    pub(crate) fn id_not_equal(expected: PodId, found: PodId) -> Self {
+        new!(IdNotEqual(expected, found))
+    }
+    pub(crate) fn type_not_equal(expected: PodType, found: Value) -> Self {
+        new!(TypeNotEqual(expected, found))
+    }
+}