files reorg, add github CI for rustfmt checks

Author: arnaucube

.github/workflows/rustfmt.yml

@@ -0,0 +1,21 @@
+name: Rustfmt Check
+
+on:
+  pull_request:
+    branches: [ main ]
+    types: [ready_for_review, opened, synchronize, reopened]
+  push:
+    branches: [ main ]
+
+jobs:
+  rustfmt:
+    if: github.event.pull_request.draft == false
+    name: Rust formatting
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: rustfmt
+      - name: Check formatting
+        uses: actions-rust-lang/rustfmt@v1

.github/workflows/typos.toml

@@ -1,2 +1,3 @@
 [default.extend-words]
 groth = "groth" # to avoid it dectecting it as 'growth'
+BA = "BA"

src/backends/mock_main.rs src/backends/mock_main/mod.rssrc/backends/mock_main.rs renamed to src/backends/mock_main/mod.rs

@@ -1,18 +1,19 @@
-mod operation;
-mod statement;
+use anyhow::{anyhow, Result};
+use itertools::Itertools;
+use plonky2::hash::poseidon::PoseidonHash;
+use plonky2::plonk::config::Hasher;
+use std::any::Any;
+use std::fmt;
 
 use crate::middleware::{
     self, hash_str, AnchoredKey, Hash, MainPodInputs, NativeOperation, NativePredicate, NonePod,
     Params, Pod, PodId, PodProver, StatementArg, ToFields, KEY_TYPE, SELF,
 };
-use anyhow::Result;
-use itertools::Itertools;
+
+mod operation;
+mod statement;
 pub use operation::*;
-use plonky2::hash::poseidon::PoseidonHash;
-use plonky2::plonk::config::Hasher;
 pub use statement::*;
-use std::any::Any;
-use std::fmt;
 
 pub const VALUE_TYPE: &str = "MockMainPOD";
 
