Get logblooms/receipts into the database.

libdevcore/FixedHash.h

@@ -231,6 +231,7 @@ using h520 = FixedHash<65>;
 using h512 = FixedHash<64>;
 using h256 = FixedHash<32>;
 using h160 = FixedHash<20>;
+using h512s = std::vector<h512>;
 using h256s = std::vector<h256>;
 using h160s = std::vector<h160>;
 using h256Set = std::set<h256>;

libethereum/BlockChain.cpp

@@ -309,10 +309,14 @@ h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 		auto b = s.oldBloom();
 		BlockBlooms bb;
 		BlockTraces bt;
+		BlockLogBlooms blb;
+		BlockReceipts br;
 		for (unsigned i = 0; i < s.pending().size(); ++i)
 		{
-			bt.traces.push_back(s.changesFromPending(i));
 			bb.blooms.push_back(s.changesFromPending(i).bloom());
+			bt.traces.push_back(s.changesFromPending(i));
+			blb.blooms.push_back(s.receipt(i).bloom());
+			br.receipts.push_back(s.receipt(i));
 		}
 		s.cleanup(true);
 		td = pd.totalDifficulty + tdIncrease;
@@ -334,11 +338,21 @@ h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 			WriteGuard l(x_traces);
 			m_traces[newHash] = bt;
 		}
+		{
+			WriteGuard l(x_logBlooms);
+			m_logBlooms[newHash] = blb;
+		}
+		{
+			WriteGuard l(x_receipts);
+			m_receipts[newHash] = br;
+		}
 
 		m_extrasDB->Put(m_writeOptions, toSlice(newHash), (ldb::Slice)dev::ref(m_details[newHash].rlp()));
 		m_extrasDB->Put(m_writeOptions, toSlice(bi.parentHash), (ldb::Slice)dev::ref(m_details[bi.parentHash].rlp()));
 		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 1), (ldb::Slice)dev::ref(m_blooms[newHash].rlp()));
 		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 2), (ldb::Slice)dev::ref(m_traces[newHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 3), (ldb::Slice)dev::ref(m_logBlooms[newHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 4), (ldb::Slice)dev::ref(m_receipts[newHash].rlp()));
 		m_db->Put(m_writeOptions, toSlice(newHash), (ldb::Slice)ref(_block));
 
 #if ETH_PARANOIA

libethereum/BlockChain.h

@@ -105,6 +105,14 @@ public:
 	BlockTraces traces(h256 _hash) const { return queryExtras<BlockTraces, 2>(_hash, m_traces, x_traces, NullBlockTraces); }
 	BlockTraces traces() const { return traces(currentHash()); }
 
+	/// Get the transactions' log blooms of a block (or the most recent mined if none given). Thread-safe.
+	BlockLogBlooms logBlooms(h256 _hash) const { return queryExtras<BlockLogBlooms, 3>(_hash, m_logBlooms, x_logBlooms, NullBlockLogBlooms); }
+	BlockLogBlooms logBlooms() const { return logBlooms(currentHash()); }
+
+	/// Get the transactions' receipts of a block (or the most recent mined if none given). Thread-safe.
+	BlockReceipts receipts(h256 _hash) const { return queryExtras<BlockReceipts, 4>(_hash, m_receipts, x_receipts, NullBlockReceipts); }
+	BlockReceipts receipts() const { return receipts(currentHash()); }
+
 	/// Get a block (RLP format) for the given hash (or the most recent mined if none given). Thread-safe.
 	bytes block(h256 _hash) const;
 	bytes block() const { return block(currentHash()); }
@@ -185,6 +193,10 @@ private:
 	mutable BlockBloomsHash m_blooms;
 	mutable boost::shared_mutex x_traces;
 	mutable BlockTracesHash m_traces;
+	mutable boost::shared_mutex x_logBlooms;
+	mutable BlockLogBloomsHash m_logBlooms;
+	mutable boost::shared_mutex x_receipts;
+	mutable BlockReceiptsHash m_receipts;
 	mutable boost::shared_mutex x_cache;
 	mutable std::map<h256, bytes> m_cache;
 

libethereum/BlockDetails.h

@@ -29,6 +29,7 @@
 #include <libdevcore/Log.h>
 #include <libdevcore/RLP.h>
 #include "Manifest.h"
+#include "TransactionReceipt.h"
 namespace ldb = leveldb;
 
 namespace dev
@@ -71,14 +72,35 @@ struct BlockTraces
 	Manifests traces;
 };
 
+struct BlockLogBlooms
+{
+	BlockLogBlooms() {}
+	BlockLogBlooms(RLP const& _r) { blooms = _r.toVector<h512>(); }
+	bytes rlp() const { RLPStream s; s << blooms; return s.out(); }
+
+	h512s blooms;
+};
+
+struct BlockReceipts
+{
+	BlockReceipts() {}
+	BlockReceipts(RLP const& _r) { for (auto const& i: _r) receipts.emplace_back(i.data()); }
+	bytes rlp() const { RLPStream s(receipts.size()); for (TransactionReceipt const& i: receipts) i.streamRLP(s); return s.out(); }
+
+	TransactionReceipts receipts;
+};
 
 typedef std::map<h256, BlockDetails> BlockDetailsHash;
 typedef std::map<h256, BlockBlooms> BlockBloomsHash;
 typedef std::map<h256, BlockTraces> BlockTracesHash;
