diff --git a/Cargo.toml b/Cargo.toml index 3a74bf589..64b49663f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,11 +9,12 @@ authors = ["Ethcore "] [dependencies] log = "0.3" env_logger = "0.3" -ethcore-util = "0.1.0" +ethcore-util = { path = "../ethcore-util" } rustc-serialize = "0.3" flate2 = "0.2" rocksdb = "0.2.1" heapsize = "0.2.0" +rust-crypto = "0.2.34" evmjit = { path = "rust-evmjit", optional = true } diff --git a/res/morden.json b/res/morden.json new file mode 100644 index 000000000..033c0651c --- /dev/null +++ b/res/morden.json @@ -0,0 +1,34 @@ +{ + "engineName": "Ethash", + "params": { + "accountStartNonce": "0x0100000", + "frontierCompatibilityModeLimit": "0xfffa2990", + "maximumExtraDataSize": "0x20", + "tieBreakingGas": false, + "minGasLimit": "0x1388", + "gasLimitBoundDivisor": "0x0400", + "minimumDifficulty": "0x020000", + "difficultyBoundDivisor": "0x0800", + "durationLimit": "0x0d", + "blockReward": "0x4563918244F40000", + "registrar": "", + "networkID" : "0x2" + }, + "genesis": { + "nonce": "0x00006d6f7264656e", + "difficulty": "0x20000", + "mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578", + "author": "0x0000000000000000000000000000000000000000", + "timestamp": "0x00", + "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "extraData": "0x", + "gasLimit": "0x2fefd8" + }, + "accounts": { + "0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } }, + "0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } }, + "0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } }, + "0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } }, + "102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": { "balance": "1606938044258990275541962092341162602522202993782792835301376", "nonce": "1048576" } + } +} \ No newline at end of file diff --git a/src/builtin.rs b/src/builtin.rs index 12ed610a6..b6eb2591b 100644 --- a/src/builtin.rs +++ b/src/builtin.rs @@ -1,4 +1,15 @@ +use std::cmp::min; +use std::fmt; use util::uint::*; +use util::hash::*; +use util::sha3::*; +use util::bytes::*; +use rustc_serialize::json::Json; +use std::io::Write; +use util::crypto::*; +use crypto::sha2::Sha256; +use crypto::ripemd160::Ripemd160; +use crypto::digest::Digest; /// Definition of a contract whose implementation is built-in. pub struct Builtin { @@ -8,3 +19,253 @@ pub struct Builtin { /// being placed into the second. pub execute: Box, } + +impl fmt::Debug for Builtin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "") + } +} + +impl Builtin { + /// Create a new object from components. + pub fn new(cost: Box U256>, execute: Box) -> Builtin { + Builtin {cost: cost, execute: execute} + } + + /// Create a new object from a builtin-function name with a linear cost associated with input size. + pub fn from_named_linear(name: &str, base_cost: usize, word_cost: usize) -> Option { + new_builtin_exec(name).map(|b| { + let cost = Box::new(move|s: usize| -> U256 { + U256::from(base_cost) + U256::from(word_cost) * U256::from((s + 31) / 32) + }); + Self::new(cost, b) + }) + } + + /// Create a builtin from JSON. + /// + /// JSON must be of the form `{ "name": "identity", "linear": {"base": 10, "word": 20} }`. + pub fn from_json(json: &Json) -> Option { + // NICE: figure out a more convenient means of handing errors here. + if let Json::String(ref name) = json["name"] { + if let Json::Object(ref o) = json["linear"] { + if let Json::U64(ref word) = o["word"] { + if let Json::U64(ref base) = o["base"] { + return Self::from_named_linear(&name[..], *base as usize, *word as usize); + } + } + } + } + None + } +} + +pub fn copy_to(src: &[u8], dest: &mut[u8]) { + // NICE: optimise + for i in 0..min(src.len(), dest.len()) { + dest[i] = src[i]; + } +} + +/// Create a new builtin executor according to `name`. +/// TODO: turn in to a factory with dynamic registration. +pub fn new_builtin_exec(name: &str) -> Option> { + match name { + "identity" => Some(Box::new(move|input: &[u8], output: &mut[u8]| { + for i in 0..min(input.len(), output.len()) { + output[i] = input[i]; + } + })), + "ecrecover" => Some(Box::new(move|input: &[u8], output: &mut[u8]| { + #[repr(packed)] + #[derive(Debug)] + struct InType { + hash: H256, + v: H256, + r: H256, + s: H256, + } + let mut it: InType = InType { hash: H256::new(), v: H256::new(), r: H256::new(), s: H256::new() }; + it.copy_raw(input); + if it.v == H256::from(&U256::from(27)) || it.v == H256::from(&U256::from(28)) { + let s = Signature::from_rsv(&it.r, &it.s, it.v[31] - 27); + if is_valid(&s) { + match recover(&s, &it.hash) { + Ok(p) => { + let r = p.as_slice().sha3(); + // NICE: optimise and separate out into populate-like function + for i in 0..min(32, output.len()) { + output[i] = if i < 12 {0} else {r[i]}; + } + } + _ => {} + }; + } + } + })), + "sha256" => Some(Box::new(move|input: &[u8], output: &mut[u8]| { + let mut sha = Sha256::new(); + sha.input(input); + if output.len() >= 32 { + sha.result(output); + } else { + let mut ret = H256::new(); + sha.result(ret.as_slice_mut()); + copy_to(&ret, output); + } + })), + "ripemd160" => Some(Box::new(move|input: &[u8], output: &mut[u8]| { + let mut sha = Ripemd160::new(); + sha.input(input); + let mut ret = H256::new(); + sha.result(&mut ret.as_slice_mut()[12..32]); + copy_to(&ret, output); + })), + _ => None + } +} + +#[test] +fn identity() { + let f = new_builtin_exec("identity").unwrap(); + let i = [0u8, 1, 2, 3]; + + let mut o2 = [255u8; 2]; + f(&i[..], &mut o2[..]); + assert_eq!(i[0..2], o2); + + let mut o4 = [255u8; 4]; + f(&i[..], &mut o4[..]); + assert_eq!(i, o4); + + let mut o8 = [255u8; 8]; + f(&i[..], &mut o8[..]); + assert_eq!(i, o8[..4]); + assert_eq!([255u8; 4], o8[4..]); +} + +#[test] +fn sha256() { + use rustc_serialize::hex::FromHex; + let f = new_builtin_exec("sha256").unwrap(); + let i = [0u8; 0]; + + let mut o = [255u8; 32]; + f(&i[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855").unwrap())[..]); + + let mut o8 = [255u8; 8]; + f(&i[..], &mut o8[..]); + assert_eq!(&o8[..], &(FromHex::from_hex("e3b0c44298fc1c14").unwrap())[..]); + + let mut o34 = [255u8; 34]; + f(&i[..], &mut o34[..]); + assert_eq!(&o34[..], &(FromHex::from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855ffff").unwrap())[..]); +} + +#[test] +fn ripemd160() { + use rustc_serialize::hex::FromHex; + let f = new_builtin_exec("ripemd160").unwrap(); + let i = [0u8; 0]; + + let mut o = [255u8; 32]; + f(&i[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31").unwrap())[..]); + + let mut o8 = [255u8; 8]; + f(&i[..], &mut o8[..]); + assert_eq!(&o8[..], &(FromHex::from_hex("0000000000000000").unwrap())[..]); + + let mut o34 = [255u8; 34]; + f(&i[..], &mut o34[..]); + assert_eq!(&o34[..], &(FromHex::from_hex("0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31ffff").unwrap())[..]); +} + +#[test] +fn ecrecover() { + use rustc_serialize::hex::FromHex; + /*let k = KeyPair::from_secret(b"test".sha3()).unwrap(); + let a: Address = From::from(k.public().sha3()); + println!("Address: {}", a); + let m = b"hello world".sha3(); + println!("Message: {}", m); + let s = k.sign(&m).unwrap(); + println!("Signed: {}", s);*/ + + let f = new_builtin_exec("ecrecover").unwrap(); + let i = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap(); + + let mut o = [255u8; 32]; + f(&i[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("000000000000000000000000c08b5542d177ac6686946920409741463a15dddb").unwrap())[..]); + + let mut o8 = [255u8; 8]; + f(&i[..], &mut o8[..]); + assert_eq!(&o8[..], &(FromHex::from_hex("0000000000000000").unwrap())[..]); + + let mut o34 = [255u8; 34]; + f(&i[..], &mut o34[..]); + assert_eq!(&o34[..], &(FromHex::from_hex("000000000000000000000000c08b5542d177ac6686946920409741463a15dddbffff").unwrap())[..]); + + let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001a650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]); + + let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b000000000000000000000000000000000000000000000000000000000000001b0000000000000000000000000000000000000000000000000000000000000000").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]); + + let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001b").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]); + + let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000001b").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]); + + let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b000000000000000000000000000000000000000000000000000000000000001bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]); + + // TODO: Should this (corrupted version of the above) fail rather than returning some address? +/* let i_bad = FromHex::from_hex("48173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap(); + let mut o = [255u8; 32]; + f(&i_bad[..], &mut o[..]); + assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);*/ +} + +#[test] +fn from_named_linear() { + let b = Builtin::from_named_linear("identity", 10, 20).unwrap(); + assert_eq!((*b.cost)(0), U256::from(10)); + assert_eq!((*b.cost)(1), U256::from(30)); + assert_eq!((*b.cost)(32), U256::from(30)); + assert_eq!((*b.cost)(33), U256::from(50)); + + let i = [0u8, 1, 2, 3]; + let mut o = [255u8; 4]; + (*b.execute)(&i[..], &mut o[..]); + assert_eq!(i, o); +} + +#[test] +fn from_json() { + let text = "{ \"name\": \"identity\", \"linear\": {\"base\": 10, \"word\": 20} }"; + let json = Json::from_str(text).unwrap(); + let b = Builtin::from_json(&json).unwrap(); + assert_eq!((*b.cost)(0), U256::from(10)); + assert_eq!((*b.cost)(1), U256::from(30)); + assert_eq!((*b.cost)(32), U256::from(30)); + assert_eq!((*b.cost)(33), U256::from(50)); + + let i = [0u8, 1, 2, 3]; + let mut o = [255u8; 4]; + (*b.execute)(&i[..], &mut o[..]); + assert_eq!(i, o); +} \ No newline at end of file diff --git a/src/engine.rs b/src/engine.rs index d920f4bef..9632ba090 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -57,7 +57,7 @@ pub trait Engine { // TODO: consider including State in the params. fn populate_from_parent(&self, _header: &mut Header, _parent: &Header) -> Result<(), EthcoreError> { Ok(()) } - // TODO: buildin contract routing - to do this properly, it will require removing the built-in configuration-reading logic + // TODO: builtin contract routing - to do this properly, it will require removing the built-in configuration-reading logic // 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; diff --git a/src/ethash.rs b/src/ethash.rs new file mode 100644 index 000000000..27d39bdaa --- /dev/null +++ b/src/ethash.rs @@ -0,0 +1,22 @@ +use engine::Engine; +use spec::Spec; +use evm_schedule::EvmSchedule; +use env_info::EnvInfo; + +/// Engine using Ethash proof-of-work consensus algorithm, suitable for Ethereum +/// mainnet chains in the Olympic, Frontier and Homestead eras. +pub struct Ethash { + spec: Spec, +} + +impl Ethash { + pub fn new_boxed(spec: Spec) -> Box { + Box::new(Ethash{spec: spec}) + } +} + +impl Engine for Ethash { + fn name(&self) -> &str { "Ethash" } + fn spec(&self) -> &Spec { &self.spec } + fn evm_schedule(&self, _env_info: &EnvInfo) -> EvmSchedule { EvmSchedule::new_frontier() } +} diff --git a/src/genesis.rs b/src/genesis.rs index 5b8bed1f8..63a0caf81 100644 --- a/src/genesis.rs +++ b/src/genesis.rs @@ -89,7 +89,7 @@ impl Genesis { // ethash specific fields let mixhash = H256::from_str(&json["mixhash"].as_string().unwrap()[2..]).unwrap(); let nonce = H64::from_str(&json["nonce"].as_string().unwrap()[2..]).unwrap(); - vec![mixhash.to_vec(), nonce.to_vec()] + vec![encode(&mixhash), encode(&nonce)] } }; diff --git a/src/header.rs b/src/header.rs index 28e568e8e..ab84d5c58 100644 --- a/src/header.rs +++ b/src/header.rs @@ -3,12 +3,22 @@ use util::bytes::*; use util::uint::*; use util::rlp::*; -pub static ZERO_ADDRESS: Address = Address([0x00; 20]); -pub static ZERO_H256: H256 = H256([0x00; 32]); -pub static ZERO_LOGBLOOM: LogBloom = H2048([0x00; 256]); - +/// Type for a 2048-bit log-bloom, as used by our blocks. pub type LogBloom = H2048; +/// Constant address for point 0. Often used as a default. +pub static ZERO_ADDRESS: Address = Address([0x00; 20]); +/// Constant 256-bit datum for 0. Often used as a default. +pub static ZERO_H256: H256 = H256([0x00; 32]); +/// Constant 2048-bit datum for 0. Often used as a default. +pub static ZERO_LOGBLOOM: LogBloom = H2048([0x00; 256]); + +/// A block header. +/// +/// Reflects the specific RLP fields of a block in the chain with additional room for the seal +/// which is non-specific. +/// +/// Doesn't do all that much on its own. #[derive(Debug)] pub struct Header { pub parent_hash: H256, @@ -31,6 +41,7 @@ pub struct Header { } impl Header { + /// Create a new, default-valued, header. pub fn new() -> Header { Header { parent_hash: ZERO_H256.clone(), @@ -76,7 +87,7 @@ impl Decodable for Header { }; for i in 13..d.len() { - blockheader.seal.push(try!(Decodable::decode(&d[i]))); + blockheader.seal.push(d[i].as_raw().to_vec()); } Ok(blockheader) @@ -101,11 +112,33 @@ impl Encodable for Header { self.extra_data.encode(e); for b in self.seal.iter() { - b.encode(e); + e.emit_raw(&b); } }) } } +/* +trait RlpStandard { + fn append(&self, s: &mut RlpStream); +} + +impl RlpStandard for Header { + fn append(&self, s: &mut RlpStream) { + s.append_list(13); + s.append(self.parent_hash); + s.append_raw(self.seal[0]); + s.append_standard(self.x); + } + fn populate(&mut self, s: &Rlp) { + } +} + +impl RlpStream { + fn append_standard(&mut self, o: &O) where O: RlpStandard { + o.append(self); + } +} +*/ #[cfg(test)] mod tests { diff --git a/src/lib.rs b/src/lib.rs index 41cdc9515..f426a4b87 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -77,6 +77,7 @@ extern crate rustc_serialize; extern crate flate2; extern crate rocksdb; extern crate heapsize; +extern crate crypto; extern crate env_logger; #[cfg(feature = "jit" )] @@ -104,3 +105,4 @@ pub mod genesis; pub mod views; pub mod blockchain; pub mod extras; +pub mod ethash; diff --git a/src/spec.rs b/src/spec.rs index b79624787..d7455b072 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -17,11 +17,12 @@ use account::*; use engine::Engine; use builtin::Builtin; use null_engine::NullEngine; +use ethash::Ethash; use denominations::*; use header::*; /// Converts file from base64 gzipped bytes to json -pub fn base_to_json(source: &[u8]) -> Json { +pub fn gzip64res_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!"); @@ -34,11 +35,12 @@ pub fn base_to_json(source: &[u8]) -> Json { /// Convert JSON value to equivlaent RLP representation. // TODO: handle container types. -pub fn json_to_rlp(json: &Json) -> Bytes { +fn json_to_rlp(json: &Json) -> Bytes { match json { + &Json::Boolean(o) => encode(&(if o {1u64} else {0})), &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() => { + &Json::String(ref s) if s.len() >= 2 && &s[0..2] == "0x" && U256::from_str(&s[2..]).is_ok() => { encode(&U256::from_str(&s[2..]).unwrap()) }, &Json::String(ref s) => { @@ -49,15 +51,16 @@ pub fn json_to_rlp(json: &Json) -> Bytes { } /// Convert JSON to a string->RLP map. -pub fn json_to_rlp_map(json: &Json) -> HashMap { +fn json_to_rlp_map(json: &Json) -> HashMap { 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 - }) + 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. +#[derive(Debug)] pub struct Spec { // What engine are we using for this? pub engine_name: String, @@ -91,6 +94,7 @@ impl Spec { pub fn to_engine(self) -> Result, EthcoreError> { match self.engine_name.as_ref() { "NullEngine" => Ok(NullEngine::new_boxed(self)), + "Ethash" => Ok(Ethash::new_boxed(self)), _ => Err(EthcoreError::UnknownName) } } @@ -98,25 +102,22 @@ impl Spec { /// Return the state root for the genesis state, memoising accordingly. pub fn state_root(&self) -> Ref { if self.state_root_memo.borrow().is_none() { - *self.state_root_memo.borrow_mut() = Some(trie_root(self.genesis_state.iter().map(|(k, v)| (k.to_vec(), v.rlp())).collect())); + *self.state_root_memo.borrow_mut() = Some(sec_trie_root(self.genesis_state.iter().map(|(k, v)| (k.to_vec(), v.rlp())).collect())); } Ref::map(self.state_root_memo.borrow(), |x|x.as_ref().unwrap()) } - /// Compose the genesis block for this chain. - pub fn genesis_block(&self) -> Bytes { - let empty_list = RlpStream::new_list(0).out(); - let empty_list_sha3 = empty_list.sha3(); - let header = Header { + fn genesis_header(&self) -> 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(), + transactions_root: SHA3_NULL_RLP.clone(), + uncles_hash: RlpStream::new_list(0).out().sha3(), extra_data: self.extra_data.clone(), state_root: self.state_root().clone(), - receipts_root: SHA3_EMPTY.clone(), + receipts_root: SHA3_NULL_RLP.clone(), log_bloom: H2048::new().clone(), gas_used: self.gas_used.clone(), gas_limit: self.gas_limit.clone(), @@ -130,67 +131,90 @@ impl Spec { let r = Rlp::new(&seal); (0..self.seal_fields).map(|i| r.at(i).raw().to_vec()).collect() }, - }; + } + } + + /// Compose the genesis block for this chain. + pub fn genesis_block(&self) -> Bytes { + let empty_list = RlpStream::new_list(0).out(); + let header = self.genesis_header(); 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 mut builtins = HashMap::new(); + + if let Some(&Json::Object(ref accounts)) = json.find("accounts") { + for (address, acc) in accounts.iter() { + let addr = Address::from_str(address).unwrap(); + if let Some(ref builtin_json) = acc.find("builtin") { + if let Some(builtin) = Builtin::from_json(builtin_json) { + builtins.insert(addr.clone(), builtin); + } + } + let balance = if let Some(&Json::String(ref b)) = acc.find("balance") {U256::from_dec_str(b).unwrap_or(U256::from(0))} else {U256::from(0)}; + let nonce = if let Some(&Json::String(ref n)) = acc.find("nonce") {U256::from_dec_str(n).unwrap_or(U256::from(0))} else {U256::from(0)}; + // TODO: handle code & data if they exist. + state.insert(addr, Account::new_basic(balance, nonce)); + } } - let builtins = { - // TODO: populate from json. - HashMap::new() - }; + let genesis = &json["genesis"];//.as_object().expect("No genesis object in JSON"); let (seal_fields, seal_rlp) = { - if json.find("mixhash").is_some() && json.find("nonce").is_some() { + if genesis.find("mixHash").is_some() && genesis.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()); + s.append(&H256::from_str(&genesis["mixHash"].as_string().expect("mixHash not a string.")[2..]).expect("Invalid mixHash string value")); + s.append(&H64::from_str(&genesis["nonce"].as_string().expect("nonce not a string.")[2..]).expect("Invalid nonce string value")); (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()) + ( + usize::from_str(&genesis["sealFields"].as_string().unwrap_or("0x")[2..]).expect("Invalid sealFields integer data"), + genesis["sealRlp"].as_string().unwrap_or("0x")[2..].from_hex().expect("Invalid sealRlp hex data") + ) } }; + 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(), + parent_hash: H256::from_str(&genesis["parentHash"].as_string().unwrap()[2..]).unwrap(), + author: Address::from_str(&genesis["author"].as_string().unwrap()[2..]).unwrap(), + difficulty: U256::from_str(&genesis["difficulty"].as_string().unwrap()[2..]).unwrap(), + gas_limit: U256::from_str(&genesis["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(), + timestamp: U256::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(), + extra_data: genesis["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())), + state_root_memo: RefCell::new(genesis.find("stateRoot").and_then(|_| genesis["stateRoot"].as_string()).map(|s| H256::from_str(&s[2..]).unwrap())), } } + /// Returns the builtins map for the standard network of Ethereum Olympic, Frontier and Homestead. + fn standard_builtins() -> HashMap { + let mut ret = HashMap::new(); + ret.insert(Address::from_str("0000000000000000000000000000000000000001").unwrap(), Builtin::from_named_linear("ecrecover", 3000, 0).unwrap()); + ret.insert(Address::from_str("0000000000000000000000000000000000000002").unwrap(), Builtin::from_named_linear("sha256", 60, 12).unwrap()); + ret.insert(Address::from_str("0000000000000000000000000000000000000003").unwrap(), Builtin::from_named_linear("ripemd160", 600, 120).unwrap()); + ret.insert(Address::from_str("0000000000000000000000000000000000000004").unwrap(), Builtin::from_named_linear("identity", 15, 3).unwrap()); + ret + } + /// Creates the Olympic network chain spec. - pub fn olympic() -> Spec { + pub fn new_like_olympic() -> Spec { Spec { engine_name: "Ethash".to_string(), engine_params: vec![ @@ -207,7 +231,7 @@ impl Spec { acc.insert(vec.0.to_string(), vec.1); acc }), - builtins: HashMap::new(), // TODO: make correct + builtins: Self::standard_builtins(), parent_hash: H256::new(), author: Address::new(), difficulty: U256::from(131_072u64), @@ -222,13 +246,13 @@ impl Spec { acc }), seal_fields: 2, - seal_rlp: { let mut r = RlpStream::new_list(2); r.append(&0x2au64); r.append(&H256::new()); r.out() }, // TODO: make correct + seal_rlp: { let mut r = RlpStream::new_list(2); r.append(&H256::new()); r.append(&0x2au64); r.out() }, // TODO: make correct state_root_memo: RefCell::new(None), } } - /// Creates the Frontier network chain spec. - pub fn frontier() -> Spec { + /// Creates the Frontier network chain spec, except for the genesis state, which is blank. + pub fn new_like_frontier() -> Spec { Spec { engine_name: "Ethash".to_string(), engine_params: vec![ @@ -245,7 +269,7 @@ impl Spec { acc.insert(vec.0.to_string(), vec.1); acc }), - builtins: HashMap::new(), // TODO: make correct + builtins: Self::standard_builtins(), parent_hash: H256::new(), author: Address::new(), difficulty: U256::from(131_072u64), @@ -260,13 +284,13 @@ impl Spec { acc }), seal_fields: 2, - seal_rlp: { let mut r = RlpStream::new_list(2); r.append(&0x42u64); r.append(&H256::new()); r.out() }, + seal_rlp: { let mut r = RlpStream::new_list(2); r.append(&H256::new()); r.append(&0x42u64); r.out() }, state_root_memo: RefCell::new(None), } } - /// Creates the Morden network chain spec. - pub fn morden() -> Spec { + /// Creates the actual Morden network chain spec. + pub fn new_morden() -> Spec { Spec { engine_name: "Ethash".to_string(), engine_params: vec![ @@ -283,24 +307,66 @@ impl Spec { acc.insert(vec.0.to_string(), vec.1); acc }), - builtins: HashMap::new(), // TODO: make correct + builtins: Self::standard_builtins(), parent_hash: H256::new(), author: Address::new(), - difficulty: U256::from(131_072u64), - gas_limit: U256::from(0u64), + difficulty: U256::from(0x20000u64), + gas_limit: U256::from(0x2fefd8u64), gas_used: U256::from(0u64), timestamp: U256::from(0u64), extra_data: vec![], - genesis_state: vec![ // TODO: make correct - (Address::new(), Account::new_basic(U256::from(1) << 200, U256::from(0))) - ].into_iter().fold(HashMap::new(), | mut acc, vec | { - acc.insert(vec.0, vec.1); - acc - }), + genesis_state: { + let n = U256::from(1) << 20; + vec![ + (Address::from_str("0000000000000000000000000000000000000001").unwrap(), Account::new_basic(U256::from(1), n)), + (Address::from_str("0000000000000000000000000000000000000002").unwrap(), Account::new_basic(U256::from(1), n)), + (Address::from_str("0000000000000000000000000000000000000003").unwrap(), Account::new_basic(U256::from(1), n)), + (Address::from_str("0000000000000000000000000000000000000004").unwrap(), Account::new_basic(U256::from(1), n)), + (Address::from_str("102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c").unwrap(), Account::new_basic(U256::from(1) << 200, n)) + ]}.into_iter().fold(HashMap::new(), | mut acc, vec | { + acc.insert(vec.0, vec.1); + acc + }), seal_fields: 2, - seal_rlp: { let mut r = RlpStream::new_list(2); r.append(&0x00006d6f7264656eu64); r.append(&H256::from_str("00000000000000000000000000000000000000647572616c65787365646c6578").unwrap()); r.out() }, // TODO: make correct + seal_rlp: { + let mut r = RlpStream::new(); + r.append(&H256::from_str("00000000000000000000000000000000000000647572616c65787365646c6578").unwrap()); + r.append(&FromHex::from_hex("00006d6f7264656e").unwrap()); + r.out() + }, state_root_memo: RefCell::new(None), } } } +#[cfg(test)] +mod tests { + use std::str::FromStr; + use util::hash::*; + use util::sha3::*; + use rustc_serialize::json::Json; + use views::*; + use super::*; + + #[test] + fn all() { + let morden = Spec::new_morden(); +// let engine = morden.to_engine(); // Ethash doesn't exist as an engine yet, so would fail. + + assert_eq!(*morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); + let genesis = morden.genesis_block(); + assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap()); + } + + #[test] + fn morden_res() { + let morden_json = Json::from_str(::std::str::from_utf8(include_bytes!("../res/morden.json")).unwrap()).expect("Json is invalid"); + let morden = Spec::from_json(morden_json); + +// let engine = morden.to_engine(); // Ethash doesn't exist as an engine yet, so would fail. + + assert_eq!(*morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap()); + let genesis = morden.genesis_block(); + assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap()); + } +} \ No newline at end of file