@@ -222,26 +223,25 @@ impl MockMainPod {
     fn find_op_arg(
         statements: &[Statement],
         op_arg: &middleware::Statement,
-    ) -> Result<OperationArg, OperationArgError> {
+    ) -> Result<OperationArg> {
         match op_arg {
             middleware::Statement::None => Ok(OperationArg::None),
             _ => statements
                 .iter()
                 .enumerate()
                 .find_map(|(i, s)| {
-                    // TODO: Error handling
-                    (&middleware::Statement::try_from(s.clone()).unwrap() == op_arg).then_some(i)
+                    (&middleware::Statement::try_from(s.clone()).ok()? == op_arg).then_some(i)
                 })
                 .map(OperationArg::Index)
-                .ok_or(OperationArgError::StatementNotFound),
+                .ok_or(anyhow!("statement not found")),
         }
     }
 
     fn process_private_statements_operations(
         params: &Params,
         statements: &[Statement],
         input_operations: &[middleware::Operation],
-    ) -> Result<Vec<Operation>, OperationArgError> {
+    ) -> Result<Vec<Operation>> {
         let mut operations = Vec::new();
         for i in 0..params.max_priv_statements() {
             let op = input_operations
@@ -252,7 +252,7 @@ impl MockMainPod {
             let mut args = mid_args
                 .iter()
                 .map(|mid_arg| Self::find_op_arg(statements, mid_arg))
-                .collect::<Result<Vec<_>, OperationArgError>>()?;
+                .collect::<Result<Vec<_>>>()?;
             Self::pad_operation_args(params, &mut args);
             operations.push(Operation(op.code(), args));
         }
@@ -265,7 +265,7 @@ impl MockMainPod {
         params: &Params,
         statements: &[Statement],
         mut operations: Vec<Operation>,
-    ) -> Result<Vec<Operation>, OperationArgError> {
+    ) -> Result<Vec<Operation>> {
         let offset_public_statements = statements.len() - params.max_public_statements;
         operations.push(Operation(NativeOperation::NewEntry, vec![]));
         for i in 0..(params.max_public_statements - 1) {
@@ -318,7 +318,7 @@ impl MockMainPod {
             statements[statements.len() - params.max_public_statements..].to_vec();
 
         // get the id out of the public statements
-        let id: PodId = PodId(hash_statements(&public_statements)?);
+        let id: PodId = PodId(hash_statements(&public_statements));
 
         Ok(Self {
             params: params.clone(),
@@ -353,12 +353,12 @@ impl MockMainPod {
     }
 }
 
-pub fn hash_statements(statements: &[Statement]) -> Result<middleware::Hash> {
+pub fn hash_statements(statements: &[Statement]) -> middleware::Hash {
     let field_elems = statements
         .into_iter()
         .flat_map(|statement| statement.clone().to_fields().0)
         .collect::<Vec<_>>();
-    Ok(Hash(PoseidonHash::hash_no_pad(&field_elems).elements))
+    Hash(PoseidonHash::hash_no_pad(&field_elems).elements)
 }
 
 impl Pod for MockMainPod {
@@ -367,7 +367,7 @@ impl Pod for MockMainPod {
         // get the input_statements from the self.statements
         let input_statements = &self.statements[input_statement_offset..];
         // get the id out of the public statements, and ensure it is equal to self.id
-        let ids_match = self.id == PodId(hash_statements(&self.public_statements).unwrap());
+        let ids_match = self.id == PodId(hash_statements(&self.public_statements));
         // find a ValueOf statement from the public statements with key=KEY_TYPE and check that the
         // value is PodType::MockMainPod
         let has_type_statement = self
@@ -473,37 +473,38 @@ pub mod tests {
     use crate::middleware;
 
     #[test]
-    fn test_mock_main_zu_kyc() {
+    fn test_mock_main_zu_kyc() -> Result<()> {
         let params = middleware::Params::default();
 
         let (gov_id_builder, pay_stub_builder) = zu_kyc_sign_pod_builders(&params);
         let mut signer = MockSigner {
             pk: "ZooGov".into(),
         };
-        let gov_id_pod = gov_id_builder.sign(&mut signer).unwrap();
+        let gov_id_pod = gov_id_builder.sign(&mut signer)?;
         let mut signer = MockSigner {
             pk: "ZooDeel".into(),
         };
-        let pay_stub_pod = pay_stub_builder.sign(&mut signer).unwrap();
+        let pay_stub_pod = pay_stub_builder.sign(&mut signer)?;
         let kyc_builder = zu_kyc_pod_builder(&params, &gov_id_pod, &pay_stub_pod);
 
         let mut prover = MockProver {};
-        let kyc_pod = kyc_builder.prove(&mut prover).unwrap();
+        let kyc_pod = kyc_builder.prove(&mut prover)?;
         let pod = kyc_pod.pod.into_any().downcast::<MockMainPod>().unwrap();
 
         println!("{:#}", pod);
 
         assert_eq!(pod.verify(), true); // TODO
                                         // println!("id: {}", pod.id());
                                         // println!("pub_statements: {:?}", pod.pub_statements());
+        Ok(())
     }
 
     #[test]
-    fn test_mock_main_great_boy() {
+    fn test_mock_main_great_boy() -> Result<()> {
         let great_boy_builder = great_boy_pod_full_flow();
 
         let mut prover = MockProver {};
-        let great_boy_pod = great_boy_builder.prove(&mut prover).unwrap();
+        let great_boy_pod = great_boy_builder.prove(&mut prover)?;
         let pod = great_boy_pod
             .pod
             .into_any()
@@ -513,16 +514,20 @@ pub mod tests {
         println!("{}", pod);
 
         assert_eq!(pod.verify(), true);
+
+        Ok(())
     }
 
     #[test]
-    fn test_mock_main_tickets() {
+    fn test_mock_main_tickets() -> Result<()> {
         let tickets_builder = tickets_pod_full_flow();
         let mut prover = MockProver {};
-        let proof_pod = tickets_builder.prove(&mut prover).unwrap();
+        let proof_pod = tickets_builder.prove(&mut prover)?;
         let pod = proof_pod.pod.into_any().downcast::<MockMainPod>().unwrap();
 
         println!("{}", pod);
         assert_eq!(pod.verify(), true);
+
+        Ok(())
     }
 }

src/backends/mock_main/operation.rs

@@ -1,10 +1,8 @@
-use std::fmt;
-
 use anyhow::Result;
-
-use crate::middleware::{self, NativeOperation};
+use std::fmt;
 
 use super::Statement;
+use crate::middleware::{self, NativeOperation};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum OperationArg {
@@ -18,23 +16,6 @@ impl OperationArg {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum OperationArgError {
-    KeyNotFound,
-    StatementNotFound,
-}
-
-impl std::fmt::Display for OperationArgError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            OperationArgError::KeyNotFound => write!(f, "Key not found"),
-            OperationArgError::StatementNotFound => write!(f, "Statement not found"),
-        }
-    }
-}
-
-impl std::error::Error for OperationArgError {}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Operation(pub NativeOperation, pub Vec<OperationArg>);
 

src/backends/mock_main/statement.rs

@@ -1,6 +1,5 @@
-use std::fmt;
-
 use anyhow::{anyhow, Result};
+use std::fmt;
 
 use crate::middleware::{self, NativePredicate, StatementArg, ToFields};
 

src/backends/mock_signed.rs

@@ -1,11 +1,12 @@
+use anyhow::Result;
+use std::any::Any;
+use std::collections::HashMap;
+
 use crate::middleware::{
     containers::Dictionary, hash_str, AnchoredKey, Hash, Params, Pod, PodId, PodSigner, PodType,
     Statement, Value, KEY_SIGNER, KEY_TYPE,
 };
 use crate::primitives::merkletree::MerkleTree;
-use anyhow::Result;
-use std::any::Any;
-use std::collections::HashMap;
 
 pub struct MockSigner {
     pub pk: String,

src/frontend.rs src/frontend/mod.rssrc/frontend.rs renamed to src/frontend/mod.rs

@@ -1,9 +1,6 @@
 //! The frontend includes the user-level abstractions and user-friendly types to define and work
 //! with Pods.
 
-mod operation;
-mod statement;
-
 use anyhow::Result;
 use itertools::Itertools;
 use std::collections::HashMap;
@@ -16,6 +13,9 @@ use crate::middleware::{
     hash_str, Hash, MainPodInputs, NativeOperation, NativePredicate, Params, PodId, PodProver,
     PodSigner, SELF,
 };
+
+mod operation;
+mod statement;
 pub use operation::*;
 pub use statement::*;
 

src/frontend/operation.rs

@@ -1,8 +1,7 @@
 use std::fmt;
 
-use crate::middleware::{hash_str, NativeOperation, NativePredicate};
-
 use super::{AnchoredKey, SignedPod, Statement, StatementArg, Value};
+use crate::middleware::{hash_str, NativeOperation, NativePredicate};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum OperationArg {

src/frontend/statement.rs

@@ -1,10 +1,8 @@
-use std::fmt;
-
 use anyhow::{anyhow, Result};
-
-use crate::middleware::{self, NativePredicate};
+use std::fmt;
 
 use super::{AnchoredKey, Value};
+use crate::middleware::{self, NativePredicate};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum StatementArg {