rrelayer_core 0.7.0

Core types and functionality for rrelayer - a powerful blockchain transaction relay service
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

mod automatic_top_up_task;
mod balance_monitor;
mod webhook_manager_task;

use crate::background_tasks::{
    balance_monitor::balance_monitor, webhook_manager_task::run_webhook_manager_task,
};
use crate::gas::{blob_gas_oracle, gas_oracle, BlobGasOracleCache, GasOracleCache};
use crate::{
    background_tasks::automatic_top_up_task::run_automatic_top_up_task, provider::EvmProvider,
    transaction::queue_system::TransactionsQueues, webhooks::WebhookManager, PostgresClient,
    SafeProxyManager, SetupConfig,
};
use std::sync::Arc;
use tokio::sync::Mutex;
use tracing::info;

#[allow(clippy::too_many_arguments)]
pub async fn run_background_tasks(
    config: &SetupConfig,
    gas_oracle_cache: Arc<Mutex<GasOracleCache>>,
    blob_gas_oracle_cache: Arc<Mutex<BlobGasOracleCache>>,
    providers: Arc<Vec<EvmProvider>>,
    postgres_client: Arc<PostgresClient>,
    webhook_manager: Option<Arc<Mutex<WebhookManager>>>,
    transactions_queues: Arc<Mutex<TransactionsQueues>>,
    safe_proxy_manager: Arc<SafeProxyManager>,
) {
    info!("Starting background tasks");

    let gas_oracle_task = gas_oracle(Arc::clone(&providers), gas_oracle_cache);

    // Only start blob gas oracle if any network has blobs enabled
    let has_blob_enabled_networks =
        config.networks.iter().any(|network| network.enable_sending_blobs.unwrap_or(false));

    let blob_gas_oracle_task = if has_blob_enabled_networks {
        info!("Starting blob gas oracle (blobs enabled on at least one network)");
        Some(blob_gas_oracle(Arc::clone(&providers), blob_gas_oracle_cache))
    } else {
        info!("Skipping blob gas oracle (no networks have blobs enabled)");
        None
    };
    let top_up_task = run_automatic_top_up_task(
        config.clone(),
        postgres_client.clone(),
        providers.clone(),
        transactions_queues,
        safe_proxy_manager,
    );

    let balance_monitor_task =
        balance_monitor(providers.clone(), postgres_client.clone(), webhook_manager.clone());

    if let Some(webhook_manager) = webhook_manager {
        run_webhook_manager_task(webhook_manager, providers.clone()).await;
    }

    if let Some(blob_task) = blob_gas_oracle_task {
        tokio::join!(gas_oracle_task, blob_task, top_up_task, balance_monitor_task);
    } else {
        tokio::join!(gas_oracle_task, top_up_task, balance_monitor_task);
    }

    info!("Background tasks spawned up");
}