bitview 0.12.0

A composition-agnostic daemon runner for Bitview plugins
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#![doc = include_str!("../README.md")]

use std::{
    path::PathBuf,
    thread::{self, sleep},
    time::Duration,
};

use bitview_query::AsyncQuery;
pub use bitview_query::QueryPluginSet;
pub use bitview_runtime::{
    BootstrapAction, ComputePluginSet, ImportContext, PluginSet, UpdateContext, bootstrap, update,
};
use bitview_server::{Server, ServerConfig};
use brk_error::{Error, Result};
use brk_mempool::Mempool;
use brk_reader::Reader;
use brk_rpc::Client;
use tokio::{
    runtime::{Builder, Runtime},
    task::JoinHandle,
};
use tracing::info;
use vecdb::{Exit, ReadOnlyClone};

/// The Bitview project website.
pub const HOMEPAGE: &str = "https://bitview.dev";

/// The official hosted Bitview instance.
pub const INSTANCE: &str = "https://bitview.space";

/// The toolkit Bitview is built on.
pub const TOOLKIT: &str = "https://bitcoinresearchkit.org";

/// Fully resolved settings for one Bitview runner.
pub struct Config {
    /// Bitcoin Core RPC client.
    pub client: Client,
    /// Directory containing Bitcoin Core's block files.
    pub blocks_path: PathBuf,
    /// HTTP server and data-directory settings.
    pub server: ServerConfig,
}

/// Runs one process-lifetime plugin composition with resolved settings and a
/// shutdown coordinator.
pub fn run<P>(
    config: Config,
    exit: Exit,
    mut import: impl FnMut(ImportContext<'_>, &Reader) -> Result<P>,
) -> Result<()>
where
    P: ComputePluginSet + ReadOnlyClone,
    P::ReadOnly: QueryPluginSet + 'static,
{
    let Config {
        client,
        blocks_path,
        server,
    } = config;
    let reader = Reader::new(blocks_path, &client);
    let outputs_path = server.data_path.clone();
    let import_context = ImportContext::new(&outputs_path);
    let update_context = UpdateContext::new(&exit);

    client.wait_for_synced_node()?;

    let mut plugins = bootstrap(
        import_context,
        |context| import(context, &reader),
        update_context,
    )?;

    let mempool = Mempool::new(&client);

    let query = AsyncQuery::build(&plugins, Some(mempool.clone()));

    let runtime = Builder::new_multi_thread().enable_all().build()?;
    let server = runtime.block_on(Server::bind(&query, server))?;
    let server_handle = runtime.spawn(server.serve());

    let mempool_clone = mempool.clone();
    let resolver = query.sync(|q| q.indexer_prevout_resolver());
    thread::spawn(move || {
        mempool_clone.start_with(resolver);
    });

    let mut last_height = query.sync(|q| q.indexer().indexed_height());
    info!("Waiting for new blocks...");

    loop {
        while last_height == client.get_last_height()? {
            if server_handle.is_finished() {
                return server_stopped(&runtime, server_handle);
            }
            sleep(Duration::from_secs(1));
        }

        client.wait_for_synced_node()?;

        last_height = client.get_last_height()?;

        info!("New chain tip: block {last_height}");

        update(&mut plugins, update_context)?;

        if server_handle.is_finished() {
            return server_stopped(&runtime, server_handle);
        }

        info!("Waiting for new blocks...");
    }
}

fn server_stopped(runtime: &Runtime, handle: JoinHandle<Result<()>>) -> Result<()> {
    runtime.block_on(handle)??;
    Err(Error::Internal("HTTP server stopped unexpectedly"))
}