initial checkin

Author: TheBlueMatt

.gitignore

@@ -0,0 +1,5 @@
+/target/
+**/*.rs.bk
+Cargo.lock
+/target/
+**/*.rs.bk

Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "lightning"
+version = "0.0.1"
+authors = ["Matt Corallo"]
+license = "AGPL-3.0"
+repository = "https://github.com/TheBlueMatt/rust-lightning/"
+description = """
+A Bitcoin Lightning implementation in Rust.
+Still super-early code-dump quality and is missing large chunks. See README in git repo for suggested projects if you want to contribute. Don't have to bother telling you not to use this for anything serious, because you'd have to finish building it to even try.
+"""
+
+[features]
+# Supports tracking channels with a non-bitcoin chain hashes. Currently enables all kinds of fun DoS attacks.
+non_bitcoin_chain_hash_routing = []
+
+[dependencies]
+bitcoin = "0.10.7"
+rust-crypto = "0.2"
+rand = "0.3"
+secp256k1 = "0.8.1"
+num = "0.1"

README.md

@@ -0,0 +1,65 @@
+Rust-Lightning, not Rusty's Lightning!
+
+Currently somewhere near 5% towards usable, published to see if there is any
+real interest from folks in either contributing to or using a lightning rust
+library.
+
+The goal is to provide a full-featured but also incredibly flexible lightning
+implementation, allowing the user to decide how they wish to use it. With that
+in mind, everything should be exposed via simple, composable APIs. The user
+should be able to decide whether they wish to use their own threading/execution
+models, allowing usage inside of existing library architectures, or allow us to
+handle that for them. Same goes with network connections - if the user wishes
+to use their own networking stack, they should be able to do so! This all means
+that we should provide simple external interfaces which allow the user to drive
+all execution, while implementing sample execution drivers that create a
+full-featured lightning daemon by default.
+
+For security reasons, do not add new dependencies. Really do not add new
+non-optional/non-test/non-library dependencies. Really really do not add
+dependencies with dependencies. Do convince Andrew to cut down dependency usage
+in rust-bitcoin.
+
+Assorted random TODOs:
+
+ * Create a general timer interface - this should be passed around in reference
+   form to most objects to allow them to register functions which are called on
+   a timer. By default we should provide an implementation of this which uses
+   some newfangled rusty promise-y library, but should generally ensure a
+   client can simply integrate this into whatever existing timer interface
+   they use.
+
+ * Networking...having a simple bytes-in-bytes-out interface which does message
+   handling and calls our encryption layer is probably the right approach. We
+   should then also probably use the same promise-y library we use for timers
+   to do socket selection and reading/writing.
+
+ * Figure out how to expose when-to-connect and who-to-connect-to.
+
+ * Implement when-to-connect and who-to-connect-to based on route/node rumoring
+   and channelmanager state.
+
+ * Some kind of serialization format for on-disk storage of things like
+   channels, channelmonitors, routing db, etc.
+
+ * BOLT 10/network bootstrapping implementation.
+
+ * Some kind of DoS thing including ban tracking and putting that info in
+   HandleError (and also rename HandleError) to be propagated up...and then
+   handled.
+
+ * All the random TODOs and unimplemented!()s across the codebase.
+
+ * BOLT 11 (invoice/address creation/generation) implementation
+
+ * Type-ify our somewhat random usage of Uint256/[u8; 32]. Use Sha256dHash
+   where appropriate, create our own types for everything else.
+
+ * Some kind of logging subsystem/API.
+
+Notes on coding style:
+ * Use tabs. If you want to align lines, use spaces. Any desired alignment
+   should display fine at any tab-length display setting.
+
+License is AGPL, but with agreement that Matt can relicense under any other
+OSI-approved license at will (and likely will with sufficient motivation).

src/chain/bitcoincorerpcchain.rs

