Change ChanInfo.DirChanInfo fields to alice/bob

Author: sourabhmarathe

lightning/src/routing/network_graph.rs

@@ -147,15 +147,15 @@ impl<C: Deref + Sync + Send, L: Deref + Sync + Send> RoutingMessageHandler for N
 			if let Some((_, ref chan)) = iter.next() {
 				if chan.announcement_message.is_some() {
 					let chan_announcement = chan.announcement_message.clone().unwrap();
-					let mut one_to_two_announcement: Option<msgs::ChannelUpdate> = None;
-					let mut two_to_one_announcement: Option<msgs::ChannelUpdate> = None;
-					if let Some(one_to_two) = chan.one_to_two.as_ref() {
-						one_to_two_announcement = one_to_two.last_update_message.clone();
+					let mut alice_to_bob_announcement: Option<msgs::ChannelUpdate> = None;
+					let mut bob_to_alice_announcement: Option<msgs::ChannelUpdate> = None;
+					if let Some(alice_to_bob) = chan.alice_to_bob.as_ref() {
+						alice_to_bob_announcement = alice_to_bob.last_update_message.clone();
 					}
-					if let Some(two_to_one) = chan.two_to_one.as_ref() {
-						two_to_one_announcement = two_to_one.last_update_message.clone();
+					if let Some(bob_to_alice) = chan.bob_to_alice.as_ref() {
+						bob_to_alice_announcement = bob_to_alice.last_update_message.clone();
 					}
-					result.push((chan_announcement, one_to_two_announcement, two_to_one_announcement));
+					result.push((chan_announcement, alice_to_bob_announcement, bob_to_alice_announcement));
 				} else {
 					// TODO: We may end up sending un-announced channel_updates if we are sending
 					// initial sync data while receiving announce/updates for this channel.
@@ -283,11 +283,11 @@ pub struct ChannelInfo {
 	/// Source node of the first direction of a channel
 	pub node_one: PublicKey,
 	/// Details about the first direction of a channel
-	pub one_to_two: Option<DirectionalChannelInfo>,
+	pub alice_to_bob: Option<DirectionalChannelInfo>,
 	/// Source node of the second direction of a channel
 	pub node_two: PublicKey,
 	/// Details about the second direction of a channel
-	pub two_to_one: Option<DirectionalChannelInfo>,
+	pub bob_to_alice: Option<DirectionalChannelInfo>,
 	/// An initial announcement of the channel
 	/// Mostly redundant with the data we store in fields explicitly.
 	/// Everything else is useful only for sending out for initial routing sync.
@@ -297,18 +297,18 @@ pub struct ChannelInfo {
 
 impl std::fmt::Display for ChannelInfo {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		write!(f, "features: {}, node_one: {}, one_to_two: {:?}, node_two: {}, two_to_one: {:?}",
-		   log_bytes!(self.features.encode()), log_pubkey!(self.node_one), self.one_to_two, log_pubkey!(self.node_two), self.two_to_one)?;
+		write!(f, "features: {}, node_one: {}, alice_to_bob: {:?}, node_two: {}, bob_to_alice: {:?}",
+		   log_bytes!(self.features.encode()), log_pubkey!(self.node_one), self.alice_to_bob, log_pubkey!(self.node_two), self.bob_to_alice)?;
 		Ok(())
 	}
 }
 
 impl_writeable!(ChannelInfo, 0, {
 	features,
 	node_one,
-	one_to_two,
+	alice_to_bob,
 	node_two,
-	two_to_one,
+	bob_to_alice,
 	announcement_message
 });
 
@@ -550,8 +550,8 @@ impl NetworkGraph {
 			for route_hop in path {
 				let short_channel_id = route_hop.short_channel_id;
 				if let Some(channel) = self.channels.get_mut(&short_channel_id) {
-					channel.one_to_two.as_mut().unwrap().channel_score.payment_sent_score += 1;
-					channel.two_to_one.as_mut().unwrap().channel_score.payment_sent_score += 1;
+					channel.alice_to_bob.as_mut().unwrap().channel_score.payment_sent_score += 1;
+					channel.bob_to_alice.as_mut().unwrap().channel_score.payment_sent_score += 1;
 				} else {
 					channel_down = true;
 					continue;
@@ -578,9 +578,9 @@ impl NetworkGraph {
 				let short_channel_id = route_hop.short_channel_id;
 				let channel = self.channels.get_mut(&short_channel_id).unwrap();
 				let directional_channel_info = if route_hop.pubkey == channel.node_one {
-					channel.one_to_two.as_mut().unwrap()
+					channel.alice_to_bob.as_mut().unwrap()
 				} else {
-					channel.two_to_one.as_mut().unwrap()
+					channel.bob_to_alice.as_mut().unwrap()
 				};
 				let channel_score = &mut directional_channel_info.channel_score;
 				if faultive_nodes.contains(&(route_hop.pubkey)) {
@@ -645,9 +645,9 @@ impl NetworkGraph {
 		let chan_info = ChannelInfo {
 				features: msg.contents.features.clone(),
 				node_one: msg.contents.node_id_1.clone(),
-				one_to_two: None,
+				alice_to_bob: None,
 				node_two: msg.contents.node_id_2.clone(),
-				two_to_one: None,
+				bob_to_alice: None,
 				announcement_message: if should_relay { Some(msg.clone()) } else { None },
 			};
 
@@ -710,11 +710,11 @@ impl NetworkGraph {
 			}
 		} else {
 			if let Some(chan) = self.channels.get_mut(&short_channel_id) {
-				if let Some(one_to_two) = chan.one_to_two.as_mut() {
-					one_to_two.enabled = false;
+				if let Some(alice_to_bob) = chan.alice_to_bob.as_mut() {
+					alice_to_bob.enabled = false;
 				}
-				if let Some(two_to_one) = chan.two_to_one.as_mut() {
-					two_to_one.enabled = false;
+				if let Some(bob_to_alice) = chan.bob_to_alice.as_mut() {
+					bob_to_alice.enabled = false;
 				}
 			}
 		}
@@ -780,13 +780,13 @@ impl NetworkGraph {
 					if let Some(sig_verifier) = secp_ctx {
 						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_two);
 					}
-					maybe_update_channel_info!(channel.two_to_one, channel.node_two);
+					maybe_update_channel_info!(channel.bob_to_alice, channel.node_two);
 				} else {
 					dest_node_id = channel.node_two.clone();
 					if let Some(sig_verifier) = secp_ctx {
 						secp_verify_sig!(sig_verifier, &msg_hash, &msg.signature, &channel.node_one);
 					}
-					maybe_update_channel_info!(channel.one_to_two, channel.node_one);
+					maybe_update_channel_info!(channel.alice_to_bob, channel.node_one);
 				}
 			}
 		}
@@ -811,9 +811,9 @@ impl NetworkGraph {
 				let chan = self.channels.get(chan_id).unwrap();
 				let chan_info_opt;
 				if chan.node_one == dest_node_id {
-					chan_info_opt = chan.two_to_one.as_ref();
+					chan_info_opt = chan.bob_to_alice.as_ref();
 				} else {
-					chan_info_opt = chan.one_to_two.as_ref();
+					chan_info_opt = chan.alice_to_bob.as_ref();
 				}
 				if let Some(chan_info) = chan_info_opt {
 					if chan_info.enabled {
@@ -1260,8 +1260,8 @@ mod tests {
 			match network.get_channels().get(&short_channel_id) {
 				None => panic!(),
 				Some(channel_info) => {
-					assert_eq!(channel_info.one_to_two.as_ref().unwrap().cltv_expiry_delta, 144);
-					assert!(channel_info.two_to_one.is_none());
+					assert_eq!(channel_info.alice_to_bob.as_ref().unwrap().cltv_expiry_delta, 144);
+					assert!(channel_info.bob_to_alice.is_none());
 				}
 			}
 		}
@@ -1395,7 +1395,7 @@ mod tests {
 			match network.get_channels().get(&short_channel_id) {
 				None => panic!(),
 				Some(channel_info) => {
-					assert!(channel_info.one_to_two.is_some());
+					assert!(channel_info.alice_to_bob.is_some());
 				}
 			}
 		}
@@ -1413,7 +1413,7 @@ mod tests {
 			match network.get_channels().get(&short_channel_id) {
 				None => panic!(),
 				Some(channel_info) => {
-					assert!(!channel_info.one_to_two.as_ref().unwrap().enabled);
+					assert!(!channel_info.alice_to_bob.as_ref().unwrap().enabled);
 				}
 			}
 		}
@@ -1803,7 +1803,7 @@ mod tests {
 			let mut network = net_graph_msg_handler.network_graph.write().unwrap();
 			let chan_id = network.get_nodes().get(&node_id_1).unwrap().channels[0];
 			let channel_info = network.channels.get_mut(&chan_id).unwrap();
-			// Assign a DirectionalChannelInfo and ChannelScore object to one_to_two of
+			// Assign a DirectionalChannelInfo and ChannelScore object to alice_to_bob of
 			// channel_info
 			let chan_score_1 = ChannelScore {
 				payment_sent_score: 0,
@@ -1838,11 +1838,11 @@ mod tests {
 				channel_score: chan_score_2,
 			};
 
-			channel_info.one_to_two = Some(dir_chan_info_1);
-			channel_info.two_to_one = Some(dir_chan_info_2);
-			let dir_one_to_two = channel_info.one_to_two.as_mut().unwrap();
-			assert_eq!(dir_one_to_two.channel_score.payment_sent_score, 0);
-			assert_eq!(dir_one_to_two.channel_score.payment_failed_score, 0);
+			channel_info.alice_to_bob = Some(dir_chan_info_1);
+			channel_info.bob_to_alice = Some(dir_chan_info_2);
+			let dir_alice_to_bob = channel_info.alice_to_bob.as_mut().unwrap();
+			assert_eq!(dir_alice_to_bob.channel_score.payment_sent_score, 0);
+			assert_eq!(dir_alice_to_bob.channel_score.payment_failed_score, 0);
 		}
 
 		{
@@ -1864,9 +1864,9 @@ mod tests {
 			// Check that score_payment_sent_for_route incremented the appropriate ChannelScore
 			let chan_id = network.get_nodes().get(&node_id_1).unwrap().channels[0];
 			let channel_info = network.channels.get_mut(&chan_id).unwrap();
-			let dir_one_to_two = &channel_info.one_to_two.as_ref();
-			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_sent_score, 1);
-			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_failed_score, 0);
+			let dir_alice_to_bob = &channel_info.alice_to_bob.as_ref();
+			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_failed_score, 0);
 		}
 
 		{
@@ -1890,9 +1890,9 @@ mod tests {
 			let chan_id = network.get_nodes().get(&node_id_1).unwrap().channels[0];
 			let channel_info = network.channels.get_mut(&chan_id).unwrap();
 			assert!(channel_info.node_two == node_id_2);
-			let dir_one_to_two = &channel_info.one_to_two.as_ref();
-			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_sent_score, 1);
-			assert_eq!(dir_one_to_two.unwrap().channel_score.payment_failed_score, 1);
+			let dir_alice_to_bob = &channel_info.alice_to_bob.as_ref();
+			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_sent_score, 1);
+			assert_eq!(dir_alice_to_bob.unwrap().channel_score.payment_failed_score, 1);
 		}
 	}
 }

lightning/src/routing/router.rs

@@ -301,19 +301,19 @@ pub fn get_route<C: Deref, L: Deref>(our_node_id: &PublicKey, net_graph_msg_hand
 					let chan = network.get_channels().get(chan_id).unwrap();
 					if !chan.features.requires_unknown_bits() {
 						if chan.node_one == *$node_id {
-							// ie $node is one, ie next hop in A* is two, via the two_to_one channel
+							// ie $node is one, ie next hop in A* is two, via the bob_to_alice channel
 							if first_hops.is_none() || chan.node_two != *our_node_id {
-								if let Some(two_to_one) = chan.two_to_one.as_ref() {
-									if two_to_one.enabled {
-										add_entry!(chan_id, chan.node_two, chan.node_one, two_to_one, chan.features, $fee_to_target_msat);
+								if let Some(bob_to_alice) = chan.bob_to_alice.as_ref() {
+									if bob_to_alice.enabled {
+										add_entry!(chan_id, chan.node_two, chan.node_one, bob_to_alice, chan.features, $fee_to_target_msat);
 									}
 								}
 							}
 						} else {
 							if first_hops.is_none() || chan.node_one != *our_node_id {
-								if let Some(one_to_two) = chan.one_to_two.as_ref() {
-									if one_to_two.enabled {
-										add_entry!(chan_id, chan.node_one, chan.node_two, one_to_two, chan.features, $fee_to_target_msat);
+								if let Some(alice_to_bob) = chan.alice_to_bob.as_ref() {
+									if alice_to_bob.enabled {
+										add_entry!(chan_id, chan.node_one, chan.node_two, alice_to_bob, chan.features, $fee_to_target_msat);
 									}
 								}