refactor: add inject sender middleware

Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

crates/service/src/error.rs

@@ -3,7 +3,10 @@
 
 use alloy::primitives::Address;
 use anyhow::Error;
-use axum::{response::{IntoResponse, Response}, Json};
+use axum::{
+    response::{IntoResponse, Response},
+    Json,
+};
 use indexer_monitor::EscrowAccountsError;
 use reqwest::StatusCode;
 use serde::Serialize;
@@ -13,7 +16,7 @@ use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum IndexerServiceError {
     #[error("Issues with provided receipt: {0}")]
-    ReceiptError(tap_core::Error),
+    ReceiptError(#[from] tap_core::Error),
     #[error("No attestation signer found for allocation `{0}`")]
     NoSignerForAllocation(Address),
     #[error("Invalid request body: {0}")]
@@ -31,7 +34,7 @@ pub enum IndexerServiceError {
     CouldNotDecodeSigner(tap_core::Error),
 
     #[error("There was an error while accessing escrow account: {0}")]
-    EscrowAccount(EscrowAccountsError),
+    EscrowAccount(#[from] EscrowAccountsError),
 }
 
 impl IntoResponse for IndexerServiceError {

crates/service/src/middleware.rs

@@ -3,3 +3,4 @@
 
 mod inject_deployment;
 mod inject_receipt;
+mod inject_sender;

crates/service/src/middleware/inject_sender.rs

@@ -0,0 +1,103 @@
+// Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
+// SPDX-License-Identifier: Apache-2.0
+
+use alloy::dyn_abi::Eip712Domain;
+use axum::{
+    extract::{Request, State},
+    middleware::Next,
+    response::Response,
+};
+use indexer_monitor::EscrowAccounts;
+use tap_core::receipt::SignedReceipt;
+use tokio::sync::watch;
+
+use crate::error::IndexerServiceError;
+
+#[derive(Clone)]
+pub struct SenderState {
+    pub domain_separator: Eip712Domain,
+    pub escrow_accounts: watch::Receiver<EscrowAccounts>,
+}
+
+#[derive(Clone)]
+pub struct Sender(String);
+
+impl From<Sender> for String {
+    fn from(value: Sender) -> Self {
+        value.0
+    }
+}
+
+pub async fn sender_middleware(
+    State(state): State<SenderState>,
+    mut request: Request,
+    next: Next,
+) -> Result<Response, IndexerServiceError> {
+    if let Some(receipt) = request.extensions().get::<SignedReceipt>() {
+        let signer = receipt.recover_signer(&state.domain_separator)?;
+        let sender = state
+            .escrow_accounts
+            .borrow()
+            .get_sender_for_signer(&signer)?;
+        request.extensions_mut().insert(Sender(sender.to_string()));
+    }
+
+    Ok(next.run(request).await)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::middleware::inject_sender::SenderState;
+
+    use super::{sender_middleware, Sender};
+    use alloy::primitives::Address;
+    use axum::{
+        body::Body,
+        http::{Extensions, Request},
+        middleware::from_fn_with_state,
+        routing::get,
+        Router,
+    };
+    use indexer_monitor::EscrowAccounts;
+    use reqwest::StatusCode;
+    use test_assets::{create_signed_receipt, ESCROW_ACCOUNTS_BALANCES, ESCROW_ACCOUNTS_SENDERS_TO_SIGNERS};
+    use tokio::sync::watch;
+    use tower::ServiceExt;
+
+    #[tokio::test]
+    async fn test_sender_middleware() {
+        let escrow_accounts = watch::channel(EscrowAccounts::new(
+            ESCROW_ACCOUNTS_BALANCES.to_owned(),
+            ESCROW_ACCOUNTS_SENDERS_TO_SIGNERS.to_owned(),
+        ))
+        .1;
+        let state = SenderState {
+            domain_separator: test_assets::TAP_EIP712_DOMAIN.clone(),
+            escrow_accounts,
+        };
+
+        let middleware = from_fn_with_state(state, sender_middleware);
+
+        async fn handle(extensions: Extensions) -> Body {
+            let sender = extensions.get::<Sender>().expect("Should contain sender");
+            assert_eq!(sender.0, test_assets::TAP_SENDER.1.to_string());
+            Body::empty()
+        }
+
+        let app = Router::new().route("/", get(handle)).layer(middleware);
+
+        let receipt = create_signed_receipt(Address::ZERO, 1, 1, 1).await;
+
+        let res = app
+            .oneshot(
+                Request::builder()
+                    .uri("/")
+                    .extension(receipt)
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+    }
+}