Merge pull request #89 from arik-so/ldk-0.1-upgrade

Upgrade LDK to 0.1

Author: TheBlueMatt

Cargo.toml

@@ -6,16 +6,16 @@ edition = "2021"
 [dependencies]
 bitcoin = "0.32.2"
 hex-conservative = "0.2.1"
-lightning = { version = "0.0.125" }
-lightning-block-sync = { version = "0.0.125", features=["rest-client"] }
-lightning-net-tokio = { version = "0.0.125" }
+lightning = { version = "0.1.0" }
+lightning-block-sync = { version = "0.1.0", features=["rest-client"] }
+lightning-net-tokio = { version = "0.1.0" }
 tokio = { version = "1.25", features = ["full"] }
 tokio-postgres = { version = "=0.7.5" }
 futures = "0.3"
 
 [dev-dependencies]
-lightning = { version = "0.0.125", features = ["_test_utils"] }
-lightning-rapid-gossip-sync = { version = "0.0.125" }
+lightning = { version = "0.1.0", features = ["_test_utils"] }
+lightning-rapid-gossip-sync = { version = "0.1.0" }
 
 [profile.dev]
 panic = "abort"

src/config.rs

@@ -337,7 +337,7 @@ pub(crate) async fn upgrade_db<L: Deref + Clone + Send + Sync + 'static>(
 				let permit = Arc::clone(&sem).acquire_owned().await.unwrap();
 				let logger = logger.clone();
 				tokio::spawn(async move {
-					let rest_client = Arc::new(RestClient::new(bitcoin_rest_endpoint()).unwrap());
+					let rest_client = Arc::new(RestClient::new(bitcoin_rest_endpoint()));
 					let txo = ChainVerifier::retrieve_txo(rest_client, scid as u64, logger).await
 						.expect("We shouldn't have accepted a channel announce with a bad TXO");
 					let client = crate::connect_to_db().await;

src/downloader.rs

@@ -3,9 +3,9 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::events::{MessageSendEvent, MessageSendEventsProvider};
-use lightning::ln::features::{InitFeatures, NodeFeatures};
 use lightning::ln::msgs::{ChannelAnnouncement, ChannelUpdate, Init, LightningError, NodeAnnouncement, QueryChannelRange, QueryShortChannelIds, ReplyChannelRange, ReplyShortChannelIdsEnd, RoutingMessageHandler};
 use lightning::routing::gossip::{NetworkGraph, NodeId, P2PGossipSync};
+use lightning::types::features::{InitFeatures, NodeFeatures};
 use lightning::util::logger::Logger;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::error::TrySendError;
@@ -132,20 +132,20 @@ impl<L: Deref + Clone + Send + Sync> MessageSendEventsProvider for GossipRouter<
 }
 
 impl<L: Deref + Clone + Send + Sync> RoutingMessageHandler for GossipRouter<L> where L::Target: Logger {
-	fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError> {
-		let res = self.native_router.handle_node_announcement(msg)?;
+	fn handle_node_announcement(&self, their_node_id: Option<PublicKey>, msg: &NodeAnnouncement) -> Result<bool, LightningError> {
+		let res = self.native_router.handle_node_announcement(their_node_id, msg)?;
 		self.new_node_announcement(msg.clone());
 		Ok(res)
 	}
 
-	fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError> {
-		let res = self.native_router.handle_channel_announcement(msg)?;
+	fn handle_channel_announcement(&self, their_node_id: Option<PublicKey>, msg: &ChannelAnnouncement) -> Result<bool, LightningError> {
+		let res = self.native_router.handle_channel_announcement(their_node_id, msg)?;
 		self.new_channel_announcement(msg.clone());
 		Ok(res)
 	}
 
-	fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError> {
-		let res = self.native_router.handle_channel_update(msg)?;
+	fn handle_channel_update(&self, their_node_id: Option<PublicKey>, msg: &ChannelUpdate) -> Result<bool, LightningError> {
+		let res = self.native_router.handle_channel_update(their_node_id, msg)?;
 		self.new_channel_update(msg.clone());
 		Ok(res)
 	}
@@ -162,27 +162,27 @@ impl<L: Deref + Clone + Send + Sync> RoutingMessageHandler for GossipRouter<L> w
 		self.native_router.get_next_node_announcement(starting_point)
 	}
 
-	fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()> {
+	fn peer_connected(&self, their_node_id: PublicKey, init: &Init, inbound: bool) -> Result<(), ()> {
 		self.native_router.peer_connected(their_node_id, init, inbound)
 	}
 
-	fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError> {
+	fn handle_reply_channel_range(&self, their_node_id: PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError> {
 		self.native_router.handle_reply_channel_range(their_node_id, msg)
 	}
 
-	fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError> {
+	fn handle_reply_short_channel_ids_end(&self, their_node_id: PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError> {
 		self.native_router.handle_reply_short_channel_ids_end(their_node_id, msg)
 	}
 
-	fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError> {
+	fn handle_query_channel_range(&self, their_node_id: PublicKey, msg: QueryChannelRange) -> Result<(), LightningError> {
 		self.native_router.handle_query_channel_range(their_node_id, msg)
 	}
 
-	fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError> {
+	fn handle_query_short_channel_ids(&self, their_node_id: PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError> {
 		self.native_router.handle_query_short_channel_ids(their_node_id, msg)
 	}
 
-	fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures {
+	fn provided_init_features(&self, their_node_id: PublicKey) -> InitFeatures {
 		self.native_router.provided_init_features(their_node_id)
 	}
 

src/lookup.rs

@@ -13,7 +13,7 @@ use tokio_postgres::Client;
 use futures::StreamExt;
 use hex_conservative::DisplayHex;
 use lightning::{log_debug, log_gossip, log_info};
-use lightning::ln::features::NodeFeatures;
+use lightning::types::features::NodeFeatures;
 use lightning::util::logger::Logger;
 
 use crate::config;

src/serialization.rs

@@ -4,8 +4,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use bitcoin::Network;
 use bitcoin::blockdata::constants::ChainHash;
-use lightning::ln::features::NodeFeatures;
 use lightning::ln::msgs::{UnsignedChannelAnnouncement, UnsignedChannelUpdate};
+use lightning::types::features::NodeFeatures;
 use lightning::util::ser::{BigSize, Writeable};
 use crate::config;
 

src/tests/mod.rs

@@ -11,9 +11,9 @@ use bitcoin::secp256k1::{Secp256k1, SecretKey};
 use bitcoin::hashes::Hash;
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 use hex_conservative::DisplayHex;
-use lightning::ln::features::{ChannelFeatures, NodeFeatures};
 use lightning::ln::msgs::{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, SocketAddress, UnsignedChannelAnnouncement, UnsignedChannelUpdate, UnsignedNodeAnnouncement};
 use lightning::routing::gossip::{NetworkGraph, NodeAlias, NodeId};
+use lightning::types::features::{ChannelFeatures, NodeFeatures};
 use lightning::util::ser::Writeable;
 use lightning_rapid_gossip_sync::RapidGossipSync;
 use crate::{calculate_delta, config, serialize_delta, serialize_empty_blob};

src/verifier.rs

@@ -35,7 +35,7 @@ struct RestBinaryResponse(Vec<u8>);
 impl<L: Deref + Clone + Send + Sync + 'static> ChainVerifier<L> where L::Target: Logger {
 	pub(crate) fn new(graph: Arc<NetworkGraph<L>>, outbound_gossiper: Arc<P2PGossipSync<Arc<NetworkGraph<L>>, Arc<Self>, L>>, logger: L) -> Self {
 		ChainVerifier {
-			rest_client: Arc::new(RestClient::new(config::bitcoin_rest_endpoint()).unwrap()),
+			rest_client: Arc::new(RestClient::new(config::bitcoin_rest_endpoint())),
 			outbound_gossiper,
 			graph,
 			peer_handler: Mutex::new(None),