renamed to Murmel

Author: tamasblummer

Cargo.toml

@@ -1,17 +1,17 @@
 [package]
-name = "bitcoin-spv"
+name = "murmel"
 version = "0.1.0"
 authors = ["Tamas Blummer <[email protected]>"]
 license = "Apache-2.0"
-homepage = "https://github.com/rust-bitcoin/rust-bitcoin-spv/"
-repository = "https://github.com/rust-bitcoin/rust-bitcoin-spv/"
-documentation = "https://github.com/rust-bitcoin/rust-bitcoin-spv/"
-description = "SPV client for Bitcoin"
-keywords = [ "bitcoin", "SPV" ]
+homepage = "https://github.com/rust-bitcoin/murmel/"
+repository = "https://github.com/rust-bitcoin/murmel/"
+documentation = "https://github.com/rust-bitcoin/murmel/"
+description = "Murmel Bitcoin node"
+keywords = [ "bitcoin" ]
 readme = "README.md"
 
 [lib]
-name = "bitcoin_spv"
+name = "murmel"
 path = "src/lib.rs"
 
 [dependencies]

NOTICE

@@ -0,0 +1 @@
+Murmel - Bitcoin Node written by Tamas Blummer 2018-2019

README.md

@@ -1,25 +1,41 @@
-# Bitcoin SPV in Rust
-This is an implementation of Bitcoin's Simplified Payment Verification mode. The SPV mode is suitable for lightweight nodes, such as a mobile phone. An SPV node verifies proof-of-work of a block but does not validate included transactions. It will follow the chain with most work.
+# Murmel
+Murmel is a lightweight Bitcoin node. Its intended use is to serve a lightning network stack with a settlement layer.
+Its resource requirements are marginal if compared to a Bitcoin Core node.
 
-An SPV node needs to connect full nodes to work. It does not offer any services to other nodes.
+Murmel filters blocks on client side implementing [BIP157](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki).
+Since Bitcoin Core does not yet support BIP157, Murmel may also be operated as filter server to serve a 
+lightweight instance of itself.
 
-This implementation is tailored to serve a Lightning Network node on a resource and bandwidth limited device. It does not feature a memory pool of transactions, as payments are assumed to use the Lightning layer and otherwise only confirmed transactions are of interest.
+A Murmel client determines the chain with most work on its own and is capable of doing further checks. Its
+security guarantee is at least as defined in the Simplified Payment Verification (SPV) section of Satoshi's white paper.
 
