Merge branch 'develop' of github.com:ethereum/cpp-ethereum into develop

cmake/EthCompilerSettings.cmake

@@ -43,8 +43,7 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
 	# warning LNK4075: ignoring '/EDITANDCONTINUE' due to '/SAFESEH' specification 
 	# warning LNK4099: pdb was not found with lib
-	# stack size 16MB
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4099,4075 /STACK:33554432")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4099,4075")
 
 	# windows likes static
 	if (NOT ETH_STATIC)

ethkey/KeyAux.h

@@ -221,26 +221,26 @@ public:
 				break;
 			}
 			case OperationMode::ImportBare:
-				for (string const& i: m_inputs)
+				for (string const& input: m_inputs)
 				{
 					h128 u;
 					bytes b;
-					b = fromHex(i);
+					b = fromHex(input);
 					if (b.size() != 32)
 					{
-						std::string s = contentsString(i);
+						std::string s = contentsString(input);
 						b = fromHex(s);
 						if (b.size() != 32)
-							u = store.importKey(i);
+							u = store.importKey(input);
 					}
 					if (!u && b.size() == 32)
 						u = store.importSecret(b, lockPassword(toAddress(Secret(b)).abridged()));
 					if (!u)
 					{
-						cerr << "Cannot import " << i << " not a file or secret." << endl;
+						cerr << "Cannot import " << input << " not a file or secret." << endl;
 						continue;
 					}
-					cout << "Successfully imported " << i << " as " << toUUID(u);
+					cout << "Successfully imported " << input << " as " << toUUID(u);
 				}
 				break;
 			case OperationMode::InspectBare:

libdevcore/Common.h

@@ -113,25 +113,27 @@ static const u256 Invalid256 = ~(u256)0;
 static const bytes NullBytes;
 static const std::map<u256, u256> EmptyMapU256U256;
 
+/// Interprets @a _u as a two's complement signed number and returns the resulting s256.
 inline s256 u2s(u256 _u)
 {
-    static const bigint c_end = (bigint)1 << 256;
-    static const u256 c_send = (u256)1 << 255;
-    if (_u < c_send)
-        return (s256)_u;
-    else
-        return (s256)-(c_end - _u);
+	static const bigint c_end = bigint(1) << 256;
+	if (boost::multiprecision::bit_test(_u, 255))
+		return s256(-(c_end - _u));
+	else
+		return s256(_u);
 }
 
+/// @returns the two's complement signed representation of the signed number _u.
 inline u256 s2u(s256 _u)
 {
-    static const bigint c_end = (bigint)1 << 256;
+	static const bigint c_end = bigint(1) << 256;
     if (_u >= 0)
-        return (u256)_u;
+		return u256(_u);
     else
-        return (u256)(c_end + _u);
+		return u256(c_end + _u);
 }
 
+/// @returns the smallest n >= 0 such that (1 << n) >= _x
 inline unsigned int toLog2(u256 _x)
 {
 	unsigned ret;
@@ -139,6 +141,7 @@ inline unsigned int toLog2(u256 _x)
 	return ret;
 }
 
+/// @returns the absolute distance between _a and _b.
 template <class N>
 inline N diff(N const& _a, N const& _b)
 {

libdevcore/CommonData.cpp

@@ -93,7 +93,7 @@ bytes dev::fromHex(std::string const& _s, WhenError _throw)
 		if (h != -1)
 			ret.push_back(h);
 		else if (_throw == WhenError::Throw)
-			throw BadHexCharacter();
+			BOOST_THROW_EXCEPTION(BadHexCharacter());
 		else
 			return bytes();
 	}
@@ -104,7 +104,7 @@ bytes dev::fromHex(std::string const& _s, WhenError _throw)
 		if (h != -1 && l != -1)
 			ret.push_back((byte)(h * 16 + l));
 		else if (_throw == WhenError::Throw)
-			throw BadHexCharacter();
+			BOOST_THROW_EXCEPTION(BadHexCharacter());
 		else
 			return bytes();
 	}

libdevcore/CommonData.h

@@ -68,11 +68,6 @@ int fromHex(char _i, WhenError _throw);
 /// If _throw = ThrowType::DontThrow, it replaces bad hex characters with 0's, otherwise it will throw an exception.
 bytes fromHex(std::string const& _s, WhenError _throw = WhenError::DontThrow);
 
-#if 0
-std::string toBase58(bytesConstRef _data);
-bytes fromBase58(std::string const& _s);
-#endif
-
 /// Converts byte array to a string containing the same (binary) data. Unless
 /// the byte array happens to contain ASCII data, this won't be printable.
 inline std::string asString(bytes const& _b)

libdevcore/CommonIO.cpp

