X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=0659412f774190ba7adee5ab599d3c4e0174cbb0;hb=17a74fcfc74936b48923bba5a416be73a01d2367;hp=38850b730cf6a18bd4f898f3b2c371e4d740b677;hpb=524981ddf4bae0da695bb40c650812dceeb4d408;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 38850b73..0659412f 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -17,7 +17,7 @@
 
 use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey};
 
-use crate::chain::keysinterface::{KeysManager, NodeSigner, Recipient};
+use crate::sign::{KeysManager, NodeSigner, Recipient};
 use crate::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider};
 use crate::ln::features::{InitFeatures, NodeFeatures};
 use crate::ln::msgs;
@@ -252,7 +252,52 @@ impl ChannelMessageHandler for ErroringMessageHandler {
 		features.set_zero_conf_optional();
 		features
 	}
+
+	fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannelV2) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.temporary_channel_id);
+	}
+
+	fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &msgs::AcceptChannelV2) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.temporary_channel_id);
+	}
+
+	fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &msgs::TxAddInput) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &msgs::TxAddOutput) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &msgs::TxRemoveInput) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &msgs::TxRemoveOutput) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &msgs::TxComplete) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &msgs::TxSignatures) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &msgs::TxInitRbf) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &msgs::TxAckRbf) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
+
+	fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &msgs::TxAbort) {
+		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
+	}
 }
+
 impl Deref for ErroringMessageHandler {
 	type Target = ErroringMessageHandler;
 	fn deref(&self) -> &Self { self }
@@ -542,6 +587,54 @@ pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArc
 /// This is not exported to bindings users as general type aliases don't make sense in bindings.
 pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, SD, M, T, F, C, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'm, M, T, F, L>, &'f P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler, &'c KeysManager>;
 
+
+/// A generic trait which is implemented for all [`PeerManager`]s. This makes bounding functions or
+/// structs on any [`PeerManager`] much simpler as only this trait is needed as a bound, rather
+/// than the full set of bounds on [`PeerManager`] itself.
+#[allow(missing_docs)]
+pub trait APeerManager {
+	type Descriptor: SocketDescriptor;
+	type CMT: ChannelMessageHandler + ?Sized;
+	type CM: Deref<Target=Self::CMT>;
+	type RMT: RoutingMessageHandler + ?Sized;
+	type RM: Deref<Target=Self::RMT>;
+	type OMT: OnionMessageHandler + ?Sized;
+	type OM: Deref<Target=Self::OMT>;
+	type LT: Logger + ?Sized;
+	type L: Deref<Target=Self::LT>;
+	type CMHT: CustomMessageHandler + ?Sized;
+	type CMH: Deref<Target=Self::CMHT>;
+	type NST: NodeSigner + ?Sized;
+	type NS: Deref<Target=Self::NST>;
+	/// Gets a reference to the underlying [`PeerManager`].
+	fn as_ref(&self) -> &PeerManager<Self::Descriptor, Self::CM, Self::RM, Self::OM, Self::L, Self::CMH, Self::NS>;
+}
+
+impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CMH: Deref, NS: Deref>
+APeerManager for PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> where
+	CM::Target: ChannelMessageHandler,
+	RM::Target: RoutingMessageHandler,
+	OM::Target: OnionMessageHandler,
+	L::Target: Logger,
+	CMH::Target: CustomMessageHandler,
+	NS::Target: NodeSigner,
+{
+	type Descriptor = Descriptor;
+	type CMT = <CM as Deref>::Target;
+	type CM = CM;
+	type RMT = <RM as Deref>::Target;
+	type RM = RM;
+	type OMT = <OM as Deref>::Target;
+	type OM = OM;
+	type LT = <L as Deref>::Target;
+	type L = L;
+	type CMHT = <CMH as Deref>::Target;
+	type CMH = CMH;
+	type NST = <NS as Deref>::Target;
+	type NS = NS;
+	fn as_ref(&self) -> &PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> { self }
+}
+
 /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
 /// socket events into messages which it passes on to its [`MessageHandler`].
 ///
@@ -1449,9 +1542,15 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			wire::Message::OpenChannel(msg) => {
 				self.message_handler.chan_handler.handle_open_channel(&their_node_id, &msg);
 			},
+			wire::Message::OpenChannelV2(msg) => {
+				self.message_handler.chan_handler.handle_open_channel_v2(&their_node_id, &msg);
+			},
 			wire::Message::AcceptChannel(msg) => {
 				self.message_handler.chan_handler.handle_accept_channel(&their_node_id, &msg);
 			},
+			wire::Message::AcceptChannelV2(msg) => {
+				self.message_handler.chan_handler.handle_accept_channel_v2(&their_node_id, &msg);
+			},
 
 			wire::Message::FundingCreated(msg) => {
 				self.message_handler.chan_handler.handle_funding_created(&their_node_id, &msg);
@@ -1463,6 +1562,35 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 				self.message_handler.chan_handler.handle_channel_ready(&their_node_id, &msg);
 			},
 
+			// Interactive transaction construction messages:
+			wire::Message::TxAddInput(msg) => {
+				self.message_handler.chan_handler.handle_tx_add_input(&their_node_id, &msg);
+			},
+			wire::Message::TxAddOutput(msg) => {
+				self.message_handler.chan_handler.handle_tx_add_output(&their_node_id, &msg);
+			},
+			wire::Message::TxRemoveInput(msg) => {
+				self.message_handler.chan_handler.handle_tx_remove_input(&their_node_id, &msg);
+			},
+			wire::Message::TxRemoveOutput(msg) => {
+				self.message_handler.chan_handler.handle_tx_remove_output(&their_node_id, &msg);
+			},
+			wire::Message::TxComplete(msg) => {
+				self.message_handler.chan_handler.handle_tx_complete(&their_node_id, &msg);
+			},
+			wire::Message::TxSignatures(msg) => {
+				self.message_handler.chan_handler.handle_tx_signatures(&their_node_id, &msg);
+			},
+			wire::Message::TxInitRbf(msg) => {
+				self.message_handler.chan_handler.handle_tx_init_rbf(&their_node_id, &msg);
+			},
+			wire::Message::TxAckRbf(msg) => {
+				self.message_handler.chan_handler.handle_tx_ack_rbf(&their_node_id, &msg);
+			},
+			wire::Message::TxAbort(msg) => {
+				self.message_handler.chan_handler.handle_tx_abort(&their_node_id, &msg);
+			}
+
 			wire::Message::Shutdown(msg) => {
 				self.message_handler.chan_handler.handle_shutdown(&their_node_id, &msg);
 			},
@@ -1728,12 +1856,24 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 								log_bytes!(msg.temporary_channel_id));
 						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 					},
