grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bloom refactor (#7475)

Browse Source 
* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor finished

* cleanup bloom mess

* simplify usage of Bloom in few places

* removed obsolete util/src/lib.rs

* removed commented out code

* ethereum-types 0.1.4

* updated ethereum-types and tiny-keccak
This commit is contained in:
Marek Kotewicz
2018-01-14 22:43:28 +01:00
committed by GitHub
parent e7f36665bb
commit 668d910c44
65 changed files with 2023 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
ethcore/src/trace/bloom.rs
View File

@@ -1,77 +0,0 @@
use bloomchain::Bloom;
use bloomchain::group::{BloomGroup, GroupPosition};
use basic_types::LogBloom;
/// Helper structure representing bloom of the trace.
#[derive(Clone, RlpEncodableWrapper, RlpDecodableWrapper)]
pub struct BlockTracesBloom(LogBloom);
impl From<LogBloom> for BlockTracesBloom {
fn from(bloom: LogBloom) -> BlockTracesBloom {
BlockTracesBloom(bloom)
}
}
impl From<Bloom> for BlockTracesBloom {
fn from(bloom: Bloom) -> BlockTracesBloom {
let bytes: [u8; 256] = bloom.into();
BlockTracesBloom(LogBloom::from(bytes))
}
}
impl Into<Bloom> for BlockTracesBloom {
fn into(self) -> Bloom {
let log = self.0;
Bloom::from(log.0)
}
}
/// Represents group of X consecutive blooms.
#[derive(Clone, RlpEncodableWrapper, RlpDecodableWrapper)]
pub struct BlockTracesBloomGroup {
blooms: Vec<BlockTracesBloom>,
}
impl From<BloomGroup> for BlockTracesBloomGroup {
fn from(group: BloomGroup) -> Self {
let blooms = group.blooms
.into_iter()
.map(From::from)
.collect();
BlockTracesBloomGroup {
blooms: blooms
}
}
}
impl Into<BloomGroup> for BlockTracesBloomGroup {
fn into(self) -> BloomGroup {
let blooms = self.blooms
.into_iter()
.map(Into::into)
.collect();
BloomGroup {
blooms: blooms
}
}
}
/// Represents `BloomGroup` position in database.
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
pub struct TraceGroupPosition {
/// Bloom level.
pub level: u8,
/// Group index.
pub index: u32,
}
impl From<GroupPosition> for TraceGroupPosition {
fn from(p: GroupPosition) -> Self {
TraceGroupPosition {
level: p.level as u8,
index: p.index as u32,
}
}
}

2
ethcore/src/trace/db.rs
View File

@@ -279,8 +279,6 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
} else {
self.traces(block_hash).expect("Traces database is incomplete.").bloom()
})
.map(blooms::Bloom::from)
.map(Into::into)
.collect();
let chain = BloomGroupChain::new(self.bloom_config, self);

1
ethcore/src/trace/mod.rs
View File

@@ -16,7 +16,6 @@
//! Tracing
mod bloom;
mod config;
mod db;
mod executive_tracer;

75
ethcore/src/trace/types/filter.rs
View File