@@ -64,59 +64,35 @@ string dev::memDump(bytes const& _bytes, unsigned _width, bool _html)
 	return ret.str();
 }
 
-// Don't forget to delete[] later.
-bytesRef dev::contentsNew(std::string const& _file, bytesRef _dest)
+template <typename _T>
+inline _T contentsGeneric(std::string const& _file)
 {
+	_T ret;
+	size_t const c_elementSize = sizeof(typename _T::value_type);
 	std::ifstream is(_file, std::ifstream::binary);
 	if (!is)
-		return bytesRef();
+		return ret;
+
 	// get length of file:
-	is.seekg (0, is.end);
+	is.seekg(0, is.end);
 	streamoff length = is.tellg();
-	if (length == 0) // return early, MSVC does not like reading 0 bytes
-		return bytesRef();
-	if (!_dest.empty() && _dest.size() != (unsigned)length)
-		return bytesRef();
-	is.seekg (0, is.beg);
-	bytesRef ret = _dest.empty() ? bytesRef(new byte[length], length) : _dest;
-	is.read((char*)ret.data(), length);
-	is.close();
+	if (length == 0)
+		return ret; // do not read empty file (MSVC does not like it)
+	is.seekg(0, is.beg);
+
+	ret.resize((length + c_elementSize - 1) / c_elementSize);
+	is.read(const_cast<char*>(reinterpret_cast<char const*>(ret.data())), length);
 	return ret;
 }
 
-bytes dev::contents(std::string const& _file)
+bytes dev::contents(string const& _file)
 {
-	std::ifstream is(_file, std::ifstream::binary);
-	if (!is)
-		return bytes();
-	// get length of file:
-	is.seekg (0, is.end);
-	streamoff length = is.tellg();
-	if (length == 0) // return early, MSVC does not like reading 0 bytes
-		return bytes();
-	is.seekg (0, is.beg);
-	bytes ret(length);
-	is.read((char*)ret.data(), length);
-	is.close();
-	return ret;
+	return contentsGeneric<bytes>(_file);
 }
 
-string dev::contentsString(std::string const& _file)
+string dev::contentsString(string const& _file)
 {
-	std::ifstream is(_file, std::ifstream::binary);
-	if (!is)
-		return string();
-	// get length of file:
-	is.seekg (0, is.end);
-	streamoff length = is.tellg();
-	if (length == 0) // return early, MSVC does not like reading 0 bytes
-		return string();
-	is.seekg (0, is.beg);
-	string ret;
-	ret.resize(length);
-	is.read((char*)ret.data(), length);
-	is.close();
-	return ret;
+	return contentsGeneric<string>(_file);
 }
 
 void dev::writeFile(std::string const& _file, bytesConstRef _data)

libdevcore/CommonIO.h

@@ -42,10 +42,14 @@
 namespace dev
 {
 
+/// Requests the user to enter a password on the console.
 std::string getPassword(std::string const& _prompt);
 
-/// Retrieve and returns the contents of the given file. If the file doesn't exist or isn't readable, returns an empty bytes.
+/// Retrieve and returns the contents of the given file.
+/// If the file doesn't exist or isn't readable, returns an empty container / bytes.
 bytes contents(std::string const& _file);
+/// Retrieve and returns the contents of the given file as a std::string.
+/// If the file doesn't exist or isn't readable, returns an empty container / bytes.
 std::string contentsString(std::string const& _file);
 /// Retrieve and returns the allocated contents of the given file; if @_dest is given, don't allocate, use it directly.
 /// If the file doesn't exist or isn't readable, returns bytesRef(). Don't forget to delete [] the returned value's data when finished.

libdevcore/vector_ref.h

@@ -9,6 +9,9 @@
 namespace dev
 {
 
+/**
+ * A modifiable reference to an existing object or vector in memory.
+ */
 template <class _T>
 class vector_ref
 {
@@ -17,34 +20,50 @@ public:
 	using element_type = _T;
 	using mutable_value_type = typename std::conditional<std::is_const<_T>::value, typename std::remove_const<_T>::type, _T>::type;
 
+	static_assert(std::is_pod<value_type>::value, "vector_ref can only be used with PODs due to its low-level treatment of data.");
+
 	vector_ref(): m_data(nullptr), m_count(0) {}
+	/// Creates a new vector_ref to point to @a _count elements starting at @a _data.
 	vector_ref(_T* _data, size_t _count): m_data(_data), m_count(_count) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as pointer).
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const*, std::string*>::type _data): m_data(reinterpret_cast<_T*>(_data->data())), m_count(_data->size() / sizeof(_T)) {}
+	/// Creates a new vector_ref pointing to the data part of a vector (given as pointer).
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::vector<typename std::remove_const<_T>::type> const*, std::vector<_T>*>::type _data): m_data(_data->data()), m_count(_data->size()) {}
-	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data((_T*)_data.data()), m_count(_data.size() / sizeof(_T)) {}
+	/// Creates a new vector_ref pointing to the data part of a string (given as reference).
+	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data(reinterpret_cast<_T*>(_data.data())), m_count(_data.size() / sizeof(_T)) {}
 #ifdef STORAGE_LEVELDB_INCLUDE_DB_H_
 	vector_ref(leveldb::Slice const& _s): m_data(reinterpret_cast<_T*>(_s.data())), m_count(_s.size() / sizeof(_T)) {}
 #endif
 	explicit operator bool() const { return m_data && m_count; }
 
