lightning: Add struct for building OurPeerStorage, which would be encrypted and sent to our peers.

Author: Aditya Sharma

lightning/src/ln/channel.rs

@@ -2101,6 +2101,14 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 		self.update_time_counter
 	}
 
+	pub fn get_commitment_secret(&self) -> CounterpartyCommitmentSecrets {
+		self.commitment_secrets.clone()
+	}
+
+	pub fn get_channel_keys_id(&self) -> [u8;32] {
+		self.channel_keys_id
+	}
+
 	pub fn increment_and_fetch_monitor_update_id(&mut self) -> u64 {
 		self.latest_monitor_update_id +=1;
 		self.latest_monitor_update_id

lightning/src/ln/channelmanager.rs

@@ -390,6 +390,69 @@ impl From<&ClaimableHTLC> for events::ClaimedHTLC {
 	}
 }
 
+#[derive(Clone, PartialEq, Eq)]
+pub struct StubChannel {
+	pub channel_id: ChannelId,
+	pub funding_outpoint: OutPoint,
+	pub channel_value_stoshis: u64,
+	pub channel_keys_id: [u8;32],
+	pub commitment_secrets: CounterpartyCommitmentSecrets,
+	pub counterparty_node_id: PublicKey,
+}
+
+impl StubChannel {
+    pub fn new(channel_id: ChannelId, funding_outpoint: OutPoint, channel_value_stoshis: u64, channel_keys_id: [u8; 32], commitment_secrets: CounterpartyCommitmentSecrets, counterparty_node_id: PublicKey) -> Self {
+        StubChannel {
+            channel_id,
+			funding_outpoint,
+			channel_value_stoshis,
+            channel_keys_id,
+            commitment_secrets,
+			counterparty_node_id,
+        }
+    }
+}
+
+impl_writeable_tlv_based!(StubChannel, {
+	(0, channel_id, required),
+	(2, channel_keys_id, required),
+	(4, channel_value_stoshis, required),
+	(6, funding_outpoint, required),
+	(8, commitment_secrets, required),
+	(10, counterparty_node_id, required),
+});
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct OurPeerStorage {
+    pub version: u32,
+    pub timestamp: u32,
+    pub channels: Vec<StubChannel>,
+}
+
+impl OurPeerStorage {
+    pub fn new() -> Self {
+        let duration_since_epoch = std::time::SystemTime::now()
+            .duration_since(std::time::SystemTime::UNIX_EPOCH)
+            .expect("Time must be > 1970");
+
+        Self {
+            version: 1,
+            timestamp: duration_since_epoch.as_secs() as u32,
+            channels: Vec::new(),
+        }
+    }
+
+    pub fn stub_channel(&mut self, chan: StubChannel) {
+        self.channels.push(chan);
+    }
+}
+
+impl_writeable_tlv_based!(OurPeerStorage, {
+	(0, version, (default_value, 1)),
+	(2, timestamp, required),
+	(4, channels, optional_vec),
+});
+
 /// A user-provided identifier in [`ChannelManager::send_payment`] used to uniquely identify
 /// a payment and ensure idempotency in LDK.
 ///
@@ -1432,6 +1495,7 @@ where
 	entropy_source: ES,
 	node_signer: NS,
 	signer_provider: SP,
+	our_peer_storage: FairRwLock<OurPeerStorage>,
 
 	logger: L,
 }
@@ -2527,6 +2591,7 @@ where
 			entropy_source,
 			node_signer,
 			signer_provider,
+			our_peer_storage: FairRwLock::new(OurPeerStorage::new()),
 			logger,
 		}
 	}
@@ -10844,6 +10909,8 @@ where
 		let mut close_background_events = Vec::new();
 		let mut funding_txo_to_channel_id = hash_map_with_capacity(channel_count as usize);
 		let mut peer_storage_dir: HashMap<PublicKey, Vec<u8>> = HashMap::new();
+		let mut our_peer_storage: OurPeerStorage = OurPeerStorage::new();
+
 		for _ in 0..channel_count {
 			let mut channel: Channel<SP> = Channel::read(reader, (
 				&args.entropy_source, &args.signer_provider, best_block_height, &provided_channel_type_features(&args.default_config)
@@ -10852,6 +10919,15 @@ where
 			let funding_txo = channel.context.get_funding_txo().ok_or(DecodeError::InvalidValue)?;
 			funding_txo_to_channel_id.insert(funding_txo, channel.context.channel_id());
 			funding_txo_set.insert(funding_txo.clone());
+			let stub_chan = StubChannel::new(
+				channel.context.channel_id(),
+				funding_txo,
+				channel.context.get_value_satoshis(),
+				channel.context.get_channel_keys_id(),
+				channel.context.get_commitment_secret(),
+				channel.context.get_counterparty_node_id(),
+			);
+			our_peer_storage.stub_channel(stub_chan);
 			if let Some(ref mut monitor) = args.channel_monitors.get_mut(&funding_txo) {
 				// Load Peer_storage from ChannelMonitor to memory.
 				peer_storage_dir.insert(channel.context.get_counterparty_node_id(), monitor.get_peer_storage());
@@ -11682,6 +11758,7 @@ where
 			entropy_source: args.entropy_source,
 			node_signer: args.node_signer,
 			signer_provider: args.signer_provider,
+			our_peer_storage: FairRwLock::new(our_peer_storage),
 			logger: args.logger,
 			default_configuration: args.default_config,
 		};