openethereum/ethcore/src/pod_state.rs

245 lines
7.2 KiB
Rust
Raw Normal View History

2020-09-22 14:53:52 +02:00
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.
2016-02-05 13:40:41 +01:00
2020-09-22 14:53:52 +02:00
// OpenEthereum is free software: you can redistribute it and/or modify
2016-02-05 13:40:41 +01:00
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
2020-09-22 14:53:52 +02:00
// OpenEthereum is distributed in the hope that it will be useful,
2016-02-05 13:40:41 +01:00
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
2020-09-22 14:53:52 +02:00
// along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
2016-02-05 13:40:41 +01:00
2016-03-17 15:51:40 +01:00
//! State of all accounts in the system expressed in Plain Old Data.
2020-08-05 06:08:03 +02:00
use ethereum_types::{Address, H256};
use ethjson;
use itertools::Itertools;
use pod_account::{self, PodAccount};
2020-08-05 06:08:03 +02:00
use std::{collections::BTreeMap, fmt};
use triehash::sec_trie_root;
use types::state_diff::StateDiff;
2016-02-03 13:20:32 +01:00
/// State of all accounts in the system expressed in Plain Old Data.
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
pub struct PodState(BTreeMap<Address, PodAccount>);
impl PodState {
2020-08-05 06:08:03 +02:00
/// Contruct a new object from the `m`.
pub fn new() -> PodState {
Default::default()
}
/// Contruct a new object from the `m`.
pub fn from(m: BTreeMap<Address, PodAccount>) -> PodState {
PodState(m)
}
/// Get the underlying map.
pub fn get(&self) -> &BTreeMap<Address, PodAccount> {
&self.0
}
/// Get the root hash of the trie of the RLP of this.
pub fn root(&self) -> H256 {
sec_trie_root(self.0.iter().map(|(k, v)| (k, v.rlp())))
}
/// Drain object to get the underlying map.
pub fn drain(self) -> BTreeMap<Address, PodAccount> {
self.0
}
2016-01-14 21:58:37 +01:00
}
impl From<ethjson::blockchain::State> for PodState {
2020-08-05 06:08:03 +02:00
fn from(s: ethjson::blockchain::State) -> PodState {
let state = s
.into_iter()
.map(|(addr, acc)| (addr.into(), PodAccount::from(acc)))
.collect();
PodState(state)
}
}
impl From<ethjson::spec::State> for PodState {
2020-08-05 06:08:03 +02:00
fn from(s: ethjson::spec::State) -> PodState {
let state: BTreeMap<_, _> = s
.into_iter()
.filter(|pair| !pair.1.is_empty())
.map(|(addr, acc)| (addr.into(), PodAccount::from(acc)))
.collect();
PodState(state)
}
2016-03-17 15:51:40 +01:00
}
impl fmt::Display for PodState {
2020-08-05 06:08:03 +02:00
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (add, acc) in &self.0 {
writeln!(f, "{} => {}", add, acc)?;
}
Ok(())
}
}
2016-01-30 12:53:16 +01:00
/// Calculate and return diff between `pre` state and `post` state.
pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff {
2020-08-05 06:08:03 +02:00
StateDiff {
raw: pre
.get()
.keys()
.merge(post.get().keys())
.filter_map(|acc| {
pod_account::diff_pod(pre.get().get(acc), post.get().get(acc))
.map(|d| (acc.clone(), d))
})
.collect(),
}
}
#[cfg(test)]
mod test {
2020-08-05 06:08:03 +02:00
use super::PodState;
use pod_account::PodAccount;
use std::collections::BTreeMap;
use types::{account_diff::*, state_diff::*};
#[test]
fn create_delete() {
let a = PodState::from(map![
1.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
}
]);
assert_eq!(
super::diff_pod(&a, &PodState::new()),
StateDiff {
raw: map![
1.into() => AccountDiff{
balance: Diff::Died(69.into()),
nonce: Diff::Died(0.into()),
code: Diff::Died(vec![]),
storage: map![],
}
]
}
);
assert_eq!(
super::diff_pod(&PodState::new(), &a),
StateDiff {
raw: map![
1.into() => AccountDiff{
balance: Diff::Born(69.into()),
nonce: Diff::Born(0.into()),
code: Diff::Born(vec![]),
storage: map![],
}
]
}
);
}
#[test]
fn create_delete_with_unchanged() {
let a = PodState::from(map![
1.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
}
]);
let b = PodState::from(map![
1.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
},
2.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
}
]);
assert_eq!(
super::diff_pod(&a, &b),
StateDiff {
raw: map![
2.into() => AccountDiff{
balance: Diff::Born(69.into()),
nonce: Diff::Born(0.into()),
code: Diff::Born(vec![]),
storage: map![],
}
]
}
);
assert_eq!(
super::diff_pod(&b, &a),
StateDiff {
raw: map![
2.into() => AccountDiff{
balance: Diff::Died(69.into()),
nonce: Diff::Died(0.into()),
code: Diff::Died(vec![]),
storage: map![],
}
]
}
);
}
#[test]
fn change_with_unchanged() {
let a = PodState::from(map![
1.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
},
2.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
}
]);
let b = PodState::from(map![
1.into() => PodAccount {
balance: 69.into(),
nonce: 1.into(),
code: Some(Vec::new()),
storage: map![],
},
2.into() => PodAccount {
balance: 69.into(),
nonce: 0.into(),
code: Some(Vec::new()),
storage: map![],
}
]);
assert_eq!(
super::diff_pod(&a, &b),
StateDiff {
raw: map![
1.into() => AccountDiff{
balance: Diff::Same,
nonce: Diff::Changed(0.into(), 1.into()),
code: Diff::Same,
storage: map![],
}
]
}
);
}
}