-	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count); }
+	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { if (!m_data || m_count == 0) return _c.empty(); else return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count * sizeof(_T)); }
 	std::vector<mutable_value_type> toVector() const { return std::vector<mutable_value_type>(m_data, m_data + m_count); }
 	std::vector<unsigned char> toBytes() const { return std::vector<unsigned char>(reinterpret_cast<unsigned char const*>(m_data), reinterpret_cast<unsigned char const*>(m_data) + m_count * sizeof(_T)); }
 	std::string toString() const { return std::string((char const*)m_data, ((char const*)m_data) + m_count * sizeof(_T)); }
+
 	template <class _T2> explicit operator vector_ref<_T2>() const { assert(m_count * sizeof(_T) / sizeof(_T2) * sizeof(_T2) / sizeof(_T) == m_count); return vector_ref<_T2>(reinterpret_cast<_T2*>(m_data), m_count * sizeof(_T) / sizeof(_T2)); }
 	operator vector_ref<_T const>() const { return vector_ref<_T const>(m_data, m_count); }
 
 	_T* data() const { return m_data; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
 	size_t count() const { return m_count; }
+	/// @returns the number of elements referenced (not necessarily number of bytes).
 	size_t size() const { return m_count; }
 	bool empty() const { return !m_count; }
-	vector_ref<_T> next() const { return vector_ref<_T>(m_data + m_count, m_count); }
+	/// @returns a new vector_ref pointing at the next chunk of @a size() elements.
+	vector_ref<_T> next() const { if (!m_data) return *this; else return vector_ref<_T>(m_data + m_count, m_count); }
+	/// @returns a new vector_ref which is a shifted and shortened view of the original data.
+	/// If this goes out of bounds in any way, returns an empty vector_ref.
+	/// If @a _count is ~size_t(0), extends the view to the end of the data.
 	vector_ref<_T> cropped(size_t _begin, size_t _count) const { if (m_data && _begin + _count <= m_count) return vector_ref<_T>(m_data + _begin, _count == ~size_t(0) ? m_count - _begin : _count); else return vector_ref<_T>(); }
+	/// @returns a new vector_ref which is a shifted view of the original data (not going beyond it).
 	vector_ref<_T> cropped(size_t _begin) const { if (m_data && _begin <= m_count) return vector_ref<_T>(m_data + _begin, m_count - _begin); else return vector_ref<_T>(); }
 	void retarget(_T* _d, size_t _s) { m_data = _d; m_count = _s; }
 	void retarget(std::vector<_T> const& _t) { m_data = _t.data(); m_count = _t.size(); }
 	template <class T> bool overlapsWith(vector_ref<T> _t) const { void const* f1 = data(); void const* t1 = data() + size(); void const* f2 = _t.data(); void const* t2 = _t.data() + _t.size(); return f1 < t2 && t1 > f2; }
+	/// Copies the contents of this vector_ref to the contents of @a _t, up to the max size of @a _t.
 	void copyTo(vector_ref<typename std::remove_const<_T>::type> _t) const { if (overlapsWith(_t)) memmove(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); else memcpy(_t.data(), m_data, std::min(_t.size(), m_count) * sizeof(_T)); }
+	/// Copies the contents of this vector_ref to the contents of @a _t, and zeros further trailing elements in @a _t.
 	void populate(vector_ref<typename std::remove_const<_T>::type> _t) const { copyTo(_t); memset(_t.data() + m_count, 0, std::max(_t.size(), m_count) - m_count); }
 
 	_T* begin() { return m_data; }

libdevcrypto/AES.h

@@ -75,6 +75,8 @@ public:
 	
 	/// Adjust mac interval. Next mac will be xored with value.
 	void adjustInterval(unsigned _interval) { m_macInterval = _interval; }
+
+	unsigned getMacInterval() { return m_macInterval;}
 	
 private:
 	AuthenticatedStream(AuthenticatedStream const&) = delete;

libethash-cl/ethash_cl_miner_kernel.cl

@@ -36,7 +36,7 @@ __constant uint2 const Keccak_f1600_RC[24] = {
 	(uint2)(0x80008008, 0x80000000),
 };
 
-void keccak_f1600_round(uint2* a, uint r, uint out_size)
+static void keccak_f1600_round(uint2* a, uint r, uint out_size)
 {
    #if !__ENDIAN_LITTLE__
 	for (uint i = 0; i != 25; ++i)
@@ -152,7 +152,7 @@ void keccak_f1600_round(uint2* a, uint r, uint out_size)
    #endif
 }
 
-void keccak_f1600_no_absorb(ulong* a, uint in_size, uint out_size, uint isolate)
+static void keccak_f1600_no_absorb(ulong* a, uint in_size, uint out_size, uint isolate)
 {
 	for (uint i = in_size; i != 25; ++i)
 	{
@@ -194,17 +194,17 @@ void keccak_f1600_no_absorb(ulong* a, uint in_size, uint out_size, uint isolate)
 
 #define countof(x) (sizeof(x) / sizeof(x[0]))
 
-uint fnv(uint x, uint y)
+static uint fnv(uint x, uint y)
 {
 	return x * FNV_PRIME ^ y;
 }
 
-uint4 fnv4(uint4 x, uint4 y)
+static uint4 fnv4(uint4 x, uint4 y)
 {
 	return x * FNV_PRIME ^ y;
 }
 
-uint fnv_reduce(uint4 v)
+static uint fnv_reduce(uint4 v)
 {
 	return fnv(fnv(fnv(v.x, v.y), v.z), v.w);
 }
@@ -227,7 +227,7 @@ typedef union
 	uint4 uint4s[128 / sizeof(uint4)];
 } hash128_t;
 
-hash64_t init_hash(__constant hash32_t const* header, ulong nonce, uint isolate)
+static hash64_t init_hash(__constant hash32_t const* header, ulong nonce, uint isolate)
 {
 	hash64_t init;
 	uint const init_size = countof(init.ulongs);
@@ -243,7 +243,7 @@ hash64_t init_hash(__constant hash32_t const* header, ulong nonce, uint isolate)
 	return init;
 }
 
-uint inner_loop_chunks(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, __global hash128_t const* g_dag1, __global hash128_t const* g_dag2, __global hash128_t const* g_dag3, uint isolate)
+static uint inner_loop_chunks(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, __global hash128_t const* g_dag1, __global hash128_t const* g_dag2, __global hash128_t const* g_dag3, uint isolate)
 {
 	uint4 mix = init;
 
@@ -277,7 +277,7 @@ uint inner_loop_chunks(uint4 init, uint thread_id, __local uint* share, __global
 
 
 
-uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, uint isolate)
+static uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, uint isolate)
 {
 	uint4 mix = init;
 
@@ -311,7 +311,7 @@ uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash12
 }
 
 
-hash32_t final_hash(hash64_t const* init, hash32_t const* mix, uint isolate)
+static hash32_t final_hash(hash64_t const* init, hash32_t const* mix, uint isolate)
 {
 	ulong state[25];
 
@@ -330,7 +330,7 @@ hash32_t final_hash(hash64_t const* init, hash32_t const* mix, uint isolate)
 	return hash;
 }
 
-hash32_t compute_hash_simple(
+static hash32_t compute_hash_simple(
 	__constant hash32_t const* g_header,
 	__global hash128_t const* g_dag,
 	ulong nonce,
@@ -383,7 +383,7 @@ typedef union
 } compute_hash_share;
 
 
-hash32_t compute_hash(
+static hash32_t compute_hash(
 	__local compute_hash_share* share,
 	__constant hash32_t const* g_header,
 	__global hash128_t const* g_dag,
@@ -427,7 +427,7 @@ hash32_t compute_hash(
 }
 
 
-hash32_t compute_hash_chunks(
+static hash32_t compute_hash_chunks(
 	__local compute_hash_share* share,
 	__constant hash32_t const* g_header,
 	__global hash128_t const* g_dag,

libethash/endian.h

@@ -32,6 +32,9 @@
 #include <libkern/OSByteOrder.h>
 #define ethash_swap_u32(input_) OSSwapInt32(input_)
 #define ethash_swap_u64(input_) OSSwapInt64(input_)
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__)
+#define ethash_swap_u32(input_) bswap32(input_)
+#define ethash_swap_u64(input_) bswap64(input_)
 #else // posix
 #include <byteswap.h>
 #define ethash_swap_u32(input_) __bswap_32(input_)

libethash/internal.c

@@ -284,13 +284,13 @@ bool ethash_quick_check_difficulty(
 	ethash_h256_t const* header_hash,
 	uint64_t const nonce,
 	ethash_h256_t const* mix_hash,
-	ethash_h256_t const* difficulty
+	ethash_h256_t const* boundary
 )
 {
 
 	ethash_h256_t return_hash;
 	ethash_quick_hash(&return_hash, header_hash, nonce, mix_hash);
-	return ethash_check_difficulty(&return_hash, difficulty);
+	return ethash_check_difficulty(&return_hash, boundary);
 }
 
 ethash_light_t ethash_light_new_internal(uint64_t cache_size, ethash_h256_t const* seed)

libethash/internal.h

@@ -46,27 +46,36 @@ static inline void ethash_h256_reset(ethash_h256_t* hash)
 	memset(hash, 0, 32);
 }
 
-// Returns if hash is less than or equal to difficulty
+// Returns if hash is less than or equal to boundary (2^256/difficulty)
 static inline bool ethash_check_difficulty(
 	ethash_h256_t const* hash,
-	ethash_h256_t const* difficulty
+	ethash_h256_t const* boundary
 )
 {
-	// Difficulty is big endian
+	// Boundary is big endian
 	for (int i = 0; i < 32; i++) {
-		if (ethash_h256_get(hash, i) == ethash_h256_get(difficulty, i)) {
+		if (ethash_h256_get(hash, i) == ethash_h256_get(boundary, i)) {
 			continue;
 		}
-		return ethash_h256_get(hash, i) < ethash_h256_get(difficulty, i);
+		return ethash_h256_get(hash, i) < ethash_h256_get(boundary, i);
 	}
 	return true;
 }
 
+/**
+ *  Difficulty quick check for POW preverification
+ *
+ * @param header_hash      The hash of the header
+ * @param nonce            The block's nonce
+ * @param mix_hash         The mix digest hash
+ * @param boundary         The boundary is defined as (2^256 / difficulty)
+ * @return                 true for succesful pre-verification and false otherwise
+ */
 bool ethash_quick_check_difficulty(
 	ethash_h256_t const* header_hash,
 	uint64_t const nonce,
 	ethash_h256_t const* mix_hash,
-	ethash_h256_t const* difficulty
+	ethash_h256_t const* boundary
 );
 
 struct ethash_light {

libethereum/EthereumHost.cpp

@@ -292,8 +292,8 @@ void EthereumHost::onPeerStatus(EthereumPeer* _peer)
 		else
 			_peer->m_expectedHashes = estimatedHashes;
 		continueSync(_peer);
+		DEV_INVARIANT_CHECK;
 	}
-	DEV_INVARIANT_CHECK;
 }
 
 unsigned EthereumHost::estimateHashes()
@@ -313,6 +313,7 @@ unsigned EthereumHost::estimateHashes()
 void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes)
 {
 	RecursiveGuard l(x_sync);
+	DEV_INVARIANT_CHECK;
 	if (_peer->m_syncHashNumber > 0)
 		_peer->m_syncHashNumber += _hashes.size();
 
@@ -322,7 +323,6 @@ void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes)
 
 void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes, bool _complete)
 {
-	DEV_INVARIANT_CHECK;
 	if (_hashes.empty())
 	{
 		_peer->m_hashSub.doneFetch();
@@ -454,7 +454,8 @@ void EthereumHost::onPeerBlocks(EthereumPeer* _peer, RLP const& _r)
 	unsigned unknown = 0;
 	unsigned got = 0;
 	unsigned repeated = 0;
-	h256 lastUnknown;
+	u256 maxDifficulty = 0;
+	h256 maxUnknown;
 
 	for (unsigned i = 0; i < itemCount; ++i)
 	{
@@ -483,9 +484,17 @@ void EthereumHost::onPeerBlocks(EthereumPeer* _peer, RLP const& _r)
 				break;
 
 			case ImportResult::UnknownParent:
-				lastUnknown = h;
+			{
 				unknown++;
+				BlockInfo bi;
+				bi.populateFromHeader(_r[i][0]);
+				if (bi.difficulty > maxDifficulty)
+				{
+					maxDifficulty = bi.difficulty;
+					maxUnknown = h;
+				}
 				break;
+			}
 
 			default:;
 			}
@@ -501,8 +510,10 @@ void EthereumHost::onPeerBlocks(EthereumPeer* _peer, RLP const& _r)
 
 	if (m_state == SyncState::NewBlocks && unknown > 0)
 	{
-		_peer->m_latestHash = lastUnknown;
-		resetSyncTo(lastUnknown);
+		_peer->m_latestHash = maxUnknown;
+		_peer->m_totalDifficulty = maxDifficulty;
+		if (peerShouldGrabChain(_peer))
+			resetSyncTo(maxUnknown);
 	}
 
 	continueSync(_peer);
@@ -528,7 +539,7 @@ void EthereumHost::onPeerNewBlock(EthereumPeer* _peer, RLP const& _r)
 {
 	RecursiveGuard l(x_sync);
 	DEV_INVARIANT_CHECK;
-	if ((isSyncing() || _peer->isConversing()) && m_state != SyncState::NewBlocks)
+	if ((isSyncing() || _peer->isConversing()))
 	{
 		clog(NetMessageSummary) << "Ignoring new blocks since we're already downloading.";
 		return;
@@ -565,11 +576,14 @@ void EthereumHost::onPeerNewBlock(EthereumPeer* _peer, RLP const& _r)
 				u256 difficulty = _r[1].toInt<u256>();
 				if (m_syncingTotalDifficulty < difficulty)
 				{
-					clog(NetMessageSummary) << "Received block with no known parent. Resyncing...";
 					_peer->m_latestHash = h;
 					_peer->m_totalDifficulty = difficulty;
-					resetSyncTo(h);;
-					sync = true;
+					if (peerShouldGrabChain(_peer))
+					{
+						clog(NetMessageSummary) << "Received block with no known parent. Resyncing...";
+						resetSyncTo(h);;
+						sync = true;
+					}
 				}
 			}
 			break;
@@ -580,7 +594,7 @@ void EthereumHost::onPeerNewBlock(EthereumPeer* _peer, RLP const& _r)
 			_peer->m_knownBlocks.insert(h);
 
 		if (sync)
-			continueSync();
+			continueSync(_peer);
 	}
 	DEV_INVARIANT_CHECK;
 }
@@ -623,6 +637,7 @@ void EthereumHost::onPeerAborting(EthereumPeer* _peer)
 			_peer->setRude();
 		continueSync();
 	}
+	DEV_INVARIANT_CHECK;
 }
 
 void EthereumHost::continueSync()
@@ -758,10 +773,6 @@ bool EthereumHost::peerShouldGrabBlocks(EthereumPeer* _peer) const
 
 bool EthereumHost::peerShouldGrabChain(EthereumPeer* _peer) const
 {
-	// Early exit if this peer has proved unreliable.
-	if (_peer->isRude())
-		return false;
-
 	h256 c = m_chain.currentHash();
 	unsigned n = m_chain.number();
 	u256 td = m_chain.details().totalDifficulty;
@@ -815,6 +826,5 @@ bool EthereumHost::invariants() const
 		return false;
 	if (needBlocks() && (m_syncingLatestHash || !m_hashes.empty()))
 		return false;
-
 	return true;
 }

libethereum/EthereumPeer.cpp

@@ -106,6 +106,7 @@ void EthereumPeer::requestStatus()
 {
 	assert(m_asking == Asking::Nothing);
 	setAsking(Asking::State);
+	m_requireTransactions = true;
 	RLPStream s;
 	bool latest = m_peerCapabilityVersion == host()->protocolVersion();
 	prep(s, StatusPacket, latest ? 6 : 5)

libevmasm/Assembly.cpp

@@ -292,16 +292,6 @@ void Assembly::injectStart(AssemblyItem const& _i)
 	m_items.insert(m_items.begin(), _i);
 }
 
-inline bool matches(AssemblyItemsConstRef _a, AssemblyItemsConstRef _b)
-{
-	if (_a.size() != _b.size())
-		return false;
-	for (unsigned i = 0; i < _a.size(); ++i)
-		if (!_a[i].match(_b[i]))
-			return false;
-	return true;
-}
-
 struct OptimiserChannel: public LogChannel { static const char* name() { return "OPT"; } static const int verbosity = 12; };
 #define copt dev::LogOutputStream<OptimiserChannel, true>()
 

libevmasm/AssemblyItem.cpp

@@ -126,10 +126,3 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item)
 	}
 	return _out;
 }
