feat: Add payload mode for webhooks (#417)

* feat: Add payload mode for webhooks

* fix: Docs

* Fix linker OOM crash in CI coverage builds (#418)

---------

Co-authored-by: Copilot <[email protected]>

Author: shahnami

.github/workflows/ci.yaml

@@ -184,19 +184,19 @@ jobs:
       - name: Generate Unit Coverage Report
         env:
           LLVM_PROFILE_FILE: unit-%p-%m.profraw
-          RUSTFLAGS: -Cinstrument-coverage
+          RUSTFLAGS: -Cinstrument-coverage -Clink-arg=-Wl,--threads=1
         run: RUST_TEST_THREADS=1 cargo hack llvm-cov --locked --lcov --output-path unit-lcov.info --lib
 
    # Integration tests coverage
       - name: Generate Integration Coverage Report
         env:
           LLVM_PROFILE_FILE: integration-%p-%m.profraw
-          RUSTFLAGS: -Cinstrument-coverage
+          RUSTFLAGS: -Cinstrument-coverage -Clink-arg=-Wl,--threads=1
         run: RUST_TEST_THREADS=1 cargo hack llvm-cov --locked --lcov --output-path integration-lcov.info --test integration
       - name: Generate Properties Coverage Report
         env:
           LLVM_PROFILE_FILE: properties-%p-%m.profraw
-          RUSTFLAGS: -Cinstrument-coverage
+          RUSTFLAGS: -Cinstrument-coverage -Clink-arg=-Wl,--threads=1
         run: RUST_TEST_THREADS=1 cargo hack llvm-cov --locked --lcov --output-path properties-lcov.info --test properties
 
    # Upload unit coverage

docs/index.mdx

@@ -625,8 +625,47 @@ A Trigger defines actions to take when monitored conditions are met. Triggers ca
 | `**config.secret.type**` | `String` | Secret type (**"Plain"**, **"Environment"**, or **"HashicorpCloudVault"**) |
 | `**config.secret.value**` | `String` | Secret value (HMAC secret, environment variable name, or vault secret name) |
 | `**config.headers**` | `Object` | Headers to include in the webhook request |
-| `**config.message.title**` | `String` | Title that appears in the webhook message |
-| `**config.message.body**` | `String` | Message template with variable substitution |
+| `**config.payload_mode**` | `String` | Payload mode: **"template"** (default) or **"raw"** |
+| `**config.message.title**` | `String` | Title that appears in the webhook message (required for template mode) |
+| `**config.message.body**` | `String` | Message template with variable substitution (required for template mode) |
+
+##### Webhook Payload Modes
+
+Webhooks support two payload modes that determine how data is sent to your endpoint:
+
+**Template Mode (default)**
+
+In template mode, the webhook sends a formatted JSON payload with `title` and `body` fields, where variables are substituted from the monitor match data:
+
+```json
+{
+  "title": "Monitor Alert triggered",
+  "body": "Large transfer detected from 0x123... to 0x456..."
+}
+```
+
+**Raw Mode**
+
+In raw mode, the webhook sends the complete `MonitorMatch` object directly as the JSON payload. This is useful when you want to receive all blockchain event data without formatting, allowing your receiving service to process the raw data as needed.
+
+```json
+{
+  "raw_webhook": {
+    "name": "Raw Payload Webhook",
+    "trigger_type": "webhook",
+    "config": {
+      "url": { "type": "plain", "value": "https://api.example.com/events" },
+      "method": "POST",
+      "payload_mode": "raw"
+    }
+  }
+}
+```
+
+When using raw mode:
+* The `message` field is ignored
+* The payload contains the full monitor match including: monitor configuration, transaction details, receipt, logs, matched conditions, and decoded arguments
+* This is particularly useful for integrations that need to process the complete event data programmatically
 
 ##### Discord Notifications
 ```json

examples/config/triggers/webhook_notifications.json

@@ -64,5 +64,24 @@
         "body": "${monitor.name} triggered because of a large swap of ${functions.0.args.out_min} tokens | https://stellar.expert/explorer/public/tx/${transaction.hash}"
       }
     }
+  },
+  "raw_payload_webhook": {
+    "name": "Raw Payload Webhook",
+    "trigger_type": "webhook",
+    "config": {
+      "url": {
+        "type": "plain",
+        "value": "https://api.example.com/events"
+      },
+      "method": "POST",
+      "secret": {
+        "type": "plain",
+        "value": "webhook-secret"
+      },
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "payload_mode": "raw"
+    }
   }
 }

src/models/config/trigger_config.rs

@@ -11,7 +11,7 @@ use std::{collections::HashMap, fs, path::Path};
 use crate::{
 	models::{
 		config::error::ConfigError, ConfigLoader, SecretValue, Trigger, TriggerType,
-		TriggerTypeConfig,
+		TriggerTypeConfig, WebhookPayloadMode,
 	},
 	services::trigger::validate_script_config,
 	utils::normalize_string,
@@ -433,6 +433,7 @@ impl ConfigLoader for Trigger {
 					url,
 					method,
 					message,
+					payload_mode,
 					..
 				} = &self.config
 				{
@@ -457,20 +458,23 @@ impl ConfigLoader for Trigger {
 							}
 						}
 					}
-					// Validate message
-					if message.title.trim().is_empty() {
-						return Err(ConfigError::validation_error(
-							"Title cannot be empty",
-							None,
-							None,
-						));
-					}
-					if message.body.trim().is_empty() {
-						return Err(ConfigError::validation_error(
-							"Body cannot be empty",
-							None,
-							None,
-						));
+					// Validate message only in template mode
+					// In raw mode, message is not used as the MonitorMatch is sent directly
+					if *payload_mode == WebhookPayloadMode::Template {
+						if message.title.trim().is_empty() {
+							return Err(ConfigError::validation_error(
+								"Title cannot be empty",
+								None,
+								None,
+							));
+						}
+						if message.body.trim().is_empty() {
+							return Err(ConfigError::validation_error(
+								"Body cannot be empty",
+								None,
+								None,
+							));
+						}
 					}
 				}
 			}
@@ -908,7 +912,7 @@ mod tests {
 
 	#[test]
 	fn test_webhook_trigger_validation() {
-		// Valid trigger
+		// Valid trigger with template mode (default)
 		let valid_trigger = TriggerBuilder::new()
 			.name("test_webhook")
 			.webhook("https://api.example.com/webhook")
@@ -923,15 +927,15 @@ mod tests {
 			.build();
 		assert!(invalid_url.validate().is_err());
 
-		// Empty title
+		// Empty title in template mode - should fail
 		let invalid_title = TriggerBuilder::new()
 			.name("test_webhook")
 			.webhook("https://api.example.com/webhook")
 			.message("", "Test message")
 			.build();
 		assert!(invalid_title.validate().is_err());
 
-		// Empty body
+		// Empty body in template mode - should fail
 		let invalid_body = TriggerBuilder::new()
 			.name("test_webhook")
 			.webhook("https://api.example.com/webhook")
@@ -940,6 +944,63 @@ mod tests {
 		assert!(invalid_body.validate().is_err());
 	}
 
+	#[test]
+	fn test_webhook_trigger_validation_raw_mode() {
+		use crate::models::WebhookPayloadMode;
+
+		// Valid trigger with raw payload mode - empty message is OK
+		let valid_raw_trigger = TriggerBuilder::new()
+			.name("test_webhook_raw")
+			.webhook("https://api.example.com/webhook")
+			.webhook_payload_mode(WebhookPayloadMode::Raw)
+			.message("", "") // Empty message is valid in raw mode
+			.build();
+		assert!(valid_raw_trigger.validate().is_ok());
+
+		// Invalid URL in raw mode - should still fail
+		let invalid_url_raw = TriggerBuilder::new()
+			.name("test_webhook_raw")
+			.webhook("invalid-url")
+			.webhook_payload_mode(WebhookPayloadMode::Raw)
+			.build();
+		assert!(invalid_url_raw.validate().is_err());
+
+		// Valid URL with raw mode and non-empty message
+		let valid_raw_with_message = TriggerBuilder::new()
+			.name("test_webhook_raw")
+			.webhook("https://api.example.com/webhook")
+			.webhook_payload_mode(WebhookPayloadMode::Raw)
+			.message("Alert", "Test message")
+			.build();
+		assert!(valid_raw_with_message.validate().is_ok());
+	}
+
+	#[test]
+	fn test_webhook_payload_mode_serialization() {
+		use crate::models::WebhookPayloadMode;
+
+		// Test serialization
+		let template_mode = WebhookPayloadMode::Template;
+		let raw_mode = WebhookPayloadMode::Raw;
+
+		assert_eq!(
+			serde_json::to_string(&template_mode).unwrap(),
+			"\"template\""
+		);
+		assert_eq!(serde_json::to_string(&raw_mode).unwrap(), "\"raw\"");
+
+		// Test deserialization
+		let deserialized_template: WebhookPayloadMode =
+			serde_json::from_str("\"template\"").unwrap();
+		let deserialized_raw: WebhookPayloadMode = serde_json::from_str("\"raw\"").unwrap();
+
+		assert_eq!(deserialized_template, WebhookPayloadMode::Template);
+		assert_eq!(deserialized_raw, WebhookPayloadMode::Raw);
+
+		// Test default
+		assert_eq!(WebhookPayloadMode::default(), WebhookPayloadMode::Template);
+	}
+
 	#[test]
 	fn test_discord_trigger_validation() {
 		// Valid trigger

src/models/core/mod.rs

@@ -14,4 +14,6 @@ pub use monitor::{
 	TransactionCondition, TransactionStatus, TriggerConditions, SCRIPT_LANGUAGE_EXTENSIONS,
 };
 pub use network::{Network, RpcUrl};
-pub use trigger::{NotificationMessage, Trigger, TriggerType, TriggerTypeConfig};
+pub use trigger::{
+	NotificationMessage, Trigger, TriggerType, TriggerTypeConfig, WebhookPayloadMode,
+};

src/models/core/trigger.rs

@@ -48,6 +48,17 @@ pub struct NotificationMessage {
 	pub body: String,
 }
 
+/// Payload mode for webhook triggers
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum WebhookPayloadMode {
+	/// Use title/body templates with variable substitution (default)
+	#[default]
+	Template,
+	/// Send the raw MonitorMatch as the JSON payload
+	Raw,
+}
+
 /// Type-specific configuration for triggers
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields)]
@@ -93,8 +104,12 @@ pub enum TriggerTypeConfig {
 		secret: Option<SecretValue>,
 		/// Optional HTTP headers
 		headers: Option<std::collections::HashMap<String, String>>,
-		/// Notification message
+		/// Notification message (required for template mode, optional for raw mode)
+		#[serde(default)]
 		message: NotificationMessage,
+		/// Payload mode: "template" (default) or "raw"
+		#[serde(default)]
+		payload_mode: WebhookPayloadMode,
 		/// Retry policy for HTTP requests
 		#[serde(default)]
 		retry_policy: RetryConfig,

src/models/mod.rs

@@ -88,7 +88,8 @@ pub use blockchain::solana::{
 pub use core::{
 	AddressWithSpec, EventCondition, FunctionCondition, MatchConditions, Monitor, Network,
 	NotificationMessage, RpcUrl, ScriptLanguage, TransactionCondition, TransactionStatus, Trigger,
-	TriggerConditions, TriggerType, TriggerTypeConfig, SCRIPT_LANGUAGE_EXTENSIONS,
+	TriggerConditions, TriggerType, TriggerTypeConfig, WebhookPayloadMode,
+	SCRIPT_LANGUAGE_EXTENSIONS,
 };
 
 // Re-export config types

src/services/filter/filters/evm/filter.rs

@@ -548,11 +548,7 @@ impl<T> EVMBlockFilter<T> {
 		{
 			Some(event) => event,
 			None => {
-				FilterError::internal_error(
-					format!("No matching event found for log topic: {:?}", log.topics[0]),
-					None,
-					None,
-				);
+				tracing::debug!("No matching event found for log topic: {:?}", log.topics[0]);
 				return None;
 			}
 		};

src/services/notification/mod.rs

@@ -18,6 +18,7 @@ mod webhook;
 use crate::{
 	models::{
 		MonitorMatch, NotificationMessage, ScriptLanguage, Trigger, TriggerType, TriggerTypeConfig,
+		WebhookPayloadMode,
 	},
 	utils::{normalize_string, RetryConfig},
 };
@@ -212,6 +213,15 @@ impl NotificationService {
 			| TriggerType::Discord
 			| TriggerType::Webhook
 			| TriggerType::Telegram => {
+				// Check if this is a webhook trigger with raw payload mode
+				let is_raw_mode = matches!(
+					&trigger.config,
+					TriggerTypeConfig::Webhook {
+						payload_mode: WebhookPayloadMode::Raw,
+						..
+					}
+				);
+
 				// Use the Webhookable trait to get config, retry policy and payload builder
 				let components = trigger.config.as_webhook_components()?;
 
@@ -228,12 +238,24 @@ impl NotificationService {
 						)
 					})?;
 
-				// Build the payload
-				let payload = components.builder.build_payload(
-					&components.config.title,
-					&components.config.body_template,
-					variables,
-				);
+				// Build the payload based on the mode
+				let payload = if is_raw_mode {
+					// In raw mode, serialize the MonitorMatch directly
+					serde_json::to_value(monitor_match).map_err(|e| {
+						NotificationError::internal_error(
+							format!("Failed to serialize MonitorMatch: {}", e),
+							Some(e.into()),
+							None,
+						)
+					})?
+				} else {
+					// In template mode, use the payload builder
+					components.builder.build_payload(
+						&components.config.title,
+						&components.config.body_template,
+						variables,
+					)
+				};
 
 				// Create the notifier
 				let notifier = WebhookNotifier::new(components.config, http_client)?;
@@ -752,6 +774,7 @@ mod tests {
 				"my-secret".to_string(),
 			))),
 			headers: Some([("X-Custom".to_string(), "Value".to_string())].into()),
+			payload_mode: WebhookPayloadMode::default(),
 			retry_policy: RetryConfig::default(),
 		};
 

src/services/notification/webhook.rs

@@ -273,7 +273,7 @@ impl WebhookNotifier {
 #[cfg(test)]
 mod tests {
 	use crate::{
-		models::{NotificationMessage, SecretString, SecretValue},
+		models::{NotificationMessage, SecretString, SecretValue, WebhookPayloadMode},
 		services::notification::{GenericWebhookPayloadBuilder, WebhookPayloadBuilder},
 		utils::{tests::create_test_http_client, RetryConfig},
 	};
@@ -311,6 +311,7 @@ mod tests {
 				title: "Test Alert".to_string(),
 				body: "Test message ${value}".to_string(),
 			},
+			payload_mode: WebhookPayloadMode::default(),
 			retry_policy: RetryConfig::default(),
 		}
 	}