@@ -0,0 +1,41 @@
+use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::script::Script;
+use bitcoin::util::hash::Sha256dHash;
+
+use chain::chaininterface::{ChainWatchInterface,ChainWatchInterfaceUtil,ChainListener};
+
+use std::sync::Weak;
+
+pub struct BitcoinCoreRPCClientChain {
+	util: ChainWatchInterfaceUtil
+}
+
+impl ChainWatchInterface for BitcoinCoreRPCClientChain {
+	fn install_watch_script(&self, spk: Script) {
+		self.util.install_watch_script(spk)
+	}
+
+	fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32)) {
+		self.util.install_watch_outpoint(outpoint)
+	}
+
+	fn watch_all_txn(&self) {
+		self.util.watch_all_txn()
+	}
+
+	fn broadcast_transaction(&self, _tx: &Transaction) {
+		unimplemented!()
+	}
+
+	fn register_listener(&self, listener: Weak<ChainListener>) {
+		self.util.register_listener(listener)
+	}
+}
+
+impl BitcoinCoreRPCClientChain {
+	pub fn new() -> BitcoinCoreRPCClientChain {
+		BitcoinCoreRPCClientChain {
+			util: ChainWatchInterfaceUtil::new(),
+		}
+	}
+}

src/chain/chaininterface.rs

@@ -0,0 +1,130 @@
+use bitcoin::blockdata::block::BlockHeader;
+use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::script::Script;
+use bitcoin::util::hash::Sha256dHash;
+
+use std::sync::{Weak,Mutex};
+
+/// An interface to request notification of certain scripts as they appear the
+/// chain.
+pub trait ChainWatchInterface: Sync + Send {
+	/// Provides a scriptPubKey which much be watched for.
+	fn install_watch_script(&self, script_pub_key: Script);
+
+	/// Provides an outpoint which must be watched for, providing any transactions which spend the
+	/// given outpoint.
+	fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32));
+
+	/// Indicates that a listener needs to see all transactions.
+	fn watch_all_txn(&self);
+
+	/// Sends a transaction out to (hopefully) be mined
+	fn broadcast_transaction(&self, tx: &Transaction);
+
+	fn register_listener(&self, listener: Weak<ChainListener>);
+	//TODO: unregister
+}
+
+/// A trait indicating a desire to listen for events from the chain
+pub trait ChainListener: Sync + Send {
+	/// Notifies a listener that a block was connected.
+	/// Note that if a new script/transaction is watched during a block_connected call, the block
+	/// *must* be re-scanned with the new script/transaction and block_connected should be called
+	/// again with the same header and (at least) the new transactions.
+	/// This also means those counting confirmations using block_connected callbacks should watch
+	/// for duplicate headers and not count them towards confirmations!
+	fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]);
+	/// Notifies a listener that a block was disconnected.
+	/// Unlike block_connected, this *must* never be called twice for the same disconnect event.
+	fn block_disconnected(&self, header: &BlockHeader);
+}
+
+pub enum ConfirmationTarget {
+	Background,
+	Normal,
+	HighPriority,
+}
+
+pub trait FeeEstimator: Sync + Send {
+	fn get_est_sat_per_vbyte(&self, ConfirmationTarget) -> u64;
+}
+
+/// Utility to capture some common parts of ChainWatchInterface implementors.
+/// Keeping a local copy of this in a ChainWatchInterface implementor is likely useful.
+pub struct ChainWatchInterfaceUtil {
+	watched: Mutex<(Vec<Script>, Vec<(Sha256dHash, u32)>, bool)>, //TODO: Something clever to optimize this
+	listeners: Mutex<Vec<Weak<ChainListener>>>,
+}
+
+impl ChainWatchInterfaceUtil {
+	pub fn new() -> ChainWatchInterfaceUtil {
+		ChainWatchInterfaceUtil {
+			watched: Mutex::new((Vec::new(), Vec::new(), false)),
+			listeners: Mutex::new(Vec::new()),
+		}
+	}
+
+	pub fn install_watch_script(&self, spk: Script) {
+		let mut watched = self.watched.lock().unwrap();
+		watched.0.push(Script::from(spk));
+	}
+
+	pub fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32)) {
+		let mut watched = self.watched.lock().unwrap();
+		watched.1.push(outpoint);
+	}
+
+	pub fn watch_all_txn(&self) { //TODO: refcnt this?
+		let mut watched = self.watched.lock().unwrap();
+		watched.2 = true;
+	}
+
+	pub fn register_listener(&self, listener: Weak<ChainListener>) {
+		let mut vec = self.listeners.lock().unwrap();
+		vec.push(listener);
+	}
+
+	pub fn do_call_block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]) {
+		let listeners = self.listeners.lock().unwrap().clone();
+		for listener in listeners.iter() {
+			match listener.upgrade() {
+				Some(arc) => arc.block_connected(header, height, txn_matched, indexes_of_txn_matched),
+				None => ()
+			}
+		}
+	}
+
+	pub fn do_call_block_disconnected(&self, header: &BlockHeader) {
+		let listeners = self.listeners.lock().unwrap().clone();
+		for listener in listeners.iter() {
+			match listener.upgrade() {
+				Some(arc) => arc.block_disconnected(header),
+				None => ()
+			}
+		}
+	}
+
+	/// Checks if a given transaction matches the current filter
+	pub fn does_match_tx(&self, tx: &Transaction) -> bool {
+		let watched = self.watched.lock().unwrap();
+		if watched.2 {
+			return true;
+		}
+		for out in tx.output.iter() {
+			for script in watched.0.iter() {
+				if script[..] == out.script_pubkey[..] {
+					return true;
+				}
+			}
+		}
+		for input in tx.input.iter() {
+			for outpoint in watched.1.iter() {
+				let &(outpoint_hash, outpoint_index) = outpoint;
+				if outpoint_hash == input.prev_hash && outpoint_index == input.prev_index {
+					return true;
+				}
+			}
+		}
+		false
+	}
+}

src/chain/mod.rs

@@ -0,0 +1,3 @@
+pub mod chaininterface;
+pub mod bitcoincorerpcchain;
+pub mod rustbitcoinchain;

src/chain/rustbitcoinchain.rs

@@ -0,0 +1,66 @@
+use bitcoin::blockdata::blockchain::Blockchain;
+use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::block::Block;
+use bitcoin::blockdata::script::Script;
+use bitcoin::network::constants::Network;
+use bitcoin::util::hash::Sha256dHash;
+
+use chain::chaininterface::{ChainWatchInterface,ChainWatchInterfaceUtil,ChainListener};
+
+use std::sync::{Mutex,Weak};
+
+/// Implements a ChainWatchInterface using rust-bitcoin's Blockchain class
+pub struct ChainWatchImpl {
+	chain: Mutex<Blockchain>,
+	util: ChainWatchInterfaceUtil
+}
+
+unsafe impl Send for ChainWatchImpl {} //TODO: GAH WTF
+unsafe impl Sync for ChainWatchImpl {} //TODO: GAH WTF
+
+impl ChainWatchInterface for ChainWatchImpl {
+	fn install_watch_script(&self, spk: Script) {
+		self.util.install_watch_script(spk)
+	}
+
+	fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32)) {
+		self.util.install_watch_outpoint(outpoint)
+	}
+
+	fn watch_all_txn(&self) {
+		self.util.watch_all_txn()
+	}
+
+	fn broadcast_transaction(&self, _tx: &Transaction) {
+		unimplemented!()
+	}
+
+	fn register_listener(&self, listener: Weak<ChainListener>) {
+		self.util.register_listener(listener)
+	}
+}
+
+impl ChainWatchImpl {
+	pub fn new(network: Network) -> ChainWatchImpl {
+		ChainWatchImpl {
+			chain: Mutex::new(Blockchain::new(network)),
+			util: ChainWatchInterfaceUtil::new(),
+		}
+	}
+
+	pub fn add_block(&mut self, block: Block) {
+		{
+			let mut txn_matched: Vec<&Transaction> = Vec::new();
+			let mut indexes_of_txn_matched = Vec::new();
+			for (idx, tx) in block.txdata.iter().enumerate() {
+				if self.util.does_match_tx(&tx) {
+					txn_matched.push(tx);
+					indexes_of_txn_matched.push(idx as u32);
+				}
+			}
+			//TODO: Height
+			self.util.do_call_block_connected(&block.header, 0, &txn_matched[..], &indexes_of_txn_matched[..]);
+		}
+		self.chain.lock().unwrap().add_block(block);
+	}
+}

src/lib.rs

@@ -0,0 +1,12 @@
+#![crate_name = "lightning"]
+
+extern crate bitcoin;
+extern crate secp256k1;
+extern crate rand;
+extern crate crypto;
+extern crate num; //TODO: Convince andrew to not rely on this for fucking casting...
+
+pub mod chain;
+pub mod wallet;
+pub mod ln;
+pub mod util;