-
-ostream& dev::eth::operator<<(ostream& _out, AssemblyItemsConstRef _i)
-{
-	for (AssemblyItem const& i: _i)
-		_out << i;
-	return _out;
-}

libevmasm/AssemblyItem.h

@@ -98,11 +98,14 @@ private:
 };
 
 using AssemblyItems = std::vector<AssemblyItem>;
-using AssemblyItemsConstRef = vector_ref<AssemblyItem const>;
 
 std::ostream& operator<<(std::ostream& _out, AssemblyItem const& _item);
-std::ostream& operator<<(std::ostream& _out, AssemblyItemsConstRef _i);
-inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _i) { return operator<<(_out, AssemblyItemsConstRef(&_i)); }
+inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _items)
+{
+	for (AssemblyItem const& item: _items)
+		_out << item;
+	return _out;
+}
 
 }
 }

liblll/CodeFragment.cpp

@@ -196,7 +196,7 @@ void CodeFragment::constructOperation(sp::utree const& _t, CompilerState& _s)
 		{
 			if (_t.size() != 2)
 				error<IncorrectParameterCount>();
-			m_asm.append(CodeFragment::compile(asString(contents(firstAsString())), _s).m_asm);
+			m_asm.append(CodeFragment::compile(contentsString(firstAsString()), _s).m_asm);
 		}
 		else if (us == "SET")
 		{

libtestutils/Common.cpp

@@ -59,7 +59,7 @@ Json::Value dev::test::loadJsonFromFile(std::string const& _path)
 {
 	Json::Reader reader;
 	Json::Value result;
-	string s = asString(dev::contents(_path));
+	string s = dev::contentsString(_path);
 	if (!s.length())
 		ctest << "Contents of " + _path + " is empty. Have you cloned the 'tests' repo branch develop and set ETHEREUM_TEST_PATH to its path?";
 	else

lllc/main.cpp

@@ -95,7 +95,7 @@ int main(int argc, char** argv)
 		}
 	}
 	else
