Getting notified when the sync finishes

[Dinonard]

Hello!

I was wondering if there's a way to be notified when the node ends the sync process?

The NetworkInfo trait provides convenient way to access the current sync state, but not to be notified about the finished sync in an async manner.
https://reth.rs/docs/reth/network/trait.NetworkInfo.html

---

I managed to do it myself by modifying the node launcher to work something like this:

    event = engine_service.next() => {
        let Some(event) = event else { break };
        debug!("Event: {event}");
        match event {
            ChainEvent::BackfillSyncFinished => {
                if terminate_after_backfill {
                    debug!("Terminating after initial backfill");
                    break
                }

                network_handle.update_sync_state(SyncState::Idle);
                // This is what I've added
                sync_state_tx.send(SyncState::Idle).expect("Channel must be open");
            }
            ChainEvent::BackfillSyncStarted => {
                network_handle.update_sync_state(SyncState::Syncing);
                // And this
                sync_state_tx.send(SyncState::Syncing).expect("Channel must be open");
            }

There's a dedicated type that receives this events and provides subscription service to be notified when sync is finished.
It works, but it's a bit hacky, and was wondering if there's a cleaner way.

[mattsse]

we could add a helper future type for this that basically behaves like eth_syncing?

like this:

reth/crates/rpc/rpc/src/eth/pubsub.rs

Lines 178 to 198 in 8758d82

	while canon_state.next().await.is_some() {
	let current_syncing = self.inner.eth_api.network().is_syncing();
	// Only send a new response if the sync status has changed
	if current_syncing != initial_sync_status {
	// Update the sync status on each new block
	initial_sync_status = current_syncing;
	// send a new message now that the status changed
	let sync_status = self.sync_status(current_syncing);
	let msg = SubscriptionMessage::new(
	accepted_sink.method_name(),
	accepted_sink.subscription_id(),
	&sync_status,
	)
	.map_err(SubscriptionSerializeError::new)?;
	if accepted_sink.send(msg).await.is_err() {
	break
	}
	}
	}

[Dinonard]

Yeah, sounds good! Thank you for the issue!

[mattsse]

opened #16911