Stable futures (#879)

* Port eth1 lib to use stable futures * Port eth1_test_rig to stable futures * Port eth1 tests to stable futures * Port genesis service to stable futures * Port genesis tests to stable futures * Port beacon_chain to stable futures * Port lcli to stable futures * Fix eth1_test_rig (#1014) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Update hashmap hashset to stable futures * Adds panic test to hashset delay * Port remote_beacon_node to stable futures * Fix lcli merge conflicts * Non rpc stuff compiles * protocol.rs compiles * Port websockets, timer and notifier to stable futures (#1035) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Port remote_beacon_node to stable futures * Partial eth2-libp2p stable future upgrade * Finished first round of fighting RPC types * Further progress towards porting eth2-libp2p adds caching to discovery * Update behaviour * RPC handler to stable futures * Update RPC to master libp2p * Network service additions * Fix the fallback transport construction (#1102) * Correct warning * Remove hashmap delay * Compiling version of eth2-libp2p * Update all crates versions * Fix conversion function and add tests (#1113) * Port validator_client to stable futures (#1114) * Add PH & MS slot clock changes * Account for genesis time * Add progress on duties refactor * Add simple is_aggregator bool to val subscription * Start work on attestation_verification.rs * Add progress on ObservedAttestations * Progress with ObservedAttestations * Fix tests * Add observed attestations to the beacon chain * Add attestation observation to processing code * Add progress on attestation verification * Add first draft of ObservedAttesters * Add more tests * Add observed attesters to beacon chain * Add observers to attestation processing * Add more attestation verification * Create ObservedAggregators map * Remove commented-out code * Add observed aggregators into chain * Add progress * Finish adding features to attestation verification * Ensure beacon chain compiles * Link attn verification into chain * Integrate new attn verification in chain * Remove old attestation processing code * Start trying to fix beacon_chain tests * Split adding into pools into two functions * Add aggregation to harness * Get test harness working again * Adjust the number of aggregators for test harness * Fix edge-case in harness * Integrate new attn processing in network * Fix compile bug in validator_client * Update validator API endpoints * Fix aggreagation in test harness * Fix enum thing * Fix attestation observation bug: * Patch failing API tests * Start adding comments to attestation verification * Remove unused attestation field * Unify "is block known" logic * Update comments * Supress fork choice errors for network processing * Add todos * Tidy * Add gossip attn tests * Disallow test harness to produce old attns * Comment out in-progress tests * Partially address pruning tests * Fix failing store test * Add aggregate tests * Add comments about which spec conditions we check * Dont re-aggregate * Split apart test harness attn production * Fix compile error in network * Make progress on commented-out test * Fix skipping attestation test * Add fork choice verification tests * Tidy attn tests, remove dead code * Remove some accidentally added code * Fix clippy lint * Rename test file * Add block tests, add cheap block proposer check * Rename block testing file * Add observed_block_producers * Tidy * Switch around block signature verification * Finish block testing * Remove gossip from signature tests * First pass of self review * Fix deviation in spec * Update test spec tags * Start moving over to hashset * Finish moving observed attesters to hashmap * Move aggregation pool over to hashmap * Make fc attn borrow again * Fix rest_api compile error * Fix missing comments * Fix monster test * Uncomment increasing slots test * Address remaining comments * Remove unsafe, use cfg test * Remove cfg test flag * Fix dodgy comment * Revert "Update hashmap hashset to stable futures" This reverts commit d432378a3c. * Revert "Adds panic test to hashset delay" This reverts commit 281502396f. * Ported attestation_service * Ported duties_service * Ported fork_service * More ports * Port block_service * Minor fixes * VC compiles * Update TODOS * Borrow self where possible * Ignore aggregates that are already known. * Unify aggregator modulo logic * Fix typo in logs * Refactor validator subscription logic * Avoid reproducing selection proof * Skip HTTP call if no subscriptions * Rename DutyAndState -> DutyAndProof * Tidy logs * Print root as dbg * Fix compile errors in tests * Fix compile error in test * Re-Fix attestation and duties service * Minor fixes Co-authored-by: Paul Hauner <paul@paulhauner.com> * Network crate update to stable futures * Port account_manager to stable futures (#1121) * Port account_manager to stable futures * Run async fns in tokio environment * Port rest_api crate to stable futures (#1118) * Port rest_api lib to stable futures * Reduce tokio features * Update notifier to stable futures * Builder update * Further updates * Convert self referential async functions * stable futures fixes (#1124) * Fix eth1 update functions * Fix genesis and client * Fix beacon node lib * Return appropriate runtimes from environment * Fix test rig * Refactor eth1 service update * Upgrade simulator to stable futures * Lighthouse compiles on stable futures * Remove println debugging statement * Update libp2p service, start rpc test upgrade * Update network crate for new libp2p * Update tokio::codec to futures_codec (#1128) * Further work towards RPC corrections * Correct http timeout and network service select * Use tokio runtime for libp2p * Revert "Update tokio::codec to futures_codec (#1128)" This reverts commit e57aea924a. * Upgrade RPC libp2p tests * Upgrade secio fallback test * Upgrade gossipsub examples * Clean up RPC protocol * Test fixes (#1133) * Correct websocket timeout and run on os thread * Fix network test * Clean up PR * Correct tokio tcp move attestation service tests * Upgrade attestation service tests * Correct network test * Correct genesis test * Test corrections * Log info when block is received * Modify logs and update attester service events * Stable futures: fixes to vc, eth1 and account manager (#1142) * Add local testnet scripts * Remove whiteblock script * Rename local testnet script * Move spawns onto handle * Fix VC panic * Initial fix to block production issue * Tidy block producer fix * Tidy further * Add local testnet clean script * Run cargo fmt * Tidy duties service * Tidy fork service * Tidy ForkService * Tidy AttestationService * Tidy notifier * Ensure await is not suppressed in eth1 * Ensure await is not suppressed in account_manager * Use .ok() instead of .unwrap_or(()) * RPC decoding test for proto * Update discv5 and eth2-libp2p deps * Fix lcli double runtime issue (#1144) * Handle stream termination and dialing peer errors * Correct peer_info variant types * Remove unnecessary warnings * Handle subnet unsubscription removal and improve logigng * Add logs around ping * Upgrade discv5 and improve logging * Handle peer connection status for multiple connections * Improve network service logging * Improve logging around peer manager * Upgrade swarm poll centralise peer management * Identify clients on error * Fix `remove_peer` in sync (#1150) * remove_peer removes from all chains * Remove logs * Fix early return from loop * Improved logging, fix panic * Partially correct tests * Stable futures: Vc sync (#1149) * Improve syncing heuristic * Add comments * Use safer method for tolerance * Fix tests * Stable futures: Fix VC bug, update agg pool, add more metrics (#1151) * Expose epoch processing summary * Expose participation metrics to prometheus * Switch to f64 * Reduce precision * Change precision * Expose observed attesters metrics * Add metrics for agg/unagg attn counts * Add metrics for gossip rx * Add metrics for gossip tx * Adds ignored attns to prom * Add attestation timing * Add timer for aggregation pool sig agg * Add write lock timer for agg pool * Add more metrics to agg pool * Change map lock code * Add extra metric to agg pool * Change lock handling in agg pool * Change .write() to .read() * Add another agg pool timer * Fix for is_aggregator * Fix pruning bug Co-authored-by: pawan <pawandhananjay@gmail.com> Co-authored-by: Paul Hauner <paul@paulhauner.com>
2026-03-03 00:31:50 +00:00 · 2020-05-17 21:16:48 +10:00
parent 21901b1615
commit b6408805a2
165 changed files with 7924 additions and 7733 deletions
--- a/account_manager/Cargo.toml
+++ b/account_manager/Cargo.toml
@@ -5,26 +5,27 @@ authors = ["Paul Hauner <paul@paulhauner.com>", "Luke Anderson <luke@sigmaprime.
 edition = "2018"

 [dev-dependencies]
-tempdir = "0.3"
+tempdir = "0.3.7"

 [dependencies]
 bls = { path = "../eth2/utils/bls" }
 clap = "2.33.0"
 slog = "2.5.2"
-slog-term = "2.4.2"
-slog-async = "2.3.0"
+slog-term = "2.5.0"
+slog-async = "2.5.0"
 types = { path = "../eth2/types" }
 dirs = "2.0.2"
 environment = { path = "../lighthouse/environment" }
 deposit_contract = { path = "../eth2/utils/deposit_contract" }
 libc = "0.2.65"
-eth2_ssz = { path = "../eth2/utils/ssz" }
-eth2_ssz_derive = { path = "../eth2/utils/ssz_derive" }
-hex = "0.3"
+eth2_ssz = "0.1.2"
+eth2_ssz_derive = "0.1.0"
+hex = "0.4.2"
 validator_client = { path = "../validator_client" }
-rayon = "1.2.0"
+rayon = "1.3.0"
 eth2_testnet_config = { path = "../eth2/utils/eth2_testnet_config" }
 web3 = "0.10.0"
-futures = "0.1.25"
+futures = { version = "0.3.5", features = ["compat"] }
 clap_utils = { path = "../eth2/utils/clap_utils" }
-tokio = "0.1.22"
+# reduce feature set
+tokio = {version = "0.2.20", features = ["full"]}
--- a/account_manager/src/deposits.rs
+++ b/account_manager/src/deposits.rs
@@ -1,15 +1,11 @@
 use clap::{App, Arg, ArgMatches};
 use clap_utils;
 use environment::Environment;
-use futures::{
-    future::{self, loop_fn, Loop},
-    Future,
-};
+use futures::compat::Future01CompatExt;
 use slog::{info, Logger};
 use std::fs;
 use std::path::PathBuf;
-use std::time::{Duration, Instant};
-use tokio::timer::Delay;
+use tokio::time::{delay_until, Duration, Instant};
 use types::EthSpec;
 use validator_client::validator_directory::ValidatorDirectoryBuilder;
 use web3::{
@@ -80,7 +76,10 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
        )
 }

-pub fn cli_run<T: EthSpec>(matches: &ArgMatches, mut env: Environment<T>) -> Result<(), String> {
+pub fn cli_run<T: EthSpec>(
+    matches: &ArgMatches<'_>,
+    mut env: Environment<T>,
+) -> Result<(), String> {
    let spec = env.core_context().eth2_config.spec;
    let log = env.core_context().log;

@@ -138,12 +137,13 @@ pub fn cli_run<T: EthSpec>(matches: &ArgMatches, mut env: Environment<T>) -> Res
        let tx_hash_log = log.clone();

        env.runtime()
-            .block_on(
+            .block_on(async {
                ValidatorDirectoryBuilder::default()
                    .spec(spec.clone())
                    .custom_deposit_amount(deposit_gwei)
                    .thread_random_keypairs()
                    .submit_eth1_deposit(web3.clone(), from_address, deposit_contract)
+                    .await
                    .map(move |(builder, tx_hash)| {
                        info!(
                            tx_hash_log,
@@ -152,8 +152,8 @@ pub fn cli_run<T: EthSpec>(matches: &ArgMatches, mut env: Environment<T>) -> Res
                            "index" => format!("{}/{}", i + 1, n),
                        );
                        builder
-                    }),
-            )?
+                    })
+            })?
            .create_directory(validator_dir.clone())?
            .write_keypair_files()?
            .write_eth1_data_file()?
@@ -183,73 +183,59 @@ fn existing_validator_count(validator_dir: &PathBuf) -> Result<usize, String> {
 }

 /// Run a poll on the `eth_syncing` endpoint, blocking until the node is synced.
-fn poll_until_synced<T>(web3: Web3<T>, log: Logger) -> impl Future<Item = (), Error = String> + Send
+async fn poll_until_synced<T>(web3: Web3<T>, log: Logger) -> Result<(), String>
 where
    T: Transport + Send + 'static,
    <T as Transport>::Out: Send,
 {
-    loop_fn((web3.clone(), log.clone()), move |(web3, log)| {
-        web3.clone()
+    loop {
+        let sync_state = web3
+            .clone()
            .eth()
            .syncing()
-            .map_err(|e| format!("Unable to read syncing state from eth1 node: {:?}", e))
-            .and_then::<_, Box<dyn Future<Item = _, Error = _> + Send>>(move |sync_state| {
-                match sync_state {
-                    SyncState::Syncing(SyncInfo {
-                        current_block,
-                        highest_block,
-                        ..
-                    }) => {
-                        info!(
-                            log,
-                            "Waiting for eth1 node to sync";
-                            "est_highest_block" => format!("{}", highest_block),
-                            "current_block" => format!("{}", current_block),
-                        );
+            .compat()
+            .await
+            .map_err(|e| format!("Unable to read syncing state from eth1 node: {:?}", e))?;
+        match sync_state {
+            SyncState::Syncing(SyncInfo {
+                current_block,
+                highest_block,
+                ..
+            }) => {
+                info!(
+                    log,
+                    "Waiting for eth1 node to sync";
+                    "est_highest_block" => format!("{}", highest_block),
+                    "current_block" => format!("{}", current_block),
+                );

-                        Box::new(
-                            Delay::new(Instant::now() + SYNCING_STATE_RETRY_DELAY)
-                                .map_err(|e| format!("Failed to trigger delay: {:?}", e))
-                                .and_then(|_| future::ok(Loop::Continue((web3, log)))),
-                        )
-                    }
-                    SyncState::NotSyncing => Box::new(
-                        web3.clone()
-                            .eth()
-                            .block_number()
-                            .map_err(|e| {
-                                format!("Unable to read block number from eth1 node: {:?}", e)
-                            })
-                            .and_then::<_, Box<dyn Future<Item = _, Error = _> + Send>>(
-                                |block_number| {
-                                    if block_number > 0.into() {
-                                        info!(
-                                            log,
-                                            "Eth1 node is synced";
-                                            "head_block" => format!("{}", block_number),
-                                        );
-                                        Box::new(future::ok(Loop::Break((web3, log))))
-                                    } else {
-                                        Box::new(
-                                            Delay::new(Instant::now() + SYNCING_STATE_RETRY_DELAY)
-                                                .map_err(|e| {
-                                                    format!("Failed to trigger delay: {:?}", e)
-                                                })
-                                                .and_then(|_| {
-                                                    info!(
-                                                        log,
-                                                        "Waiting for eth1 node to sync";
-                                                        "current_block" => 0,
-                                                    );
-                                                    future::ok(Loop::Continue((web3, log)))
-                                                }),
-                                        )
-                                    }
-                                },
-                            ),
-                    ),
+                delay_until(Instant::now() + SYNCING_STATE_RETRY_DELAY).await;
+            }
+            SyncState::NotSyncing => {
+                let block_number = web3
+                    .clone()
+                    .eth()
+                    .block_number()
+                    .compat()
+                    .await
+                    .map_err(|e| format!("Unable to read block number from eth1 node: {:?}", e))?;
+                if block_number > 0.into() {
+                    info!(
+                        log,
+                        "Eth1 node is synced";
+                        "head_block" => format!("{}", block_number),
+                    );
+                    break;
+                } else {
+                    delay_until(Instant::now() + SYNCING_STATE_RETRY_DELAY).await;
+                    info!(
+                        log,
+                        "Waiting for eth1 node to sync";
+                        "current_block" => 0,
+                    );
                }
-            })
-    })
-    .map(|_| ())
+            }
+        }
+    }
+    Ok(())
 }
--- a/account_manager/src/lib.rs
+++ b/account_manager/src/lib.rs
@@ -5,7 +5,8 @@ use clap::ArgMatches;
 use deposit_contract::DEPOSIT_GAS;
 use environment::{Environment, RuntimeContext};
 use eth2_testnet_config::Eth2TestnetConfig;
-use futures::{future, Future, IntoFuture, Stream};
+use futures::compat::Future01CompatExt;
+use futures::{FutureExt, StreamExt};
 use rayon::prelude::*;
 use slog::{error, info, Logger};
 use std::fs;
@@ -23,7 +24,7 @@ use web3::{
 pub use cli::cli_app;

 /// Run the account manager, returning an error if the operation did not succeed.
-pub fn run<T: EthSpec>(matches: &ArgMatches, mut env: Environment<T>) -> Result<(), String> {
+pub fn run<T: EthSpec>(matches: &ArgMatches<'_>, mut env: Environment<T>) -> Result<(), String> {
    let context = env.core_context();
    let log = context.log.clone();

@@ -292,7 +293,7 @@ fn make_validators(
 ///
 /// Returns success as soon as the eth1 endpoint accepts the transaction (i.e., does not wait for
 /// transaction success/revert).
-fn deposit_validators<E: EthSpec>(
+async fn deposit_validators<E: EthSpec>(
    context: RuntimeContext<E>,
    eth1_endpoint: String,
    deposit_contract: Address,
@@ -300,156 +301,154 @@ fn deposit_validators<E: EthSpec>(
    account_index: usize,
    deposit_value: u64,
    password: Option<String>,
-) -> impl Future<Item = (), Error = ()> {
+) -> Result<(), ()> {
    let log_1 = context.log.clone();
    let log_2 = context.log.clone();

-    Http::new(&eth1_endpoint)
-        .map_err(move |e| {
-            error!(
-                log_1,
-                "Failed to start web3 HTTP transport";
-                "error" => format!("{:?}", e)
+    let (event_loop, transport) = Http::new(&eth1_endpoint).map_err(move |e| {
+        error!(
+            log_1,
+            "Failed to start web3 HTTP transport";
+            "error" => format!("{:?}", e)
+        )
+    })?;
+    /*
+     * Loop through the validator directories and submit the deposits.
+     */
+    let web3 = Web3::new(transport);
+
+    futures::stream::iter(validators)
+        .for_each(|validator| async {
+            let web3 = web3.clone();
+            let log = log_2.clone();
+            let password = password.clone();
+
+            let _ = deposit_validator(
+                web3,
+                deposit_contract,
+                validator,
+                deposit_value,
+                account_index,
+                password,
+                log,
            )
+            .await;
        })
-        .into_future()
-        /*
-         * Loop through the validator directories and submit the deposits.
-         */
-        .and_then(move |(event_loop, transport)| {
-            let web3 = Web3::new(transport);
-
-            futures::stream::iter_ok(validators)
-                .for_each(move |validator| {
-                    let web3 = web3.clone();
-                    let log = log_2.clone();
-                    let password = password.clone();
-
-                    deposit_validator(
-                        web3,
-                        deposit_contract,
-                        &validator,
-                        deposit_value,
-                        account_index,
-                        password,
-                        log,
-                    )
-                })
-                .map(|_| event_loop)
-        })
-        // Web3 gives errors if the event loop is dropped whilst performing requests.
+        .map(|_| event_loop)
+        // // Web3 gives errors if the event loop is dropped whilst performing requests.
        .map(drop)
+        .await;
+
+    Ok(())
 }

 /// For the given `ValidatorDirectory`, submit a deposit transaction to the `web3` node.
 ///
 /// Returns success as soon as the eth1 endpoint accepts the transaction (i.e., does not wait for
 /// transaction success/revert).
-fn deposit_validator(
+async fn deposit_validator(
    web3: Web3<Http>,
    deposit_contract: Address,
-    validator: &ValidatorDirectory,
+    validator: ValidatorDirectory,
    deposit_amount: u64,
    account_index: usize,
    password_opt: Option<String>,
    log: Logger,
-) -> impl Future<Item = (), Error = ()> {
-    validator
+) -> Result<(), ()> {
+    let voting_keypair = validator
        .voting_keypair
        .clone()
-        .ok_or_else(|| error!(log, "Validator does not have voting keypair"))
-        .and_then(|voting_keypair| {
-            validator
-                .deposit_data
-                .clone()
-                .ok_or_else(|| error!(log, "Validator does not have deposit data"))
-                .map(|deposit_data| (voting_keypair, deposit_data))
-        })
-        .into_future()
-        .and_then(move |(voting_keypair, deposit_data)| {
-            let pubkey_1 = voting_keypair.pk.clone();
-            let pubkey_2 = voting_keypair.pk;
+        .ok_or_else(|| error!(log, "Validator does not have voting keypair"))?;

-            let web3_1 = web3.clone();
-            let web3_2 = web3.clone();
+    let deposit_data = validator
+        .deposit_data
+        .clone()
+        .ok_or_else(|| error!(log, "Validator does not have deposit data"))?;

-            let log_1 = log.clone();
-            let log_2 = log.clone();
+    let pubkey_1 = voting_keypair.pk.clone();
+    let pubkey_2 = voting_keypair.pk;

-            web3.eth()
-                .accounts()
-                .map_err(|e| format!("Failed to get accounts: {:?}", e))
-                .and_then(move |accounts| {
-                    accounts
-                        .get(account_index)
-                        .cloned()
-                        .ok_or_else(|| "Insufficient accounts for deposit".to_string())
-                })
-                /*
-                 * If a password was supplied, unlock the account.
-                 */
-                .and_then(move |from_address| {
-                    let future: Box<dyn Future<Item = Address, Error = String> + Send> =
-                        if let Some(password) = password_opt {
-                            // Unlock for only a single transaction.
-                            let duration = None;
+    let log_1 = log.clone();
+    let log_2 = log.clone();

-                            let future = web3_1
-                                .personal()
-                                .unlock_account(from_address, &password, duration)
-                                .then(move |result| match result {
-                                    Ok(true) => Ok(from_address),
-                                    Ok(false) => {
-                                        Err("Eth1 node refused to unlock account. Check password."
-                                            .to_string())
-                                    }
-                                    Err(e) => Err(format!("Eth1 unlock request failed: {:?}", e)),
-                                });
+    // TODO: creating a future to extract the Error type
+    // check if there's a better way
+    let future = async move {
+        let accounts = web3
+            .eth()
+            .accounts()
+            .compat()
+            .await
+            .map_err(|e| format!("Failed to get accounts: {:?}", e))?;

-                            Box::new(future)
-                        } else {
-                            Box::new(future::ok(from_address))
-                        };
+        let from_address = accounts
+            .get(account_index)
+            .cloned()
+            .ok_or_else(|| "Insufficient accounts for deposit".to_string())?;

-                    future
-                })
-                /*
-                 * Submit the deposit transaction.
-                 */
-                .and_then(move |from| {
-                    let tx_request = TransactionRequest {
-                        from,
-                        to: Some(deposit_contract),
-                        gas: Some(U256::from(DEPOSIT_GAS)),
-                        gas_price: None,
-                        value: Some(from_gwei(deposit_amount)),
-                        data: Some(deposit_data.into()),
-                        nonce: None,
-                        condition: None,
-                    };
+        /*
+         * If a password was supplied, unlock the account.
+         */
+        let from = if let Some(password) = password_opt {
+            // Unlock for only a single transaction.
+            let duration = None;

-                    web3_2
-                        .eth()
-                        .send_transaction(tx_request)
-                        .map_err(|e| format!("Failed to call deposit fn: {:?}", e))
-                })
-                .map(move |tx| {
-                    info!(
-                        log_1,
-                        "Validator deposit successful";
-                        "eth1_tx_hash" => format!("{:?}", tx),
-                        "validator_voting_pubkey" => format!("{:?}", pubkey_1)
+            let result = web3
+                .personal()
+                .unlock_account(from_address, &password, duration)
+                .compat()
+                .await;
+            match result {
+                Ok(true) => from_address,
+                Ok(false) => {
+                    return Err::<(), String>(
+                        "Eth1 node refused to unlock account. Check password.".to_string(),
                    )
-                })
-                .map_err(move |e| {
-                    error!(
-                        log_2,
-                        "Validator deposit_failed";
-                        "error" => e,
-                        "validator_voting_pubkey" => format!("{:?}", pubkey_2)
-                    )
-                })
-        })
+                }
+                Err(e) => return Err::<(), String>(format!("Eth1 unlock request failed: {:?}", e)),
+            }
+        } else {
+            from_address
+        };
+
+        /*
+         * Submit the deposit transaction.
+         */
+        let tx_request = TransactionRequest {
+            from,
+            to: Some(deposit_contract),
+            gas: Some(U256::from(DEPOSIT_GAS)),
+            gas_price: None,
+            value: Some(from_gwei(deposit_amount)),
+            data: Some(deposit_data.into()),
+            nonce: None,
+            condition: None,
+        };
+
+        let tx = web3
+            .eth()
+            .send_transaction(tx_request)
+            .compat()
+            .await
+            .map_err(|e| format!("Failed to call deposit fn: {:?}", e))?;
+        info!(
+            log_1,
+            "Validator deposit successful";
+            "eth1_tx_hash" => format!("{:?}", tx),
+            "validator_voting_pubkey" => format!("{:?}", pubkey_1)
+        );
+        Ok(())
+    };
+
+    future.await.map_err(move |e| {
+        error!(
+            log_2,
+            "Validator deposit_failed";
+            "error" => e,
+            "validator_voting_pubkey" => format!("{:?}", pubkey_2)
+        );
+    })?;
+    Ok(())
 }

 /// Converts gwei to wei.