Allow sending onion messages to 1-hop blinded path

This allows for specifying the introduction node as the message
recipient.

fuzz/src/onion_message.rs

@@ -211,19 +211,6 @@ mod tests {
 
 	#[test]
 	fn test_no_onion_message_breakage() {
-		let one_hop_om = "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";
-		let logger = TrackingLogger { lines: Mutex::new(HashMap::new()) };
-		super::do_test(&::hex::decode(one_hop_om).unwrap(), &logger);
-		{
-			let log_entries = logger.lines.lock().unwrap();
-			assert_eq!(log_entries.get(&("lightning::onion_message::messenger".to_string(),
-						"Received an onion message with path_id None and a reply_path".to_string())), Some(&1));
-			assert_eq!(log_entries.get(&("lightning::onion_message::messenger".to_string(),
-						"Sending onion message when responding to Custom onion message with path_id None".to_string())), Some(&1));
-			assert_eq!(log_entries.get(&("lightning::onion_message::messenger".to_string(),
-						"Failed sending onion message when responding to Custom onion message with path_id None: TooFewBlindedHops".to_string())), Some(&1));
-		}
-
 		let two_unblinded_hops_om = "020000000000000000000000000000000000000000000000000000000000000e01055600020000000000000000000000000000000000000000000000000000000000000e0135043304210202020202020202020202020202020202020202020202020202020202020202026d000000000000000000000000000000eb0000000000000000000000000000000000000000000000000000000000000036041096000000000000000000000000000000fd1092202a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004800000000000000000000000000000000000000000000000000000000000000";
 		let logger = TrackingLogger { lines: Mutex::new(HashMap::new()) };
 		super::do_test(&::hex::decode(two_unblinded_hops_om).unwrap(), &logger);

lightning/src/blinded_path/mod.rs

@@ -56,15 +56,22 @@ pub struct BlindedHop {
 }
 
 impl BlindedPath {
+	/// Create a one-hop blinded path for a message.
+	pub fn one_hop_for_message<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>(
+		recipient_node_id: PublicKey, entropy_source: &ES, secp_ctx: &Secp256k1<T>
+	) -> Result<Self, ()> {
+		Self::new_for_message(&[recipient_node_id], entropy_source, secp_ctx)
+	}
+
 	/// Create a blinded path for an onion message, to be forwarded along `node_pks`. The last node
 	/// pubkey in `node_pks` will be the destination node.
 	///
-	/// Errors if less than two hops are provided or if `node_pk`(s) are invalid.
+	/// Errors if no hops are provided or if `node_pk`(s) are invalid.
 	//  TODO: make all payloads the same size with padding + add dummy hops
-	pub fn new_for_message<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>
-		(node_pks: &[PublicKey], entropy_source: &ES, secp_ctx: &Secp256k1<T>) -> Result<Self, ()>
-	{
-		if node_pks.len() < 2 { return Err(()) }
+	pub fn new_for_message<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>(
+		node_pks: &[PublicKey], entropy_source: &ES, secp_ctx: &Secp256k1<T>
+	) -> Result<Self, ()> {
+		if node_pks.is_empty() { return Err(()) }
 		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
 		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
 		let introduction_node_id = node_pks[0];

lightning/src/onion_message/functional_tests.rs

@@ -197,7 +197,7 @@ fn pass_along_path(path: &Vec<MessengerNode>) {
 }
 
 #[test]
-fn one_hop() {
+fn one_unblinded_hop() {
 	let nodes = create_nodes(2);
 	let test_msg = TestCustomMessage::Response;
 
@@ -224,6 +224,22 @@ fn two_unblinded_hops() {
 	pass_along_path(&nodes);
 }
 
+#[test]
+fn one_blinded_hop() {
+	let nodes = create_nodes(2);
+	let test_msg = TestCustomMessage::Response;
+
+	let secp_ctx = Secp256k1::new();
+	let blinded_path = BlindedPath::new_for_message(&[nodes[1].get_node_pk()], &*nodes[1].keys_manager, &secp_ctx).unwrap();
+	let path = OnionMessagePath {
+		intermediate_nodes: vec![],
+		destination: Destination::BlindedPath(blinded_path),
+	};
+	nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap();
+	nodes[1].custom_message_handler.expect_message(TestCustomMessage::Response);
+	pass_along_path(&nodes);
+}
+
 #[test]
 fn two_unblinded_two_blinded() {
 	let nodes = create_nodes(5);
@@ -320,17 +336,6 @@ fn invalid_blinded_path_error() {
 	};
 	let err = nodes[0].messenger.send_onion_message(path, test_msg.clone(), None).unwrap_err();
 	assert_eq!(err, SendError::TooFewBlindedHops);
-
-	// 1 hop
-	let mut blinded_path = BlindedPath::new_for_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk()], &*nodes[2].keys_manager, &secp_ctx).unwrap();
-	blinded_path.blinded_hops.remove(0);
-	assert_eq!(blinded_path.blinded_hops.len(), 1);
-	let path = OnionMessagePath {
-		intermediate_nodes: vec![],
-		destination: Destination::BlindedPath(blinded_path),
-	};
-	let err = nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap_err();
-	assert_eq!(err, SendError::TooFewBlindedHops);
 }
 
 #[test]

lightning/src/onion_message/messenger.rs

@@ -225,8 +225,8 @@ pub enum SendError {
 	/// Because implementations such as Eclair will drop onion messages where the message packet
 	/// exceeds 32834 bytes, we refuse to send messages where the packet exceeds this size.
 	TooBigPacket,
-	/// The provided [`Destination`] was an invalid [`BlindedPath`], due to having fewer than two
-	/// blinded hops.
+	/// The provided [`Destination`] was an invalid [`BlindedPath`] due to not having any blinded
+	/// hops.
 	TooFewBlindedHops,
 	/// Our next-hop peer was offline or does not support onion message forwarding.
 	InvalidFirstHop,
@@ -299,7 +299,7 @@ where
 {
 	let OnionMessagePath { intermediate_nodes, mut destination } = path;
 	if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
-		if blinded_hops.len() < 2 {
+		if blinded_hops.is_empty() {
 			return Err(SendError::TooFewBlindedHops);
 		}
 	}