Pump up some deps

Needed to pump the lightning version used and had to pump bitcoin, bitcoincore-rpc aswell to match dep verions in lightining
merkle root computation changed in `bitcoin`, thus some methods in the test_utils needed to adapt (basically by adding a tx if there is none in a block). See: rust-bitcoin/rust-bitcoin@b454cf8
Also SecretKey had it's `to_string` method removed, so TEOS now encodes its tower key using `secret_bytes()` and `from_slice()`. See: rust-bitcoin/rust-secp256k1#312

Author: mariocynicys

teos-common/Cargo.toml

@@ -15,5 +15,5 @@ rand = "0.8.4"
 chacha20poly1305 = "0.8.0"
 
 # Bitcoin and Lightning
-bitcoin = "0.28.1"
+bitcoin = "0.28.0"
 lightning = { git = "https://github.com/meryacine/rust-lightning", branch = "expose-tlv-macros" }

teos/Cargo.toml

@@ -33,11 +33,11 @@ warp = "0.3.2"
 torut = "0.2.1"
 
 # Bitcoin and Lightning
-bitcoin = { version = "0.27", features = [ "base64" ] }
-bitcoincore-rpc = "0.14.0"
-lightning = "0.0.105"
-lightning-net-tokio = "0.0.105"
-lightning-block-sync = { version = "0.0.105", features = [ "rpc-client" ] }
+bitcoin = { version = "0.28.0", features = [ "base64" ] }
+bitcoincore-rpc = "0.15.0"
+lightning = "0.0.108"#{ git = "https://github.com/meryacine/rust-lightning", branch = "expose-tlv-macros" }
+lightning-net-tokio = "0.0.108"
+lightning-block-sync = { version = "0.0.108", features = [ "rpc-client" ] }
 
 # Local
 teos-common = { path = "../teos-common" }

teos/src/bitcoin_cli.rs

@@ -38,31 +38,31 @@ pub struct BitcoindClient<'a> {
 impl BlockSource for &BitcoindClient<'_> {
     /// Gets a block header given its hash.
     fn get_header<'a>(
-        &'a mut self,
+        &'a self,
         header_hash: &'a BlockHash,
         height_hint: Option<u32>,
     ) -> AsyncBlockSourceResult<'a, BlockHeaderData> {
         Box::pin(async move {
-            let mut rpc = self.bitcoind_rpc_client.lock().await;
+            let rpc = self.bitcoind_rpc_client.lock().await;
             rpc.get_header(header_hash, height_hint).await
         })
     }
 
     /// Gets a block given its hash.
     fn get_block<'a>(
-        &'a mut self,
+        &'a self,
         header_hash: &'a BlockHash,
     ) -> AsyncBlockSourceResult<'a, Block> {
         Box::pin(async move {
-            let mut rpc = self.bitcoind_rpc_client.lock().await;
+            let rpc = self.bitcoind_rpc_client.lock().await;
             rpc.get_block(header_hash).await
         })
     }
 
     /// Get the best block known by our node.