+typedef std::map<h256, BlockLogBlooms> BlockLogBloomsHash;
+typedef std::map<h256, BlockReceipts> BlockReceiptsHash;
 
 static const BlockDetails NullBlockDetails;
 static const BlockBlooms NullBlockBlooms;
 static const BlockTraces NullBlockTraces;
+static const BlockLogBlooms NullBlockLogBlooms;
+static const BlockReceipts NullBlockReceipts;
 
 }
 }

libethereum/ExtVM.h

@@ -102,7 +102,7 @@ public:
 
 private:
 	State& m_s;										///< A reference to the base state.
-	std::map<Address, Account> m_origCache;	///< The cache of the address states (i.e. the externalities) as-was prior to the execution.
+	std::map<Address, Account> m_origCache;			///< The cache of the address states (i.e. the externalities) as-was prior to the execution.
 	Manifest* m_ms;
 };
 

libethereum/State.cpp

@@ -723,9 +723,7 @@ void State::cleanup(bool _fullCommit)
 		m_previousBlock = m_currentBlock;
 	}
 	else
-	{
 		m_db.rollback();
-	}
 
 	resetCurrent();
 }

libethereum/State.h

@@ -35,6 +35,7 @@
 #include "TransactionQueue.h"
 #include "Account.h"
 #include "Transaction.h"
+#include "TransactionReceipt.h"
 #include "Executive.h"
 #include "AccountDiff.h"
 
@@ -52,37 +53,6 @@ struct StateChat: public LogChannel { static const char* name() { return "-S-";
 struct StateTrace: public LogChannel { static const char* name() { return "=S="; } static const int verbosity = 7; };
 struct StateDetail: public LogChannel { static const char* name() { return "/S/"; } static const int verbosity = 14; };
 
-class TransactionReceipt
-{
-public:
-	TransactionReceipt(h256 _root, u256 _gasUsed, LogEntries const& _log, Manifest const& _ms): m_stateRoot(_root), m_gasUsed(_gasUsed), m_bloom(eth::bloom(_log)), m_log(_log), m_changes(_ms) {}
-
-	Manifest const& changes() const { return m_changes; }
-
-	h256 const& stateRoot() const { return m_stateRoot; }
-	u256 const& gasUsed() const { return m_gasUsed; }
-	LogBloom const& bloom() const { return m_bloom; }
-	LogEntries const& log() const { return m_log; }
-
-	void streamRLP(RLPStream& _s) const
-	{
-		_s.appendList(4) << m_stateRoot << m_gasUsed << m_bloom;
-		_s.appendList(m_log.size());
-		for (LogEntry const& l: m_log)
-			l.streamRLP(_s);
-	}
-
-private:
-	h256 m_stateRoot;
-	u256 m_gasUsed;
-	LogBloom m_bloom;
-	LogEntries m_log;
-
-	Manifest m_changes;	///< TODO: PoC-7: KILL
-};
-
-using TransactionReceipts = std::vector<TransactionReceipt>;
-
 struct PrecompiledAddress
 {
 	unsigned gas;

libethereum/TransactionReceipt.h

@@ -0,0 +1,70 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum is free software: you can redistribute it and/or modify
+	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.
+
+	cpp-ethereum is distributed in the hope that it will be useful,
+	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
+	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file TransactionReceipt.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <array>
+#include <map>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
+#include <libevm/ExtVMFace.h>
+#include "Manifest.h"
+
+namespace dev
+{
+
+namespace eth
+{
+
+class TransactionReceipt
+{
+public:
+	TransactionReceipt(bytesConstRef _rlp) { RLP r(_rlp); m_stateRoot = (h256)r[0]; m_gasUsed = (u256)r[1]; m_bloom = (LogBloom)r[2]; for (auto const& i: r[3]) m_log.emplace_back(i); }
+	TransactionReceipt(h256 _root, u256 _gasUsed, LogEntries const& _log, Manifest const& _ms): m_stateRoot(_root), m_gasUsed(_gasUsed), m_bloom(eth::bloom(_log)), m_log(_log), m_changes(_ms) {}
+
+	Manifest const& changes() const { return m_changes; }
+
+	h256 const& stateRoot() const { return m_stateRoot; }
+	u256 const& gasUsed() const { return m_gasUsed; }
+	LogBloom const& bloom() const { return m_bloom; }
+	LogEntries const& log() const { return m_log; }
+
+	void streamRLP(RLPStream& _s) const
+	{
+		_s.appendList(4) << m_stateRoot << m_gasUsed << m_bloom;
+		_s.appendList(m_log.size());
+		for (LogEntry const& l: m_log)
+			l.streamRLP(_s);
+	}
+
+private:
+	h256 m_stateRoot;
+	u256 m_gasUsed;
+	LogBloom m_bloom;
+	LogEntries m_log;
+
+	Manifest m_changes;	///< TODO: PoC-7: KILL
+};
+
+using TransactionReceipts = std::vector<TransactionReceipt>;
+
+}
+}