pool: change log levels for relay filtering check

Signed-off-by: Yuki Kishimoto <[email protected]>

Author: yukibtc

crates/nostr-relay-pool/src/relay/error.rs

@@ -8,7 +8,7 @@ use std::time::Duration;
 use async_utility::thread;
 use nostr::message::relay::NegentropyErrorCode;
 use nostr::message::MessageHandleError;
-use nostr::{event, EventId, Kind, PublicKey};
+use nostr::{event, EventId, Kind};
 use nostr_database::DatabaseError;
 use thiserror::Error;
 
@@ -131,15 +131,6 @@ pub enum Error {
         /// Min. difficulty
         min: u8,
     },
-    /// Event ID blacklisted
-    #[error("Received event with blacklisted ID: {0}")]
-    EventIdBlacklisted(EventId),
-    /// Public key whitelist
-    #[error("Received event authored by non-whitelisted public key: {0}")]
-    PublicKeyNotInWhitelist(PublicKey),
-    /// Public key blacklisted
-    #[error("Received event authored by blacklisted public key: {0}")]
-    PublicKeyBlacklisted(PublicKey),
     /// Unexpected kind
     #[error("Unexpected kind: expected={expected}, found={found}")]
     UnexpectedKind {

crates/nostr-relay-pool/src/relay/filtering.rs

@@ -11,7 +11,12 @@ use std::sync::Arc;
 use nostr::{EventId, PartialEvent, PublicKey};
 use tokio::sync::RwLock;
 
-use super::error::Error;
+pub(crate) enum CheckFiltering {
+    Allow,
+    EventIdBlacklisted(EventId),
+    PublicKeyBlacklisted(PublicKey),
+    PublicKeyNotInWhitelist(PublicKey),
+}
 
 /// Filtering mode
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -181,28 +186,25 @@ impl RelayFiltering {
         public_keys.contains(public_key)
     }
 
-    pub(crate) async fn check_partial_event(
-        &self,
-        partial_event: &PartialEvent,
-    ) -> Result<(), Error> {
+    pub(crate) async fn check_partial_event(&self, partial_event: &PartialEvent) -> CheckFiltering {
         match self.mode.load() {
             RelayFilteringMode::Whitelist => {
                 if !self.has_public_key(&partial_event.pubkey).await {
-                    return Err(Error::PublicKeyNotInWhitelist(partial_event.pubkey));
+                    return CheckFiltering::PublicKeyNotInWhitelist(partial_event.pubkey);
                 }
             }
             RelayFilteringMode::Blacklist => {
                 if self.has_id(&partial_event.id).await {
-                    return Err(Error::EventIdBlacklisted(partial_event.id));
+                    return CheckFiltering::EventIdBlacklisted(partial_event.id);
                 }
 
                 if self.has_public_key(&partial_event.pubkey).await {
-                    return Err(Error::PublicKeyBlacklisted(partial_event.pubkey));
+                    return CheckFiltering::PublicKeyBlacklisted(partial_event.pubkey);
                 }
             }
         };
 
-        Ok(())
+        CheckFiltering::Allow
     }
 
     /// Remove everything

crates/nostr-relay-pool/src/relay/internal.rs

@@ -30,7 +30,7 @@ use tokio::sync::mpsc::{self, Receiver, Sender};
 use tokio::sync::{broadcast, oneshot, watch, Mutex, MutexGuard, RwLock};
 
 use super::constants::{MIN_ATTEMPTS, MIN_UPTIME, PING_INTERVAL, WEBSOCKET_TX_TIMEOUT};
-use super::filtering::RelayFiltering;
+use super::filtering::{CheckFiltering, RelayFiltering};
 use super::flags::AtomicRelayServiceFlags;
 use super::options::{
     FilterOptions, NegentropyOptions, RelayOptions, RelaySendOptions, SubscribeAutoCloseOptions,
@@ -930,7 +930,27 @@ impl InternalRelay {
                 let partial_event: PartialEvent = PartialEvent::from_raw(&event)?;
 
                 // Check filtering
-                self.filtering.check_partial_event(&partial_event).await?;
+                match self.filtering.check_partial_event(&partial_event).await {
+                    CheckFiltering::Allow => {
+                        // Nothing to do
+                    }
+                    CheckFiltering::EventIdBlacklisted(id) => {
+                        tracing::debug!("Received event with blacklisted ID: {id}");
+                        return Ok(None);
+                    }
+                    CheckFiltering::PublicKeyBlacklisted(pubkey) => {
+                        tracing::debug!(
+                            "Received event authored by blacklisted public key: {pubkey}"
+                        );
+                        return Ok(None);
+                    }
+                    CheckFiltering::PublicKeyNotInWhitelist(pubkey) => {
+                        tracing::debug!(
+                            "Received event authored by non-whitelisted public key: {pubkey}"
+                        );
+                        return Ok(None);
+                    }
+                }
 
                 // Check min POW
                 let difficulty: u8 = self.opts.get_pow_difficulty();