kyoto-cbf 0.15.1

A Bitcoin light-client according to the BIP-157/BIP-158 specifications
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

/// Errors when initializing a SQL-based backend.
#[cfg(feature = "rusqlite")]
#[derive(Debug)]
pub enum SqlInitializationError {
    /// A file or directory could not be opened or created.
    IO(std::io::Error),
    /// An error occured performing a SQL operation.
    SQL(rusqlite::Error),
}

#[cfg(feature = "rusqlite")]
impl core::fmt::Display for SqlInitializationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SqlInitializationError::IO(e) => {
                write!(f, "a file or directory could not be opened or created: {e}")
            }
            SqlInitializationError::SQL(e) => {
                write!(f, "reading or writing from the database failed: {e}")
            }
        }
    }
}

#[cfg(feature = "rusqlite")]
impl std::error::Error for SqlInitializationError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            SqlInitializationError::IO(error) => Some(error),
            SqlInitializationError::SQL(error) => Some(error),
        }
    }
}

#[cfg(feature = "rusqlite")]
impl From<rusqlite::Error> for SqlInitializationError {
    fn from(value: rusqlite::Error) -> Self {
        Self::SQL(value)
    }
}

#[cfg(feature = "rusqlite")]
impl From<std::io::Error> for SqlInitializationError {
    fn from(value: std::io::Error) -> Self {
        Self::IO(value)
    }
}

/// Errors while reading or writing to and from a SQL-based peer backend.
#[cfg(feature = "rusqlite")]
#[derive(Debug)]
pub enum SqlPeerStoreError {
    /// A consensus critical data structure is malformed.
    Deserialize(bitcoin::consensus::encode::Error),
    /// There are no known peers in the database.
    Empty,
    /// An error occured performing a SQL operation.
    SQL(rusqlite::Error),
}

#[cfg(feature = "rusqlite")]
impl core::fmt::Display for SqlPeerStoreError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SqlPeerStoreError::Deserialize(e) => {
                write!(
                    f,
                    "a byte array could not be deserialized into a known datatype: {e}"
                )
            }
            Self::Empty => {
                write!(f, "there are no known peers in the database.")
            }
            SqlPeerStoreError::SQL(e) => {
                write!(f, "reading or writing from the database failed: {e}")
            }
        }
    }
}

#[cfg(feature = "rusqlite")]
impl std::error::Error for SqlPeerStoreError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            SqlPeerStoreError::Deserialize(error) => Some(error),
            SqlPeerStoreError::Empty => None,
            SqlPeerStoreError::SQL(error) => Some(error),
        }
    }
}

#[cfg(feature = "rusqlite")]
impl From<rusqlite::Error> for SqlPeerStoreError {
    fn from(value: rusqlite::Error) -> Self {
        Self::SQL(value)
    }
}

#[cfg(feature = "rusqlite")]
impl From<bitcoin::consensus::encode::Error> for SqlPeerStoreError {
    fn from(value: bitcoin::consensus::encode::Error) -> Self {
        Self::Deserialize(value)
    }
}

/// Errors while reading or writing to and from a SQL-based block header backend.
#[cfg(feature = "rusqlite")]
#[derive(Debug)]
pub enum SqlHeaderStoreError {
    /// The headers do not link together.
    Corruption,
    /// Consensus deserialization failed.
    Deserialize(bitcoin::consensus::encode::Error),
    /// An error occured performing a SQL operation.
    SQL(rusqlite::Error),
}

#[cfg(feature = "rusqlite")]
impl core::fmt::Display for SqlHeaderStoreError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SqlHeaderStoreError::SQL(e) => {
                write!(f, "reading or writing from the database failed: {e}")
            }
            SqlHeaderStoreError::Deserialize(e) => {
                write!(f, "consensus decoding failed {e}")
            }
            SqlHeaderStoreError::Corruption => {
                write!(f, "a consensus critical data structure is malformed.")
            }
        }
    }
}

#[cfg(feature = "rusqlite")]
impl std::error::Error for SqlHeaderStoreError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            SqlHeaderStoreError::Corruption => None,
            SqlHeaderStoreError::SQL(error) => Some(error),
            SqlHeaderStoreError::Deserialize(error) => Some(error),
        }
    }
}

#[cfg(feature = "rusqlite")]
impl From<rusqlite::Error> for SqlHeaderStoreError {
    fn from(value: rusqlite::Error) -> Self {
        Self::SQL(value)
    }
}

#[cfg(feature = "rusqlite")]
impl From<bitcoin::consensus::encode::Error> for SqlHeaderStoreError {
    fn from(value: bitcoin::consensus::encode::Error) -> Self {
        Self::Deserialize(value)
    }
}