diff --git a/src/genesis.rs b/src/genesis.rs index d4829a70e..5b8bed1f8 100644 --- a/src/genesis.rs +++ b/src/genesis.rs @@ -34,7 +34,7 @@ impl Genesis { pub fn new_frontier() -> Genesis { let root = H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap(); let json = base_to_json(include_bytes!("../res/genesis_frontier")); - let (header, state) = Self::load_genesis_json(&json, &root); + let (header, state) = Self::load_genesis_json(json, root); Self::new_from_header_and_state(header, state) } @@ -53,7 +53,7 @@ impl Genesis { } /// Loads genesis block from json file - fn load_genesis_json(json: &Json, state_root: &H256) -> (Header, HashMap) { + fn load_genesis_json(json: Json, state_root: H256) -> (Header, HashMap) { // once we commit ourselves to some json parsing library (serde?) // move it to proper data structure @@ -62,11 +62,20 @@ impl Genesis { let empty_data = encode(&""); let empty_data_sha3 = empty_data.sha3(); + let mut state = HashMap::new(); + let accounts = json["alloc"].as_object().expect("Missing genesis state"); + for (address, acc) in accounts.iter() { + let addr = Address::from_str(address).unwrap(); + let o = acc.as_object().unwrap(); + let balance = U256::from_dec_str(o["balance"].as_string().unwrap()).unwrap(); + state.insert(addr, Account::new_basic(balance, U256::from(0))); + } + let header = Header { parent_hash: H256::from_str(&json["parentHash"].as_string().unwrap()[2..]).unwrap(), uncles_hash: empty_list_sha3.clone(), author: Address::from_str(&json["coinbase"].as_string().unwrap()[2..]).unwrap(), - state_root: state_root.clone(), + state_root: state_root, transactions_root: empty_data_sha3.clone(), receipts_root: empty_data_sha3.clone(), log_bloom: H2048::new(), @@ -84,15 +93,6 @@ impl Genesis { } }; - let mut state = HashMap::new(); - let accounts = json["alloc"].as_object().expect("Missing genesis state"); - for (address, acc) in accounts.iter() { - let addr = Address::from_str(address).unwrap(); - let o = acc.as_object().unwrap(); - let balance = U256::from_dec_str(o["balance"].as_string().unwrap()).unwrap(); - state.insert(addr, Account::new_basic(balance, U256::from(0))); - } - (header, state) } diff --git a/src/spec.rs b/src/spec.rs index b62da9620..d47a2a3c2 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -1,17 +1,41 @@ -use std::collections::hash_map::*; +use std::io::Read; +use std::collections::HashMap; use std::cell::*; use std::str::FromStr; +use rustc_serialize::base64::FromBase64; +use rustc_serialize::json::Json; +use rustc_serialize::hex::FromHex; +use flate2::read::GzDecoder; use util::uint::*; use util::hash::*; use util::bytes::*; use util::triehash::*; use util::error::*; use util::rlp::*; -use account::Account; +use util::sha3::*; +use account::*; use engine::Engine; use builtin::Builtin; use null_engine::NullEngine; use denominations::*; +use header::*; + +/// Converts file from base64 gzipped bytes to json +pub fn base_to_json(source: &[u8]) -> Json { + // there is probably no need to store genesis in based64 gzip, + // but that's what go does, and it was easy to load it this way + let data = source.from_base64().expect("Genesis block is malformed!"); + let data_ref: &[u8] = &data; + let mut decoder = GzDecoder::new(data_ref).expect("Gzip is invalid"); + let mut s: String = "".to_string(); + decoder.read_to_string(&mut s).expect("Gzip is invalid"); + Json::from_str(&s).expect("Json is invalid") +} + +/// Convert JSON to a string->RLP map. +pub fn json_to_rlp(_json: &Json) -> HashMap { + unimplemented!(); +} /// Parameters for a block chain; includes both those intrinsic to the design of the /// chain and those to be interpreted by the active chain engine. @@ -43,6 +67,9 @@ pub struct Spec { } impl Spec { +// pub fn new(engine_name: String, engine_params: HashMap, builtins: HashMap, genesis: Genesis) { +// } + /// Convert this object into a boxed Engine of the right underlying type. // TODO avoid this hard-coded nastiness - use dynamic-linked plugin framework instead. pub fn to_engine(self) -> Result, EthcoreError> { @@ -62,13 +89,90 @@ impl Spec { /// Compose the genesis block for this chain. pub fn genesis_block(&self) -> Bytes { - // TODO - unimplemented!(); + let empty_list = RlpStream::new_list(0).out(); + let empty_list_sha3 = empty_list.sha3(); + let header = Header { + parent_hash: self.parent_hash.clone(), + timestamp: self.timestamp.clone(), + number: U256::from(0u8), + author: self.author.clone(), + transactions_root: SHA3_EMPTY.clone(), + uncles_hash: empty_list_sha3.clone(), + extra_data: self.extra_data.clone(), + state_root: self.state_root().clone(), + receipts_root: SHA3_EMPTY.clone(), + log_bloom: H2048::new().clone(), + gas_used: self.gas_used.clone(), + gas_limit: self.gas_limit.clone(), + difficulty: self.difficulty.clone(), + seal: { + let seal = { + let mut s = RlpStream::new_list(self.seal_fields); + s.append_raw(&self.seal_rlp, self.seal_fields); + s.out() + }; + let r = Rlp::new(&seal); + (0..self.seal_fields).map(|i| r.at(i).raw().to_vec()).collect() + }, + }; + let mut ret = RlpStream::new_list(3); + ret.append(&header); + ret.append_raw(&empty_list, 1); + ret.append_raw(&empty_list, 1); + ret.out() } } impl Spec { + /// Loads genesis block from json file + pub fn from_json(json: Json) -> Spec { + // once we commit ourselves to some json parsing library (serde?) + // move it to proper data structure + let mut state = HashMap::new(); + let accounts = json["alloc"].as_object().expect("Missing genesis state"); + for (address, acc) in accounts.iter() { + let addr = Address::from_str(address).unwrap(); + let o = acc.as_object().unwrap(); + let balance = U256::from_dec_str(o["balance"].as_string().unwrap()).unwrap(); + state.insert(addr, Account::new_basic(balance, U256::from(0))); + } + + let builtins = { + // TODO: populate from json. + HashMap::new() + }; + + let (seal_fields, seal_rlp) = { + if json.find("mixhash").is_some() && json.find("nonce").is_some() { + let mut s = RlpStream::new(); + s.append(&H256::from_str(&json["mixhash"].as_string().unwrap()[2..]).unwrap()); + s.append(&H64::from_str(&json["nonce"].as_string().unwrap()[2..]).unwrap()); + (2, s.out()) + } else { + // backup algo that will work with sealFields/sealRlp (and without). + (usize::from_str(&json["sealFields"].as_string().unwrap_or("0x")[2..]).unwrap(), json["sealRlp"].as_string().unwrap_or("0x")[2..].from_hex().unwrap()) + } + }; + + Spec { + engine_name: json["engineName"].as_string().unwrap().to_string(), + engine_params: json_to_rlp(&json["engineParams"]), + builtins: builtins, + parent_hash: H256::from_str(&json["parentHash"].as_string().unwrap()[2..]).unwrap(), + author: Address::from_str(&json["coinbase"].as_string().unwrap()[2..]).unwrap(), + difficulty: U256::from_str(&json["difficulty"].as_string().unwrap()[2..]).unwrap(), + gas_limit: U256::from_str(&json["gasLimit"].as_string().unwrap()[2..]).unwrap(), + gas_used: U256::from(0u8), + timestamp: U256::from_str(&json["timestamp"].as_string().unwrap()[2..]).unwrap(), + extra_data: json["extraData"].as_string().unwrap()[2..].from_hex().unwrap(), + genesis_state: state, + seal_fields: seal_fields, + seal_rlp: seal_rlp, + state_root_memo: RefCell::new(json["stateRoot"].as_string().map(|s| H256::from_str(&s[2..]).unwrap())), + } + } + pub fn olympic() -> Spec { Spec { engine_name: "Ethash".to_string(),