refactor: Remove pre-genesis polling

[dknopik]

Proposed Changes

Replace poll_whilst_waiting_for_genesis with a simple sleep to genesis. This function will never be useful in production, as SSV requires an already existing network to bootstrap the SSV contract (and then supply the address of that contract to Anchor). The only reason against removing wait_for_genesis altogether is that someone might pre-deploy the contracts in a local devnet and spin up the node before genesis has occurred. However, this scenario does not require the extensive logging offered by poll_whilst_waiting_for_genesis.

Additional Info

This is useful for updating dependencies in a later step as get_lighthouse_staking was removed upstream. (see #452)

[dknopik]

Meta: I was unsure what conventional commit type to pick for this one. feat feels wrong because we are removing a feature.

[diegomrsantos]

The only reason against removing wait_for_genesis altogether is that someone might pre-deploy the contracts in a local devnet and spin up the node before genesis has occurred

IMO, we should have code only for the current needs. If something is necessary in the future, we add it. Isn't the network already running anyway?

[dknopik]

IMO, we should have code only for the current needs. If something is necessary in the future, we add it. Isn't the network already running anyway?

The approach I described is valid already for construction of devnets - in particular, it can be used for ssv-mini as soon as there is development capacity to implement that approach there. Artificially introducing a blocker for that now seems counter-productive.

Isn't the network already running anyway?

In the scenario I described, genesis might lie in the future.

[diegomrsantos]

how about something like

use chrono::{DateTime, Utc};
use tokio::time::{interval, Duration};
use tracing::{info, debug};

/// Wait until `genesis_at`, emitting a progress line every 30 s.
/// This future is **cancellable** simply by dropping it (handled by TaskExecutor).
pub async fn wait_for_genesis(genesis_at: DateTime<Utc>) {
    // Restarted after genesis?
    if Utc::now() >= genesis_at {
        info!(?genesis_at, "Genesis already passed – skipping wait");
        return;
    }

    let mut ticker = interval(Duration::from_secs(30));

    loop {
        ticker.tick().await;                       // <-- only awaited future
        let now = Utc::now();
        if now >= genesis_at {
            info!(?genesis_at, "Genesis reached – continuing startup");
            break;
        }
        debug!(
            remaining = (genesis_at - now).num_seconds(),
            "Waiting for genesis…"
        );
    }
}

[diegomrsantos]

Utc::now comes from https://docs.rs/chrono/latest/chrono/

[diegomrsantos]

Utc::now isn't necessary, although it could be a better option. But logging from time to time while waiting seems a good idea.

[dknopik]

Pushed a suggestion that avoids chono, wdyt?

[diegomrsantos]

Looks good. I suggested chrono because it seems odd to have to handle an error when getting the current time

[Copilot]

Pull Request Overview

This PR refactors the pre-genesis waiting logic by removing the complex polling mechanism and replacing it with a simple sleep until genesis time. The change removes the poll_whilst_waiting_for_genesis function that was checking beacon node staking status, as this functionality is not needed in production environments where SSV requires an existing network.

• Replaces polling-based wait with a simple sleep-based approach
• Removes the poll_whilst_waiting_for_genesis function and related constants
• Simplifies the wait_for_genesis function to use a sleep with periodic logging

[Copilot]

The variable now is calculated outside the loop at line 752 and never updated. This will cause the logged seconds_to_wait to remain constant and potentially become inaccurate as time passes. You should recalculate now inside the loop or use a different approach to get the current remaining time.

Suggested change

	_ = log_interval.tick() => info!(
	seconds_to_wait = (genesis_time - now).as_secs(),
	"Waiting for genesis",
	),
	_ = log_interval.tick() => {
	let now = SystemTime::now()
	.duration_since(UNIX_EPOCH)
	.expect("Unable to read system time");
	info!(
	seconds_to_wait = (genesis_time - now).as_secs(),
	"Waiting for genesis",
	);
	},

[dknopik]

oh thanks mate

[diegomrsantos]

Do we need to create it, or can we use the fn directly?

[dknopik]

done

[diegomrsantos]

Can we return this result or zero if it's negative? Then we don't need the if/else, and we can have a log "Genesis occurred" inside the loop. Wdyt?

[dknopik]

nice idea. wdyt?

[diegomrsantos]

Sorry for another one, could we use Instant::now() for the initial now too? Also, do you think we need a log for when genesis happens?

[dknopik]

I do not think so, as we need some association to the system time. Instant in opaque, we can't really derive the current time of the system through it. It works further below because we piggyback off the sleep, which has an instant as deadline.

I do not care strongly about the log.

[diegomrsantos]

Thanks a lot!