Return rules evaluation from the api response on rule valuation

src/api.rs

@@ -1,11 +1,13 @@
 use crate::config::Config;
 use crate::controller::{ControllerCommands, ControllerInterface, DBQuery};
+use crate::rules::Results;
 use crate::storage;
 use crate::types::PremintTypes;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::routing::{get, post};
 use axum::{Json, Router};
+use serde::Serialize;
 use sqlx::SqlitePool;
 use tokio::net::TcpListener;
 
@@ -64,13 +66,59 @@ async fn health() -> &'static str {
 async fn submit_premint(
     State(state): State<AppState>,
     Json(premint): Json<PremintTypes>,
-) -> (StatusCode, String) {
+) -> (StatusCode, Json<APIResponse>) {
+    let (snd, recv) = tokio::sync::oneshot::channel();
     match state
         .controller
-        .send_command(ControllerCommands::Broadcast { message: premint })
+        .send_command(ControllerCommands::Broadcast {
+            message: premint,
+            channel: snd,
+        })
         .await
     {
-        Ok(()) => (StatusCode::OK, "Premint submitted".to_string()),
-        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
+        Ok(()) => match recv.await {
+            Ok(Ok(_)) => (
+                StatusCode::OK,
+                Json(APIResponse::Success {
+                    message: "Premint submitted".to_string(),
+                }),
+            ),
+            Ok(Err(e)) => match e.downcast_ref::<Results>() {
+                Some(res) => (
+                    StatusCode::BAD_REQUEST,
+                    Json(APIResponse::RulesError {
+                        evaluation: res.clone(),
+                    }),
+                ),
+                None => (
+                    StatusCode::BAD_REQUEST,
+                    Json(APIResponse::Error {
+                        message: e.to_string(),
+                    }),
+                ),
+            },
+            Err(e) => {
+                tracing::warn!("Failed to submit premint: {:?}", e);
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(APIResponse::Error {
+                        message: e.to_string(),
+                    }),
+                )
+            }
+        },
+        Err(e) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(APIResponse::Error {
+                message: e.to_string(),
+            }),
+        ),
     }
 }
+
+#[derive(Serialize)]
+pub enum APIResponse {
+    RulesError { evaluation: Results },
+    Error { message: String },
+    Success { message: String },
+}

src/controller.rs

