Struct Monitor

pub struct Monitor {
    pub name: String,
    pub networks: Vec<String>,
    pub paused: bool,
    pub addresses: Vec<AddressWithSpec>,
    pub match_conditions: MatchConditions,
    pub trigger_conditions: Vec<TriggerConditions>,
    pub triggers: Vec<String>,
}

Configuration for monitoring specific blockchain activity.

A Monitor defines what blockchain activity to watch for through a combination of:

• Network targets (which chains to monitor)
• Contract addresses to watch
• Conditions to match (functions, events, transactions)
• Triggers conditions refers to a custom filter script that being executed apply extra filters to the matched transactions before triggering the notifications
• Triggers to execute when conditions are met

Fields

name: String

Unique name identifying this monitor

networks: Vec<String>

List of network slugs this monitor should watch

paused: bool

Whether this monitor is currently paused

addresses: Vec<AddressWithSpec>

Contract addresses to monitor, optionally with their contract specs

match_conditions: MatchConditions

Conditions that should trigger this monitor

trigger_conditions: Vec<TriggerConditions>

Conditions that should be met prior to triggering notifications

triggers: Vec<String>

IDs of triggers to execute when conditions match

Trait Implementations

impl Clone for Monitor

fn clone(&self) -> Monitor

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConfigLoader for Monitor

fn resolve_secrets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self, ConfigError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Resolve all secrets in the monitor configuration

fn load_all<'life0, 'async_trait, T>( path: Option<&'life0 Path>, ) -> Pin<Box<dyn Future<Output = Result<T, ConfigError>> + Send + 'async_trait>>

where T: FromIterator<(String, Self)> + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Load all monitor configurations from a directory

Reads and parses all JSON files in the specified directory (or default config directory) as monitor configurations.

fn load_from_path<'life0, 'async_trait>( path: &'life0 Path, ) -> Pin<Box<dyn Future<Output = Result<Self, ConfigError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load a monitor configuration from a specific file

Reads and parses a single JSON file as a monitor configuration.

fn validate(&self) -> Result<(), ConfigError>

Validate the monitor configuration

fn validate_protocol(&self)

Validate the safety of the protocols used in the monitor

Returns if safe, or logs a warning message if unsafe.

fn is_json_file(path: &Path) -> bool

Check if a file is a JSON file based on extension

impl Debug for Monitor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Monitor

fn default() -> Monitor

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Monitor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Monitor

fn eq(&self, other: &Monitor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Monitor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Monitor