chia-tools 0.40.0

Utility functions and types used by the Chia blockchain full node
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

use clap::Parser;
use rusqlite::Connection;

/// Optimize a chia blockchain database
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Path to blockchain database file to optimize
    file: String,

    /// Path to destination blockchain database file
    output: String,
}

fn main() {
    let args = Args::parse();

    let connection = Connection::open(args.file).expect("failed to open database file");
    let peak_hash: [u8; 32] = connection
        .prepare("SELECT hash FROM current_peak WHERE key = 0")
        .expect("prepare")
        .query([])
        .expect("query")
        .next()
        .expect("current_peak")
        .expect("current_peak")
        .get(0)
        .expect("get current_peak");

    println!("peak block hash: {}", hex::encode(peak_hash));

    let peak_height: u32 = connection
        .prepare("SELECT height FROM full_blocks WHERE header_hash=?")
        .expect("prepare")
        .query([peak_hash])
        .expect("query")
        .next()
        .expect("peak height")
        .expect("peak height")
        .get(0)
        .expect("get peak height");

    println!("peak height: {peak_height}");

    println!("dropping orphaned blocks...");
    let removed = connection
        .execute(
            "DELETE FROM full_blocks WHERE in_main_chain=0 AND height < ?",
            [peak_height - 10],
        )
        .expect("drop orphaned blocks");

    println!("removed {removed} orphaned blocks");

    let compact: usize = connection
        .prepare(
            "SELECT COUNT(*) FROM full_blocks WHERE is_fully_compactified=1 AND in_main_chain=1",
        )
        .expect("prepare compact")
        .query([])
        .expect("query compact")
        .next()
        .expect("compact")
        .expect("compact")
        .get(0)
        .expect("compact");

    println!(
        "{} fully compact blocks ({:.2}%)",
        compact,
        compact as f64 / f64::from(peak_height) * 100.0
    );

    println!("analyze block table");
    let _ = connection
        .execute("ANALYZE full_blocks", [])
        .expect("analyze");

    println!("analyze coins table");
    let _ = connection
        .execute("ANALYZE coin_record", [])
        .expect("analyze");

    println!("analyze hints table");
    let _ = connection.execute("ANALYZE hints", []).expect("analyze");

    println!("vacuum into {}", args.output);
    let _ = connection
        .execute("VACUUM INTO ?", [args.output])
        .expect("vacuum");
    println!("all done!");
}