@@ -41,6 +41,7 @@ pub enum ControllerCommands {
     AnnounceSelf,
     Broadcast {
         message: PremintTypes,
+        channel: oneshot::Sender<eyre::Result<()>>,
     },
     ReturnNodeInfo {
         channel: oneshot::Sender<MintpoolNodeInfo>,
@@ -125,16 +126,28 @@ impl Controller {
                     .send(SwarmCommand::AnnounceSelf)
                     .await?;
             }
-            ControllerCommands::Broadcast { message } => {
+            ControllerCommands::Broadcast { message, channel } => {
                 match self.validate_and_insert(message.clone()).await {
-                    Ok(_) => {
-                        self.swarm_command_sender
+                    Ok(_result) => {
+                        if let Err(err) = self
+                            .swarm_command_sender
                             .send(SwarmCommand::Broadcast { message })
-                            .await?;
-                    }
-                    Err(err) => {
-                        tracing::warn!("Invalid premint, not broadcasting: {:?}", err);
+                            .await
+                        {
+                            channel
+                                .send(Err(eyre::eyre!("Error broadcasing premint: {:?}", err)))
+                                .map_err(|err| {
+                                    eyre::eyre!("error broadcasting via channel: {:?}", err)
+                                })?;
+                        } else {
+                            channel.send(Ok(())).map_err(|err| {
+                                eyre::eyre!("error broadcasting via channel: {:?}", err)
+                            })?;
+                        }
                     }
+                    Err(err) => channel
+                        .send(Err(err))
+                        .map_err(|err| eyre::eyre!("error broadcasting via channel: {:?}", err))?,
                 }
             }
             ControllerCommands::ReturnNodeInfo { channel } => {

src/p2p.rs

@@ -315,6 +315,8 @@ impl SwarmController {
                 } else {
                     match serde_json::from_str::<PremintTypes>(&msg) {
                         Ok(premint) => {
+                            let id = premint.metadata().id;
+                            tracing::info!(id = id, "Received new premint");
                             self.event_sender
                                 .send(P2PEvent::PremintReceived(premint.clone()))
                                 .await

src/rules.rs

@@ -13,7 +13,7 @@ use crate::config::Config;
 use crate::storage::{PremintStorage, Reader};
 use crate::types::PremintTypes;
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum Evaluation {
     Accept,
     Ignore(String),
@@ -67,6 +67,18 @@ pub struct RuleResult {
     pub result: eyre::Result<Evaluation>,
 }
 
+impl Clone for RuleResult {
+    fn clone(&self) -> Self {
+        Self {
+            rule_name: self.rule_name,
+            result: match &self.result {
+                Ok(e) => Ok(e.clone()),
+                Err(e) => Err(eyre::eyre!(e.to_string())),
+            },
+        }
+    }
+}
+
 impl Serialize for RuleResult {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -91,7 +103,7 @@ impl Serialize for RuleResult {
     }
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Clone)]
 pub struct Results(Vec<RuleResult>);
 
 impl Results {
@@ -437,7 +449,7 @@ mod test {
     use crate::premints::zora_premint_v2::types::ZoraPremintV2;
     use crate::rules::general::existing_token_uri;
     use crate::rules::Evaluation::{Accept, Reject};
-    use crate::storage::Writer;
+    use crate::storage::{PremintStorage, Writer};
     use crate::types::{Premint, SimplePremint};
 
     use super::*;

src/stdin.rs

@@ -122,12 +122,27 @@ async fn process_stdin_line(ctl: ControllerInterface, line: String) {
     } else {
         match PremintTypes::from_json(line) {
             Ok(premint) => {
+                let (snd, recv) = tokio::sync::oneshot::channel();
                 if let Err(err) = ctl
-                    .send_command(ControllerCommands::Broadcast { message: premint })
+                    .send_command(ControllerCommands::Broadcast {
+                        message: premint,
+                        channel: snd,
+                    })
                     .await
                 {
                     tracing::error!(error = err.to_string(), "Error sending broadcast command");
                 };
+                match recv.await {
+                    Ok(Ok(())) => {
+                        tracing::info!("Premint broadcasted successfully");
+                    }
+                    Ok(Err(e)) => {
+                        tracing::warn!("Error broadcasting premint: {:?}", e);
+                    }
+                    Err(e) => {
+                        tracing::error!("Error broadcasting premint: {:?}", e);
+                    }
+                }
             }
 
             Err(e) => {

tests/e2e_test.rs

@@ -76,8 +76,10 @@ async fn test_zora_premint_v2_e2e() {
     // Push a message to the mintpool
     let premint: ZoraPremintV2 = serde_json::from_str(PREMINT_JSON).unwrap();
 
+    let (send, _recv) = tokio::sync::oneshot::channel();
     ctl.send_command(ControllerCommands::Broadcast {
         message: PremintTypes::ZoraV2(premint),
+        channel: send,
     })
     .await
     .unwrap();

tests/p2p_test.rs

@@ -55,17 +55,20 @@ async fn test_list_all_premints() {
 
     let nodes = mintpool_build::gen_fully_connected_swarm(2310, num_nodes).await;
     let (first, nodes) = mintpool_build::split_first_rest(nodes).await;
-
+    let (snd, rcv) = tokio::sync::oneshot::channel();
     first
         .send_command(Broadcast {
             message: PremintTypes::ZoraV2(Default::default()),
+            channel: snd,
         })
         .await
         .unwrap();
+    let (snd, rcv) = tokio::sync::oneshot::channel();
 
     first
         .send_command(Broadcast {
             message: PremintTypes::Simple(SimplePremint::build_default()),
+            channel: snd,
         })
         .await
         .unwrap();