gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-23 14:54:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make account manager submit deposits

Browse Source
This commit is contained in:
Paul Hauner
2019-11-25 10:51:11 +11:00
parent 4b15d4f433
commit 140a0517a7
7 changed files with 100 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
account_manager/src/lib.rs
View File

@@ -2,11 +2,11 @@ mod cli;
use clap::ArgMatches;
use deposit_contract::DEPOSIT_GAS;
use environment::RuntimeContext;
use environment::{Environment, RuntimeContext};
use eth2_testnet::Eth2TestnetDir;
use futures::{stream::unfold, Future, IntoFuture, Stream};
use rayon::prelude::*;
use slog::{crit, error, info};
use slog::{crit, error, info, Logger};
use std::fs;
use std::path::PathBuf;
use types::{ChainSpec, EthSpec};
@@ -20,9 +20,9 @@ use web3::{
pub use cli::cli_app;
/// Run the account manager, logging an error if the operation did not succeed.
pub fn run<T: EthSpec>(matches: &ArgMatches, context: RuntimeContext<T>) {
let log = context.log.clone();
match run_account_manager(matches, context) {
pub fn run<T: EthSpec>(matches: &ArgMatches, mut env: Environment<T>) {
let log = env.core_context().log.clone();
match run_account_manager(matches, env) {
Ok(()) => (),
Err(e) => crit!(log, "Account manager failed"; "error" => e),
}
@@ -31,8 +31,9 @@ pub fn run<T: EthSpec>(matches: &ArgMatches, context: RuntimeContext<T>) {
/// Run the account manager, returning an error if the operation did not succeed.
fn run_account_manager<T: EthSpec>(
matches: &ArgMatches,
context: RuntimeContext<T>,
mut env: Environment<T>,
) -> Result<(), String> {
let context = env.core_context();
let log = context.log.clone();
let datadir = matches
@@ -60,7 +61,7 @@ fn run_account_manager<T: EthSpec>(
match matches.subcommand() {
("validator", Some(matches)) => match matches.subcommand() {
("new", Some(matches)) => run_new_validator_subcommand(matches, datadir, context)?,
("new", Some(matches)) => run_new_validator_subcommand(matches, datadir, env)?,
_ => {
return Err("Invalid 'validator new' command. See --help.".to_string());
}
@@ -85,8 +86,9 @@ enum KeygenMethod {
fn run_new_validator_subcommand<T: EthSpec>(
matches: &ArgMatches,
datadir: PathBuf,
context: RuntimeContext<T>,
mut env: Environment<T>,
) -> Result<(), String> {
let context = env.core_context();
let log = context.log.clone();
let methods: Vec<KeygenMethod> = match matches.subcommand() {
@@ -130,6 +132,12 @@ fn run_new_validator_subcommand<T: EthSpec>(
.parse::<usize>()
.map_err(|e| format!("Unable to parse account-index: {}", e))?;
info!(
log,
"Submitting validator deposits";
"eth1_node_http_endpoint" => eth1_endpoint
);
let deposit_contract = if let Some(testnet_dir_str) = matches.value_of("testnet-dir") {
let testnet_dir = testnet_dir_str
.parse::<PathBuf>()
@@ -152,13 +160,23 @@ fn run_new_validator_subcommand<T: EthSpec>(
.map_err(|e| format!("Unable to parse deposit-contract: {}", e))?
};
context.executor.spawn(deposit_validators(
if let Err(()) = env.runtime().block_on(deposit_validators(
context.clone(),
eth1_endpoint.to_string(),
deposit_contract,
validators.clone(),
account_index,
));
)) {
error!(
log,
"Failed to deposit validators";
)
} else {
info!(
log,
"Validator deposits complete";
);
}
}
info!(
@@ -179,16 +197,24 @@ fn deposit_validators<E: EthSpec>(
account_index: usize,
) -> impl Future<Item = (), Error = ()> {
let deposit_amount = context.eth2_config.spec.max_effective_balance;
let log = context.log.clone();
let log_1 = context.log.clone();
let log_2 = context.log.clone();
Http::new(&eth1_endpoint)
.map_err(|e| format!("Failed to start web3 HTTP transport: {:?}", e))
.map_err(move |e| {
error!(
log_1,
"Failed to start web3 HTTP transport";
"error" => format!("{:?}", e)
)
})
.into_future()
.and_then(move |(_event_loop, transport)| {
.and_then(move |(event_loop, transport)| {
let web3 = Web3::new(transport);
unfold(validators.into_iter(), move |mut validators| {
let web3 = web3.clone();
let log = log_2.clone();
validators.next().map(move |validator| {
deposit_validator(
@@ -197,14 +223,16 @@ fn deposit_validators<E: EthSpec>(
&validator,
deposit_amount,
account_index,
log,
)
.map(|()| ((), validators))
})
})
.collect()
.map(|_| event_loop)
})
.map_err(move |e| error!(log, "Error whilst depositing validator"; "error" => e))
.map(|_| ())
// Web3 gives errors if the event loop is dropped whilst performing requests.
.map(|event_loop| drop(event_loop))
}
fn deposit_validator(
@@ -213,9 +241,20 @@ fn deposit_validator(
validator: &ValidatorDirectory,
deposit_amount: u64,
account_index: usize,
) -> impl Future<Item = (), Error = String> {
log: Logger,
) -> impl Future<Item = (), Error = ()> {
let web3_1 = web3.clone();
let log_1 = log.clone();
let log_2 = log.clone();
let validator_voting_pubkey_1 = validator
.voting_keypair
.clone()
.expect("Validators must have a voting public key")
.pk;
let validator_voting_pubkey_2 = validator_voting_pubkey_1.clone();
let deposit_data = validator
.deposit_data
.clone()
@@ -236,7 +275,7 @@ fn deposit_validator(
to: Some(deposit_contract),
gas: Some(U256::from(DEPOSIT_GAS)),
gas_price: None,
value: Some(U256::from(deposit_amount)),
value: Some(U256::from(from_gwei(deposit_amount))),
data: Some(deposit_data.into()),
nonce: None,
condition: None,
@@ -247,7 +286,26 @@ fn deposit_validator(
.send_transaction(tx_request)
.map_err(|e| format!("Failed to call deposit fn: {:?}", e))
})
.map(|_| ())
.map(move |tx| {
info!(
log_1,
"Validator deposit successful";
"eth1_tx_hash" => format!("{:?}", tx),
"validator_voting_pubkey" => format!("{:?}", validator_voting_pubkey_1)
)
})
.map_err(move |e| {
error!(
log_2,
"Validator deposit_failed";
"error" => e,
"validator_voting_pubkey" => format!("{:?}", validator_voting_pubkey_2)
)
})
}
fn from_gwei(gwei: u64) -> U256 {
U256::from(gwei) * U256::exp10(9)
}
/// Produces a validator directory for each of the key generation methods provided in `methods`.

8
eth2/utils/bls/src/fake_public_key.rs
View File

@@ -13,7 +13,7 @@ use std::hash::{Hash, Hasher};
///
/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
/// serialization).
#[derive(Debug, Clone, Eq)]
#[derive(Clone, Eq)]
pub struct FakePublicKey {
bytes: Vec<u8>,
/// Never used, only use for compatibility with "real" `PublicKey`.
@@ -93,6 +93,12 @@ impl fmt::Display for FakePublicKey {
}
}
impl fmt::Debug for FakePublicKey {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "0x{}", self.as_hex_string())
}
}
impl default::Default for FakePublicKey {
fn default() -> Self {
let secret_key = SecretKey::random();

2
eth2/utils/bls/src/public_key.rs
View File

@@ -81,7 +81,7 @@ impl fmt::Display for PublicKey {
impl fmt::Debug for PublicKey {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.as_hex_string())
write!(f, "0x{}", self.as_hex_string())
}
}

7
lcli/src/testnet.rs → lcli/src/deploy_deposit_contract.rs
View File

@@ -8,10 +8,7 @@ use web3::{transports::Http, Web3};
pub const DEFAULT_DATA_DIR: &str = ".lighthouse/testnet";
pub fn new_testnet<T: EthSpec>(
mut env: Environment<T>,
matches: &ArgMatches,
) -> Result<(), String> {
pub fn run<T: EthSpec>(mut env: Environment<T>, matches: &ArgMatches) -> Result<(), String> {
let min_genesis_time = matches
.value_of("min_genesis_time")
.ok_or_else(|| "min_genesis_time not specified")?
@@ -65,6 +62,8 @@ pub fn new_testnet<T: EthSpec>(
info!("Present eth1 block number is {}", deploy_block);
info!("Deploying the bytecode at https://github.com/sigp/unsafe-eth2-deposit-contract",);
info!(
"Submitting deployment transaction, waiting for {} confirmations",
confirmations

78
lcli/src/deposit_contract.rs
View File

@@ -1,78 +0,0 @@
use clap::ArgMatches;
use environment::Environment;
use eth1_test_rig::{DelayThenDeposit, DepositContract};
use futures::Future;
use std::time::Duration;
use types::{test_utils::generate_deterministic_keypair, EthSpec, Hash256};
use web3::{transports::Http, Web3};
pub fn run_deposit_contract<T: EthSpec>(
mut env: Environment<T>,
matches: &ArgMatches,
) -> Result<(), String> {
let count = matches
.value_of("count")
.ok_or_else(|| "Deposit count not specified")?
.parse::<usize>()
.map_err(|e| format!("Failed to parse deposit count: {}", e))?;
let delay = matches
.value_of("delay")
.ok_or_else(|| "Deposit count not specified")?
.parse::<u64>()
.map(Duration::from_millis)
.map_err(|e| format!("Failed to parse deposit count: {}", e))?;
let confirmations = matches
.value_of("confirmations")
.ok_or_else(|| "Confirmations not specified")?
.parse::<usize>()
.map_err(|e| format!("Failed to parse confirmations: {}", e))?;
let endpoint = matches
.value_of("endpoint")
.ok_or_else(|| "Endpoint not specified")?;
let (_event_loop, transport) = Http::new(&endpoint).map_err(|e| {
format!(
"Failed to start HTTP transport connected to ganache: {:?}",
e
)
})?;
let web3 = Web3::new(transport);
let deposit_contract = env
.runtime()
.block_on(DepositContract::deploy(web3, confirmations))
.map_err(|e| format!("Failed to deploy contract: {}", e))?;
info!(
"Deposit contract deployed. Address: {}",
deposit_contract.address()
);
env.runtime()
.block_on(do_deposits::<T>(deposit_contract, count, delay))
.map_err(|e| format!("Failed to submit deposits: {}", e))?;
Ok(())
}
fn do_deposits<T: EthSpec>(
deposit_contract: DepositContract,
count: usize,
delay: Duration,
) -> impl Future<Item = (), Error = String> {
let deposits = (0..count)
.map(|i| DelayThenDeposit {
deposit: deposit_contract.deposit_helper::<T>(
generate_deterministic_keypair(i),
Hash256::from_low_u64_le(i as u64),
32_000_000_000,
),
delay,
})
.collect();
deposit_contract.deposit_multiple(deposits)
}

54
lcli/src/main.rs
View File

@@ -1,14 +1,12 @@
#[macro_use]
extern crate log;
mod deposit_contract;
mod deploy_deposit_contract;
mod parse_hex;
mod pycli;
mod testnet;
mod transition_blocks;
use clap::{App, Arg, SubCommand};
use deposit_contract::run_deposit_contract;
use environment::EnvironmentBuilder;
use log::Level;
use parse_hex::run_parse_hex;
@@ -113,46 +111,10 @@ fn main() {
),
)
.subcommand(
SubCommand::with_name("deposit-contract")
SubCommand::with_name("deploy-deposit-contract")
.about(
"Uses an eth1 test rpc (e.g., ganache-cli) to simulate the deposit contract.",
)
.arg(
Arg::with_name("count")
.short("c")
.value_name("INTEGER")
.takes_value(true)
.required(true)
.help("The number of deposits to be submitted."),
)
.arg(
Arg::with_name("delay")
.short("d")
.value_name("MILLIS")
.takes_value(true)
.required(true)
.help("The delay (in milliseconds) between each deposit"),
)
.arg(
Arg::with_name("endpoint")
.short("e")
.value_name("HTTP_SERVER")
.takes_value(true)
.default_value("http://localhost:8545")
.help("The URL to the eth1 JSON-RPC http API."),
)
.arg(
Arg::with_name("confirmations")
.value_name("INTEGER")
.takes_value(true)
.default_value("3")
.help("The number of block confirmations before declaring the contract deployed."),
)
)
.subcommand(
SubCommand::with_name("testnet")
.about(
"Deploy an eth1 deposit contract and create files with testnet details.",
"Deploy an eth1 deposit contract and create a ~/.lighthouse/testnet directory \
(unless another directory is specified).",
)
.arg(
Arg::with_name("output")
@@ -254,10 +216,10 @@ fn main() {
}
("pycli", Some(matches)) => run_pycli::<LocalEthSpec>(matches)
.unwrap_or_else(|e| error!("Failed to run pycli: {}", e)),
("deposit-contract", Some(matches)) => run_deposit_contract::<LocalEthSpec>(env, matches)
.unwrap_or_else(|e| error!("Failed to run deposit contract sim: {}", e)),
("testnet", Some(matches)) => testnet::new_testnet::<LocalEthSpec>(env, matches)
.unwrap_or_else(|e| error!("Failed to run testnet commmand: {}", e)),
("deploy-deposit-contract", Some(matches)) => {
deploy_deposit_contract::run::<LocalEthSpec>(env, matches)
.unwrap_or_else(|e| error!("Failed to run deploy-deposit-contract commmand: {}", e))
}
(other, _) => error!("Unknown subcommand {}. See --help.", other),
}
}

8
lighthouse/src/main.rs
View File

@@ -133,10 +133,12 @@ fn run<E: EthSpec>(
// Creating a command which can run both might be useful future works.
if let Some(sub_matches) = matches.subcommand_matches("account_manager") {
let runtime_context = environment.core_context();
// Pass the entire `environment` to the account manager so it can run blocking operations.
account_manager::run(sub_matches, environment);
account_manager::run(sub_matches, runtime_context);
}
// Exit as soon as account manager returns control.
return Ok(());
};
let beacon_node = if let Some(sub_matches) = matches.subcommand_matches("beacon_node") {
let runtime_context = environment.core_context();