@@ -17,11 +17,8 @@
//! Trace filters type definitions
use std::ops::Range;
use bloomchain::{Filter as BloomFilter, Bloom, Number};
use hash::keccak;
use ethereum_types::Address;
use bloomable::Bloomable;
use basic_types::LogBloom;
use bloomchain::{Filter as BloomFilter, Number};
use ethereum_types::{Address, Bloom, BloomInput};
use trace::flat::FlatTrace;
use super::trace::{Action, Res};
@@ -51,23 +48,27 @@ impl AddressesFilter {
}
/// Returns blooms of this addresses filter.
pub fn blooms(&self) -> Vec<LogBloom> {
pub fn blooms(&self) -> Vec<Bloom> {
match self.list.is_empty() {
true => vec![LogBloom::default()],
true => vec![Bloom::default()],
false => self.list.iter()
.map(|address| LogBloom::from_bloomed(&keccak(address)))
.map(|address| Bloom::from(BloomInput::Raw(address)))
.collect(),
}
}
/// Returns vector of blooms zipped with blooms of this addresses filter.
pub fn with_blooms(&self, blooms: Vec<LogBloom>) -> Vec<LogBloom> {
pub fn with_blooms(&self, blooms: Vec<Bloom>) -> Vec<Bloom> {
match self.list.is_empty() {
true => blooms,
false => blooms
.into_iter()
.flat_map(|bloom| self.list.iter()
.map(|address| bloom.with_bloomed(&keccak(address)))
.map(|address| {
let mut bloom = Bloom::from(bloom.0);
bloom.accrue(BloomInput::Raw(address));
bloom
})
.collect::<Vec<_>>())
.collect(),
}
@@ -102,7 +103,7 @@ impl BloomFilter for Filter {
impl Filter {
/// Returns combinations of each address.
fn bloom_possibilities(&self) -> Vec<LogBloom> {
fn bloom_possibilities(&self) -> Vec<Bloom> {
self.to_address.with_blooms(self.from_address.blooms())
}
@@ -138,9 +139,7 @@ impl Filter {
#[cfg(test)]
mod tests {
use ethereum_types::Address;
use hash::keccak;
use bloomable::Bloomable;
use ethereum_types::{Address, Bloom, BloomInput};
use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide, Reward};
use trace::flat::FlatTrace;
use trace::{Filter, AddressesFilter, TraceError, RewardType};
@@ -155,7 +154,7 @@ mod tests {
};
let blooms = filter.bloom_possibilities();
assert_eq!(blooms, vec![Default::default()]);
assert_eq!(blooms, vec![Bloom::default()]);
}
#[test]
@@ -169,9 +168,9 @@ mod tests {
let blooms = filter.bloom_possibilities();
assert_eq!(blooms.len(), 1);
assert!(blooms[0].contains_bloomed(&keccak(Address::from(1))));
assert!(blooms[0].contains_bloomed(&keccak(Address::from(2))));
assert!(!blooms[0].contains_bloomed(&keccak(Address::from(3))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(2))));
assert!(!blooms[0].contains_input(BloomInput::Raw(&Address::from(3))));
}
#[test]
@@ -185,8 +184,8 @@ mod tests {
let blooms = filter.bloom_possibilities();
assert_eq!(blooms.len(), 1);
assert!(blooms[0].contains_bloomed(&keccak(Address::from(1))));
assert!(!blooms[0].contains_bloomed(&keccak(Address::from(2))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(!blooms[0].contains_input(BloomInput::Raw(&Address::from(2))));
}
#[test]
@@ -200,8 +199,8 @@ mod tests {
let blooms = filter.bloom_possibilities();
assert_eq!(blooms.len(), 1);
assert!(blooms[0].contains_bloomed(&keccak(Address::from(1))));
assert!(!blooms[0].contains_bloomed(&keccak(Address::from(2))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(!blooms[0].contains_input(BloomInput::Raw(&Address::from(2))));
}
#[test]
@@ -215,25 +214,25 @@ mod tests {
let blooms = filter.bloom_possibilities();
assert_eq!(blooms.len(), 4);
assert!(blooms[0].contains_bloomed(&keccak(Address::from(1))));
assert!(blooms[0].contains_bloomed(&keccak(Address::from(2))));
assert!(!blooms[0].contains_bloomed(&keccak(Address::from(3))));
assert!(!blooms[0].contains_bloomed(&keccak(Address::from(4))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(blooms[0].contains_input(BloomInput::Raw(&Address::from(2))));
assert!(!blooms[0].contains_input(BloomInput::Raw(&Address::from(3))));
assert!(!blooms[0].contains_input(BloomInput::Raw(&Address::from(4))));
assert!(blooms[1].contains_bloomed(&keccak(Address::from(1))));
assert!(blooms[1].contains_bloomed(&keccak(Address::from(4))));
assert!(!blooms[1].contains_bloomed(&keccak(Address::from(2))));
assert!(!blooms[1].contains_bloomed(&keccak(Address::from(3))));
assert!(blooms[1].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(blooms[1].contains_input(BloomInput::Raw(&Address::from(4))));
assert!(!blooms[1].contains_input(BloomInput::Raw(&Address::from(2))));
assert!(!blooms[1].contains_input(BloomInput::Raw(&Address::from(3))));
assert!(blooms[2].contains_bloomed(&keccak(Address::from(2))));
assert!(blooms[2].contains_bloomed(&keccak(Address::from(3))));
assert!(!blooms[2].contains_bloomed(&keccak(Address::from(1))));
assert!(!blooms[2].contains_bloomed(&keccak(Address::from(4))));
assert!(blooms[2].contains_input(BloomInput::Raw(&Address::from(2))));
assert!(blooms[2].contains_input(BloomInput::Raw(&Address::from(3))));
assert!(!blooms[2].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(!blooms[2].contains_input(BloomInput::Raw(&Address::from(4))));
assert!(blooms[3].contains_bloomed(&keccak(Address::from(3))));
assert!(blooms[3].contains_bloomed(&keccak(Address::from(4))));
assert!(!blooms[3].contains_bloomed(&keccak(Address::from(1))));
assert!(!blooms[3].contains_bloomed(&keccak(Address::from(2))));
assert!(blooms[3].contains_input(BloomInput::Raw(&Address::from(3))));
assert!(blooms[3].contains_input(BloomInput::Raw(&Address::from(4))));
assert!(!blooms[3].contains_input(BloomInput::Raw(&Address::from(1))));
assert!(!blooms[3].contains_input(BloomInput::Raw(&Address::from(2))));
}
#[test]

8
ethcore/src/trace/types/flat.rs
View File

@@ -19,7 +19,7 @@
use std::collections::VecDeque;
use rlp::*;
use heapsize::HeapSizeOf;
use basic_types::LogBloom;
use ethereum_types::Bloom;
use super::trace::{Action, Res};
/// Trace localized in vector of traces produced by a single transaction.
@@ -41,7 +41,7 @@ pub struct FlatTrace {
impl FlatTrace {
/// Returns bloom of the trace.
pub fn bloom(&self) -> LogBloom {
pub fn bloom(&self) -> Bloom {
self.action.bloom() | self.result.bloom()
}
}
@@ -94,7 +94,7 @@ impl HeapSizeOf for FlatTransactionTraces {
impl FlatTransactionTraces {
/// Returns bloom of all traces in the collection.
pub fn bloom(&self) -> LogBloom {
pub fn bloom(&self) -> Bloom {
self.0.iter().fold(Default::default(), | bloom, trace | bloom | trace.bloom())
}
}
@@ -123,7 +123,7 @@ impl From<Vec<FlatTransactionTraces>> for FlatBlockTraces {
impl FlatBlockTraces {
/// Returns bloom of all traces in the block.
pub fn bloom(&self) -> LogBloom {
pub fn bloom(&self) -> Bloom {
self.0.iter().fold(Default::default(), | bloom, tx_traces | bloom | tx_traces.bloom())
}
}

37
ethcore/src/trace/types/trace.rs
View File

@@ -16,14 +16,11 @@
//! Tracing datatypes.
use ethereum_types::{U256, Address};
use ethereum_types::{U256, Address, Bloom, BloomInput};
use bytes::Bytes;
use hash::keccak;
use bloomable::Bloomable;
use rlp::*;
use vm::ActionParams;
use basic_types::LogBloom;
use evm::CallType;
use super::error::Error;
@@ -49,8 +46,8 @@ pub struct CreateResult {
impl CreateResult {
/// Returns bloom.
pub fn bloom(&self) -> LogBloom {
LogBloom::from_bloomed(&keccak(&self.address))
pub fn bloom(&self) -> Bloom {
BloomInput::Raw(&self.address).into()
}
}
@@ -87,9 +84,11 @@ impl From<ActionParams> for Call {
impl Call {
/// Returns call action bloom.
/// The bloom contains from and to addresses.
pub fn bloom(&self) -> LogBloom {
LogBloom::from_bloomed(&keccak(&self.from))
.with_bloomed(&keccak(&self.to))
pub fn bloom(&self) -> Bloom {
let mut bloom = Bloom::default();
bloom.accrue(BloomInput::Raw(&self.from));
bloom.accrue(BloomInput::Raw(&self.to));
bloom
}
}
@@ -120,8 +119,8 @@ impl From<ActionParams> for Create {
impl Create {
/// Returns bloom create action bloom.
/// The bloom contains only from address.
pub fn bloom(&self) -> LogBloom {
LogBloom::from_bloomed(&keccak(&self.from))
pub fn bloom(&self) -> Bloom {
BloomInput::Raw(&self.from).into()
}
}
@@ -167,8 +166,8 @@ pub struct Reward {
impl Reward {
/// Return reward action bloom.
pub fn bloom(&self) -> LogBloom {
LogBloom::from_bloomed(&keccak(&self.author))
pub fn bloom(&self) -> Bloom {
BloomInput::Raw(&self.author).into()
}
}
@@ -207,9 +206,11 @@ pub struct Suicide {
impl Suicide {
/// Return suicide action bloom.
pub fn bloom(&self) -> LogBloom {
LogBloom::from_bloomed(&keccak(self.address))
.with_bloomed(&keccak(self.refund_address))
pub fn bloom(&self) -> Bloom {
let mut bloom = Bloom::default();
bloom.accrue(BloomInput::Raw(&self.address));
bloom.accrue(BloomInput::Raw(&self.refund_address));
bloom
}
}
@@ -266,7 +267,7 @@ impl Decodable for Action {
impl Action {
/// Returns action bloom.
pub fn bloom(&self) -> LogBloom {
pub fn bloom(&self) -> Bloom {
match *self {
Action::Call(ref call) => call.bloom(),
Action::Create(ref create) => create.bloom(),
@@ -338,7 +339,7 @@ impl Decodable for Res {
impl Res {
/// Returns result bloom.
pub fn bloom(&self) -> LogBloom {
pub fn bloom(&self) -> Bloom {
match *self {
Res::Create(ref create) => create.bloom(),
Res::Call(_) | Res::FailedCall(_) | Res::FailedCreate(_) | Res::None => Default::default(),