Merge branch 'master' of https://github.com/gavofyork/ethcore into evm

src/engine.rs

@@ -1,5 +1,7 @@
 use std::collections::hash_map::*;
 use util::bytes::*;
+use util::uint::*;
+use util::rlp::*;
 use util::semantic_version::*;
 use util::error::*;
 use header::Header;
@@ -27,25 +29,40 @@ pub trait Engine {
 	/// Get the general parameters of the chain.
 	fn spec(&self) -> &Spec;
 
-	/// Get the EVM schedule for 
+	/// Get the EVM schedule for the given `env_info`.
 	fn evm_schedule(&self, env_info: &EnvInfo) -> EvmSchedule;
 
+	/// Some intrinsic operation parameters; by default they take their value from the `spec()`'s `engine_params`.
+	fn maximum_extra_data_size(&self, _env_info: &EnvInfo) -> usize { decode(&self.spec().engine_params.get("maximum_extra_data_size").unwrap()) }
+	fn account_start_nonce(&self, _env_info: &EnvInfo) -> U256 { decode(&self.spec().engine_params.get("account_start_nonce").unwrap()) }
+	// TODO: refactor in terms of `on_preseal_block`
+	fn block_reward(&self, _env_info: &EnvInfo) -> U256 { decode(&self.spec().engine_params.get("block_reward").unwrap()) }
+
+	/// Block transformation functions, before and after the transactions.
+//	fn on_new_block(&self, _env_info: &EnvInfo, _block: &mut Block) -> Result<(), EthcoreError> {}
+//	fn on_preseal_block(&self, _env_info: &EnvInfo, _block: &mut Block) -> Result<(), EthcoreError> {}
+
 	/// Verify that `header` is valid.
 	/// `parent` (the parent header) and `block` (the header's full block) may be provided for additional
 	/// checks. Returns either a null `Ok` or a general error detailing the problem with import.
+	// TODO: consider including State in the params.
 	fn verify(&self, _header: &Header, _parent: Option<&Header>, _block: Option<&[u8]>) -> Result<(), EthcoreError> { Ok(()) }
 
 	/// Additional verification for transactions in blocks.
 	// TODO: Add flags for which bits of the transaction to check.
+	// TODO: consider including State in the params.
 	fn verify_transaction(&self, _t: &Transaction, _header: &Header) -> Result<(), EthcoreError> { Ok(()) }
 
 	/// Don't forget to call Super::populateFromParent when subclassing & overriding.
+	// TODO: consider including State in the params.
 	fn populate_from_parent(&self, _header: &mut Header, _parent: &Header) -> Result<(), EthcoreError> { Ok(()) }
 
-	// TODO: buildin contract routing - this will require removing the built-in configuration reading logic from Spec
+	// TODO: buildin contract routing - to do this properly, it will require removing the built-in configuration-reading logic
-	// into here and removing the Spec::builtins field. It's a big job.
+	// from Spec into here and removing the Spec::builtins field.
 /*	fn is_builtin(&self, a: Address) -> bool;
 	fn cost_of_builtin(&self, a: Address, in: &[u8]) -> bignum;
 	fn execute_builtin(&self, a: Address, in: &[u8], out: &mut [u8]);
 */
+
+	// TODO: sealing stuff - though might want to leave this for later.
 }

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<Address, Account>)  {
+	fn load_genesis_json(json: Json, state_root: H256) -> (Header, HashMap<Address, Account>)  {
 		// 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)
 	}
 

src/spec.rs

@@ -1,17 +1,60 @@
-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 value to equivlaent RLP representation.
+// TODO: handle container types.
+pub fn json_to_rlp(json: &Json) -> Bytes {
+	match json {
+		&Json::I64(o) => encode(&(o as u64)),
+		&Json::U64(o) => encode(&o),
+		&Json::String(ref s) if &s[0..2] == "0x" && U256::from_str(&s[2..]).is_ok() => {
+			encode(&U256::from_str(&s[2..]).unwrap())
+		},
+		&Json::String(ref s) => {
+			encode(s)
+		},
+		_ => panic!()
+	}
+}
+
+/// Convert JSON to a string->RLP map.
+pub fn json_to_rlp_map(json: &Json) -> HashMap<String, Bytes> {
+	json.as_object().unwrap().iter().map(|(k, v)| (k, json_to_rlp(v))).fold(HashMap::new(), |mut acc, kv| {
+				acc.insert(kv.0.clone(), kv.1);
+				acc
+			})
+}
 
 /// 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.
@@ -19,11 +62,9 @@ pub struct Spec {
 	// What engine are we using for this?
 	pub engine_name: String,
 
-	// Various parameters for the chain operation.
+	// Parameters concerning operation of the specific engine we're using.
-	pub block_reward: U256,
+	// Name -> RLP-encoded value
-	pub maximum_extra_data_size: U256,
+	pub engine_params: HashMap<String, Bytes>,
-	pub account_start_nonce: U256,
-	pub misc: HashMap<String, Bytes>,
 
 	// Builtin-contracts are here for now but would like to abstract into Engine API eventually.
 	pub builtins: HashMap<Address, Builtin>,
@@ -62,26 +103,100 @@ impl Spec {
 		Ref::map(self.state_root_memo.borrow(), |x|x.as_ref().unwrap())
 	}
 
-	pub fn block_reward(&self) -> U256 { self.block_reward }
-	pub fn maximum_extra_data_size(&self) -> U256 { self.maximum_extra_data_size }
-	pub fn account_start_nonce(&self) -> U256 { self.account_start_nonce }
-
 	/// Compose the genesis block for this chain.
 	pub fn genesis_block(&self) -> Bytes {
-		// TODO
+		let empty_list = RlpStream::new_list(0).out();
-		unimplemented!();
+		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 a chain-specification from a json data structure
+	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_map(&json["params"]),
+			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())),
+		}
+	}
+
+	/// Creates the Olympic network chain spec.
 	pub fn olympic() -> Spec {
 		Spec {
 			engine_name: "Ethash".to_string(),
-			block_reward: finney() * U256::from(1500u64),
+			engine_params: vec![
-			maximum_extra_data_size: U256::from(1024u64),
+				("block_reward", encode(&(finney() * U256::from(1500u64)))),
-			account_start_nonce: U256::from(0u64),
+				("maximum_extra_data_size", encode(&U256::from(1024u64))),
-			misc: vec![
+				("account_start_nonce", encode(&U256::from(0u64))),
 				("gas_limit_bounds_divisor", encode(&1024u64)), 
 				("minimum_difficulty", encode(&131_072u64)), 
 				("difficulty_bound_divisor", encode(&2048u64)), 
@@ -112,13 +227,14 @@ impl Spec {
 		}
 	}
 
+	/// Creates the Frontier network chain spec.
 	pub fn frontier() -> Spec {
 		Spec {
 			engine_name: "Ethash".to_string(),
-			block_reward: ether() * U256::from(5u64),
+			engine_params: vec![
-			maximum_extra_data_size: U256::from(32u64),
+				("block_reward", encode(&(ether() * U256::from(5u64)))),
-			account_start_nonce: U256::from(0u64),
+				("maximum_extra_data_size", encode(&U256::from(32u64))),
-			misc: vec![
+				("account_start_nonce", encode(&U256::from(0u64))),
 				("gas_limit_bounds_divisor", encode(&1024u64)), 
 				("minimum_difficulty", encode(&131_072u64)), 
 				("difficulty_bound_divisor", encode(&2048u64)), 
@@ -149,13 +265,14 @@ impl Spec {
 		}
 	}
 
+	/// Creates the Morden network chain spec.
 	pub fn morden() -> Spec {
 		Spec {
 			engine_name: "Ethash".to_string(),
-			block_reward: ether() * U256::from(5u64),
+			engine_params: vec![
-			maximum_extra_data_size: U256::from(32u64),
+				("block_reward", encode(&(ether() * U256::from(5u64)))),
-			account_start_nonce: U256::from(1u64) << 20,
+				("maximum_extra_data_size", encode(&U256::from(32u64))),
-			misc: vec![
+				("account_start_nonce", encode(&(U256::from(1u64) << 20))),
 				("gas_limit_bounds_divisor", encode(&1024u64)), 
 				("minimum_difficulty", encode(&131_072u64)), 
 				("difficulty_bound_divisor", encode(&2048u64)),