-## Status
-This is work in progress, far from production quality. It aims to serve parallel development of a Lightning Node.
+Murmel does not maintain a memory pool of transactions, as payments are assumed to use the Lightning Network layer and otherwise only confirmed transactions are of interest.
+
+#### About the name
+Murmel is German for marble. Murmel is small, fast, hard and beautiful just like a marble. 
+
+## Design and Implementation notes
+Murmel implements a small and fast P2P engine using on [mio](https://crates.io/crates/mio). The network messages are routed 
+to their respective processors and back through message queues. Processors of logically distinct tasks are otherwise 
+de-coupled and run in their own thread. 
 
-The code currently has a lot of dependencies as I wanted to progress quickly towards the stuff that is really new. Most dependencies will be removed later.  Networking and Database code is carefully isolated from the logic of the node, so their implementations can be replaced.
+The blockchain data is persisted in a [Hammersbald](https://github.com/rust-bitcoin/hammersbald) database. 
+The calculated [BIP157](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki) filters for scripts and also for
+spent outpoints allow checking the UTXO based on its immutable store. In contrast to Bitcoin Core, Murmel does not have
+to re-compute anything on a re-org (switch of fork with most work) and optionally able to verify spent coins and 
+block reward. These additional checks to that required by SPV allows Murmel to have a security guarantee higher than
+any other light node, but certainly still sub-par to a Bitcoin Core node.
 
-I plan to implement BIP157 and BIP158 as soon as they are available in Bitcoin. Until that the node will download full blocks. I do not want to waste time implementing BIP37 that hurts privacy.
 
-## Contributions and Vision
-The current plan is to create a small footprint, low bandwidth, stable and secure Lightning Network node combining with the below projects:
+## Status
+Not yet for serious use. Marble is able to support it's own and Lightning Node development. 
+
+## Uses
+Marble uses and supports below projects:
 
 * [Rust language bindings for Bitcoin secp256k1 library.](https://github.com/rust-bitcoin/rust-secp256k1)
 * [Rust Bitcoin library](https://github.com/rust-bitcoin/rust-bitcoin)
 * [Bitcoin's libbitcoinconsenus.a with Rust binding.](https://github.com/rust-bitcoin/rust-bitcoinconsensus)
-* [Bitcoin SPV in Rust](https://github.com/rust-bitcoin/bitcoin-spv)
 * [Rust-Lightning, not Rusty's Lightning](https://github.com/rust-bitcoin/rust-lightning)
 * [Hammersbald](https://github.com/rust-bitcoin/hammersbald)
 
-Send in your PRs if aligned with above vision.

src/bin/client.rs

@@ -14,23 +14,22 @@
 // limitations under the License.
 //
 extern crate bitcoin;
-extern crate bitcoin_spv;
+extern crate murmel;
 extern crate log;
 extern crate rand;
 extern crate simple_logger;
 
 use std::env::args;
 
 use bitcoin::network::constants::Network;
-use bitcoin_spv::constructor::Constructor;
+use murmel::constructor::Constructor;
 use log::Level;
 use std::net::{SocketAddr,SocketAddrV4,Ipv4Addr};
 use std::path::Path;
 
-/// simple test drive that connects to a local bitcoind
 pub fn main() {
     if find_opt("help") {
-        println!("BIP157 Filter Client");
+        println!("Murmel Client");
         println!("{} [--help] [--log trace|debug|info|warn|error] [--connections n] [--peer ip_address:port] [--db database_file] [--network main|test]", args().next().unwrap());
         println!("--log level: level is one of trace|debug|info|warn|error");
         println!("--connections n: maintain at least n connections");
@@ -85,7 +84,7 @@ pub fn main() {
     else {
         spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("client.db"), listen, false).unwrap();
     }
-    spv.run(peers, connections, true).expect("can not start SPV");
+    spv.run(peers, connections, true).expect("can not start node");
 }
 
 use std::str::FromStr;

src/bin/server.rs

@@ -14,23 +14,22 @@
 // limitations under the License.
 //
 extern crate bitcoin;
-extern crate bitcoin_spv;
+extern crate murmel;
 extern crate log;
 extern crate rand;
 extern crate simple_logger;
 
 use std::env::args;
 
 use bitcoin::network::constants::Network;
-use bitcoin_spv::constructor::Constructor;
+use murmel::constructor::Constructor;
 use log::Level;
 use std::net::{SocketAddr,SocketAddrV4,Ipv4Addr};
 use std::path::Path;
 
-/// simple test drive that connects to a local bitcoind
 pub fn main() {
     if find_opt("help") {
-        println!("BIP157 Filter Server");
+        println!("Murmel Server");
         println!("{} [--help] [--log trace|debug|info|warn|error] [--connections n] [--peer ip_address:port] [--db database_file] [--network main|test]", args().next().unwrap());
         println!("--log level: level is one of trace|debug|info|warn|error");
         println!("--connections n: maintain at least n connections");
@@ -87,7 +86,7 @@ pub fn main() {
     else {
         spv = Constructor::new("/https://github.com/rust-bitcoin/rust-bitcoin-spv/".to_string(), network, Path::new("server.db"), listen, true).unwrap();
     }
-    spv.run(peers, connections, find_opt("nodns")).expect("can not start SPV");
+    spv.run(peers, connections, find_opt("nodns")).expect("can not start node");
 }
 
 use std::str::FromStr;

src/blockfilter.rs

@@ -21,7 +21,7 @@
 //! that minimizes filter size by using Golomb-Rice coding for compression.
 //!
 
-use error::SPVError;
+use error::MurmelError;
 use chaindb::ScriptAccessor;
 
 use bitcoin::{
@@ -59,7 +59,7 @@ pub struct BlockFilter {
 
 impl BlockFilter {
 
-    pub fn compute_script_filter(block: &Block, height: u32, script_accessor: impl ScriptAccessor) -> Result<BlockFilter, SPVError> {
+    pub fn compute_script_filter(block: &Block, height: u32, script_accessor: impl ScriptAccessor) -> Result<BlockFilter, MurmelError> {
         let mut bytes = Vec::new();
         let mut out = Cursor::new(&mut bytes);
         {
@@ -70,7 +70,7 @@ impl BlockFilter {
         Ok(BlockFilter{block: block.bitcoin_hash(), filter_type: SCRIPT_FILTER, content: out.into_inner().to_vec()})
     }
 
-    pub fn compute_coin_filter(block: &Block) -> Result<BlockFilter, SPVError> {
+    pub fn compute_coin_filter(block: &Block) -> Result<BlockFilter, MurmelError> {
         let mut bytes = Vec::new();
         let mut out = Cursor::new(&mut bytes);
         {
@@ -108,7 +108,7 @@ impl <'a> BlockFilterWriter<'a> {
     }
 
     /// Add consumed output scripts of a block to filter
-    fn add_consumed_scripts (&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
+    fn add_consumed_scripts (&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), MurmelError> {
         let mut coins = Vec::new();
         for transaction in &self.block.txdata {
             if !transaction.is_coin_base() {
@@ -124,13 +124,13 @@ impl <'a> BlockFilterWriter<'a> {
     }
 
     /// compile a filter useful for wallets
-    pub fn script_filter(&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), SPVError> {
+    pub fn script_filter(&mut self, height: u32, tx_accessor: impl ScriptAccessor) -> Result<(), MurmelError> {
         self.add_output_scripts();
         self.add_consumed_scripts(height, tx_accessor)
     }
 
     /// compile a filter useful to find spent outputs
-    pub fn coin_filter(&mut self) -> Result<(), SPVError> {
+    pub fn coin_filter(&mut self) -> Result<(), MurmelError> {
         let mut buf = Vec::with_capacity(40);
         for tx in &self.block.txdata {
             let txid = tx.txid();
@@ -409,7 +409,7 @@ mod test {
     use bitcoin::blockdata::script::Script;
     use bitcoin::blockdata::transaction::OutPoint;
 
-    use error::SPVError;
+    use error::MurmelError;
     use blockfilter::test::rustc_serialize::json::Json;
     use rand;
     use rand::RngCore;
@@ -432,7 +432,7 @@ mod test {
     }
 
     impl ScriptAccessor for HashMap<OutPoint, Script> {
-        fn get_scripts(&self, _: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, SPVError> {
+        fn get_scripts(&self, _: u32, coins: Vec<OutPoint>) -> Result<Vec<Script>, MurmelError> {
             let mut result = Vec::new();
             for coin in coins {
                 if let Some(ux) = self.get(&coin) {

src/blockserver.rs

@@ -28,7 +28,7 @@ use bitcoin::{
 use blockfilter::{COIN_FILTER, SCRIPT_FILTER};
 use chaindb::SharedChainDB;
 use chaindb::StoredFilter;
-use error::SPVError;
+use error::MurmelError;
 use p2p::{P2PControl, P2PControlSender, PeerId, PeerMessage, PeerMessageReceiver, PeerMessageSender};
 use std::{
     sync::mpsc,
@@ -70,7 +70,7 @@ impl BlockServer {
         panic!("Block server thread failed.");
     }
 
-    fn get_headers(&self, peer: PeerId, get: GetHeadersMessage) -> Result<(), SPVError> {
+    fn get_headers(&self, peer: PeerId, get: GetHeadersMessage) -> Result<(), MurmelError> {
         let chaindb = self.chaindb.read().unwrap();
         for locator in get.locator_hashes.iter () {
             if let Some(pos) = chaindb.pos_on_trunk(locator) {
@@ -85,7 +85,7 @@ impl BlockServer {
         Ok(())
     }
 
-    fn get_blocks(&self, peer: PeerId, get: GetBlocksMessage) -> Result<(), SPVError> {
+    fn get_blocks(&self, peer: PeerId, get: GetBlocksMessage) -> Result<(), MurmelError> {
         let chaindb = self.chaindb.read().unwrap();
         for locator in get.locator_hashes.iter () {
             if let Some(pos) = chaindb.pos_on_trunk(locator) {
@@ -100,7 +100,7 @@ impl BlockServer {
         Ok(())
     }
 
-    fn get_data(&self, peer: PeerId, get: Vec<Inventory>) -> Result<(), SPVError> {
+    fn get_data(&self, peer: PeerId, get: Vec<Inventory>) -> Result<(), MurmelError> {
         let chaindb = self.chaindb.read().unwrap();
         for inv in get {
             if inv.inv_type == InvType::WitnessBlock {