-		src = asString(contents(infile));
+		src = contentsString(infile);
 
 	vector<string> errors;
 	if (src.empty())

solc/CommandLineInterface.cpp

@@ -401,7 +401,7 @@ bool CommandLineInterface::processInput()
 				continue;
 			}
 
-			m_sourceCodes[infile] = asString(dev::contents(infile));
+			m_sourceCodes[infile] = dev::contentsString(infile);
 		}
 
 	m_compiler.reset(new CompilerStack(m_args["add-std"].as<bool>()));

test/TestHelper.cpp

@@ -598,7 +598,7 @@ void userDefinedTest(std::function<void(json_spirit::mValue&, bool)> doTests)
 	{
 		cnote << "Testing user defined test: " << filename;
 		json_spirit::mValue v;
-		string s = asString(contents(filename));
+		string s = contentsString(filename);
 		BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + filename + " is empty. ");
 		json_spirit::read_string(s, v);
 		json_spirit::mObject oSingleTest;

test/libdevcore/rlp.cpp

@@ -67,7 +67,7 @@ namespace dev
 			string testPath = getTestPath();
 			testPath += "/BasicTests";
 
-			string s = asString(contents(testPath + "/rlptest.json"));
+			string s = contentsString(testPath + "/rlptest.json");
 			BOOST_REQUIRE_MESSAGE( s.length() > 0,
 				"Contents of 'rlptest.json' is empty. Have you cloned the 'tests' repo branch develop?");
 			js::read_string(s, v);

