Merge branch 'deposit-flow' into kill-grpc

eth2/utils/deposit_contract/.gitignore

@@ -0,0 +1 @@
+contract/

eth2/utils/deposit_contract/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "deposit_contract"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+build = "build.rs"
+
+[build-dependencies]
+reqwest = "0.9.20"
+serde_json = "1.0"
+
+[dependencies]
+types = { path = "../../types"}
+eth2_ssz = { path = "../ssz"}
+tree_hash = { path = "../tree_hash"}
+ethabi = "9.0"

eth2/utils/deposit_contract/build.rs

@@ -0,0 +1,95 @@
+//! Downloads the ABI and bytecode for the deposit contract from the ethereum spec repository and
+//! stores them in a `contract/` directory in the crate root.
+//!
+//! These files are required for some `include_bytes` calls used in this crate.
+
+use reqwest::Response;
+use serde_json::Value;
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+const GITHUB_RAW: &str = "https://raw.githubusercontent.com";
+const SPEC_REPO: &str = "ethereum/eth2.0-specs";
+const SPEC_TAG: &str = "v0.8.3";
+const ABI_FILE: &str = "validator_registration.json";
+const BYTECODE_FILE: &str = "validator_registration.bytecode";
+
+fn main() {
+    match init_deposit_contract_abi() {
+        Ok(()) => (),
+        Err(e) => panic!(e),
+    }
+}
+
+/// Attempts to download the deposit contract ABI from github if a local copy is not already
+/// present.
+pub fn init_deposit_contract_abi() -> Result<(), String> {
+    let abi_file = abi_dir().join(format!("{}_{}", SPEC_TAG, ABI_FILE));
+    let bytecode_file = abi_dir().join(format!("{}_{}", SPEC_TAG, BYTECODE_FILE));
+
+    if abi_file.exists() {
+        // Nothing to do.
+    } else {
+        match download_abi() {
+            Ok(mut response) => {
+                let mut abi_file = File::create(abi_file)
+                    .map_err(|e| format!("Failed to create local abi file: {:?}", e))?;
+                let mut bytecode_file = File::create(bytecode_file)
+                    .map_err(|e| format!("Failed to create local bytecode file: {:?}", e))?;
+
+                let contract: Value = response
+                    .json()
+                    .map_err(|e| format!("Respsonse is not a valid json {:?}", e))?;
+
+                let abi = contract
+                    .get("abi")
+                    .ok_or(format!("Response does not contain key: abi"))?
+                    .to_string();
+                abi_file
+                    .write(abi.as_bytes())
+                    .map_err(|e| format!("Failed to write http response to abi file: {:?}", e))?;
+
+                let bytecode = contract
+                    .get("bytecode")
+                    .ok_or(format!("Response does not contain key: bytecode"))?
+                    .to_string();
+                bytecode_file.write(bytecode.as_bytes()).map_err(|e| {
+                    format!("Failed to write http response to bytecode file: {:?}", e)
+                })?;
+            }
+            Err(e) => {
+                return Err(format!(
+                    "No abi file found. Failed to download from github: {:?}",
+                    e
+                ))
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Attempts to download the deposit contract file from the Ethereum github.
+fn download_abi() -> Result<Response, String> {
+    reqwest::get(&format!(
+        "{}/{}/{}/deposit_contract/contracts/{}",
+        GITHUB_RAW, SPEC_REPO, SPEC_TAG, ABI_FILE
+    ))
+    .map_err(|e| format!("Failed to download deposit ABI from github: {:?}", e))
+}
+
+/// Returns the directory that will be used to store the deposit contract ABI.
+fn abi_dir() -> PathBuf {
+    let base = env::var("CARGO_MANIFEST_DIR")
+        .expect("should know manifest dir")
+        .parse::<PathBuf>()
+        .expect("should parse manifest dir as path")
+        .join("contract");
+
+    std::fs::create_dir_all(base.clone())
+        .expect("should be able to create abi directory in manifest");
+
+    base
+}

eth2/utils/deposit_contract/src/lib.rs

@@ -0,0 +1,56 @@
+use ethabi::{Contract, Token};
+use ssz::Encode;
+use types::{DepositData, SecretKey};
+
+pub use ethabi::Error;
+
+pub const CONTRACT_DEPLOY_GAS: usize = 4_000_000;
+pub const DEPOSIT_GAS: usize = 4_000_000;
+pub const ABI: &[u8] = include_bytes!("../contract/v0.8.3_validator_registration.json");
+pub const BYTECODE: &[u8] = include_bytes!("../contract/v0.8.3_validator_registration.bytecode");
+
+pub fn eth1_tx_data(deposit_data: &DepositData) -> Result<Vec<u8>, Error> {
+    let params = vec![
+        Token::Bytes(deposit_data.pubkey.as_ssz_bytes()),
+        Token::Bytes(deposit_data.withdrawal_credentials.as_ssz_bytes()),
+        Token::Bytes(deposit_data.signature.as_ssz_bytes()),
+    ];
+
+    let abi = Contract::load(ABI)?;
+    let function = abi.function("deposit")?;
+    function.encode_input(&params)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use types::{
+        test_utils::generate_deterministic_keypair, ChainSpec, EthSpec, Hash256, Keypair,
+        MinimalEthSpec, Signature,
+    };
+
+    type E = MinimalEthSpec;
+
+    fn get_deposit(keypair: Keypair, spec: &ChainSpec) -> DepositData {
+        let mut deposit_data = DepositData {
+            pubkey: keypair.pk.into(),
+            withdrawal_credentials: Hash256::from_slice(&[42; 32]),
+            amount: u64::max_value(),
+            signature: Signature::empty_signature().into(),
+        };
+        deposit_data.signature = deposit_data.create_signature(&keypair.sk, spec);
+        deposit_data
+    }
+
+    #[test]
+    fn basic() {
+        let spec = &E::default_spec();
+
+        let keypair = generate_deterministic_keypair(42);
+        let deposit = get_deposit(keypair.clone(), spec);
+
+        let data = eth1_tx_data(&deposit).expect("should produce tx data");
+
+        assert_eq!(data.len(), 388, "bytes should be correct length");
+    }
+}