Skip to content

Peer Storage (Part 3): Identifying Lost Channel States #3897

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 7 commits into
base: main
Choose a base branch
from
Open

Peer Storage (Part 3): Identifying Lost Channel States #3897

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
a6f1785
Write structs to serialise-deserialise Channels inside Peer-storage
adi2011 Jun 28, 2025
9a0ef54
Serialise ChannelMonitors and send them over inside Peer Storage
adi2011 Jun 28, 2025
8d82fd3
Determine if we have lost data
adi2011 Jun 28, 2025
4c9f3c3
test: Modify test_peer_storage to check latest changes
adi2011 Jun 28, 2025
006a5d0
fixup: Serialise ChannelMonitors and send them over inside Peer Storage
adi2011 Jul 11, 2025
27303ec
fixup: Write structs to serialise-deserialise Channels inside Peer-st…
adi2011 Jul 11, 2025
676afbc
fixup: Determine if we have lost data
adi2011 Jul 11, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 51 additions & 5 deletions lightning/src/chain/chainmonitor.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,15 +29,17 @@ use bitcoin::hash_types::{BlockHash, Txid};
use crate::chain;
use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
use crate::chain::channelmonitor::{
Balance, ChannelMonitor, ChannelMonitorUpdate, MonitorEvent, TransactionOutputs,
write_util, Balance, ChannelMonitor, ChannelMonitorUpdate, MonitorEvent, TransactionOutputs,
WithChannelMonitor,
};
use crate::chain::transaction::{OutPoint, TransactionData};
use crate::chain::{ChannelMonitorUpdateStatus, Filter, WatchedOutput};
use crate::events::{self, Event, EventHandler, ReplayEvent};
use crate::ln::channel_state::ChannelDetails;
use crate::ln::msgs::{self, BaseMessageHandler, Init, MessageSendEvent};
use crate::ln::our_peer_storage::DecryptedOurPeerStorage;
use crate::ln::our_peer_storage::{
DecryptedOurPeerStorage, PeerStorageMonitorHolder, PeerStorageMonitorHolderList,
};
use crate::ln::types::ChannelId;
use crate::prelude::*;
use crate::sign::ecdsa::EcdsaChannelSigner;
Expand All @@ -47,6 +49,7 @@ use crate::types::features::{InitFeatures, NodeFeatures};
use crate::util::errors::APIError;
use crate::util::logger::{Logger, WithContext};
use crate::util::persist::MonitorName;
use crate::util::ser::{VecWriter, Writeable};
use crate::util::wakers::{Future, Notifier};
use bitcoin::secp256k1::PublicKey;
use core::ops::Deref;
Expand Down Expand Up @@ -810,10 +813,53 @@ where
}

fn send_peer_storage(&self, their_node_id: PublicKey) {
// TODO: Serialize `ChannelMonitor`s inside `our_peer_storage`.

static MAX_PEER_STORAGE_SIZE: usize = 65000;
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This should be a const rather than static, I think? Also, would probably make sense to add this add the module level, with some docs.

Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Also isn't the max size 64 KiB, not 65K?

let random_bytes = self.entropy_source.get_secure_random_bytes();
let serialised_channels = Vec::new();
let random_usize = usize::from_le_bytes(random_bytes[0..8].try_into().unwrap());
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Depending on the platform, a usize might not always be 8 bytes. You'll probably need to do

const USIZE_LEN: usize = core::mem::size_of::<usize>();

and use that instead of 8.


let monitors = self.monitors.read().unwrap();
let mut monitors_list = PeerStorageMonitorHolderList { monitors: Vec::new() };
let mut curr_size = 0;

// Randomising Keys in the HashMap to fetch monitors without repetition.
let mut keys: Vec<&ChannelId> = monitors.keys().collect();
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Can we make this a bit cleaner by using the proposed iterator skiping approach in the loop below, maybe while simply keeping track of which monitors we already wrote?

for i in (1..keys.len()).rev() {
let j = random_usize % (i + 1);
keys.swap(i, j);
}

for chan_id in keys {
let mon = &monitors[chan_id];
let mut ser_chan = VecWriter(Vec::new());
let min_seen_secret = mon.monitor.get_min_seen_secret();
let counterparty_node_id = mon.monitor.get_counterparty_node_id();

match write_util(&mon.monitor.inner.lock().unwrap(), true, &mut ser_chan) {
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nit: Please move taking the lock out into a dedicated variable. This would also make it easier to spot the scoping of the lock, IMO.

Ok(_) => {
let mut ser_channel = Vec::new();
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think instead of creating a new Vec and then writing to it, you should be able to just call encode on the PeerStorageMonitorHolder.

But I'm currently confused what we use ser_channel to begin with is it just to calculate the length below? That seems like a big unnecessary allocation? You could use serialized_length for example and keep track of the written bytes and compare them to MAX_PEER_STORAGE_SIZE.

let peer_storage_monitor = PeerStorageMonitorHolder {
channel_id: *chan_id,
min_seen_secret,
counterparty_node_id,
monitor_bytes: ser_chan.0,
};
peer_storage_monitor.write(&mut ser_channel).unwrap();

curr_size += ser_channel.len();
if curr_size > MAX_PEER_STORAGE_SIZE {
break;
}

monitors_list.monitors.push(peer_storage_monitor);
},
Err(_) => {
panic!("Can not write monitor for {}", mon.monitor.channel_id())
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Really, please avoid these explicit panics in any of this code.

},
}
}

let mut serialised_channels = Vec::new();
monitors_list.write(&mut serialised_channels).unwrap();
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Same here, just use encode.

let our_peer_storage = DecryptedOurPeerStorage::new(serialised_channels);
let cipher = our_peer_storage.encrypt(&self.our_peerstorage_encryption_key, &random_bytes);

Expand Down
Loading