fuel-core 0.9.1

Fuel client.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use super::Config;
use crate::{database::Database, tx_pool::TxPool};
use anyhow::Result;
use fuel_block_importer::{Config as FuelBlockImporterConfig, Service as FuelBlockImporterService};
use fuel_block_producer::{Config as FuelBlockProducerConfig, Service as FuelBlockProducerService};
use fuel_core_bft::{Config as FuelCoreBftConfig, Service as FuelCoreBftService};
use fuel_sync::{Config as FuelSyncConfig, Service as FuelSyncService};
use futures::future::join_all;
use std::sync::Arc;
use tokio::task::JoinHandle;

pub struct Modules {
    pub tx_pool: Arc<TxPool>,
    pub block_importer: Arc<FuelBlockImporterService>,
    pub block_producer: Arc<FuelBlockProducerService>,
    pub bft: Arc<FuelCoreBftService>,
    pub sync: Arc<FuelSyncService>,
}

impl Modules {
    pub async fn stop(&self) {
        let stops: Vec<JoinHandle<()>> = vec![
            //self.tx_pool.stop().await,
            self.block_importer.stop().await,
            self.block_producer.stop().await,
            self.bft.stop().await,
            self.sync.stop().await,
        ]
        .into_iter()
        .flatten()
        .collect();

        join_all(stops).await;
    }
}

pub async fn start_modules(config: &Config, database: &Database) -> Result<Modules> {
    let db = ();
    // initialize transaction pool
    let tx_pool = TxPool::new(database.clone(), config.clone());
    // Initialize and bind all components
    let block_importer =
        FuelBlockImporterService::new(&FuelBlockImporterConfig::default(), db).await?;
    let block_producer =
        FuelBlockProducerService::new(&FuelBlockProducerConfig::default(), db).await?;
    let bft = FuelCoreBftService::new(&FuelCoreBftConfig::default(), db).await?;
    let sync = FuelSyncService::new(&FuelSyncConfig::default()).await?;
    // let mut relayer = FuelRelayer::new(FuelRelayerConfig::default());
    // let mut p2p = FuelP2P::new(FuelP2PConfig::default());
    // let mut txpool = FuelTxpool::new(FuelTxpoolConfig::default());

    let txpool_mpsc = ();
    let p2p_mpsc = ();
    let p2p_broadcast_consensus = ();
    let p2p_broadcast_block = ();
    let relayer_mpsc = ();

    block_importer.start().await;
    block_producer.start(txpool_mpsc).await;
    bft.start(
        relayer_mpsc,
        p2p_broadcast_consensus,
        block_producer.sender().clone(),
        block_importer.sender().clone(),
        block_importer.subscribe(),
    )
    .await;

    sync.start(
        p2p_broadcast_block,
        p2p_mpsc,
        relayer_mpsc,
        bft.sender().clone(),
        block_importer.sender().clone(),
    )
    .await;

    Ok(Modules {
        tx_pool: Arc::new(tx_pool),
        block_importer: Arc::new(block_importer),
        block_producer: Arc::new(block_producer),
        bft: Arc::new(bft),
        sync: Arc::new(sync),
    })
}