+					MessageSendEvent::SendAcceptChannelV2 { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendAcceptChannelV2 event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.temporary_channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
 					MessageSendEvent::SendOpenChannel { ref node_id, ref msg } => {
 						log_debug!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}",
 								log_pubkey!(node_id),
 								log_bytes!(msg.temporary_channel_id));
 						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 					},
+					MessageSendEvent::SendOpenChannelV2 { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendOpenChannelV2 event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.temporary_channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
 					MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => {
 						log_debug!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})",
 								log_pubkey!(node_id),
@@ -1755,6 +1895,60 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 								log_bytes!(msg.channel_id));
 						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 					},
+					MessageSendEvent::SendTxAddInput { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxAddInput event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxAddOutput { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxAddOutput event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxRemoveInput { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxRemoveInput event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxRemoveOutput { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxRemoveOutput event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxComplete { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxComplete event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxSignatures { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxSignatures event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxInitRbf { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxInitRbf event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxAckRbf { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxAckRbf event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
+					MessageSendEvent::SendTxAbort { ref node_id, ref msg } => {
+						log_debug!(self.logger, "Handling SendTxAbort event in peer_handler for node {} for channel {}",
+								log_pubkey!(node_id),
+								log_bytes!(msg.channel_id));
+						self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
+					},
 					MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
 						log_debug!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})",
 								log_pubkey!(node_id),
@@ -2202,7 +2396,7 @@ fn is_gossip_msg(type_id: u16) -> bool {
 
 #[cfg(test)]
 mod tests {
-	use crate::chain::keysinterface::{NodeSigner, Recipient};
+	use crate::sign::{NodeSigner, Recipient};
 	use crate::events;
 	use crate::ln::peer_channel_encryptor::PeerChannelEncryptor;
 	use crate::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses};