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

This commit is contained in:
debris 2015-12-14 11:02:33 +01:00
commit 2ac0f0f4ac
2 changed files with 92 additions and 48 deletions

View File

@ -6,52 +6,91 @@ use util::trie::*;
use util::rlp::*; use util::rlp::*;
use util::uint::*; use util::uint::*;
enum HashOrData { pub const SHA3_EMPTY: H256 = H256( [0xc5, 0xd2, 0x46, 0x01, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x03, 0xc0, 0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70] );
Hash(H256),
Data(Bytes),
Both(H256, Bytes),
}
/// Single account in the system.
pub struct Account { pub struct Account {
// Balance of the account.
balance: U256, balance: U256,
// Nonce of the account.
nonce: U256, nonce: U256,
// Trie-backed storage. // Trie-backed storage.
storage_root: H256, storage_root: H256,
// Overlay on trie-backed storage. // Overlay on trie-backed storage.
storage_overlay: HashMap<H256, H256>, storage_overlay: HashMap<H256, H256>,
code: HashOrData, // Code hash of the account. If None, means that it's a contract whose code has not yet been set.
code_hash: Option<H256>,
// Code cache of the account.
code_cache: Bytes,
} }
impl Account { impl Account {
pub fn new_with_balance(balance: U256) -> Account { /// General constructor.
pub fn new(balance: U256, nonce: U256, storage: HashMap<H256, H256>, code: Bytes) -> Account {
Account {
balance: balance,
nonce: nonce,
storage_root: SHA3_NULL_RLP,
storage_overlay: storage,
code_hash: None,
code_cache: code
}
}
/// Create a new account with the given balance.
pub fn new_basic(balance: U256) -> Account {
Account { Account {
balance: balance, balance: balance,
nonce: U256::from(0u8), nonce: U256::from(0u8),
code: HashOrData::Data(vec![]),
storage_root: SHA3_NULL_RLP, storage_root: SHA3_NULL_RLP,
storage_overlay: HashMap::new(), storage_overlay: HashMap::new(),
code_hash: Some(SHA3_EMPTY),
code_cache: vec![],
} }
} }
/// Create a new contract account.
/// NOTE: make sure you use `set_code` on this before `commit`ing.
pub fn new_contract(balance: U256) -> Account {
Account {
balance: balance,
nonce: U256::from(0u8),
storage_root: SHA3_NULL_RLP,
storage_overlay: HashMap::new(),
code_hash: None,
code_cache: vec![],
}
}
/// Create a new account from RLP.
pub fn from_rlp(_rlp: &[u8]) -> Account { pub fn from_rlp(_rlp: &[u8]) -> Account {
//TODO // unimplemented!();
Account { Account {
balance: U256::from(0u8), balance: U256::from(0u8),
nonce: U256::from(0u8), nonce: U256::from(0u8),
code: HashOrData::Hash(SHA3_NULL_RLP),
storage_root: SHA3_NULL_RLP, storage_root: SHA3_NULL_RLP,
storage_overlay: HashMap::new(), storage_overlay: HashMap::new(),
code_hash: Some(SHA3_EMPTY),
code_cache: vec![],
} }
} }
/// Set this account's code to the given code.
/// NOTE: Account should have been created with `new_contract`.
pub fn set_code(&mut self, code: Bytes) {
assert!(self.code_hash.is_none());
self.code_cache = code;
}
/// return the balance associated with this account.
pub fn balance(&self) -> &U256 { &self.balance } pub fn balance(&self) -> &U256 { &self.balance }
/// return the nonce associated with this account.
pub fn nonce(&self) -> &U256 { &self.nonce } pub fn nonce(&self) -> &U256 { &self.nonce }
pub fn code_hash(&self) -> Option<&H256> { /// return the code hash associated with this account.
match self.code { pub fn code_hash(&self) -> H256 {
HashOrData::Hash(ref h) | HashOrData::Both(ref h, _) => Some(h), self.code_hash.clone().unwrap_or(SHA3_EMPTY)
_ => None,
}
} }
/// return the storage root associated with this account.
pub fn storage_root(&self) -> Option<&H256> { if self.storage_overlay.is_empty() {Some(&self.storage_root)} else {None} } pub fn storage_root(&self) -> Option<&H256> { if self.storage_overlay.is_empty() {Some(&self.storage_root)} else {None} }
/// Commit the `storage_overlay` to the backing DB and update `storage_root`. /// Commit the `storage_overlay` to the backing DB and update `storage_root`.
@ -67,19 +106,18 @@ impl Account {
/// Commit any unsaved code and ensure code is not `HashOrData::Data`. /// Commit any unsaved code and ensure code is not `HashOrData::Data`.
pub fn commit_code(&mut self, db: &mut HashDB) { pub fn commit_code(&mut self, db: &mut HashDB) {
if let Some(new_code) = match self.code { if self.code_hash.is_none() && !self.code_cache.is_empty() {
HashOrData::Data(ref d) => { Some(HashOrData::Both(db.insert(d), d.clone())) }, self.code_hash = Some(db.insert(&self.code_cache));
_ => None, }
}{
self.code = new_code;
} }
// that nasty bit of code should really be: /// Export to RLP.
/*if let HashOrData::Data(ref d) = self.code { pub fn rlp(&self) -> Bytes {
let h = db.insert(d); let mut stream = RlpStream::new_list(4);
self.code = HashOrData::Both(h, d.clone()); stream.append(&self.nonce);
}*/ stream.append(&self.balance);
// a rewrite it closer to this would be good... stream.append(&self.storage_root);
stream.append(self.code_hash.as_ref().expect("Cannot form RLP of contract account without code."));
stream.out()
} }
} }

View File

@ -7,10 +7,11 @@ use util::rlp::*;
use util::uint::*; use util::uint::*;
use account::Account; use account::Account;
/// Representation of the entire state of all accounts in the system.
pub struct State { pub struct State {
db: OverlayDB, db: OverlayDB,
root: H256, root: H256,
_cache: HashMap<Address, Option<Account>>, cache: HashMap<Address, Option<Account>>,
_account_start_nonce: U256, _account_start_nonce: U256,
} }
@ -27,7 +28,7 @@ impl State {
State { State {
db: db, db: db,
root: root, root: root,
_cache: HashMap::new(), cache: HashMap::new(),
_account_start_nonce: account_start_nonce, _account_start_nonce: account_start_nonce,
} }
} }
@ -42,7 +43,7 @@ impl State {
State { State {
db: db, db: db,
root: root, root: root,
_cache: HashMap::new(), cache: HashMap::new(),
_account_start_nonce: account_start_nonce, _account_start_nonce: account_start_nonce,
} }
} }
@ -57,37 +58,42 @@ impl State {
&self.root &self.root
} }
/// Commit everything to the disk /// Expose the underlying database; good to use for calling `state.db().commit()`.
pub fn commit_db(&mut self) { pub fn db(&mut self) -> &mut OverlayDB {
self.db.commit().expect("Number of kills exceeded number of inserts!"); &mut self.db
} }
/// Commit accounts to TrieDB. This is simplified version of /// Commit accounts to TrieDB. This is simplified version of
/// cpp-ethereum's dev::eth::commit. /// cpp-ethereum's dev::eth::commit.
/// accounts mutable because we may need to commit the code or storage and record that. /// accounts mutable because we may need to commit the code or storage and record that.
pub fn commit(db: &mut HashDB, mut root: H256, accounts: &mut HashMap<Address, Account>) -> H256 { pub fn commit_into(db: &mut HashDB, mut root: H256, accounts: &mut HashMap<Address, Option<Account>>) -> H256 {
// first, commit the sub trees. // first, commit the sub trees.
for (_, ref mut account) in accounts.iter_mut() { // TODO: is this necessary or can we dispense with the `ref mut a` for just `a`?
for (_, ref mut a) in accounts.iter_mut() {
match a {
&mut&mut Some(ref mut account) => {
account.commit_storage(db); account.commit_storage(db);
account.commit_code(db); account.commit_code(db);
} }
&mut&mut None => {}
}
}
{ {
let mut trie = TrieDB::new_existing(db, &mut root); let mut trie = TrieDB::new_existing(db, &mut root);
for (address, account) in accounts.iter() { for (address, ref a) in accounts.iter() {
let mut stream = RlpStream::new_list(4); match a {
stream.append(account.nonce()); &&Some(ref account) => trie.insert(address, &account.rlp()),
stream.append(account.balance()); &&None => trie.remove(address),
stream.append(account.storage_root().unwrap()); }
stream.append(account.code_hash().unwrap());
trie.insert(address, &stream.out());
} }
} }
root root
} }
pub fn insert_accounts(&mut self, accounts: &mut HashMap<Address, Account>) { /// Commits our cached account changes into the trie.
pub fn commit(&mut self) {
let r = self.root.clone(); // would prefer not to do this, really. let r = self.root.clone(); // would prefer not to do this, really.
self.root = Self::commit(&mut self.db, r, accounts); self.root = Self::commit_into(&mut self.db, r, &mut self.cache);
} }
} }