-    fn get_best_block(&mut self) -> AsyncBlockSourceResult<(BlockHash, Option<u32>)> {
+    fn get_best_block(&self) -> AsyncBlockSourceResult<(BlockHash, Option<u32>)> {
         Box::pin(async move {
-            let mut rpc = self.bitcoind_rpc_client.lock().await;
+            let rpc = self.bitcoind_rpc_client.lock().await;
             rpc.get_best_block().await
         })
     }
@@ -108,14 +108,14 @@ impl<'a> BitcoindClient<'a> {
     pub async fn get_best_block_hash_and_height(
         &self,
     ) -> Result<(BlockHash, Option<u32>), std::io::Error> {
-        let mut rpc = self.bitcoind_rpc_client.lock().await;
+        let rpc = self.bitcoind_rpc_client.lock().await;
         rpc.call_method::<(BlockHash, Option<u32>)>("getblockchaininfo", &[])
             .await
     }
 
     /// Sends a transaction to the network.
     pub async fn send_raw_transaction(&self, raw_tx: &Transaction) -> Result<Txid, std::io::Error> {
-        let mut rpc = self.bitcoind_rpc_client.lock().await;
+        let rpc = self.bitcoind_rpc_client.lock().await;
 
         let raw_tx_json = serde_json::json!(raw_tx.encode().to_hex());
         rpc.call_method::<Txid>("sendrawtransaction", &[raw_tx_json])
@@ -124,7 +124,7 @@ impl<'a> BitcoindClient<'a> {
 
     /// Gets a transaction given its id.
     pub async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction, std::io::Error> {
-        let mut rpc = self.bitcoind_rpc_client.lock().await;
+        let rpc = self.bitcoind_rpc_client.lock().await;
 
         let txid_hex = serde_json::json!(txid.encode().to_hex());
         rpc.call_method::<Transaction>("getrawtransaction", &[txid_hex])

teos/src/chain_monitor.rs

@@ -22,7 +22,7 @@ where
     P: Poll,
     C: Cache,
     L: Deref,
-    L::Target: chain::Listen,
+    <L as Deref>::Target: chain::Listen,
 {
     /// A bitcoin client to poll best tips from.
     spv_client: SpvClient<'a, P, C, L>,
@@ -43,7 +43,7 @@ where
     P: Poll,
     C: Cache,
     L: Deref,
-    L::Target: chain::Listen,
+    <L as Deref>::Target: chain::Listen,
 {
     /// Creates a new [ChainMonitor] instance.
     pub async fn new(
@@ -167,6 +167,10 @@ mod tests {
                 .borrow_mut()
                 .insert(header.block_hash());
         }
+
+        fn filtered_block_connected(&self, header: &bitcoin::BlockHeader, txdata: &chain::transaction::TransactionData, height: u32) {
+            
+        }
     }
 
     #[tokio::test]

teos/src/dbm.rs

@@ -3,7 +3,6 @@
 
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
-use std::str::FromStr;
 
 use rusqlite::ffi::{SQLITE_CONSTRAINT_FOREIGNKEY, SQLITE_CONSTRAINT_PRIMARYKEY};
 use rusqlite::limits::Limit;
@@ -567,7 +566,8 @@ impl DBM {
     /// When a new key is generated, old keys are not overwritten but are not retrievable from the API either.
     pub fn store_tower_key(&self, sk: &SecretKey) -> Result<(), Error> {
         let query = "INSERT INTO keys (key) VALUES (?)";
-        self.store_data(query, params![sk.to_string()])
+        let sk_bytes = Vec::from(sk.secret_bytes());
+        self.store_data(query, params![sk_bytes])
     }
 
     /// Loads the last known tower secret key from the database.
@@ -583,8 +583,8 @@ impl DBM {
             .unwrap();
 
         stmt.query_row(["keys"], |row| {
-            let sk: String = row.get(0).unwrap();
-            Ok(SecretKey::from_str(&sk).unwrap())
+            let sk: Vec<u8> = row.get(0).unwrap();
+            Ok(SecretKey::from_slice(&sk).unwrap())
         })
         .map_err(|_| Error::NotFound)
     }
@@ -599,7 +599,7 @@ mod tests {
         get_random_tracker, get_random_user_id,
     };
     use std::iter::FromIterator;
-    use teos_common::cryptography::get_random_bytes;
+    use teos_common::cryptography::{get_random_bytes, get_random_keypair};
 
     impl DBM {
         pub(crate) fn in_memory() -> Result<Self, SqliteError> {
@@ -1166,4 +1166,16 @@ mod tests {
 
         assert!(matches!(dbm.load_last_known_block(), Err(Error::NotFound)));
     }
+
+    #[test]
+    fn test_store_load_tower_key() {
+        let dbm = DBM::in_memory().unwrap();
+
+        assert!(matches!(dbm.load_tower_key(), Err(Error::NotFound)));
+        for _ in 0..7 {
+            let sk = get_random_keypair().0;
+            dbm.store_tower_key(&sk).unwrap();
+            assert_eq!(dbm.load_tower_key().unwrap(), sk);
+        }
+    }
 }

teos/src/gatekeeper.rs

@@ -327,6 +327,10 @@ impl chain::Listen for Gatekeeper {
         self.last_known_block_height
             .store(height - 1, Ordering::Release);
     }
+
+    fn filtered_block_connected(&self, header: &bitcoin::BlockHeader, txdata: &chain::transaction::TransactionData, height: u32) {
+        
+    }
 }
 
 #[cfg(test)]

teos/src/responder.rs

@@ -557,6 +557,10 @@ impl chain::Listen for Responder {
             }
         }
     }
+
+    fn filtered_block_connected(&self, header: &BlockHeader, txdata: &chain::transaction::TransactionData, height: u32) {
+        
+    }
 }
 
 #[cfg(test)]

teos/src/test_utils.rs

@@ -23,7 +23,7 @@ use bitcoin::blockdata::block::{Block, BlockHeader};
 use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::blockdata::script::{Builder, Script};
 use bitcoin::blockdata::transaction::{OutPoint, Transaction, TxIn, TxOut};
-use bitcoin::consensus;
+use bitcoin::{consensus, Witness};
 use bitcoin::hash_types::BlockHash;
 use bitcoin::hash_types::Txid;
 use bitcoin::hashes::hex::FromHex;
@@ -89,16 +89,19 @@ impl Blockchain {
             let prev_block = &self.blocks[i - 1];
             let prev_blockhash = prev_block.block_hash();
             let time = prev_block.header.time + height as u32;
+            let txdata = vec![get_random_tx()];
+            let hashes = txdata.iter().map(|obj| obj.txid().as_hash());
+    
             self.blocks.push(Block {
                 header: BlockHeader {
                     version: 0,
                     prev_blockhash,
-                    merkle_root: Default::default(),
+                    merkle_root: bitcoin_merkle_root(hashes).unwrap().into(),
                     time,
                     bits,
                     nonce: 0,
                 },
-                txdata: vec![],
+                txdata,
             });
         }
         self
@@ -204,15 +207,15 @@ impl Blockchain {
         let time = prev_block.header.time + (self.blocks.len() + 1) as u32;
         let txdata = match txs {
             Some(t) => t,
-            None => vec![],
+            None => vec![get_random_tx()],
         };
         let hashes = txdata.iter().map(|obj| obj.txid().as_hash());
 
         let block = Block {
             header: BlockHeader {
                 version: 0,
                 prev_blockhash,
-                merkle_root: bitcoin_merkle_root(hashes).into(),
+                merkle_root: bitcoin_merkle_root(hashes).unwrap().into(),
                 time,
                 bits,
                 nonce: 0,
@@ -228,7 +231,7 @@ impl Blockchain {
 
 impl BlockSource for Blockchain {
     fn get_header<'a>(
-        &'a mut self,
+        &'a self,
         header_hash: &'a BlockHash,
         _height_hint: Option<u32>,
     ) -> AsyncBlockSourceResult<'a, BlockHeaderData> {
@@ -252,7 +255,7 @@ impl BlockSource for Blockchain {
     }
 
     fn get_block<'a>(
-        &'a mut self,
+        &'a self,
         header_hash: &'a BlockHash,
     ) -> AsyncBlockSourceResult<'a, Block> {
         Box::pin(async move {
@@ -271,7 +274,7 @@ impl BlockSource for Blockchain {
         })
     }
 
-    fn get_best_block(&mut self) -> AsyncBlockSourceResult<(BlockHash, Option<u32>)> {
+    fn get_best_block(&self) -> AsyncBlockSourceResult<(BlockHash, Option<u32>)> {
         Box::pin(async move {
             if *self.unreachable.lock().unwrap() {
                 return Err(BlockSourceError::transient("Connection refused"));
@@ -312,7 +315,7 @@ pub(crate) fn get_random_tx() -> Transaction {
                 rng.gen_range(0..200),
             ),
             script_sig: Script::new(),
-            witness: Vec::new(),
+            witness: Witness::new(),
             sequence: 0,
         }],
         output: vec![TxOut {
@@ -384,7 +387,7 @@ pub(crate) fn store_appointment_and_fks_to_db(
 
 pub(crate) async fn get_last_n_blocks(chain: &mut Blockchain, n: usize) -> Vec<ValidatedBlock> {
     let tip = chain.tip();
-    let mut poller = ChainPoller::new(chain, Network::Bitcoin);
+    let poller = ChainPoller::new(chain, Network::Bitcoin);
 
     let mut last_n_blocks = Vec::new();
     let mut last_known_block = tip;

teos/src/watcher.rs

@@ -861,6 +861,10 @@ impl chain::Listen for Watcher {
         self.last_known_block_height
             .store(height - 1, Ordering::Release);
     }
+
+    fn filtered_block_connected(&self, header: &BlockHeader, txdata: &chain::transaction::TransactionData, height: u32) {
+        
+    }
 }
 
 #[cfg(test)]