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

@@ -20,8 +20,8 @@ rand = "0.8.4"
 chacha20poly1305 = "0.8.0"
 
 # Bitcoin and Lightning
-bitcoin = { version = "0.27", features = [ "use-serde" ] }
-lightning = "0.0.105"
+bitcoin = { version = "0.28.0", features = [ "use-serde" ] }
+lightning = "0.0.108"
 
 [build-dependencies]
-tonic-build = "0.6"
+tonic-build = "0.6"

teos-common/src/appointment.rs

@@ -1,8 +1,6 @@
 //! Logic related to appointments shared between users and the towers.
 
-use hex;
 use serde::{Deserialize, Serialize};
-
 use std::array::TryFromSliceError;
 use std::{convert::TryInto, fmt};
 

teos/Cargo.toml

@@ -34,11 +34,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"
+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,28 @@ 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,
-        header_hash: &'a BlockHash,
-    ) -> AsyncBlockSourceResult<'a, Block> {
+    fn get_block<'a>(&'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 +105,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 +121,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

@@ -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

@@ -4,7 +4,6 @@
 use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
 use std::path::PathBuf;
-use std::str::FromStr;
 
 use rusqlite::limits::Limit;
 use rusqlite::{params, params_from_iter, Connection, Error as SqliteError};
@@ -533,7 +532,7 @@ 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()])
+        self.store_data(query, params![sk.secret_bytes().to_vec()])
     }
 
     /// Loads the last known tower secret key from the database.
@@ -549,8 +548,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)
     }
@@ -561,7 +560,7 @@ mod tests {
     use super::*;
     use std::iter::FromIterator;
 
-    use teos_common::cryptography::get_random_bytes;
+    use teos_common::cryptography::{get_random_bytes, get_random_keypair};
     use teos_common::test_utils::get_random_user_id;
 
     use crate::test_utils::{
@@ -1201,4 +1200,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

@@ -328,6 +328,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

@@ -499,11 +499,7 @@ impl chain::Listen for Responder {
         if self.trackers.lock().unwrap().len() > 0 {
             // Complete those appointments that are due at this height
             let completed_trackers = self.check_confirmations(
-                &block
-                    .txdata
-                    .iter()
-                    .map(|tx| tx.txid())
-                    .collect::<Vec<Txid>>(),
+                &txdata.iter().map(|(_, tx)| tx.txid()).collect::<Vec<_>>(),
                 height,
             );
             let trackers_to_delete_gk = completed_trackers
@@ -560,6 +556,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

@@ -28,6 +28,7 @@ use bitcoin::hashes::Hash;
 use bitcoin::network::constants::Network;
 use bitcoin::util::hash::bitcoin_merkle_root;
 use bitcoin::util::uint::Uint256;
+use bitcoin::Witness;
 use lightning_block_sync::poll::{
     ChainPoller, Poll, Validate, ValidatedBlock, ValidatedBlockHeader,
 };
@@ -82,16 +83,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
@@ -196,14 +200,15 @@ impl Blockchain {
         let prev_blockhash = prev_block.block_hash();
         let time = prev_block.header.time + (self.blocks.len() + 1) as u32;
         let txdata = match txs {
+            None => vec![get_random_tx()],
+            Some(v) if v.is_empty() => vec![get_random_tx()],
             Some(t) => t,
-            None => vec![],
         };
         let hashes = txdata.iter().map(|obj| obj.txid().as_hash());
         let mut 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,
@@ -222,7 +227,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> {
@@ -245,10 +250,7 @@ impl BlockSource for Blockchain {
         })
     }
 
-    fn get_block<'a>(
-        &'a mut self,
-        header_hash: &'a BlockHash,
-    ) -> AsyncBlockSourceResult<'a, Block> {
+    fn get_block<'a>(&'a self, header_hash: &'a BlockHash) -> AsyncBlockSourceResult<'a, Block> {
         Box::pin(async move {
             for (height, block) in self.blocks.iter().enumerate() {
                 if block.header.block_hash() == *header_hash {
@@ -265,7 +267,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"));
@@ -300,7 +302,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 {
@@ -356,7 +358,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

@@ -877,6 +877,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)]