test/libdevcrypto/AES.cpp

@@ -0,0 +1,92 @@
+/*
+	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 AES.cpp
+ * @author Christoph Jentzsch <cj@ethdev.com>
+ * @date 2015
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <libdevcore/Common.h>
+#include <libdevcrypto/Common.h>
+#include <libdevcore/SHA3.h>
+#include <libdevcrypto/AES.h>
+#include <libdevcore/FixedHash.h>
+
+using namespace std;
+using namespace dev;
+
+BOOST_AUTO_TEST_SUITE(AES)
+
+BOOST_AUTO_TEST_CASE(AesDecrypt)
+{
+	cout << "AesDecrypt" << endl;
+	bytes seed = fromHex("2dbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "test")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") == kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptWrongSeed)
+{
+	cout << "AesDecryptWrongSeed" << endl;
+	bytes seed = fromHex("badaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "test")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") != kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptWrongPassword)
+{
+	cout << "AesDecryptWrongPassword" << endl;
+	bytes seed = fromHex("2dbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	KeyPair kp(sha3(aesDecrypt(&seed, "badtest")));
+	BOOST_CHECK(Address("07746f871de684297923f933279555dda418f8a2") != kp.address());
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeed)
+{
+	cout << "AesDecryptFailInvalidSeed" << endl;
+	bytes seed = fromHex("xdbaead416c20cfd00c2fc9f1788ff9f965a2000799c96a624767cb0e1e90d2d7191efdd92349226742fdc73d1d87e2d597536c4641098b9a89836c94f58a2ab4c525c27c4cb848b3e22ea245b2bc5c8c7beaa900b0c479253fc96fce7ffc621");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeedSize)
+{
+	cout << "AesDecryptFailInvalidSeedSize" << endl;
+	bytes seed = fromHex("000102030405060708090a0b0c0d0e0f");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+
+BOOST_AUTO_TEST_CASE(AesDecryptFailInvalidSeed2)
+{
+	cout << "AesDecryptFailInvalidSeed2" << endl;
+	bytes seed = fromHex("000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f");
+	BOOST_CHECK(bytes() == aesDecrypt(&seed, "test"));
+}
+BOOST_AUTO_TEST_CASE(AuthenticatedStreamConstructor)
+{
+	cout << "AuthenticatedStreamConstructor" << endl;
+
+	Secret const sec("test");
+	crypto::aes::AuthenticatedStream as(crypto::aes::Encrypt, sec, 0);
+	BOOST_CHECK(as.getMacInterval() == 0);
+	as.adjustInterval(1);
+	BOOST_CHECK(as.getMacInterval() == 1);
+	crypto::aes::AuthenticatedStream as_mac(crypto::aes::Encrypt, h128(), h128(), 42);
+	BOOST_CHECK(as_mac.getMacInterval() == 42);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+

test/libdevcrypto/SecretStore.cpp

@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(basic_tests)
 
 	cnote << "Testing Key Store...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/basic_tests.json"));
+	string s = contentsString(testPath + "/basic_tests.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'KeyStoreTests/basic_tests.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 	for (auto& i: v.get_obj())

test/libdevcrypto/hexPrefix.cpp

@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(hexPrefix_test)
 
 	cnote << "Testing Hex-Prefix-Encode...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/hexencodetest.json"));
+	string s = contentsString(testPath + "/hexencodetest.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Content from 'hexencodetest.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 	for (auto& i: v.get_obj())

test/libdevcrypto/trie.cpp

@@ -82,7 +82,7 @@ BOOST_AUTO_TEST_CASE(hex_encoded_securetrie_test)
 
 	cnote << "Testing Secure Trie...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/hex_encoded_securetrie_test.json"));
+	string s = contentsString(testPath + "/hex_encoded_securetrie_test.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'hex_encoded_securetrie_test.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 	for (auto& i: v.get_obj())
@@ -149,7 +149,7 @@ BOOST_AUTO_TEST_CASE(trie_test_anyorder)
 
 	cnote << "Testing Trie...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/trieanyorder.json"));
+	string s = contentsString(testPath + "/trieanyorder.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'trieanyorder.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 	for (auto& i: v.get_obj())
@@ -216,7 +216,7 @@ BOOST_AUTO_TEST_CASE(trie_tests_ordered)
 
 	cnote << "Testing Trie...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/trietest.json"));
+	string s = contentsString(testPath + "/trietest.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'trietest.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 

test/libethcore/dagger.cpp

@@ -47,7 +47,7 @@ BOOST_AUTO_TEST_CASE(basic_test)
 
 	cnote << "Testing Proof of Work...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/ethash_tests.json"));
+	string s = contentsString(testPath + "/ethash_tests.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'ethash_tests.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);
 	for (auto& i: v.get_obj())

test/libethereum/StateTestsFiller/stPreCompiledContractsFiller.json

@@ -140,7 +140,7 @@
         "expect" : {
             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
                 "storage" : {
-                    "0x" : "0x3f17f1962b36e491b30a40b2405849e597ba5fb5",
+                    "0x" : "0x00",
                     "0x01" : "0x00",
                     "0x02" : "0x01"
                 }
@@ -226,7 +226,7 @@
         "expect" : {
             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
                 "storage" : {
-                    "0x" : "0x3f17f1962b36e491b30a40b2405849e597ba5fb5",
+                    "0x" : "0x00",
                     "0x01" : "0x00",
                     "0x02" : "0x01"
                 }
@@ -1946,7 +1946,7 @@
         "expect" : {
             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
                 "storage" : {
-                    "0x" : "0x3f17f1962b36e491b30a40b2405849e597ba5fb5",
+                    "0x" : "0x00",
                     "0x01" : "0x00",
                     "0x02" : "0x01"
                 }
@@ -2032,7 +2032,7 @@
         "expect" : {
             "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
                 "storage" : {
-                    "0x" : "0x3f17f1962b36e491b30a40b2405849e597ba5fb5",
+                    "0x" : "0x00",
                     "0x01" : "0x00",
                     "0x02" : "0x01"
                 }
@@ -3645,4 +3645,4 @@
             "data" : ""
         }
     }
-}
+}

test/libethereum/genesis.cpp

@@ -54,7 +54,7 @@ BOOST_AUTO_TEST_CASE(genesis_tests)
 
 	cnote << "Testing Genesis block...";
 	js::mValue v;
-	string s = asString(contents(testPath + "/genesishashestest.json"));
+	string s = contentsString(testPath + "/genesishashestest.json");
 	BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'genesishashestest.json' is empty. Have you cloned the 'tests' repo branch develop?");
 	js::read_string(s, v);