Browse Source
Conflicts: README.md libethereum/Instruction.cpp libethereum/Instruction.h libethereum/PeerNetwork.cppcl-refactor
Gav Wood
11 years ago
109 changed files with 7628 additions and 3789 deletions
@ -1,6 +0,0 @@ |
|||||
cpp-ethereum for Debian |
|
||||
----------------------- |
|
||||
|
|
||||
<possible notes regarding this package - if none, delete this file> |
|
||||
|
|
||||
-- Gav <Gav Wood <i@gavwood.com>> Mon, 03 Feb 2014 14:50:20 +0000 |
|
||||
@ -1,9 +0,0 @@ |
|||||
cpp-ethereum for Debian |
|
||||
----------------------- |
|
||||
|
|
||||
<this file describes information about the source package, see Debian policy |
|
||||
manual section 4.14. You WILL either need to modify or delete this file> |
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
@ -1,23 +0,0 @@ |
|||||
cpp-ethereum (0.1.0-1) saucy; urgency=low |
|
||||
|
|
||||
* Various improvements moving towards PoC-2. |
|
||||
|
|
||||
-- Ethereum (Ethereum Project) <ethereum@gavwood.com> Fri, 07 Feb 2014 00:48:26 +0000 |
|
||||
|
|
||||
cpp-ethereum (0.1-3) saucy; urgency=low |
|
||||
|
|
||||
* Packaging stuff. |
|
||||
|
|
||||
-- Ethereum (Ethereum Project) <ethereum@gavwood.com> Thu, 06 Feb 2014 14:13:00 +0000 |
|
||||
|
|
||||
cpp-ethereum (0.1-2) saucy; urgency=low |
|
||||
|
|
||||
* Fix Qt dep. |
|
||||
|
|
||||
-- Gav Wood <ethereum@gavwood.com> Mon, 06 Feb 2014 11:35:20 +0000 |
|
||||
|
|
||||
cpp-ethereum (0.1-1) saucy; urgency=low |
|
||||
|
|
||||
* Initial release. |
|
||||
|
|
||||
-- Gav Wood <ethereum@gavwood.com> Mon, 03 Feb 2014 14:50:20 +0000 |
|
||||
@ -1 +0,0 @@ |
|||||
8 |
|
||||
@ -1,29 +0,0 @@ |
|||||
Source: cpp-ethereum |
|
||||
Section: science |
|
||||
Priority: extra |
|
||||
Maintainer: Ethereum (Ethereum Project) <ethereum@gavwood.com> |
|
||||
Build-Depends: debhelper (>= 8.0.0), cmake, libgmp-dev, libboost-thread-dev, libcryptoppeth-dev, libboost-filesystem-dev, libboost-mpi-dev, libboost-dev, libleveldb-dev, libminiupnpc-dev, qtbase5-dev, qt5-default |
|
||||
Standards-Version: 3.9.4 |
|
||||
Homepage: http://ethereum.org |
|
||||
#Vcs-Git: git://git.debian.org/collab-maint/cpp-ethereum.git |
|
||||
#Vcs-Browser: http://git.debian.org/?p=collab-maint/cpp-ethereum.git;a=summary |
|
||||
|
|
||||
Package: libethereum |
|
||||
Section: libdevel |
|
||||
Architecture: any |
|
||||
Depends: ${shlibs:Depends}, ${misc:Depends} |
|
||||
Description: The future of computational social contracts. |
|
||||
A long description of libethereum. |
|
||||
|
|
||||
Package: libethereum-dev |
|
||||
Section: libdevel |
|
||||
Architecture: any |
|
||||
Depends: libethereum (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends} |
|
||||
Description: The future of computational social contracts. Dev Files. |
|
||||
A long description of libethereum. Dev Files. |
|
||||
|
|
||||
Package: alethzero |
|
||||
Architecture: any |
|
||||
Depends: ${shlibs:Depends}, ${misc:Depends}, libethereum (= ${binary:Version}) |
|
||||
Description: The Qt-based Ethereum GUI. |
|
||||
A long description of alethzero. |
|
||||
@ -1,24 +0,0 @@ |
|||||
Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ |
|
||||
Upstream-Name: cpp-ethereum |
|
||||
Source: github.com/ethereum/cpp-ethereum |
|
||||
|
|
||||
Files: * |
|
||||
Copyright: 2014 Gav Wood <i@gavwood.com> |
|
||||
License: MIT |
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|
||||
of this software and associated documentation files (the "Software"), to deal |
|
||||
in the Software without restriction, including without limitation the rights |
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
||||
copies of the Software, and to permit persons to whom the Software is |
|
||||
furnished to do so, subject to the following conditions: |
|
||||
|
|
||||
The above copyright notice and this permission notice shall be included in |
|
||||
all copies or substantial portions of the Software. |
|
||||
|
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
||||
THE SOFTWARE. |
|
||||
@ -1,3 +0,0 @@ |
|||||
CodingStandards.txt |
|
||||
README.md |
|
||||
TODO |
|
||||
@ -1,36 +0,0 @@ |
|||||
#!/usr/bin/make -f |
|
||||
# -*- makefile -*- |
|
||||
# Sample debian/rules that uses debhelper. |
|
||||
# |
|
||||
# This file was originally written by Joey Hess and Craig Small. |
|
||||
# As a special exception, when this file is copied by dh-make into a |
|
||||
# dh-make output file, you may use that output file without restriction. |
|
||||
# This special exception was added by Craig Small in version 0.37 of dh-make. |
|
||||
# |
|
||||
# Modified to make a template file for a multi-binary package with separated |
|
||||
# build-arch and build-indep targets by Bill Allombert 2001 |
|
||||
|
|
||||
# Uncomment this to turn on verbose mode. |
|
||||
#export DH_VERBOSE=1 |
|
||||
|
|
||||
# This has to be exported to make some magic below work. |
|
||||
export DH_OPTIONS |
|
||||
|
|
||||
|
|
||||
%: |
|
||||
dh $@ |
|
||||
|
|
||||
override_dh_auto_configure: |
|
||||
cmake -DCMAKE_INSTALL_PREFIX=$(CURDIR)/debian/libethereum-dev/usr . |
|
||||
|
|
||||
override_dh_auto_build: |
|
||||
$(MAKE) -j8 |
|
||||
|
|
||||
override_dh_auto_install: |
|
||||
$(MAKE) install |
|
||||
# Move the libs over to the non-dev package. |
|
||||
mkdir -p $(CURDIR)/debian/libethereum/usr |
|
||||
mv $(CURDIR)/debian/libethereum-dev/usr/lib $(CURDIR)/debian/libethereum/usr/lib |
|
||||
mkdir -p $(CURDIR)/debian/alethzero/usr/bin |
|
||||
mv $(CURDIR)/debian/libethereum-dev/usr/bin/alethzero $(CURDIR)/debian/alethzero/usr/bin |
|
||||
|
|
||||
@ -0,0 +1,48 @@ |
|||||
|
cmake_policy(SET CMP0015 NEW) |
||||
|
|
||||
|
aux_source_directory(. SRC_LIST) |
||||
|
|
||||
|
include_directories(../libethereum) |
||||
|
link_directories(../libethereum) |
||||
|
|
||||
|
add_executable(eth ${SRC_LIST}) |
||||
|
|
||||
|
if (${TARGET_PLATFORM} STREQUAL "w64") |
||||
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++") |
||||
|
target_link_libraries(eth gcc) |
||||
|
target_link_libraries(eth gdi32) |
||||
|
target_link_libraries(eth ws2_32) |
||||
|
target_link_libraries(eth mswsock) |
||||
|
target_link_libraries(eth shlwapi) |
||||
|
target_link_libraries(eth iphlpapi) |
||||
|
target_link_libraries(eth cryptopp) |
||||
|
target_link_libraries(eth ncurses) |
||||
|
target_link_libraries(eth form) |
||||
|
target_link_libraries(eth boost_system-mt-s) |
||||
|
target_link_libraries(eth boost_filesystem-mt-s) |
||||
|
target_link_libraries(eth boost_thread_win32-mt-s) |
||||
|
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS) |
||||
|
elseif (UNIX) |
||||
|
target_link_libraries(eth ncurses) |
||||
|
target_link_libraries(eth form) |
||||
|
else () |
||||
|
target_link_libraries(eth ${CRYPTOPP_LIBRARIES}) |
||||
|
target_link_libraries(eth boost_system) |
||||
|
target_link_libraries(eth boost_filesystem) |
||||
|
target_link_libraries(eth ncurses) |
||||
|
target_link_libraries(eth form) |
||||
|
find_package(Threads REQUIRED) |
||||
|
target_link_libraries(eth ${CMAKE_THREAD_LIBS_INIT}) |
||||
|
endif () |
||||
|
|
||||
|
if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") |
||||
|
include_directories(/usr/local/include) |
||||
|
endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") |
||||
|
|
||||
|
target_link_libraries(eth ethereum) |
||||
|
target_link_libraries(eth miniupnpc) |
||||
|
target_link_libraries(eth leveldb) |
||||
|
target_link_libraries(eth gmp) |
||||
|
|
||||
|
install( TARGETS eth DESTINATION bin ) |
||||
|
|
||||
File diff suppressed because it is too large
@ -0,0 +1,95 @@ |
|||||
|
/*
|
||||
|
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 Common.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "CommonData.h" |
||||
|
|
||||
|
#include <random> |
||||
|
#include "Exceptions.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
std::string eth::escaped(std::string const& _s, bool _all) |
||||
|
{ |
||||
|
std::string ret; |
||||
|
ret.reserve(_s.size()); |
||||
|
ret.push_back('"'); |
||||
|
for (auto i: _s) |
||||
|
if (i == '"' && !_all) |
||||
|
ret += "\\\""; |
||||
|
else if (i == '\\' && !_all) |
||||
|
ret += "\\\\"; |
||||
|
else if (i < ' ' || _all) |
||||
|
{ |
||||
|
ret += "\\x"; |
||||
|
ret.push_back("0123456789abcdef"[(uint8_t)i / 16]); |
||||
|
ret.push_back("0123456789abcdef"[(uint8_t)i % 16]); |
||||
|
} |
||||
|
else |
||||
|
ret.push_back(i); |
||||
|
ret.push_back('"'); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
std::string eth::randomWord() |
||||
|
{ |
||||
|
static std::mt19937_64 s_eng(0); |
||||
|
std::string ret(std::uniform_int_distribution<int>(4, 10)(s_eng), ' '); |
||||
|
char const n[] = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"; |
||||
|
std::uniform_int_distribution<int> d(0, sizeof(n) - 2); |
||||
|
for (char& c: ret) |
||||
|
c = n[d(s_eng)]; |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
int eth::fromHex(char _i) |
||||
|
{ |
||||
|
if (_i >= '0' && _i <= '9') |
||||
|
return _i - '0'; |
||||
|
if (_i >= 'a' && _i <= 'f') |
||||
|
return _i - 'a' + 10; |
||||
|
if (_i >= 'A' && _i <= 'F') |
||||
|
return _i - 'A' + 10; |
||||
|
throw BadHexCharacter(); |
||||
|
} |
||||
|
|
||||
|
bytes eth::fromHex(std::string const& _s) |
||||
|
{ |
||||
|
if (_s.size() % 2 || _s.size() < 2) |
||||
|
return bytes(); |
||||
|
uint s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0; |
||||
|
std::vector<uint8_t> ret; |
||||
|
ret.reserve((_s.size() - s) / 2); |
||||
|
for (uint i = s; i < _s.size(); i += 2) |
||||
|
ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1]))); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bytes eth::asNibbles(std::string const& _s) |
||||
|
{ |
||||
|
std::vector<uint8_t> ret; |
||||
|
ret.reserve(_s.size() * 2); |
||||
|
for (auto i: _s) |
||||
|
{ |
||||
|
ret.push_back(i / 16); |
||||
|
ret.push_back(i % 16); |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
@ -0,0 +1,195 @@ |
|||||
|
/*
|
||||
|
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 Common.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* Shared algorithms and data types. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <vector> |
||||
|
#include <algorithm> |
||||
|
#include <type_traits> |
||||
|
#include <cstring> |
||||
|
#include <string> |
||||
|
#include "Common.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
// String conversion functions, mainly to/from hex/nibble/byte representations.
|
||||
|
|
||||
|
/// Convert a series of bytes to the corresponding string of hex duplets.
|
||||
|
/// @param _w specifies the width of each of the elements. Defaults to two - enough to represent a byte.
|
||||
|
/// @example toHex("A\x69") == "4169"
|
||||
|
template <class _T> |
||||
|
std::string toHex(_T const& _data, int _w = 2) |
||||
|
{ |
||||
|
std::ostringstream ret; |
||||
|
for (auto i: _data) |
||||
|
ret << std::hex << std::setfill('0') << std::setw(_w) << (int)(typename std::make_unsigned<decltype(i)>::type)i; |
||||
|
return ret.str(); |
||||
|
} |
||||
|
|
||||
|
/// Converts a (printable) ASCII hex character into the correspnding integer value.
|
||||
|
/// @example fromHex('A') == 10 && fromHex('f') == 15 && fromHex('5') == 5
|
||||
|
int fromHex(char _i); |
||||
|
|
||||
|
/// Converts a (printable) ASCII hex string into the corresponding byte stream.
|
||||
|
/// @example fromHex("41626261") == asBytes("Abba")
|
||||
|
bytes fromHex(std::string const& _s); |
||||
|
|
||||
|
/// 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) |
||||
|
{ |
||||
|
return std::string((char const*)_b.data(), (char const*)(_b.data() + _b.size())); |
||||
|
} |
||||
|
|
||||
|
/// Converts a string to a byte array containing the string's (byte) data.
|
||||
|
inline bytes asBytes(std::string const& _b) |
||||
|
{ |
||||
|
return bytes((byte const*)_b.data(), (byte const*)(_b.data() + _b.size())); |
||||
|
} |
||||
|
|
||||
|
/// Converts a string into the big-endian base-16 stream of integers (NOT ASCII).
|
||||
|
/// @example asNibbles("A")[0] == 4 && asNibbles("A")[1] == 1
|
||||
|
bytes asNibbles(std::string const& _s); |
||||
|
|
||||
|
|
||||
|
// Big-endian to/from host endian conversion functions.
|
||||
|
|
||||
|
/// Converts a templated integer value to the big-endian byte-stream represented on a templated collection.
|
||||
|
/// The size of the collection object will be unchanged. If it is too small, it will not represent the
|
||||
|
/// value properly, if too big then the additional elements will be zeroed out.
|
||||
|
/// @a _Out will typically be either std::string or bytes.
|
||||
|
/// @a _T will typically by uint, u160, u256 or bigint.
|
||||
|
template <class _T, class _Out> |
||||
|
inline void toBigEndian(_T _val, _Out& o_out) |
||||
|
{ |
||||
|
for (auto i = o_out.size(); i-- != 0; _val >>= 8) |
||||
|
o_out[i] = (typename _Out::value_type)(uint8_t)_val; |
||||
|
} |
||||
|
|
||||
|
/// Converts a big-endian byte-stream represented on a templated collection to a templated integer value.
|
||||
|
/// @a _In will typically be either std::string or bytes.
|
||||
|
/// @a _T will typically by uint, u160, u256 or bigint.
|
||||
|
template <class _T, class _In> |
||||
|
inline _T fromBigEndian(_In const& _bytes) |
||||
|
{ |
||||
|
_T ret = 0; |
||||
|
for (auto i: _bytes) |
||||
|
ret = (ret << 8) | (byte)(typename std::make_unsigned<typename _In::value_type>::type)i; |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
/// Convenience functions for toBigEndian
|
||||
|
inline std::string toBigEndianString(u256 _val) { std::string ret(32, '\0'); toBigEndian(_val, ret); return ret; } |
||||
|
inline std::string toBigEndianString(u160 _val) { std::string ret(20, '\0'); toBigEndian(_val, ret); return ret; } |
||||
|
inline bytes toBigEndian(u256 _val) { bytes ret(32); toBigEndian(_val, ret); return ret; } |
||||
|
inline bytes toBigEndian(u160 _val) { bytes ret(20); toBigEndian(_val, ret); return ret; } |
||||
|
|
||||
|
/// Convenience function for toBigEndian.
|
||||
|
/// @returns a string just big enough to represent @a _val.
|
||||
|
template <class _T> |
||||
|
inline std::string toCompactBigEndianString(_T _val) |
||||
|
{ |
||||
|
int i = 0; |
||||
|
for (_T v = _val; v; ++i, v >>= 8) {} |
||||
|
std::string ret(i, '\0'); |
||||
|
toBigEndian(_val, ret); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Algorithms for string and string-like collections.
|
||||
|
|
||||
|
/// Escapes a string into the C-string representation.
|
||||
|
/// @p _all if true will escape all characters, not just the unprintable ones.
|
||||
|
std::string escaped(std::string const& _s, bool _all = true); |
||||
|
|
||||
|
/// Determines the length of the common prefix of the two collections given.
|
||||
|
/// @returns the number of elements both @a _t and @a _u share, in order, at the beginning.
|
||||
|
/// @example commonPrefix("Hello world!", "Hello, world!") == 5
|
||||
|
template <class _T, class _U> |
||||
|
uint commonPrefix(_T const& _t, _U const& _u) |
||||
|
{ |
||||
|
uint s = std::min<uint>(_t.size(), _u.size()); |
||||
|
for (uint i = 0;; ++i) |
||||
|
if (i == s || _t[i] != _u[i]) |
||||
|
return i; |
||||
|
return s; |
||||
|
} |
||||
|
|
||||
|
/// Creates a random, printable, word.
|
||||
|
std::string randomWord(); |
||||
|
|
||||
|
|
||||
|
// General datatype convenience functions.
|
||||
|
|
||||
|
/// Determine bytes required to encode the given integer value. @returns 0 if @a _i is zero.
|
||||
|
template <class _T> |
||||
|
inline uint bytesRequired(_T _i) |
||||
|
{ |
||||
|
uint i = 0; |
||||
|
for (; _i != 0; ++i, _i >>= 8) {} |
||||
|
return i; |
||||
|
} |
||||
|
|
||||
|
/// Trims a given number of elements from the front of a collection.
|
||||
|
/// Only works for POD element types.
|
||||
|
template <class _T> |
||||
|
void trimFront(_T& _t, uint _elements) |
||||
|
{ |
||||
|
static_assert(std::is_pod<typename _T::value_type>::value, ""); |
||||
|
memmove(_t.data(), _t.data() + _elements, (_t.size() - _elements) * sizeof(_t[0])); |
||||
|
_t.resize(_t.size() - _elements); |
||||
|
} |
||||
|
|
||||
|
/// Pushes an element on to the front of a collection.
|
||||
|
/// Only works for POD element types.
|
||||
|
template <class _T, class _U> |
||||
|
void pushFront(_T& _t, _U _e) |
||||
|
{ |
||||
|
static_assert(std::is_pod<typename _T::value_type>::value, ""); |
||||
|
_t.push_back(_e); |
||||
|
memmove(_t.data() + 1, _t.data(), (_t.size() - 1) * sizeof(_e)); |
||||
|
_t[0] = _e; |
||||
|
} |
||||
|
|
||||
|
/// Concatenate two vectors of elements. _T must be POD.
|
||||
|
template <class _T> |
||||
|
inline std::vector<_T>& operator+=(std::vector<typename std::enable_if<std::is_pod<_T>::value, _T>::type>& _a, std::vector<_T> const& _b) |
||||
|
{ |
||||
|
auto s = _a.size(); |
||||
|
_a.resize(_a.size() + _b.size()); |
||||
|
memcpy(_a.data() + s, _b.data(), _b.size() * sizeof(_T)); |
||||
|
return _a; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/// Concatenate two vectors of elements. _T must be POD.
|
||||
|
template <class _T> |
||||
|
inline std::vector<_T> operator+(std::vector<typename std::enable_if<std::is_pod<_T>::value, _T>::type> const& _a, std::vector<_T> const& _b) |
||||
|
{ |
||||
|
std::vector<_T> ret(_a); |
||||
|
return ret += _b; |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,189 @@ |
|||||
|
/*
|
||||
|
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 CommonEth.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "CommonEth.h" |
||||
|
#include "CryptoHeaders.h" |
||||
|
#include "Exceptions.h" |
||||
|
#include <random> |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
//#define ETH_ADDRESS_DEBUG 1
|
||||
|
|
||||
|
static const vector<pair<u256, string>> g_units = |
||||
|
{ |
||||
|
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Uether"}, |
||||
|
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Vether"}, |
||||
|
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Dether"}, |
||||
|
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Nether"}, |
||||
|
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Yether"}, |
||||
|
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Zether"}, |
||||
|
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000000, "Eether"}, |
||||
|
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000, "Pether"}, |
||||
|
{((u256(1000000000) * 1000000000) * 1000000000) * 1000, "Tether"}, |
||||
|
{(u256(1000000000) * 1000000000) * 1000000000, "Gether"}, |
||||
|
{(u256(1000000000) * 1000000000) * 1000000, "Mether"}, |
||||
|
{(u256(1000000000) * 1000000000) * 1000, "Kether"}, |
||||
|
{u256(1000000000) * 1000000000, "ether"}, |
||||
|
{u256(1000000000) * 1000000, "finney"}, |
||||
|
{u256(1000000000) * 1000, "szabo"}, |
||||
|
{u256(1000000000), "Gwei"}, |
||||
|
{u256(1000000), "Mwei"}, |
||||
|
{u256(1000), "Kwei"}, |
||||
|
{u256(1), "wei"} |
||||
|
}; |
||||
|
|
||||
|
vector<pair<u256, string>> const& eth::units() |
||||
|
{ |
||||
|
return g_units; |
||||
|
} |
||||
|
|
||||
|
std::string eth::formatBalance(u256 _b) |
||||
|
{ |
||||
|
ostringstream ret; |
||||
|
if (_b > g_units[0].first * 10000) |
||||
|
{ |
||||
|
ret << (_b / g_units[0].first) << " " << g_units[0].second; |
||||
|
return ret.str(); |
||||
|
} |
||||
|
ret << setprecision(5); |
||||
|
for (auto const& i: g_units) |
||||
|
if (i.first != 1 && _b >= i.first * 100) |
||||
|
{ |
||||
|
ret << (double(_b / (i.first / 1000)) / 1000.0) << " " << i.second; |
||||
|
return ret.str(); |
||||
|
} |
||||
|
ret << _b << " wei"; |
||||
|
return ret.str(); |
||||
|
} |
||||
|
|
||||
|
Address eth::toAddress(Secret _private) |
||||
|
{ |
||||
|
secp256k1_start(); |
||||
|
|
||||
|
byte pubkey[65]; |
||||
|
int pubkeylen = 65; |
||||
|
int ok = secp256k1_ecdsa_seckey_verify(_private.data()); |
||||
|
if (!ok) |
||||
|
return Address(); |
||||
|
ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _private.data(), 0); |
||||
|
assert(pubkeylen == 65); |
||||
|
if (!ok) |
||||
|
return Address(); |
||||
|
ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65); |
||||
|
if (!ok) |
||||
|
return Address(); |
||||
|
auto ret = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64))); |
||||
|
#if ETH_ADDRESS_DEBUG |
||||
|
cout << "---- ADDRESS -------------------------------" << endl; |
||||
|
cout << "SEC: " << _private << endl; |
||||
|
cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl; |
||||
|
cout << "ADR: " << ret << endl; |
||||
|
#endif |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
KeyPair KeyPair::create() |
||||
|
{ |
||||
|
secp256k1_start(); |
||||
|
static std::mt19937_64 s_eng(time(0)); |
||||
|
std::uniform_int_distribution<uint16_t> d(0, 255); |
||||
|
|
||||
|
for (int i = 0; i < 100; ++i) |
||||
|
{ |
||||
|
h256 sec; |
||||
|
for (unsigned i = 0; i < 32; ++i) |
||||
|
sec[i] = (byte)d(s_eng); |
||||
|
|
||||
|
KeyPair ret(sec); |
||||
|
if (ret.address()) |
||||
|
return ret; |
||||
|
} |
||||
|
return KeyPair(); |
||||
|
} |
||||
|
|
||||
|
KeyPair::KeyPair(h256 _sec): |
||||
|
m_secret(_sec) |
||||
|
{ |
||||
|
int ok = secp256k1_ecdsa_seckey_verify(m_secret.data()); |
||||
|
if (!ok) |
||||
|
return; |
||||
|
|
||||
|
byte pubkey[65]; |
||||
|
int pubkeylen = 65; |
||||
|
ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, m_secret.data(), 0); |
||||
|
if (!ok || pubkeylen != 65) |
||||
|
return; |
||||
|
|
||||
|
ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65); |
||||
|
if (!ok) |
||||
|
return; |
||||
|
|
||||
|
m_secret = m_secret; |
||||
|
memcpy(m_public.data(), &(pubkey[1]), 64); |
||||
|
m_address = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64))); |
||||
|
|
||||
|
#if ETH_ADDRESS_DEBUG |
||||
|
cout << "---- ADDRESS -------------------------------" << endl; |
||||
|
cout << "SEC: " << m_secret << endl; |
||||
|
cout << "PUB: " << m_public << endl; |
||||
|
cout << "ADR: " << m_address << endl; |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
std::string eth::sha3(std::string const& _input, bool _hex) |
||||
|
{ |
||||
|
if (!_hex) |
||||
|
{ |
||||
|
string ret(32, '\0'); |
||||
|
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)ret.data(), 32)); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
uint8_t buf[32]; |
||||
|
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)&(buf[0]), 32)); |
||||
|
std::string ret(64, '\0'); |
||||
|
for (unsigned int i = 0; i < 32; i++) |
||||
|
sprintf((char*)(ret.data())+i*2, "%02x", buf[i]); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void eth::sha3(bytesConstRef _input, bytesRef _output) |
||||
|
{ |
||||
|
CryptoPP::SHA3_256 ctx; |
||||
|
ctx.Update((byte*)_input.data(), _input.size()); |
||||
|
assert(_output.size() >= 32); |
||||
|
ctx.Final(_output.data()); |
||||
|
} |
||||
|
|
||||
|
bytes eth::sha3Bytes(bytesConstRef _input) |
||||
|
{ |
||||
|
bytes ret(32); |
||||
|
sha3(_input, &ret); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
h256 eth::sha3(bytesConstRef _input) |
||||
|
{ |
||||
|
h256 ret; |
||||
|
sha3(_input, bytesRef(&ret[0], 32)); |
||||
|
return ret; |
||||
|
} |
||||
@ -0,0 +1,137 @@ |
|||||
|
/*
|
||||
|
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 CommonEth.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* Ethereum-specific data structures & algorithms. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "Common.h" |
||||
|
#include "FixedHash.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
/// A secret key: 32 bytes.
|
||||
|
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
||||
|
using Secret = h256; |
||||
|
|
||||
|
/// A public key: 64 bytes.
|
||||
|
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
||||
|
using Public = h512; |
||||
|
|
||||
|
/// An Ethereum address: 20 bytes.
|
||||
|
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
||||
|
using Address = h160; |
||||
|
|
||||
|
/// A vector of Ethereum addresses.
|
||||
|
using Addresses = h160s; |
||||
|
|
||||
|
/// User-friendly string representation of the amount _b in wei.
|
||||
|
std::string formatBalance(u256 _b); |
||||
|
|
||||
|
/// Get information concerning the currency denominations.
|
||||
|
std::vector<std::pair<u256, std::string>> const& units(); |
||||
|
|
||||
|
// The various denominations; here for ease of use where needed within code.
|
||||
|
static const u256 Uether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000; |
||||
|
static const u256 Vether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000; |
||||
|
static const u256 Dether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000; |
||||
|
static const u256 Nether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000; |
||||
|
static const u256 Yether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000; |
||||
|
static const u256 Zether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000; |
||||
|
static const u256 Eether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000000000; |
||||
|
static const u256 Pether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000000; |
||||
|
static const u256 Tether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000; |
||||
|
static const u256 Gether = (u256(1000000000) * 1000000000) * 1000000000; |
||||
|
static const u256 Mether = (u256(1000000000) * 1000000000) * 1000000; |
||||
|
static const u256 Kether = (u256(1000000000) * 1000000000) * 1000; |
||||
|
static const u256 ether = u256(1000000000) * 1000000000; |
||||
|
static const u256 finney = u256(1000000000) * 1000000; |
||||
|
static const u256 szabo = u256(1000000000) * 1000; |
||||
|
static const u256 Gwei = u256(1000000000); |
||||
|
static const u256 Mwei = u256(1000000); |
||||
|
static const u256 Kwei = u256(1000); |
||||
|
static const u256 wei = u256(1); |
||||
|
|
||||
|
/// Convert a private key into the public key equivalent.
|
||||
|
/// @returns 0 if it's not a valid private key.
|
||||
|
Address toAddress(h256 _private); |
||||
|
|
||||
|
/// Simple class that represents a "key pair".
|
||||
|
/// All of the data of the class can be regenerated from the secret key (m_secret) alone.
|
||||
|
/// Actually stores a tuplet of secret, public and address (the right 160-bits of the public).
|
||||
|
class KeyPair |
||||
|
{ |
||||
|
public: |
||||
|
/// Null constructor.
|
||||
|
KeyPair() {} |
||||
|
|
||||
|
/// Normal constructor - populates object from the given secret key.
|
||||
|
KeyPair(Secret _k); |
||||
|
|
||||
|
/// Create a new, randomly generated object.
|
||||
|
static KeyPair create(); |
||||
|
|
||||
|
/// Retrieve the secret key.
|
||||
|
Secret const& secret() const { return m_secret; } |
||||
|
/// Retrieve the secret key.
|
||||
|
Secret const& sec() const { return m_secret; } |
||||
|
|
||||
|
/// Retrieve the public key.
|
||||
|
Public const& pub() const { return m_public; } |
||||
|
|
||||
|
/// Retrieve the associated address of the public key.
|
||||
|
Address const& address() const { return m_address; } |
||||
|
|
||||
|
private: |
||||
|
Secret m_secret; |
||||
|
Public m_public; |
||||
|
Address m_address; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// SHA-3 convenience routines.
|
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input and load it into the given output.
|
||||
|
void sha3(bytesConstRef _input, bytesRef _output); |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input, possibly interpreting it as nibbles, and return the hash as a string filled with binary data.
|
||||
|
std::string sha3(std::string const& _input, bool _isNibbles); |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input, returning as a byte array.
|
||||
|
bytes sha3Bytes(bytesConstRef _input); |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input (presented as a binary string), returning as a byte array.
|
||||
|
inline bytes sha3Bytes(std::string const& _input) { return sha3Bytes((std::string*)&_input); } |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input, returning as a byte array.
|
||||
|
inline bytes sha3Bytes(bytes const& _input) { return sha3Bytes((bytes*)&_input); } |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input, returning as a 256-bit hash.
|
||||
|
h256 sha3(bytesConstRef _input); |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input, returning as a 256-bit hash.
|
||||
|
inline h256 sha3(bytes const& _input) { return sha3(bytesConstRef((bytes*)&_input)); } |
||||
|
|
||||
|
/// Calculate SHA3-256 hash of the given input (presented as a binary-filled string), returning as a 256-bit hash.
|
||||
|
inline h256 sha3(std::string const& _input) { return sha3(bytesConstRef(_input)); } |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,48 @@ |
|||||
|
/*
|
||||
|
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 CommonIO.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "Common.h" |
||||
|
|
||||
|
#include <fstream> |
||||
|
#include "Exceptions.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
bytes eth::contents(std::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(); |
||||
|
is.seekg (0, is.beg); |
||||
|
bytes ret(length); |
||||
|
is.read((char*)ret.data(), length); |
||||
|
is.close(); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void eth::writeFile(std::string const& _file, bytes const& _data) |
||||
|
{ |
||||
|
ofstream(_file, ios::trunc).write((char const*)_data.data(), _data.size()); |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,223 @@ |
|||||
|
/*
|
||||
|
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 CommonIO.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* File & stream I/O routines. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <map> |
||||
|
#include <set> |
||||
|
#include <unordered_map> |
||||
|
#include <unordered_set> |
||||
|
#include <array> |
||||
|
#include <list> |
||||
|
#include <memory> |
||||
|
#include <vector> |
||||
|
#include <array> |
||||
|
#include <sstream> |
||||
|
#include <string> |
||||
|
#include <iostream> |
||||
|
#include "Common.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
/// Retrieve and returns the contents of the given file. If the file doesn't exist or isn't readable, returns an empty bytes.
|
||||
|
bytes contents(std::string const& _file); |
||||
|
|
||||
|
/// Write the given binary data into the given file, replacing the file if it pre-exists.
|
||||
|
void writeFile(std::string const& _file, bytes const& _data); |
||||
|
|
||||
|
/// Converts arbitrary value to string representation using std::stringstream.
|
||||
|
template <class _T> |
||||
|
std::string toString(_T const& _t) |
||||
|
{ |
||||
|
std::ostringstream o; |
||||
|
o << _t; |
||||
|
return o.str(); |
||||
|
} |
||||
|
|
||||
|
// Stream I/O functions.
|
||||
|
// Provides templated stream I/O for all STL collections so they can be shifted on to any iostream-like interface.
|
||||
|
|
||||
|
template <class S, class T> struct StreamOut { static S& bypass(S& _out, T const& _t) { _out << _t; return _out; } }; |
||||
|
template <class S> struct StreamOut<S, uint8_t> { static S& bypass(S& _out, uint8_t const& _t) { _out << (int)_t; return _out; } }; |
||||
|
|
||||
|
template <class S, class T> |
||||
|
inline S& streamout(S& _out, std::vector<T> const& _e) |
||||
|
{ |
||||
|
_out << "["; |
||||
|
if (!_e.empty()) |
||||
|
{ |
||||
|
StreamOut<S, T>::bypass(_out, _e.front()); |
||||
|
for (auto i = ++_e.begin(); i != _e.end(); ++i) |
||||
|
StreamOut<S, T>::bypass(_out << ",", *i); |
||||
|
} |
||||
|
_out << "]"; |
||||
|
return _out; |
||||
|
} |
||||
|
|
||||
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::vector<T> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, unsigned Z> |
||||
|
inline S& streamout(S& _out, std::array<T, Z> const& _e) |
||||
|
{ |
||||
|
_out << "["; |
||||
|
if (!_e.empty()) |
||||
|
{ |
||||
|
StreamOut<S, T>::bypass(_out, _e.front()); |
||||
|
auto i = _e.begin(); |
||||
|
for (++i; i != _e.end(); ++i) |
||||
|
StreamOut<S, T>::bypass(_out << ",", *i); |
||||
|
} |
||||
|
_out << "]"; |
||||
|
return _out; |
||||
|
} |
||||
|
template <class T, unsigned Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, unsigned long Z> |
||||
|
inline S& streamout(S& _out, std::array<T, Z> const& _e) |
||||
|
{ |
||||
|
_out << "["; |
||||
|
if (!_e.empty()) |
||||
|
{ |
||||
|
StreamOut<S, T>::bypass(_out, _e.front()); |
||||
|
auto i = _e.begin(); |
||||
|
for (++i; i != _e.end(); ++i) |
||||
|
StreamOut<S, T>::bypass(_out << ",", *i); |
||||
|
} |
||||
|
_out << "]"; |
||||
|
return _out; |
||||
|
} |
||||
|
template <class T, unsigned long Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T> |
||||
|
inline S& streamout(S& _out, std::list<T> const& _e) |
||||
|
{ |
||||
|
_out << "["; |
||||
|
if (!_e.empty()) |
||||
|
{ |
||||
|
_out << _e.front(); |
||||
|
for (auto i = ++_e.begin(); i != _e.end(); ++i) |
||||
|
_out << "," << *i; |
||||
|
} |
||||
|
_out << "]"; |
||||
|
return _out; |
||||
|
} |
||||
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::list<T> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, class U> |
||||
|
inline S& streamout(S& _out, std::pair<T, U> const& _e) |
||||
|
{ |
||||
|
_out << "(" << _e.first << "," << _e.second << ")"; |
||||
|
return _out; |
||||
|
} |
||||
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::pair<T, U> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T1, class T2, class T3> |
||||
|
inline S& streamout(S& _out, std::tuple<T1, T2, T3> const& _t) |
||||
|
{ |
||||
|
_out << "(" << std::get<0>(_t) << "," << std::get<1>(_t) << "," << std::get<2>(_t) << ")"; |
||||
|
return _out; |
||||
|
} |
||||
|
template <class T1, class T2, class T3> inline std::ostream& operator<<(std::ostream& _out, std::tuple<T1, T2, T3> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, class U> |
||||
|
S& streamout(S& _out, std::map<T, U> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::map<T, U> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, class U> |
||||
|
S& streamout(S& _out, std::unordered_map<T, U> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::unordered_map<T, U> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T> |
||||
|
S& streamout(S& _out, std::set<T> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
_out << (!(i++) ? "{ " : ", ") << p; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::set<T> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T> |
||||
|
S& streamout(S& _out, std::unordered_set<T> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
_out << (!(i++) ? "{ " : ", ") << p; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::unordered_set<T> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T> |
||||
|
S& streamout(S& _out, std::multiset<T> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
_out << (!(i++) ? "{ " : ", ") << p; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::multiset<T> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class S, class T, class U> |
||||
|
S& streamout(S& _out, std::multimap<T, U> const& _v) |
||||
|
{ |
||||
|
if (_v.empty()) |
||||
|
return _out << "{}"; |
||||
|
T l; |
||||
|
int i = 0; |
||||
|
for (auto p: _v) |
||||
|
if (!(i++)) |
||||
|
_out << "{ " << (l = p.first) << " => " << p.second; |
||||
|
else if (l == p.first) |
||||
|
_out << ", " << p.second; |
||||
|
else |
||||
|
_out << "; " << (l = p.first) << " => " << p.second; |
||||
|
return _out << " }"; |
||||
|
} |
||||
|
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::multimap<T, U> const& _e) { streamout(_out, _e); return _out; } |
||||
|
|
||||
|
template <class _S, class _T> _S& operator<<(_S& _out, std::shared_ptr<_T> const& _p) { if (_p) _out << "@" << (*_p); else _out << "nullptr"; return _out; } |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,36 @@ |
|||||
|
/*
|
||||
|
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 CryptoHeaders.h
|
||||
|
* @author Tim Hughes <tim@twistedfury.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
#pragma once |
||||
|
|
||||
|
// need to leave this one disabled
|
||||
|
#pragma GCC diagnostic ignored "-Wunused-function" |
||||
|
|
||||
|
#pragma warning(push) |
||||
|
#pragma warning(disable:4100 4244) |
||||
|
#pragma GCC diagnostic push |
||||
|
#pragma GCC diagnostic ignored "-Wconversion" |
||||
|
#pragma GCC diagnostic ignored "-Wunused-parameter" |
||||
|
#include <sha.h> |
||||
|
#include <sha3.h> |
||||
|
#include <ripemd.h> |
||||
|
#include <secp256k1.h> |
||||
|
#pragma warning(pop) |
||||
|
#pragma GCC diagnostic pop |
||||
@ -0,0 +1,25 @@ |
|||||
|
/*
|
||||
|
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 FixedHash.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "FixedHash.h" |
||||
|
|
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
@ -0,0 +1,195 @@ |
|||||
|
/*
|
||||
|
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 FixedHash.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* The FixedHash fixed-size "hash" container type. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <array> |
||||
|
#include <algorithm> |
||||
|
#include "CommonData.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
/// Fixed-size raw-byte array container type, with an API optimised for storing hashes.
|
||||
|
/// Transparently converts to/from the corresponding arithmetic type; this will
|
||||
|
/// assume the data contained in the hash is big-endian.
|
||||
|
template <unsigned N> |
||||
|
class FixedHash |
||||
|
{ |
||||
|
/// The corresponding arithmetic type.
|
||||
|
using Arith = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>; |
||||
|
|
||||
|
public: |
||||
|
/// The size of the container.
|
||||
|
enum { size = N }; |
||||
|
|
||||
|
/// A dummy flag to avoid accidental construction from pointer.
|
||||
|
enum ConstructFromPointerType { ConstructFromPointer }; |
||||
|
|
||||
|
/// Method to convert from a string.
|
||||
|
enum ConstructFromStringType { FromHex, FromBinary }; |
||||
|
|
||||
|
/// Construct an empty hash.
|
||||
|
FixedHash() { m_data.fill(0); } |
||||
|
|
||||
|
/// Convert from the corresponding arithmetic type.
|
||||
|
FixedHash(Arith const& _arith) { toBigEndian(_arith, m_data); } |
||||
|
|
||||
|
/// Explicitly construct, copying from a byte array.
|
||||
|
explicit FixedHash(bytes const& _b) { if (_b.size() == N) memcpy(m_data.data(), _b.data(), std::min<uint>(_b.size(), N)); } |
||||
|
|
||||
|
/// Explicitly construct, copying from a bytes in memory with given pointer.
|
||||
|
explicit FixedHash(byte const* _bs, ConstructFromPointerType) { memcpy(m_data.data(), _bs, N); } |
||||
|
|
||||
|
/// Explicitly construct, copying from a string.
|
||||
|
explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex): FixedHash(_t == FromHex ? fromHex(_s) : eth::asBytes(_s)) {} |
||||
|
|
||||
|
/// Convert to arithmetic type.
|
||||
|
operator Arith() const { return fromBigEndian<Arith>(m_data); } |
||||
|
|
||||
|
/// @returns true iff this is the empty hash.
|
||||
|
operator bool() const { return ((Arith)*this) != 0; } |
||||
|
|
||||
|
// The obvious comparison operators.
|
||||
|
bool operator==(FixedHash const& _c) const { return m_data == _c.m_data; } |
||||
|
bool operator!=(FixedHash const& _c) const { return m_data != _c.m_data; } |
||||
|
bool operator<(FixedHash const& _c) const { return m_data < _c.m_data; } |
||||
|
|
||||
|
// The obvious binary operators.
|
||||
|
FixedHash& operator^=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] ^= _c.m_data[i]; return *this; } |
||||
|
FixedHash operator^(FixedHash const& _c) const { return FixedHash(*this) ^= _c; } |
||||
|
FixedHash& operator|=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] |= _c.m_data[i]; return *this; } |
||||
|
FixedHash operator|(FixedHash const& _c) const { return FixedHash(*this) |= _c; } |
||||
|
FixedHash& operator&=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] &= _c.m_data[i]; return *this; } |
||||
|
FixedHash operator&(FixedHash const& _c) const { return FixedHash(*this) &= _c; } |
||||
|
FixedHash& operator~() { for (auto i = 0; i < N; ++i) m_data[i] = ~m_data[i]; return *this; } |
||||
|
|
||||
|
/// @returns a particular byte from the hash.
|
||||
|
byte& operator[](unsigned _i) { return m_data[_i]; } |
||||
|
/// @returns a particular byte from the hash.
|
||||
|
byte operator[](unsigned _i) const { return m_data[_i]; } |
||||
|
|
||||
|
/// @returns an abridged version of the hash as a user-readable hex string.
|
||||
|
std::string abridged() const { return toHex(ref().cropped(0, 4)) + ".."; } |
||||
|
|
||||
|
/// @returns a mutable byte vector_ref to the object's data.
|
||||
|
bytesRef ref() { return bytesRef(m_data.data(), N); } |
||||
|
|
||||
|
/// @returns a constant byte vector_ref to the object's data.
|
||||
|
bytesConstRef ref() const { return bytesConstRef(m_data.data(), N); } |
||||
|
|
||||
|
/// @returns a mutable byte pointer to the object's data.
|
||||
|
byte* data() { return m_data.data(); } |
||||
|
|
||||
|
/// @returns a constant byte pointer to the object's data.
|
||||
|
byte const* data() const { return m_data.data(); } |
||||
|
|
||||
|
/// @returns a copy of the object's data as a byte vector.
|
||||
|
bytes asBytes() const { return bytes(data(), data() + N); } |
||||
|
|
||||
|
/// @returns a mutable reference to the object's data as an STL array.
|
||||
|
std::array<byte, N>& asArray() { return m_data; } |
||||
|
|
||||
|
/// @returns a constant reference to the object's data as an STL array.
|
||||
|
std::array<byte, N> const& asArray() const { return m_data; } |
||||
|
|
||||
|
/// A generic std::hash compatible function object.
|
||||
|
struct hash |
||||
|
{ |
||||
|
/// Make a hash of the object's data.
|
||||
|
size_t operator()(FixedHash const& value) const |
||||
|
{ |
||||
|
size_t h = 0; |
||||
|
for (auto i: value.m_data) |
||||
|
h = (h << (5 - h)) + i; |
||||
|
return h; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
private: |
||||
|
std::array<byte, N> m_data; ///< The binary data.
|
||||
|
}; |
||||
|
|
||||
|
|
||||
|
/// Fast equality operator for h256.
|
||||
|
template<> inline bool FixedHash<32>::operator==(FixedHash<32> const& _other) const |
||||
|
{ |
||||
|
const uint64_t* hash1 = (const uint64_t*)this->data(); |
||||
|
const uint64_t* hash2 = (const uint64_t*)_other.data(); |
||||
|
return (hash1[0] == hash2[0]) && (hash1[1] == hash2[1]) && (hash1[2] == hash2[2]) && (hash1[3] == hash2[3]); |
||||
|
} |
||||
|
|
||||
|
/// Fast std::hash compatible hash function object for h256.
|
||||
|
template<> inline size_t FixedHash<32>::hash::operator()(FixedHash<32> const& value) const |
||||
|
{ |
||||
|
const uint64_t*data = (const uint64_t*)value.data(); |
||||
|
uint64_t hash = data[0]; |
||||
|
hash ^= data[1]; |
||||
|
hash ^= data[2]; |
||||
|
hash ^= data[3]; |
||||
|
return (size_t)hash; |
||||
|
} |
||||
|
|
||||
|
/// Stream I/O for the FixedHash class.
|
||||
|
template <unsigned N> |
||||
|
inline std::ostream& operator<<(std::ostream& _out, FixedHash<N> const& _h) |
||||
|
{ |
||||
|
_out << std::noshowbase << std::hex << std::setfill('0'); |
||||
|
for (unsigned i = 0; i < N; ++i) |
||||
|
_out << std::setw(2) << (int)_h[i]; |
||||
|
_out << std::dec; |
||||
|
return _out; |
||||
|
} |
||||
|
|
||||
|
// Common types of FixedHash.
|
||||
|
using h512 = FixedHash<64>; |
||||
|
using h256 = FixedHash<32>; |
||||
|
using h160 = FixedHash<20>; |
||||
|
using h256s = std::vector<h256>; |
||||
|
using h160s = std::vector<h160>; |
||||
|
using h256Set = std::set<h256>; |
||||
|
using h160Set = std::set<h160>; |
||||
|
|
||||
|
/// Convert the given value into h160 (160-bit unsigned integer) using the right 20 bytes.
|
||||
|
inline h160 right160(h256 const& _t) |
||||
|
{ |
||||
|
h160 ret; |
||||
|
memcpy(ret.data(), _t.data() + 12, 20); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
/// Convert the given value into h160 (160-bit unsigned integer) using the left 20 bytes.
|
||||
|
inline h160 left160(h256 const& _t) |
||||
|
{ |
||||
|
h160 ret; |
||||
|
memcpy(&ret[0], _t.data(), 20); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
namespace std |
||||
|
{ |
||||
|
/// Forward std::hash<eth::h256> to eth::h256::hash.
|
||||
|
template<> struct hash<eth::h256>: eth::h256::hash {}; |
||||
|
} |
||||
File diff suppressed because it is too large
@ -0,0 +1,54 @@ |
|||||
|
/*
|
||||
|
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 Log.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "Log.h" |
||||
|
|
||||
|
#include <string> |
||||
|
#include <iostream> |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
// Logging
|
||||
|
int eth::g_logVerbosity = 8; |
||||
|
map<type_info const*, bool> eth::g_logOverride; |
||||
|
|
||||
|
ThreadLocalLogName eth::t_logThreadName("main"); |
||||
|
|
||||
|
// foward declare without all of Windows.h
|
||||
|
#ifdef _WIN32 |
||||
|
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char* lpOutputString); |
||||
|
#endif |
||||
|
|
||||
|
void eth::simpleDebugOut(std::string const& _s, char const*) |
||||
|
{ |
||||
|
cout << _s << endl << flush; |
||||
|
|
||||
|
// helpful to use OutputDebugString on windows
|
||||
|
#ifdef _WIN32 |
||||
|
{ |
||||
|
OutputDebugStringA(_s.data()); |
||||
|
OutputDebugStringA("\n"); |
||||
|
} |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
std::function<void(std::string const&, char const*)> eth::g_logPost = simpleDebugOut; |
||||
|
|
||||
@ -0,0 +1,134 @@ |
|||||
|
/*
|
||||
|
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 Log.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* The logging subsystem. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <ctime> |
||||
|
#include <chrono> |
||||
|
#include <boost/thread.hpp> |
||||
|
#include "vector_ref.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
/// The null output stream. Used when logging is disabled.
|
||||
|
class NullOutputStream |
||||
|
{ |
||||
|
public: |
||||
|
template <class T> NullOutputStream& operator<<(T const&) { return *this; } |
||||
|
}; |
||||
|
|
||||
|
/// A simple log-output function that prints log messages to stdout.
|
||||
|
void simpleDebugOut(std::string const&, char const* ); |
||||
|
|
||||
|
/// The logging system's current verbosity.
|
||||
|
extern int g_logVerbosity; |
||||
|
|
||||
|
/// The current method that the logging system uses to output the log messages. Defaults to simpleDebugOut().
|
||||
|
extern std::function<void(std::string const&, char const*)> g_logPost; |
||||
|
|
||||
|
/// Map of Log Channel types to bool, false forces the channel to be disabled, true forces it to be enabled.
|
||||
|
/// If a channel has no entry, then it will output as long as its verbosity (LogChannel::verbosity) is less than
|
||||
|
/// or equal to the currently output verbosity (g_logVerbosity).
|
||||
|
extern std::map<std::type_info const*, bool> g_logOverride; |
||||
|
|
||||
|
/// Associate a name with each thread for nice logging.
|
||||
|
struct ThreadLocalLogName |
||||
|
{ |
||||
|
ThreadLocalLogName(std::string _name) { m_name.reset(new std::string(_name)); }; |
||||
|
boost::thread_specific_ptr<std::string> m_name; |
||||
|
}; |
||||
|
|
||||
|
/// The current thread's name.
|
||||
|
extern ThreadLocalLogName t_logThreadName; |
||||
|
|
||||
|
/// Set the current thread's log name.
|
||||
|
inline void setThreadName(char const* _n) { t_logThreadName.m_name.reset(new std::string(_n)); } |
||||
|
|
||||
|
/// The default logging channels. Each has an associated verbosity and three-letter prefix (name() ).
|
||||
|
/// Channels should inherit from LogChannel and define name() and verbosity.
|
||||
|
struct LogChannel { static const char* name() { return " "; } static const int verbosity = 1; }; |
||||
|
struct LeftChannel: public LogChannel { static const char* name() { return "<<<"; } }; |
||||
|
struct RightChannel: public LogChannel { static const char* name() { return ">>>"; } }; |
||||
|
struct WarnChannel: public LogChannel { static const char* name() { return "!!!"; } static const int verbosity = 0; }; |
||||
|
struct NoteChannel: public LogChannel { static const char* name() { return "***"; } }; |
||||
|
struct DebugChannel: public LogChannel { static const char* name() { return "---"; } static const int verbosity = 0; }; |
||||
|
|
||||
|
/// Logging class, iostream-like, that can be shifted to.
|
||||
|
template <class Id, bool _AutoSpacing = true> |
||||
|
class LogOutputStream |
||||
|
{ |
||||
|
public: |
||||
|
/// Construct a new object.
|
||||
|
/// If _term is true the the prefix info is terminated with a ']' character; if not it ends only with a '|' character.
|
||||
|
LogOutputStream(bool _term = true) |
||||
|
{ |
||||
|
std::type_info const* i = &typeid(Id); |
||||
|
auto it = g_logOverride.find(i); |
||||
|
if ((it != g_logOverride.end() && it->second == true) || (it == g_logOverride.end() && Id::verbosity <= g_logVerbosity)) |
||||
|
{ |
||||
|
time_t rawTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); |
||||
|
char buf[24]; |
||||
|
if (strftime(buf, 24, "%X", localtime(&rawTime)) == 0) |
||||
|
buf[0] = '\0'; // empty if case strftime fails
|
||||
|
m_sstr << Id::name() << " [ " << buf << " | " << *(t_logThreadName.m_name.get()) << (_term ? " ] " : ""); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// Destructor. Posts the accrued log entry to the g_logPost function.
|
||||
|
~LogOutputStream() { if (Id::verbosity <= g_logVerbosity) g_logPost(m_sstr.str(), Id::name()); } |
||||
|
|
||||
|
/// Shift arbitrary data to the log. Spaces will be added between items as required.
|
||||
|
template <class T> LogOutputStream& operator<<(T const& _t) { if (Id::verbosity <= g_logVerbosity) { if (_AutoSpacing && m_sstr.str().size() && m_sstr.str().back() != ' ') m_sstr << " "; m_sstr << _t; } return *this; } |
||||
|
|
||||
|
private: |
||||
|
std::stringstream m_sstr; ///< The accrued log entry.
|
||||
|
}; |
||||
|
|
||||
|
// Simple cout-like stream objects for accessing common log channels.
|
||||
|
// Dirties the global namespace, but oh so convenient...
|
||||
|
#define cnote eth::LogOutputStream<eth::NoteChannel, true>() |
||||
|
#define cwarn eth::LogOutputStream<eth::WarnChannel, true>() |
||||
|
|
||||
|
// Null stream-like objects.
|
||||
|
#define ndebug if (true) {} else eth::NullOutputStream() |
||||
|
#define nlog(X) if (true) {} else eth::NullOutputStream() |
||||
|
#define nslog(X) if (true) {} else eth::NullOutputStream() |
||||
|
|
||||
|
// Kill debugging log channel when we're in release mode.
|
||||
|
#if NDEBUG |
||||
|
#define cdebug ndebug |
||||
|
#else |
||||
|
#define cdebug eth::LogOutputStream<eth::DebugChannel, true>() |
||||
|
#endif |
||||
|
|
||||
|
// Kill all logs when when NLOG is defined.
|
||||
|
#if NLOG |
||||
|
#define clog(X) nlog(X) |
||||
|
#define cslog(X) nslog(X) |
||||
|
#else |
||||
|
#define clog(X) eth::LogOutputStream<X, true>() |
||||
|
#define cslog(X) eth::LogOutputStream<X, false>() |
||||
|
#endif |
||||
|
|
||||
|
} |
||||
File diff suppressed because it is too large
@ -0,0 +1,562 @@ |
|||||
|
/*
|
||||
|
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 PeerNetwork.cpp
|
||||
|
* @authors: |
||||
|
* Gav Wood <i@gavwood.com> |
||||
|
* Eric Lombrozo <elombrozo@gmail.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "PeerServer.h" |
||||
|
|
||||
|
#include <sys/types.h> |
||||
|
#ifdef _WIN32 |
||||
|
// winsock is already included
|
||||
|
// #include <winsock.h>
|
||||
|
#else |
||||
|
#include <ifaddrs.h> |
||||
|
#endif |
||||
|
|
||||
|
#include <set> |
||||
|
#include <chrono> |
||||
|
#include <thread> |
||||
|
#include "Exceptions.h" |
||||
|
#include "Common.h" |
||||
|
#include "BlockChain.h" |
||||
|
#include "BlockInfo.h" |
||||
|
#include "TransactionQueue.h" |
||||
|
#include "UPnP.h" |
||||
|
#include "PeerSession.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
// Addresses we will skip during network interface discovery
|
||||
|
// Use a vector as the list is small
|
||||
|
// Why this and not names?
|
||||
|
// Under MacOSX loopback (127.0.0.1) can be named lo0 and br0 are bridges (0.0.0.0)
|
||||
|
static const set<bi::address> c_rejectAddresses = { |
||||
|
{bi::address_v4::from_string("127.0.0.1")}, |
||||
|
{bi::address_v6::from_string("::1")}, |
||||
|
{bi::address_v4::from_string("0.0.0.0")}, |
||||
|
{bi::address_v6::from_string("::")} |
||||
|
}; |
||||
|
|
||||
|
PeerServer::PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, unsigned short _port, NodeMode _m, string const& _publicAddress, bool _upnp): |
||||
|
m_clientVersion(_clientVersion), |
||||
|
m_mode(_m), |
||||
|
m_listenPort(_port), |
||||
|
m_chain(&_ch), |
||||
|
m_acceptor(m_ioService, bi::tcp::endpoint(bi::tcp::v4(), _port)), |
||||
|
m_socket(m_ioService), |
||||
|
m_key(KeyPair::create()), |
||||
|
m_networkId(_networkId) |
||||
|
{ |
||||
|
populateAddresses(); |
||||
|
determinePublic(_publicAddress, _upnp); |
||||
|
ensureAccepting(); |
||||
|
clog(NetNote) << "Id:" << toHex(m_key.address().ref().cropped(0, 4)) << "Mode: " << (_m == NodeMode::PeerServer ? "PeerServer" : "Full"); |
||||
|
} |
||||
|
|
||||
|
PeerServer::PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, NodeMode _m, string const& _publicAddress, bool _upnp): |
||||
|
m_clientVersion(_clientVersion), |
||||
|
m_mode(_m), |
||||
|
m_listenPort(0), |
||||
|
m_chain(&_ch), |
||||
|
m_acceptor(m_ioService, bi::tcp::endpoint(bi::tcp::v4(), 0)), |
||||
|
m_socket(m_ioService), |
||||
|
m_key(KeyPair::create()), |
||||
|
m_networkId(_networkId) |
||||
|
{ |
||||
|
m_listenPort = m_acceptor.local_endpoint().port(); |
||||
|
|
||||
|
// populate addresses.
|
||||
|
populateAddresses(); |
||||
|
determinePublic(_publicAddress, _upnp); |
||||
|
ensureAccepting(); |
||||
|
clog(NetNote) << "Id:" << toHex(m_key.address().ref().cropped(0, 4)) << "Mode: " << (m_mode == NodeMode::PeerServer ? "PeerServer" : "Full"); |
||||
|
} |
||||
|
|
||||
|
PeerServer::PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, NodeMode _m): |
||||
|
m_clientVersion(_clientVersion), |
||||
|
m_mode(_m), |
||||
|
m_listenPort(0), |
||||
|
m_chain(&_ch), |
||||
|
m_acceptor(m_ioService, bi::tcp::endpoint(bi::tcp::v4(), 0)), |
||||
|
m_socket(m_ioService), |
||||
|
m_key(KeyPair::create()), |
||||
|
m_networkId(_networkId) |
||||
|
{ |
||||
|
// populate addresses.
|
||||
|
populateAddresses(); |
||||
|
clog(NetNote) << "Id:" << toHex(m_key.address().ref().cropped(0, 4)) << "Mode: " << (m_mode == NodeMode::PeerServer ? "PeerServer" : "Full"); |
||||
|
} |
||||
|
|
||||
|
PeerServer::~PeerServer() |
||||
|
{ |
||||
|
for (auto const& i: m_peers) |
||||
|
if (auto p = i.second.lock()) |
||||
|
p->disconnect(ClientQuit); |
||||
|
delete m_upnp; |
||||
|
} |
||||
|
|
||||
|
unsigned PeerServer::protocolVersion() |
||||
|
{ |
||||
|
return 11; |
||||
|
} |
||||
|
|
||||
|
void PeerServer::determinePublic(string const& _publicAddress, bool _upnp) |
||||
|
{ |
||||
|
if (_upnp) |
||||
|
try |
||||
|
{ |
||||
|
m_upnp = new UPnP; |
||||
|
} |
||||
|
catch (NoUPnPDevice) {} // let m_upnp continue as null - we handle it properly.
|
||||
|
|
||||
|
bi::tcp::resolver r(m_ioService); |
||||
|
if (m_upnp && m_upnp->isValid() && m_peerAddresses.size()) |
||||
|
{ |
||||
|
clog(NetNote) << "External addr: " << m_upnp->externalIP(); |
||||
|
int p = m_upnp->addRedirect(m_peerAddresses[0].to_string().c_str(), m_listenPort); |
||||
|
if (p) |
||||
|
clog(NetNote) << "Punched through NAT and mapped local port" << m_listenPort << "onto external port" << p << "."; |
||||
|
else |
||||
|
{ |
||||
|
// couldn't map
|
||||
|
clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place). Assuming " << m_listenPort << " is local & external port."; |
||||
|
p = m_listenPort; |
||||
|
} |
||||
|
|
||||
|
auto eip = m_upnp->externalIP(); |
||||
|
if (eip == string("0.0.0.0") && _publicAddress.empty()) |
||||
|
m_public = bi::tcp::endpoint(bi::address(), (unsigned short)p); |
||||
|
else |
||||
|
{ |
||||
|
m_public = bi::tcp::endpoint(bi::address::from_string(_publicAddress.empty() ? eip : _publicAddress), (unsigned short)p); |
||||
|
m_addresses.push_back(m_public.address().to_v4()); |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// No UPnP - fallback on given public address or, if empty, the assumed peer address.
|
||||
|
m_public = bi::tcp::endpoint(_publicAddress.size() ? bi::address::from_string(_publicAddress) |
||||
|
: m_peerAddresses.size() ? m_peerAddresses[0] |
||||
|
: bi::address(), m_listenPort); |
||||
|
m_addresses.push_back(m_public.address().to_v4()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void PeerServer::populateAddresses() |
||||
|
{ |
||||
|
#ifdef _WIN32 |
||||
|
WSAData wsaData; |
||||
|
if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) |
||||
|
throw NoNetworking(); |
||||
|
|
||||
|
char ac[80]; |
||||
|
if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) |
||||
|
{ |
||||
|
clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name."; |
||||
|
WSACleanup(); |
||||
|
throw NoNetworking(); |
||||
|
} |
||||
|
|
||||
|
struct hostent* phe = gethostbyname(ac); |
||||
|
if (phe == 0) |
||||
|
{ |
||||
|
clog(NetWarn) << "Bad host lookup."; |
||||
|
WSACleanup(); |
||||
|
throw NoNetworking(); |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; phe->h_addr_list[i] != 0; ++i) |
||||
|
{ |
||||
|
struct in_addr addr; |
||||
|
memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr)); |
||||
|
char *addrStr = inet_ntoa(addr); |
||||
|
bi::address ad(bi::address::from_string(addrStr)); |
||||
|
m_addresses.push_back(ad.to_v4()); |
||||
|
bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end(); |
||||
|
if (!isLocal) |
||||
|
m_peerAddresses.push_back(ad.to_v4()); |
||||
|
clog(NetNote) << "Address: " << ac << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]"); |
||||
|
} |
||||
|
|
||||
|
WSACleanup(); |
||||
|
#else |
||||
|
ifaddrs* ifaddr; |
||||
|
if (getifaddrs(&ifaddr) == -1) |
||||
|
throw NoNetworking(); |
||||
|
|
||||
|
bi::tcp::resolver r(m_ioService); |
||||
|
|
||||
|
for (ifaddrs* ifa = ifaddr; ifa; ifa = ifa->ifa_next) |
||||
|
{ |
||||
|
if (!ifa->ifa_addr) |
||||
|
continue; |
||||
|
if (ifa->ifa_addr->sa_family == AF_INET) |
||||
|
{ |
||||
|
char host[NI_MAXHOST]; |
||||
|
if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)) |
||||
|
continue; |
||||
|
// TODO: Make exception safe when no internet.
|
||||
|
auto it = r.resolve({host, "30303"}); |
||||
|
bi::tcp::endpoint ep = it->endpoint(); |
||||
|
bi::address ad = ep.address(); |
||||
|
m_addresses.push_back(ad.to_v4()); |
||||
|
bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end(); |
||||
|
if (!isLocal) |
||||
|
m_peerAddresses.push_back(ad.to_v4()); |
||||
|
clog(NetNote) << "Address: " << host << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]"); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
freeifaddrs(ifaddr); |
||||
|
#endif |
||||
|
} |
||||
|
|
||||
|
std::map<Public, bi::tcp::endpoint> PeerServer::potentialPeers() |
||||
|
{ |
||||
|
std::map<Public, bi::tcp::endpoint> ret; |
||||
|
if (!m_public.address().is_unspecified()) |
||||
|
ret.insert(make_pair(m_key.pub(), m_public)); |
||||
|
for (auto i: m_peers) |
||||
|
if (auto j = i.second.lock()) |
||||
|
{ |
||||
|
auto ep = j->endpoint(); |
||||
|
// Skip peers with a listen port of zero or are on a private network
|
||||
|
bool peerOnNet = (j->m_listenPort != 0 && !isPrivateAddress(ep.address())); |
||||
|
if (peerOnNet && ep.port() && j->m_id) |
||||
|
ret.insert(make_pair(i.first, ep)); |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void PeerServer::ensureAccepting() |
||||
|
{ |
||||
|
if (m_accepting == false) |
||||
|
{ |
||||
|
clog(NetNote) << "Listening on local port " << m_listenPort << " (public: " << m_public << ")"; |
||||
|
m_accepting = true; |
||||
|
m_acceptor.async_accept(m_socket, [=](boost::system::error_code ec) |
||||
|
{ |
||||
|
if (!ec) |
||||
|
try |
||||
|
{ |
||||
|
try { |
||||
|
clog(NetNote) << "Accepted connection from " << m_socket.remote_endpoint(); |
||||
|
} catch (...){} |
||||
|
bi::address remoteAddress = m_socket.remote_endpoint().address(); |
||||
|
// Port defaults to 0 - we let the hello tell us which port the peer listens to
|
||||
|
auto p = std::make_shared<PeerSession>(this, std::move(m_socket), m_networkId, remoteAddress); |
||||
|
p->start(); |
||||
|
} |
||||
|
catch (std::exception const& _e) |
||||
|
{ |
||||
|
clog(NetWarn) << "ERROR: " << _e.what(); |
||||
|
} |
||||
|
m_accepting = false; |
||||
|
if (ec.value() != 1 && (m_mode == NodeMode::PeerServer || m_peers.size() < m_idealPeerCount * 2)) |
||||
|
ensureAccepting(); |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void PeerServer::connect(std::string const& _addr, unsigned short _port) noexcept |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
connect(bi::tcp::endpoint(bi::address::from_string(_addr), _port)); |
||||
|
} |
||||
|
catch (exception const& e) |
||||
|
{ |
||||
|
// Couldn't connect
|
||||
|
clog(NetNote) << "Bad host " << _addr << " (" << e.what() << ")"; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void PeerServer::connect(bi::tcp::endpoint const& _ep) |
||||
|
{ |
||||
|
clog(NetNote) << "Attempting connection to " << _ep; |
||||
|
bi::tcp::socket* s = new bi::tcp::socket(m_ioService); |
||||
|
s->async_connect(_ep, [=](boost::system::error_code const& ec) |
||||
|
{ |
||||
|
if (ec) |
||||
|
{ |
||||
|
clog(NetNote) << "Connection refused to " << _ep << " (" << ec.message() << ")"; |
||||
|
for (auto i = m_incomingPeers.begin(); i != m_incomingPeers.end(); ++i) |
||||
|
if (i->second.first == _ep && i->second.second < 3) |
||||
|
{ |
||||
|
m_freePeers.push_back(i->first); |
||||
|
goto OK; |
||||
|
} |
||||
|
// for-else
|
||||
|
clog(NetNote) << "Giving up."; |
||||
|
OK:; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
auto p = make_shared<PeerSession>(this, std::move(*s), m_networkId, _ep.address(), _ep.port()); |
||||
|
clog(NetNote) << "Connected to " << _ep; |
||||
|
p->start(); |
||||
|
} |
||||
|
delete s; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
bool PeerServer::sync() |
||||
|
{ |
||||
|
bool ret = false; |
||||
|
if (isInitialised()) |
||||
|
for (auto i = m_peers.begin(); i != m_peers.end();) |
||||
|
{ |
||||
|
auto p = i->second.lock(); |
||||
|
if (p && p->m_socket.is_open() && |
||||
|
(p->m_disconnect == chrono::steady_clock::time_point::max() || chrono::steady_clock::now() - p->m_disconnect < chrono::seconds(1))) // kill old peers that should be disconnected.
|
||||
|
++i; |
||||
|
else |
||||
|
{ |
||||
|
i = m_peers.erase(i); |
||||
|
ret = true; |
||||
|
} |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bool PeerServer::ensureInitialised(BlockChain& _bc, TransactionQueue& _tq) |
||||
|
{ |
||||
|
if (m_latestBlockSent == h256()) |
||||
|
{ |
||||
|
// First time - just initialise.
|
||||
|
m_latestBlockSent = _bc.currentHash(); |
||||
|
clog(NetNote) << "Initialising: latest=" << m_latestBlockSent; |
||||
|
|
||||
|
for (auto const& i: _tq.transactions()) |
||||
|
m_transactionsSent.insert(i.first); |
||||
|
m_lastPeersRequest = chrono::steady_clock::time_point::min(); |
||||
|
return true; |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
bool PeerServer::sync(BlockChain& _bc, TransactionQueue& _tq, Overlay& _o) |
||||
|
{ |
||||
|
bool ret = ensureInitialised(_bc, _tq); |
||||
|
|
||||
|
if (sync()) |
||||
|
ret = true; |
||||
|
|
||||
|
if (m_mode == NodeMode::Full) |
||||
|
{ |
||||
|
for (auto it = m_incomingTransactions.begin(); it != m_incomingTransactions.end(); ++it) |
||||
|
if (_tq.import(*it)) |
||||
|
{}//ret = true; // just putting a transaction in the queue isn't enough to change the state - it might have an invalid nonce...
|
||||
|
else |
||||
|
m_transactionsSent.insert(sha3(*it)); // if we already had the transaction, then don't bother sending it on.
|
||||
|
m_incomingTransactions.clear(); |
||||
|
|
||||
|
auto h = _bc.currentHash(); |
||||
|
bool resendAll = (h != m_latestBlockSent); |
||||
|
|
||||
|
// Send any new transactions.
|
||||
|
for (auto j: m_peers) |
||||
|
if (auto p = j.second.lock()) |
||||
|
{ |
||||
|
bytes b; |
||||
|
uint n = 0; |
||||
|
for (auto const& i: _tq.transactions()) |
||||
|
if ((!m_transactionsSent.count(i.first) && !p->m_knownTransactions.count(i.first)) || p->m_requireTransactions || resendAll) |
||||
|
{ |
||||
|
b += i.second; |
||||
|
++n; |
||||
|
m_transactionsSent.insert(i.first); |
||||
|
} |
||||
|
if (n) |
||||
|
{ |
||||
|
RLPStream ts; |
||||
|
PeerSession::prep(ts); |
||||
|
ts.appendList(n + 1) << TransactionsPacket; |
||||
|
ts.appendRaw(b, n).swapOut(b); |
||||
|
seal(b); |
||||
|
p->send(&b); |
||||
|
} |
||||
|
p->m_knownTransactions.clear(); |
||||
|
p->m_requireTransactions = false; |
||||
|
} |
||||
|
|
||||
|
// Send any new blocks.
|
||||
|
if (h != m_latestBlockSent) |
||||
|
{ |
||||
|
// TODO: find where they diverge and send complete new branch.
|
||||
|
RLPStream ts; |
||||
|
PeerSession::prep(ts); |
||||
|
ts.appendList(2) << BlocksPacket; |
||||
|
bytes b; |
||||
|
ts.appendRaw(_bc.block(_bc.currentHash())).swapOut(b); |
||||
|
seal(b); |
||||
|
for (auto j: m_peers) |
||||
|
if (auto p = j.second.lock()) |
||||
|
{ |
||||
|
if (!p->m_knownBlocks.count(_bc.currentHash())) |
||||
|
p->send(&b); |
||||
|
p->m_knownBlocks.clear(); |
||||
|
} |
||||
|
} |
||||
|
m_latestBlockSent = h; |
||||
|
|
||||
|
for (int accepted = 1, n = 0; accepted; ++n) |
||||
|
{ |
||||
|
accepted = 0; |
||||
|
|
||||
|
if (m_incomingBlocks.size()) |
||||
|
for (auto it = prev(m_incomingBlocks.end());; --it) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
_bc.import(*it, _o); |
||||
|
it = m_incomingBlocks.erase(it); |
||||
|
++accepted; |
||||
|
ret = true; |
||||
|
} |
||||
|
catch (UnknownParent) |
||||
|
{ |
||||
|
// Don't (yet) know its parent. Leave it for later.
|
||||
|
m_unknownParentBlocks.push_back(*it); |
||||
|
it = m_incomingBlocks.erase(it); |
||||
|
} |
||||
|
catch (...) |
||||
|
{ |
||||
|
// Some other error - erase it.
|
||||
|
it = m_incomingBlocks.erase(it); |
||||
|
} |
||||
|
|
||||
|
if (it == m_incomingBlocks.begin()) |
||||
|
break; |
||||
|
} |
||||
|
if (!n && accepted) |
||||
|
{ |
||||
|
for (auto i: m_unknownParentBlocks) |
||||
|
m_incomingBlocks.push_back(i); |
||||
|
m_unknownParentBlocks.clear(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Connect to additional peers
|
||||
|
while (m_peers.size() < m_idealPeerCount) |
||||
|
{ |
||||
|
if (m_freePeers.empty()) |
||||
|
{ |
||||
|
if (chrono::steady_clock::now() > m_lastPeersRequest + chrono::seconds(10)) |
||||
|
{ |
||||
|
RLPStream s; |
||||
|
bytes b; |
||||
|
(PeerSession::prep(s).appendList(1) << GetPeersPacket).swapOut(b); |
||||
|
seal(b); |
||||
|
for (auto const& i: m_peers) |
||||
|
if (auto p = i.second.lock()) |
||||
|
if (p->isOpen()) |
||||
|
p->send(&b); |
||||
|
m_lastPeersRequest = chrono::steady_clock::now(); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
if (!m_accepting) |
||||
|
ensureAccepting(); |
||||
|
|
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
auto x = time(0) % m_freePeers.size(); |
||||
|
m_incomingPeers[m_freePeers[x]].second++; |
||||
|
connect(m_incomingPeers[m_freePeers[x]].first); |
||||
|
m_freePeers.erase(m_freePeers.begin() + x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// platform for consensus of social contract.
|
||||
|
// restricts your freedom but does so fairly. and that's the value proposition.
|
||||
|
// guarantees that everyone else respect the rules of the system. (i.e. obeys laws).
|
||||
|
|
||||
|
// We'll keep at most twice as many as is ideal, halfing what counts as "too young to kill" until we get there.
|
||||
|
for (uint old = 15000; m_peers.size() > m_idealPeerCount * 2 && old > 100; old /= 2) |
||||
|
while (m_peers.size() > m_idealPeerCount) |
||||
|
{ |
||||
|
// look for worst peer to kick off
|
||||
|
// first work out how many are old enough to kick off.
|
||||
|
shared_ptr<PeerSession> worst; |
||||
|
unsigned agedPeers = 0; |
||||
|
for (auto i: m_peers) |
||||
|
if (auto p = i.second.lock()) |
||||
|
if ((m_mode != NodeMode::PeerServer || p->m_caps != 0x01) && chrono::steady_clock::now() > p->m_connect + chrono::milliseconds(old)) // don't throw off new peers; peer-servers should never kick off other peer-servers.
|
||||
|
{ |
||||
|
++agedPeers; |
||||
|
if ((!worst || p->m_rating < worst->m_rating || (p->m_rating == worst->m_rating && p->m_connect > worst->m_connect))) // kill older ones
|
||||
|
worst = p; |
||||
|
} |
||||
|
if (!worst || agedPeers <= m_idealPeerCount) |
||||
|
break; |
||||
|
worst->disconnect(TooManyPeers); |
||||
|
} |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
std::vector<PeerInfo> PeerServer::peers() const |
||||
|
{ |
||||
|
const_cast<PeerServer*>(this)->pingAll(); |
||||
|
this_thread::sleep_for(chrono::milliseconds(200)); |
||||
|
std::vector<PeerInfo> ret; |
||||
|
for (auto& i: m_peers) |
||||
|
if (auto j = i.second.lock()) |
||||
|
if (j->m_socket.is_open()) |
||||
|
ret.push_back(j->m_info); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
void PeerServer::pingAll() |
||||
|
{ |
||||
|
for (auto& i: m_peers) |
||||
|
if (auto j = i.second.lock()) |
||||
|
j->ping(); |
||||
|
} |
||||
|
|
||||
|
bytes PeerServer::savePeers() const |
||||
|
{ |
||||
|
RLPStream ret; |
||||
|
int n = 0; |
||||
|
for (auto& i: m_peers) |
||||
|
if (auto p = i.second.lock()) |
||||
|
if (p->m_socket.is_open() && p->endpoint().port()) |
||||
|
{ |
||||
|
ret.appendList(3) << p->endpoint().address().to_v4().to_bytes() << p->endpoint().port() << p->m_id; |
||||
|
n++; |
||||
|
} |
||||
|
return RLPStream(n).appendRaw(ret.out(), n).out(); |
||||
|
} |
||||
|
|
||||
|
void PeerServer::restorePeers(bytesConstRef _b) |
||||
|
{ |
||||
|
for (auto i: RLP(_b)) |
||||
|
{ |
||||
|
auto k = (Public)i[2]; |
||||
|
if (!m_incomingPeers.count(k)) |
||||
|
{ |
||||
|
m_incomingPeers.insert(make_pair(k, make_pair(bi::tcp::endpoint(bi::address_v4(i[0].toArray<byte, 4>()), i[1].toInt<short>()), 0))); |
||||
|
m_freePeers.push_back(k); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,136 @@ |
|||||
|
/*
|
||||
|
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 PeerServer.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <map> |
||||
|
#include <vector> |
||||
|
#include <set> |
||||
|
#include <memory> |
||||
|
#include <utility> |
||||
|
#include <thread> |
||||
|
#include "PeerNetwork.h" |
||||
|
#include "CommonEth.h" |
||||
|
namespace ba = boost::asio; |
||||
|
namespace bi = boost::asio::ip; |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
class PeerServer |
||||
|
{ |
||||
|
friend class PeerSession; |
||||
|
|
||||
|
public: |
||||
|
/// Start server, listening for connections on the given port.
|
||||
|
PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, unsigned short _port, NodeMode _m = NodeMode::Full, std::string const& _publicAddress = std::string(), bool _upnp = true); |
||||
|
/// Start server, listening for connections on a system-assigned port.
|
||||
|
PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, NodeMode _m = NodeMode::Full, std::string const& _publicAddress = std::string(), bool _upnp = true); |
||||
|
/// Start server, but don't listen.
|
||||
|
PeerServer(std::string const& _clientVersion, BlockChain const& _ch, unsigned int _networkId, NodeMode _m = NodeMode::Full); |
||||
|
|
||||
|
~PeerServer(); |
||||
|
|
||||
|
static unsigned protocolVersion(); |
||||
|
unsigned networkId() { return m_networkId; } |
||||
|
|
||||
|
/// Connect to a peer explicitly.
|
||||
|
void connect(std::string const& _addr, unsigned short _port = 30303) noexcept; |
||||
|
void connect(bi::tcp::endpoint const& _ep); |
||||
|
|
||||
|
/// Sync with the BlockChain. It might contain one of our mined blocks, we might have new candidates from the network.
|
||||
|
bool sync(BlockChain& _bc, TransactionQueue&, Overlay& _o); |
||||
|
bool sync(); |
||||
|
|
||||
|
/// Conduct I/O, polling, syncing, whatever.
|
||||
|
/// Ideally all time-consuming I/O is done in a background thread or otherwise asynchronously, but you get this call every 100ms or so anyway.
|
||||
|
/// This won't touch alter the blockchain.
|
||||
|
void process() { if (isInitialised()) m_ioService.poll(); } |
||||
|
|
||||
|
/// Set ideal number of peers.
|
||||
|
void setIdealPeerCount(unsigned _n) { m_idealPeerCount = _n; } |
||||
|
|
||||
|
void setMode(NodeMode _m) { m_mode = _m; } |
||||
|
|
||||
|
/// Get peer information.
|
||||
|
std::vector<PeerInfo> peers() const; |
||||
|
|
||||
|
/// Get number of peers connected; equivalent to, but faster than, peers().size().
|
||||
|
size_t peerCount() const { return m_peers.size(); } |
||||
|
|
||||
|
/// Ping the peers, to update the latency information.
|
||||
|
void pingAll(); |
||||
|
|
||||
|
/// Get the port we're listening on currently.
|
||||
|
unsigned short listenPort() const { return m_public.port(); } |
||||
|
|
||||
|
bytes savePeers() const; |
||||
|
void restorePeers(bytesConstRef _b); |
||||
|
|
||||
|
private: |
||||
|
void seal(bytes& _b); |
||||
|
void populateAddresses(); |
||||
|
void determinePublic(std::string const& _publicAddress, bool _upnp); |
||||
|
void ensureAccepting(); |
||||
|
|
||||
|
/// Check to see if the network peer-state initialisation has happened.
|
||||
|
bool isInitialised() const { return m_latestBlockSent; } |
||||
|
/// Initialises the network peer-state, doing the stuff that needs to be once-only. @returns true if it really was first.
|
||||
|
bool ensureInitialised(BlockChain& _bc, TransactionQueue& _tq); |
||||
|
|
||||
|
std::map<Public, bi::tcp::endpoint> potentialPeers(); |
||||
|
|
||||
|
std::string m_clientVersion; |
||||
|
NodeMode m_mode = NodeMode::Full; |
||||
|
|
||||
|
unsigned short m_listenPort; |
||||
|
|
||||
|
BlockChain const* m_chain = nullptr; |
||||
|
ba::io_service m_ioService; |
||||
|
bi::tcp::acceptor m_acceptor; |
||||
|
bi::tcp::socket m_socket; |
||||
|
|
||||
|
UPnP* m_upnp = nullptr; |
||||
|
bi::tcp::endpoint m_public; |
||||
|
KeyPair m_key; |
||||
|
|
||||
|
unsigned m_networkId; |
||||
|
std::map<Public, std::weak_ptr<PeerSession>> m_peers; |
||||
|
|
||||
|
std::vector<bytes> m_incomingTransactions; |
||||
|
std::vector<bytes> m_incomingBlocks; |
||||
|
std::vector<bytes> m_unknownParentBlocks; |
||||
|
std::vector<Public> m_freePeers; |
||||
|
std::map<Public, std::pair<bi::tcp::endpoint, unsigned>> m_incomingPeers; |
||||
|
|
||||
|
h256 m_latestBlockSent; |
||||
|
std::set<h256> m_transactionsSent; |
||||
|
|
||||
|
std::chrono::steady_clock::time_point m_lastPeersRequest; |
||||
|
unsigned m_idealPeerCount = 5; |
||||
|
|
||||
|
std::vector<bi::address_v4> m_addresses; |
||||
|
std::vector<bi::address_v4> m_peerAddresses; |
||||
|
|
||||
|
bool m_accepting = false; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,587 @@ |
|||||
|
/*
|
||||
|
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 PeerSession.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "PeerSession.h" |
||||
|
|
||||
|
#include <chrono> |
||||
|
#include "Exceptions.h" |
||||
|
#include "Common.h" |
||||
|
#include "BlockChain.h" |
||||
|
#include "BlockInfo.h" |
||||
|
#include "PeerServer.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
#define clogS(X) eth::LogOutputStream<X, true>(false) << "| " << std::setw(2) << m_socket.native_handle() << "] " |
||||
|
|
||||
|
static const eth::uint c_maxHashes = 32; ///< Maximum number of hashes GetChain will ever send.
|
||||
|
static const eth::uint c_maxBlocks = 32; ///< Maximum number of blocks Blocks will ever send. BUG: if this gets too big (e.g. 2048) stuff starts going wrong.
|
||||
|
static const eth::uint c_maxBlocksAsk = 256; ///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
|
||||
|
|
||||
|
PeerSession::PeerSession(PeerServer* _s, bi::tcp::socket _socket, uint _rNId, bi::address _peerAddress, unsigned short _peerPort): |
||||
|
m_server(_s), |
||||
|
m_socket(std::move(_socket)), |
||||
|
m_reqNetworkId(_rNId), |
||||
|
m_listenPort(_peerPort), |
||||
|
m_rating(0) |
||||
|
{ |
||||
|
m_disconnect = std::chrono::steady_clock::time_point::max(); |
||||
|
m_connect = std::chrono::steady_clock::now(); |
||||
|
m_info = PeerInfo({"?", _peerAddress.to_string(), m_listenPort, std::chrono::steady_clock::duration(0)}); |
||||
|
} |
||||
|
|
||||
|
PeerSession::~PeerSession() |
||||
|
{ |
||||
|
m_socket.close(); |
||||
|
} |
||||
|
|
||||
|
bi::tcp::endpoint PeerSession::endpoint() const |
||||
|
{ |
||||
|
if (m_socket.is_open()) |
||||
|
try { |
||||
|
return bi::tcp::endpoint(m_socket.remote_endpoint().address(), m_listenPort); |
||||
|
} catch (...){} |
||||
|
|
||||
|
return bi::tcp::endpoint(); |
||||
|
} |
||||
|
|
||||
|
// TODO: BUG! 256 -> work out why things start to break with big packet sizes -> g.t. ~370 blocks.
|
||||
|
|
||||
|
bool PeerSession::interpret(RLP const& _r) |
||||
|
{ |
||||
|
clogS(NetRight) << _r; |
||||
|
switch (_r[0].toInt<unsigned>()) |
||||
|
{ |
||||
|
case HelloPacket: |
||||
|
{ |
||||
|
m_protocolVersion = _r[1].toInt<uint>(); |
||||
|
m_networkId = _r[2].toInt<uint>(); |
||||
|
auto clientVersion = _r[3].toString(); |
||||
|
m_caps = _r[4].toInt<uint>(); |
||||
|
m_listenPort = _r[5].toInt<unsigned short>(); |
||||
|
m_id = _r[6].toHash<h512>(); |
||||
|
|
||||
|
clogS(NetMessageSummary) << "Hello: " << clientVersion << "V[" << m_protocolVersion << "/" << m_networkId << "]" << m_id.abridged() << showbase << hex << m_caps << dec << m_listenPort; |
||||
|
|
||||
|
if (m_server->m_peers.count(m_id)) |
||||
|
if (auto l = m_server->m_peers[m_id].lock()) |
||||
|
if (l.get() != this && l->isOpen()) |
||||
|
{ |
||||
|
// Already connected.
|
||||
|
cwarn << "Already have peer id" << m_id.abridged() << "at" << l->endpoint() << "rather than" << endpoint(); |
||||
|
disconnect(DuplicatePeer); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
if (m_protocolVersion != PeerServer::protocolVersion() || m_networkId != m_server->networkId() || !m_id) |
||||
|
{ |
||||
|
disconnect(IncompatibleProtocol); |
||||
|
return false; |
||||
|
} |
||||
|
try |
||||
|
{ m_info = PeerInfo({clientVersion, m_socket.remote_endpoint().address().to_string(), m_listenPort, std::chrono::steady_clock::duration()}); } |
||||
|
catch (...) |
||||
|
{ |
||||
|
disconnect(BadProtocol); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
m_server->m_peers[m_id] = shared_from_this(); |
||||
|
|
||||
|
// Grab their block chain off them.
|
||||
|
{ |
||||
|
clogS(NetAllDetail) << "Want chain. Latest:" << m_server->m_latestBlockSent << ", number:" << m_server->m_chain->details(m_server->m_latestBlockSent).number; |
||||
|
uint count = std::min(c_maxHashes, m_server->m_chain->details(m_server->m_latestBlockSent).number + 1); |
||||
|
RLPStream s; |
||||
|
prep(s).appendList(2 + count); |
||||
|
s << GetChainPacket; |
||||
|
auto h = m_server->m_latestBlockSent; |
||||
|
for (uint i = 0; i < count; ++i, h = m_server->m_chain->details(h).parent) |
||||
|
{ |
||||
|
clogS(NetAllDetail) << " " << i << ":" << h; |
||||
|
s << h; |
||||
|
} |
||||
|
|
||||
|
s << c_maxBlocksAsk; |
||||
|
sealAndSend(s); |
||||
|
s.clear(); |
||||
|
prep(s).appendList(1); |
||||
|
s << GetTransactionsPacket; |
||||
|
sealAndSend(s); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
case DisconnectPacket: |
||||
|
{ |
||||
|
string reason = "Unspecified"; |
||||
|
if (_r[1].isInt()) |
||||
|
reason = reasonOf((DisconnectReason)_r[1].toInt<int>()); |
||||
|
|
||||
|
clogS(NetMessageSummary) << "Disconnect (reason: " << reason << ")"; |
||||
|
if (m_socket.is_open()) |
||||
|
clogS(NetNote) << "Closing " << m_socket.remote_endpoint(); |
||||
|
else |
||||
|
clogS(NetNote) << "Remote closed."; |
||||
|
m_socket.close(); |
||||
|
return false; |
||||
|
} |
||||
|
case PingPacket: |
||||
|
{ |
||||
|
// clogS(NetMessageSummary) << "Ping";
|
||||
|
RLPStream s; |
||||
|
sealAndSend(prep(s).appendList(1) << PongPacket); |
||||
|
break; |
||||
|
} |
||||
|
case PongPacket: |
||||
|
m_info.lastPing = std::chrono::steady_clock::now() - m_ping; |
||||
|
// clogS(NetMessageSummary) << "Latency: " << chrono::duration_cast<chrono::milliseconds>(m_lastPing).count() << " ms";
|
||||
|
break; |
||||
|
case GetPeersPacket: |
||||
|
{ |
||||
|
clogS(NetMessageSummary) << "GetPeers"; |
||||
|
auto peers = m_server->potentialPeers(); |
||||
|
RLPStream s; |
||||
|
prep(s).appendList(peers.size() + 1); |
||||
|
s << PeersPacket; |
||||
|
for (auto i: peers) |
||||
|
{ |
||||
|
clogS(NetMessageDetail) << "Sending peer " << toHex(i.first.ref().cropped(0, 4)) << i.second; |
||||
|
s.appendList(3) << i.second.address().to_v4().to_bytes() << i.second.port() << i.first; |
||||
|
} |
||||
|
sealAndSend(s); |
||||
|
break; |
||||
|
} |
||||
|
case PeersPacket: |
||||
|
clogS(NetMessageSummary) << "Peers (" << dec << (_r.itemCount() - 1) << " entries)"; |
||||
|
for (unsigned i = 1; i < _r.itemCount(); ++i) |
||||
|
{ |
||||
|
bi::address_v4 peerAddress(_r[i][0].toArray<byte, 4>()); |
||||
|
auto ep = bi::tcp::endpoint(peerAddress, _r[i][1].toInt<short>()); |
||||
|
Public id = _r[i][2].toHash<Public>(); |
||||
|
if (isPrivateAddress(peerAddress)) |
||||
|
goto CONTINUE; |
||||
|
|
||||
|
clogS(NetAllDetail) << "Checking: " << ep << "(" << toHex(id.ref().cropped(0, 4)) << ")"; |
||||
|
|
||||
|
// check that it's not us or one we already know:
|
||||
|
if (id && (m_server->m_key.pub() == id || m_server->m_peers.count(id) || m_server->m_incomingPeers.count(id))) |
||||
|
goto CONTINUE; |
||||
|
|
||||
|
// check that we're not already connected to addr:
|
||||
|
if (!ep.port()) |
||||
|
goto CONTINUE; |
||||
|
for (auto i: m_server->m_addresses) |
||||
|
if (ep.address() == i && ep.port() == m_server->listenPort()) |
||||
|
goto CONTINUE; |
||||
|
for (auto i: m_server->m_peers) |
||||
|
if (shared_ptr<PeerSession> p = i.second.lock()) |
||||
|
{ |
||||
|
clogS(NetAllDetail) << " ...against " << p->endpoint(); |
||||
|
if (p->m_socket.is_open() && p->endpoint() == ep) |
||||
|
goto CONTINUE; |
||||
|
} |
||||
|
for (auto i: m_server->m_incomingPeers) |
||||
|
if (i.second.first == ep) |
||||
|
goto CONTINUE; |
||||
|
m_server->m_incomingPeers[id] = make_pair(ep, 0); |
||||
|
m_server->m_freePeers.push_back(id); |
||||
|
clogS(NetMessageDetail) << "New peer: " << ep << "(" << id << ")"; |
||||
|
CONTINUE:; |
||||
|
} |
||||
|
break; |
||||
|
case TransactionsPacket: |
||||
|
if (m_server->m_mode == NodeMode::PeerServer) |
||||
|
break; |
||||
|
clogS(NetMessageSummary) << "Transactions (" << dec << (_r.itemCount() - 1) << " entries)"; |
||||
|
m_rating += _r.itemCount() - 1; |
||||
|
for (unsigned i = 1; i < _r.itemCount(); ++i) |
||||
|
{ |
||||
|
m_server->m_incomingTransactions.push_back(_r[i].data().toBytes()); |
||||
|
m_knownTransactions.insert(sha3(_r[i].data())); |
||||
|
} |
||||
|
break; |
||||
|
case BlocksPacket: |
||||
|
{ |
||||
|
if (m_server->m_mode == NodeMode::PeerServer) |
||||
|
break; |
||||
|
clogS(NetMessageSummary) << "Blocks (" << dec << (_r.itemCount() - 1) << " entries)"; |
||||
|
unsigned used = 0; |
||||
|
for (unsigned i = 1; i < _r.itemCount(); ++i) |
||||
|
{ |
||||
|
auto h = sha3(_r[i].data()); |
||||
|
if (!m_server->m_chain->details(h)) |
||||
|
{ |
||||
|
m_server->m_incomingBlocks.push_back(_r[i].data().toBytes()); |
||||
|
m_knownBlocks.insert(h); |
||||
|
used++; |
||||
|
} |
||||
|
} |
||||
|
m_rating += used; |
||||
|
if (g_logVerbosity >= 3) |
||||
|
for (unsigned i = 1; i < _r.itemCount(); ++i) |
||||
|
{ |
||||
|
auto h = sha3(_r[i].data()); |
||||
|
BlockInfo bi(_r[i].data()); |
||||
|
if (!m_server->m_chain->details(bi.parentHash) && !m_knownBlocks.count(bi.parentHash)) |
||||
|
clogS(NetMessageDetail) << "Unknown parent " << bi.parentHash << " of block " << h; |
||||
|
else |
||||
|
clogS(NetMessageDetail) << "Known parent " << bi.parentHash << " of block " << h; |
||||
|
} |
||||
|
if (used) // we received some - check if there's any more
|
||||
|
{ |
||||
|
RLPStream s; |
||||
|
prep(s).appendList(3); |
||||
|
s << GetChainPacket; |
||||
|
s << sha3(_r[1].data()); |
||||
|
s << c_maxBlocksAsk; |
||||
|
sealAndSend(s); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
case GetChainPacket: |
||||
|
{ |
||||
|
if (m_server->m_mode == NodeMode::PeerServer) |
||||
|
break; |
||||
|
clogS(NetMessageSummary) << "GetChain (" << (_r.itemCount() - 2) << " hashes, " << (_r[_r.itemCount() - 1].toInt<bigint>()) << ")"; |
||||
|
// ********************************************************************
|
||||
|
// NEEDS FULL REWRITE!
|
||||
|
h256s parents; |
||||
|
parents.reserve(_r.itemCount() - 2); |
||||
|
for (unsigned i = 1; i < _r.itemCount() - 1; ++i) |
||||
|
parents.push_back(_r[i].toHash<h256>()); |
||||
|
if (_r.itemCount() == 2) |
||||
|
break; |
||||
|
// return 2048 block max.
|
||||
|
uint baseCount = (uint)min<bigint>(_r[_r.itemCount() - 1].toInt<bigint>(), c_maxBlocks); |
||||
|
clogS(NetMessageSummary) << "GetChain (" << baseCount << " max, from " << parents.front() << " to " << parents.back() << ")"; |
||||
|
for (auto parent: parents) |
||||
|
{ |
||||
|
auto h = m_server->m_chain->currentHash(); |
||||
|
h256 latest = m_server->m_chain->currentHash(); |
||||
|
uint latestNumber = 0; |
||||
|
uint parentNumber = 0; |
||||
|
RLPStream s; |
||||
|
|
||||
|
if (m_server->m_chain->details(parent)) |
||||
|
{ |
||||
|
latestNumber = m_server->m_chain->details(latest).number; |
||||
|
parentNumber = m_server->m_chain->details(parent).number; |
||||
|
uint count = min<uint>(latestNumber - parentNumber, baseCount); |
||||
|
clogS(NetAllDetail) << "Requires " << dec << (latestNumber - parentNumber) << " blocks from " << latestNumber << " to " << parentNumber; |
||||
|
clogS(NetAllDetail) << latest << " - " << parent; |
||||
|
|
||||
|
prep(s); |
||||
|
s.appendList(1 + count) << BlocksPacket; |
||||
|
uint endNumber = m_server->m_chain->details(parent).number; |
||||
|
uint startNumber = endNumber + count; |
||||
|
clogS(NetAllDetail) << "Sending " << dec << count << " blocks from " << startNumber << " to " << endNumber; |
||||
|
|
||||
|
uint n = latestNumber; |
||||
|
for (; n > startNumber; n--, h = m_server->m_chain->details(h).parent) {} |
||||
|
for (uint i = 0; i < count; ++i, --n, h = m_server->m_chain->details(h).parent) |
||||
|
{ |
||||
|
if (h == parent || n == endNumber) |
||||
|
{ |
||||
|
cwarn << "BUG! Couldn't create the reply for GetChain!"; |
||||
|
return true; |
||||
|
} |
||||
|
clogS(NetAllDetail) << " " << dec << i << " " << h; |
||||
|
s.appendRaw(m_server->m_chain->block(h)); |
||||
|
} |
||||
|
clogS(NetAllDetail) << "Parent: " << h; |
||||
|
} |
||||
|
else if (parent != parents.back()) |
||||
|
continue; |
||||
|
|
||||
|
if (h != parent) |
||||
|
{ |
||||
|
// not in the blockchain;
|
||||
|
if (parent == parents.back()) |
||||
|
{ |
||||
|
// out of parents...
|
||||
|
clogS(NetAllDetail) << "GetChain failed; not in chain"; |
||||
|
// No good - must have been on a different branch.
|
||||
|
s.clear(); |
||||
|
prep(s).appendList(2) << NotInChainPacket << parents.back(); |
||||
|
} |
||||
|
else |
||||
|
// still some parents left - try them.
|
||||
|
continue; |
||||
|
} |
||||
|
// send the packet (either Blocks or NotInChain) & exit.
|
||||
|
sealAndSend(s); |
||||
|
break; |
||||
|
// ********************************************************************
|
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
case NotInChainPacket: |
||||
|
{ |
||||
|
if (m_server->m_mode == NodeMode::PeerServer) |
||||
|
break; |
||||
|
h256 noGood = _r[1].toHash<h256>(); |
||||
|
clogS(NetMessageSummary) << "NotInChain (" << noGood << ")"; |
||||
|
if (noGood == m_server->m_chain->genesisHash()) |
||||
|
{ |
||||
|
clogS(NetWarn) << "Discordance over genesis block! Disconnect."; |
||||
|
disconnect(WrongGenesis); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
uint count = std::min(c_maxHashes, m_server->m_chain->details(noGood).number); |
||||
|
RLPStream s; |
||||
|
prep(s).appendList(2 + count); |
||||
|
s << GetChainPacket; |
||||
|
auto h = m_server->m_chain->details(noGood).parent; |
||||
|
for (uint i = 0; i < count; ++i, h = m_server->m_chain->details(h).parent) |
||||
|
s << h; |
||||
|
s << c_maxBlocksAsk; |
||||
|
sealAndSend(s); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
case GetTransactionsPacket: |
||||
|
{ |
||||
|
if (m_server->m_mode == NodeMode::PeerServer) |
||||
|
break; |
||||
|
m_requireTransactions = true; |
||||
|
break; |
||||
|
} |
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
void PeerSession::ping() |
||||
|
{ |
||||
|
RLPStream s; |
||||
|
sealAndSend(prep(s).appendList(1) << PingPacket); |
||||
|
m_ping = std::chrono::steady_clock::now(); |
||||
|
} |
||||
|
|
||||
|
RLPStream& PeerSession::prep(RLPStream& _s) |
||||
|
{ |
||||
|
return _s.appendRaw(bytes(8, 0)); |
||||
|
} |
||||
|
|
||||
|
void PeerServer::seal(bytes& _b) |
||||
|
{ |
||||
|
_b[0] = 0x22; |
||||
|
_b[1] = 0x40; |
||||
|
_b[2] = 0x08; |
||||
|
_b[3] = 0x91; |
||||
|
uint32_t len = (uint32_t)_b.size() - 8; |
||||
|
_b[4] = (len >> 24) & 0xff; |
||||
|
_b[5] = (len >> 16) & 0xff; |
||||
|
_b[6] = (len >> 8) & 0xff; |
||||
|
_b[7] = len & 0xff; |
||||
|
} |
||||
|
|
||||
|
void PeerSession::sealAndSend(RLPStream& _s) |
||||
|
{ |
||||
|
bytes b; |
||||
|
_s.swapOut(b); |
||||
|
m_server->seal(b); |
||||
|
sendDestroy(b); |
||||
|
} |
||||
|
|
||||
|
bool PeerSession::checkPacket(bytesConstRef _msg) |
||||
|
{ |
||||
|
if (_msg.size() < 8) |
||||
|
return false; |
||||
|
if (!(_msg[0] == 0x22 && _msg[1] == 0x40 && _msg[2] == 0x08 && _msg[3] == 0x91)) |
||||
|
return false; |
||||
|
uint32_t len = ((_msg[4] * 256 + _msg[5]) * 256 + _msg[6]) * 256 + _msg[7]; |
||||
|
if (_msg.size() != len + 8) |
||||
|
return false; |
||||
|
RLP r(_msg.cropped(8)); |
||||
|
if (r.actualSize() != len) |
||||
|
return false; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
void PeerSession::sendDestroy(bytes& _msg) |
||||
|
{ |
||||
|
clogS(NetLeft) << RLP(bytesConstRef(&_msg).cropped(8)); |
||||
|
|
||||
|
if (!checkPacket(bytesConstRef(&_msg))) |
||||
|
{ |
||||
|
cwarn << "INVALID PACKET CONSTRUCTED!"; |
||||
|
} |
||||
|
|
||||
|
auto self(shared_from_this()); |
||||
|
bytes* buffer = new bytes(std::move(_msg)); |
||||
|
if (m_socket.is_open()) |
||||
|
ba::async_write(m_socket, ba::buffer(*buffer), [self, buffer](boost::system::error_code ec, std::size_t /*length*/) |
||||
|
{ |
||||
|
delete buffer; |
||||
|
if (ec) |
||||
|
{ |
||||
|
cwarn << "Error sending: " << ec.message(); |
||||
|
self->dropped(); |
||||
|
} |
||||
|
// cbug << length << " bytes written (EC: " << ec << ")";
|
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
void PeerSession::send(bytesConstRef _msg) |
||||
|
{ |
||||
|
clogS(NetLeft) << RLP(_msg.cropped(8)); |
||||
|
|
||||
|
if (!checkPacket(_msg)) |
||||
|
{ |
||||
|
cwarn << "INVALID PACKET CONSTRUCTED!"; |
||||
|
} |
||||
|
|
||||
|
auto self(shared_from_this()); |
||||
|
bytes* buffer = new bytes(_msg.toBytes()); |
||||
|
if (m_socket.is_open()) |
||||
|
ba::async_write(m_socket, ba::buffer(*buffer), [self, buffer](boost::system::error_code ec, std::size_t /*length*/) |
||||
|
{ |
||||
|
delete buffer; |
||||
|
if (ec) |
||||
|
{ |
||||
|
cwarn << "Error sending: " << ec.message(); |
||||
|
self->dropped(); |
||||
|
} |
||||
|
// cbug << length << " bytes written (EC: " << ec << ")";
|
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
void PeerSession::dropped() |
||||
|
{ |
||||
|
if (m_socket.is_open()) |
||||
|
try { |
||||
|
clogS(NetNote) << "Closing " << m_socket.remote_endpoint(); |
||||
|
m_socket.close(); |
||||
|
}catch (...){} |
||||
|
for (auto i = m_server->m_peers.begin(); i != m_server->m_peers.end(); ++i) |
||||
|
if (i->second.lock().get() == this) |
||||
|
{ |
||||
|
m_server->m_peers.erase(i); |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void PeerSession::disconnect(int _reason) |
||||
|
{ |
||||
|
clogS(NetNote) << "Disconnecting (reason:" << reasonOf((DisconnectReason)_reason) << ")"; |
||||
|
if (m_socket.is_open()) |
||||
|
{ |
||||
|
if (m_disconnect == chrono::steady_clock::time_point::max()) |
||||
|
{ |
||||
|
RLPStream s; |
||||
|
prep(s); |
||||
|
s.appendList(2) << DisconnectPacket << _reason; |
||||
|
sealAndSend(s); |
||||
|
m_disconnect = chrono::steady_clock::now(); |
||||
|
} |
||||
|
else |
||||
|
dropped(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void PeerSession::start() |
||||
|
{ |
||||
|
RLPStream s; |
||||
|
prep(s); |
||||
|
s.appendList(7) << HelloPacket << (uint)PeerServer::protocolVersion() << m_server->networkId() << m_server->m_clientVersion << (m_server->m_mode == NodeMode::Full ? 0x07 : m_server->m_mode == NodeMode::PeerServer ? 0x01 : 0) << m_server->m_public.port() << m_server->m_key.pub(); |
||||
|
sealAndSend(s); |
||||
|
|
||||
|
ping(); |
||||
|
|
||||
|
doRead(); |
||||
|
} |
||||
|
|
||||
|
void PeerSession::doRead() |
||||
|
{ |
||||
|
auto self(shared_from_this()); |
||||
|
m_socket.async_read_some(boost::asio::buffer(m_data), [this,self](boost::system::error_code ec, std::size_t length) |
||||
|
{ |
||||
|
if (ec) |
||||
|
{ |
||||
|
cwarn << "Error reading: " << ec.message(); |
||||
|
dropped(); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
m_incoming.resize(m_incoming.size() + length); |
||||
|
memcpy(m_incoming.data() + m_incoming.size() - length, m_data.data(), length); |
||||
|
while (m_incoming.size() > 8) |
||||
|
{ |
||||
|
if (m_incoming[0] != 0x22 || m_incoming[1] != 0x40 || m_incoming[2] != 0x08 || m_incoming[3] != 0x91) |
||||
|
{ |
||||
|
clogS(NetWarn) << "Out of alignment."; |
||||
|
disconnect(BadProtocol); |
||||
|
return; |
||||
|
clogS(NetNote) << "Skipping: " << hex << showbase << (int)m_incoming[0] << dec; |
||||
|
memmove(m_incoming.data(), m_incoming.data() + 1, m_incoming.size() - 1); |
||||
|
m_incoming.resize(m_incoming.size() - 1); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
uint32_t len = fromBigEndian<uint32_t>(bytesConstRef(m_incoming.data() + 4, 4)); |
||||
|
uint32_t tlen = len + 8; |
||||
|
if (m_incoming.size() < tlen) |
||||
|
break; |
||||
|
|
||||
|
// enough has come in.
|
||||
|
// cerr << "Received " << len << ": " << toHex(bytesConstRef(m_incoming.data() + 8, len)) << endl;
|
||||
|
auto data = bytesConstRef(m_incoming.data(), tlen); |
||||
|
if (!checkPacket(data)) |
||||
|
{ |
||||
|
cerr << "Received " << len << ": " << toHex(bytesConstRef(m_incoming.data() + 8, len)) << endl; |
||||
|
cwarn << "INVALID MESSAGE RECEIVED"; |
||||
|
disconnect(BadProtocol); |
||||
|
return; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
RLP r(data.cropped(8)); |
||||
|
if (!interpret(r)) |
||||
|
{ |
||||
|
// error
|
||||
|
dropped(); |
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
memmove(m_incoming.data(), m_incoming.data() + tlen, m_incoming.size() - tlen); |
||||
|
m_incoming.resize(m_incoming.size() - tlen); |
||||
|
} |
||||
|
} |
||||
|
doRead(); |
||||
|
} |
||||
|
catch (Exception const& _e) |
||||
|
{ |
||||
|
clogS(NetWarn) << "ERROR: " << _e.description(); |
||||
|
dropped(); |
||||
|
} |
||||
|
catch (std::exception const& _e) |
||||
|
{ |
||||
|
clogS(NetWarn) << "ERROR: " << _e.what(); |
||||
|
dropped(); |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
@ -0,0 +1,90 @@ |
|||||
|
/*
|
||||
|
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 PeerSession.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <array> |
||||
|
#include <set> |
||||
|
#include <memory> |
||||
|
#include <utility> |
||||
|
#include "RLP.h" |
||||
|
#include "CommonEth.h" |
||||
|
#include "PeerNetwork.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
class PeerSession: public std::enable_shared_from_this<PeerSession> |
||||
|
{ |
||||
|
friend class PeerServer; |
||||
|
|
||||
|
public: |
||||
|
PeerSession(PeerServer* _server, bi::tcp::socket _socket, uint _rNId, bi::address _peerAddress, unsigned short _peerPort = 0); |
||||
|
~PeerSession(); |
||||
|
|
||||
|
void start(); |
||||
|
void disconnect(int _reason); |
||||
|
|
||||
|
void ping(); |
||||
|
|
||||
|
bool isOpen() const { return m_socket.is_open(); } |
||||
|
|
||||
|
bi::tcp::endpoint endpoint() const; ///< for other peers to connect to.
|
||||
|
|
||||
|
private: |
||||
|
void dropped(); |
||||
|
void doRead(); |
||||
|
void doWrite(std::size_t length); |
||||
|
bool interpret(RLP const& _r); |
||||
|
|
||||
|
/// @returns true iff the _msg forms a valid message for sending or receiving on the network.
|
||||
|
static bool checkPacket(bytesConstRef _msg); |
||||
|
|
||||
|
static RLPStream& prep(RLPStream& _s); |
||||
|
void sealAndSend(RLPStream& _s); |
||||
|
void sendDestroy(bytes& _msg); |
||||
|
void send(bytesConstRef _msg); |
||||
|
PeerServer* m_server; |
||||
|
|
||||
|
bi::tcp::socket m_socket; |
||||
|
std::array<byte, 65536> m_data; |
||||
|
PeerInfo m_info; |
||||
|
Public m_id; |
||||
|
|
||||
|
bytes m_incoming; |
||||
|
uint m_protocolVersion; |
||||
|
uint m_networkId; |
||||
|
uint m_reqNetworkId; |
||||
|
unsigned short m_listenPort; ///< Port that the remote client is listening on for connections. Useful for giving to peers.
|
||||
|
uint m_caps; |
||||
|
|
||||
|
std::chrono::steady_clock::time_point m_ping; |
||||
|
std::chrono::steady_clock::time_point m_connect; |
||||
|
std::chrono::steady_clock::time_point m_disconnect; |
||||
|
|
||||
|
uint m_rating; |
||||
|
bool m_requireTransactions; |
||||
|
|
||||
|
std::set<h256> m_knownBlocks; |
||||
|
std::set<h256> m_knownTransactions; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
@ -1,8 +0,0 @@ |
|||||
#!/bin/bash |
|
||||
|
|
||||
set -e |
|
||||
rm -f ../cpp-ethereum_*_source.changes |
|
||||
debuild -S -sa |
|
||||
cd .. |
|
||||
dput -f ppa:ethereum/ethereum cpp-ethereum_*_source.changes |
|
||||
|
|
||||
@ -1,74 +0,0 @@ |
|||||
#!/bin/bash |
|
||||
|
|
||||
dist="saucy" |
|
||||
version=$(grep "define ETH_VERSION" libethereum/Common.h | cut -d ' ' -f 3) |
|
||||
branch="$(git branch | grep \* | cut -c 3-)" |
|
||||
|
|
||||
if [[ ! "$1" == "" ]]; then |
|
||||
version=$1 |
|
||||
fi |
|
||||
|
|
||||
if [[ ! "$3" == "" ]]; then |
|
||||
if [[ ! "$4" == "" ]]; then |
|
||||
dist=$4 |
|
||||
fi |
|
||||
if [[ "$2" == "-i" ]]; then |
|
||||
# increment current debian release only |
|
||||
# new version ./release VERSION -i MESSAGE DIST |
|
||||
debchange -i -p "$3" -D "$dist" |
|
||||
git commit -a -m "$3" |
|
||||
else |
|
||||
# new version ./release VERSION DEB-VERSION MESSAGE DIST |
|
||||
debchange -v $version-$2 -p "$3" -D "$dist" |
|
||||
git commit -a -m "$3" |
|
||||
fi |
|
||||
fi |
|
||||
|
|
||||
opwd=`pwd` |
|
||||
cd /tmp |
|
||||
|
|
||||
echo Checking out... |
|
||||
git clone $opwd |
|
||||
cd cpp-ethereum |
|
||||
git checkout "$branch" |
|
||||
|
|
||||
archdir="cpp-ethereum-$version" |
|
||||
archfile="$archdir.tar.bz2" |
|
||||
|
|
||||
echo Making BuildInfo... |
|
||||
mkdir build |
|
||||
cd build |
|
||||
cmake .. |
|
||||
cd .. |
|
||||
cp build/BuildInfo.h . |
|
||||
rm -rf build |
|
||||
|
|
||||
echo Cleaning backup files... |
|
||||
find . | grep \~ | xargs rm -f |
|
||||
|
|
||||
echo Cleaning others... |
|
||||
rm release.sh |
|
||||
|
|
||||
echo Cleaning versioning... |
|
||||
rm -rf .git .gitignore |
|
||||
|
|
||||
echo Renaming directory... |
|
||||
cd .. |
|
||||
rm -rf $archdir |
|
||||
mv cpp-ethereum $archdir |
|
||||
|
|
||||
echo Creating archive... |
|
||||
tar c $archdir | bzip2 -- > $archfile |
|
||||
shasum $archfile |
|
||||
|
|
||||
[[ ! "$version" == "" ]] && ln -sf $archfile "cpp-ethereum_$version.orig.tar.bz2" |
|
||||
|
|
||||
echo Packaging... |
|
||||
cd "$archdir" |
|
||||
./package.sh |
|
||||
|
|
||||
echo Cleaning up... |
|
||||
rm -rf /tmp/$archdir |
|
||||
mv /tmp/$archfile ~ |
|
||||
|
|
||||
echo Done. |
|
||||
@ -0,0 +1,32 @@ |
|||||
|
/*
|
||||
|
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 JsonSpiritHeaders.h
|
||||
|
* @author Tim Hughes <tim@twistedfury.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
#pragma once |
||||
|
|
||||
|
#pragma warning(push) |
||||
|
#pragma warning(disable: 4100) |
||||
|
#pragma GCC diagnostic push |
||||
|
#pragma GCC diagnostic ignored "-Wconversion" |
||||
|
#pragma GCC diagnostic ignored "-Wunused-parameter" |
||||
|
#include "../json_spirit/json_spirit_reader_template.h" |
||||
|
#include "../json_spirit/json_spirit_writer_template.h" |
||||
|
#pragma GCC diagnostic pop |
||||
|
#pragma warning(pop) |
||||
|
|
||||
@ -0,0 +1,49 @@ |
|||||
|
/*
|
||||
|
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 TestHelper.cpp
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include <thread> |
||||
|
#include <chrono> |
||||
|
#include <Client.h> |
||||
|
#include "TestHelper.h" |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
void mine(Client& c, int numBlocks) |
||||
|
{ |
||||
|
auto startBlock = c.blockChain().details().number; |
||||
|
|
||||
|
c.startMining(); |
||||
|
while(c.blockChain().details().number < startBlock + numBlocks) |
||||
|
std::this_thread::sleep_for(std::chrono::milliseconds(100)); |
||||
|
c.stopMining(); |
||||
|
} |
||||
|
|
||||
|
void connectClients(Client& c1, Client& c2) |
||||
|
{ |
||||
|
short c1Port = 20000; |
||||
|
short c2Port = 21000; |
||||
|
c1.startNetwork(c1Port); |
||||
|
c2.startNetwork(c2Port); |
||||
|
c2.connect("127.0.0.1", c1Port); |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,30 @@ |
|||||
|
/*
|
||||
|
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 TestHelper.h
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
namespace eth |
||||
|
{ |
||||
|
|
||||
|
void mine(Client& c, int numBlocks); |
||||
|
void connectClients(Client& c1, Client& c2); |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,24 @@ |
|||||
|
/*
|
||||
|
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 boostTest.cpp
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
* Stub for generating main boost.test module. |
||||
|
*/ |
||||
|
|
||||
|
#define BOOST_TEST_MODULE EthereumTests |
||||
|
#include <boost/test/included/unit_test.hpp> |
||||
@ -0,0 +1,56 @@ |
|||||
|
/*
|
||||
|
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 fork.cpp
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
* Tests for different forking behavior |
||||
|
*/ |
||||
|
|
||||
|
#include <boost/test/unit_test.hpp> |
||||
|
#include <boost/filesystem/operations.hpp> |
||||
|
#include <Client.h> |
||||
|
#include <BlockChain.h> |
||||
|
#include <PeerServer.h> |
||||
|
#include "TestHelper.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(simple_chain_fork) |
||||
|
{ |
||||
|
//start a client and mine a short chain
|
||||
|
Client c1("TestClient1", KeyPair::create().address(), |
||||
|
(boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
mine(c1, 4); |
||||
|
|
||||
|
//start another client and mine a longer chain
|
||||
|
Client c2("TestClient2", KeyPair::create().address(), |
||||
|
(boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
mine(c2, 6); |
||||
|
|
||||
|
//connect the two clients up to resolve chain
|
||||
|
c1.startNetwork(20000); |
||||
|
c2.startNetwork(21000); |
||||
|
c2.connect("127.0.0.1", 20000); |
||||
|
|
||||
|
//mine an extra block to cement it
|
||||
|
mine(c1, 1); |
||||
|
|
||||
|
//check the balances are where they should be
|
||||
|
//c1's chain should have been clobbered by c2
|
||||
|
BOOST_REQUIRE(c1.state().balance(c1.address()) == 0); |
||||
|
BOOST_REQUIRE(c2.state().balance(c2.address()) > 0); |
||||
|
} |
||||
@ -0,0 +1,51 @@ |
|||||
|
/*
|
||||
|
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 network.cpp
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
* Basic networking tests |
||||
|
*/ |
||||
|
|
||||
|
#include <boost/test/unit_test.hpp> |
||||
|
#include <boost/filesystem/operations.hpp> |
||||
|
#include <Client.h> |
||||
|
#include <BlockChain.h> |
||||
|
#include <PeerServer.h> |
||||
|
#include "TestHelper.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(listen_port_busy) |
||||
|
{ |
||||
|
short port = 20000; |
||||
|
|
||||
|
//make use of the port ahead of our client
|
||||
|
ba::io_service ioService; |
||||
|
bi::tcp::endpoint endPoint(bi::tcp::v4(), port); |
||||
|
bi::tcp::acceptor acceptor(ioService, endPoint); |
||||
|
acceptor.listen(10); |
||||
|
|
||||
|
//prepare client and try to listen on same, used, port
|
||||
|
Client c1("TestClient1", KeyPair::create().address(), |
||||
|
(boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
|
||||
|
c1.startNetwork(port); |
||||
|
|
||||
|
BOOST_REQUIRE(c1.haveNetwork()); |
||||
|
BOOST_REQUIRE(c1.peerServer()->listenPort() != 0); |
||||
|
BOOST_REQUIRE(c1.peerServer()->listenPort() != port); |
||||
|
} |
||||
@ -0,0 +1,117 @@ |
|||||
|
/*
|
||||
|
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 txTest.cpp
|
||||
|
* @author Marko Simovic <markobarko@gmail.com> |
||||
|
* @date 2014 |
||||
|
* Simple peer transaction send test. |
||||
|
*/ |
||||
|
|
||||
|
#include <boost/test/unit_test.hpp> |
||||
|
#include <boost/filesystem/operations.hpp> |
||||
|
#include <Client.h> |
||||
|
#include <BlockChain.h> |
||||
|
#include <PeerServer.h> |
||||
|
#include "TestHelper.h" |
||||
|
using namespace std; |
||||
|
using namespace eth; |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(mine_local_simple_tx) |
||||
|
{ |
||||
|
KeyPair kp1 = KeyPair::create(); |
||||
|
KeyPair kp2 = KeyPair::create(); |
||||
|
|
||||
|
Client c1("TestClient1", kp1.address(), (boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
|
||||
|
//mine some blocks so that client 1 has a balance
|
||||
|
mine(c1, 1); |
||||
|
auto c1bal = c1.state().balance(kp1.address()); |
||||
|
BOOST_REQUIRE(c1bal > 0); |
||||
|
|
||||
|
//send c2 some eth from c1
|
||||
|
auto txAmount = c1bal / 2u; |
||||
|
auto gasPrice = 10 * szabo; |
||||
|
auto gas = eth::c_callGas; |
||||
|
c1.transact(kp1.secret(), txAmount, kp2.address(), bytes(), gas, gasPrice); |
||||
|
|
||||
|
//mine some more to include the transaction on chain
|
||||
|
mine(c1, 1); |
||||
|
auto c2bal = c1.state().balance(kp2.address()); |
||||
|
BOOST_REQUIRE(c2bal > 0); |
||||
|
BOOST_REQUIRE(c2bal == txAmount); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(mine_and_send_to_peer) |
||||
|
{ |
||||
|
KeyPair kp1 = KeyPair::create(); |
||||
|
KeyPair kp2 = KeyPair::create(); |
||||
|
|
||||
|
Client c1("TestClient1", kp1.address(), (boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
Client c2("TestClient2", kp2.address(), (boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
|
||||
|
connectClients(c1, c2); |
||||
|
|
||||
|
//mine some blocks so that client 1 has a balance
|
||||
|
mine(c1, 1); |
||||
|
auto c1bal = c1.state().balance(kp1.address()); |
||||
|
BOOST_REQUIRE(c1bal > 0); |
||||
|
|
||||
|
//send c2 some eth from c1
|
||||
|
auto txAmount = c1bal / 2u; |
||||
|
auto gasPrice = 10 * szabo; |
||||
|
auto gas = eth::c_callGas; |
||||
|
c1.transact(kp1.secret(), txAmount, kp2.address(), bytes(), gas, gasPrice); |
||||
|
|
||||
|
//mine some more to include the transaction on chain
|
||||
|
mine(c1, 1); |
||||
|
auto c2bal = c2.state().balance(kp2.address()); |
||||
|
BOOST_REQUIRE(c2bal > 0); |
||||
|
BOOST_REQUIRE(c2bal == txAmount); |
||||
|
} |
||||
|
|
||||
|
BOOST_AUTO_TEST_CASE(mine_and_send_to_peer_fee_check) |
||||
|
{ |
||||
|
KeyPair kp1 = KeyPair::create(); |
||||
|
KeyPair kp2 = KeyPair::create(); |
||||
|
|
||||
|
Client c1("TestClient1", kp1.address(), (boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
Client c2("TestClient2", kp2.address(), (boost::filesystem::temp_directory_path() / boost::filesystem::unique_path()).string()); |
||||
|
|
||||
|
connectClients(c1, c2); |
||||
|
|
||||
|
//mine some blocks so that client 1 has a balance
|
||||
|
mine(c1, 1); |
||||
|
|
||||
|
auto c1StartBalance = c1.state().balance(kp1.address()); |
||||
|
auto c2StartBalance = c2.state().balance(kp2.address()); |
||||
|
BOOST_REQUIRE(c1StartBalance > 0); |
||||
|
BOOST_REQUIRE(c2StartBalance == 0); |
||||
|
|
||||
|
//send c2 some eth from c1
|
||||
|
auto txAmount = c1StartBalance / 2u; |
||||
|
auto gasPrice = 10 * szabo; |
||||
|
auto gas = eth::c_callGas; |
||||
|
c1.transact(kp1.secret(), txAmount, c2.address(), bytes(), gas, gasPrice); |
||||
|
|
||||
|
//mine some more, this time with second client (so he can get fees from first client's tx)
|
||||
|
mine(c2, 1); |
||||
|
|
||||
|
auto c1EndBalance = c1.state().balance(kp1.address()); |
||||
|
auto c2EndBalance = c2.state().balance(kp2.address()); |
||||
|
BOOST_REQUIRE(c1EndBalance > 0); |
||||
|
BOOST_REQUIRE(c1EndBalance == c1StartBalance - txAmount - gasPrice * gas); |
||||
|
BOOST_REQUIRE(c2EndBalance > 0); |
||||
|
} |
||||
@ -0,0 +1,115 @@ |
|||||
|
cmake_policy(SET CMP0015 NEW) |
||||
|
|
||||
|
if ("${TARGET_PLATFORM}" STREQUAL "w64") |
||||
|
cmake_policy(SET CMP0020 NEW) |
||||
|
endif () |
||||
|
|
||||
|
|
||||
|
set(CMAKE_INCLUDE_CURRENT_DIR ON) |
||||
|
aux_source_directory(. SRC_LIST) |
||||
|
|
||||
|
include_directories(..) |
||||
|
link_directories(../libethereum) |
||||
|
|
||||
|
# Find Qt5 for Apple and update src_list for windows |
||||
|
if (APPLE) |
||||
|
# homebrew defaults to qt4 and installs qt5 as 'keg-only' |
||||
|
# which places it into /usr/local/opt insteadof /usr/local. |
||||
|
|
||||
|
set(CMAKE_PREFIX_PATH /usr/local/opt/qt5) |
||||
|
include_directories(/usr/local/opt/qt5/include /usr/local/include) |
||||
|
elseif (${TARGET_PLATFORM} STREQUAL "w64") |
||||
|
set(SRC_LIST ${SRC_LIST} ../windows/qt_plugin_import.cpp) |
||||
|
elseif (UNIX) |
||||
|
set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ";$ENV{QTDIR}/lib/cmake") |
||||
|
endif () |
||||
|
|
||||
|
|
||||
|
find_package(Qt5Widgets REQUIRED) |
||||
|
find_package(Qt5Gui REQUIRED) |
||||
|
find_package(Qt5Quick REQUIRED) |
||||
|
find_package(Qt5Qml REQUIRED) |
||||
|
find_package(Qt5Network REQUIRED) |
||||
|
qt5_wrap_ui(ui_Main.h Main.ui) |
||||
|
qt5_add_resources(RESOURCE_ADDED Resources.qrc) |
||||
|
|
||||
|
# Set name of binary and add_executable() |
||||
|
if (APPLE) |
||||
|
set(EXECUTEABLE Walleth) |
||||
|
set(CMAKE_INSTALL_PREFIX ./) |
||||
|
set(BIN_INSTALL_DIR ".") |
||||
|
set(DOC_INSTALL_DIR ".") |
||||
|
|
||||
|
set(PROJECT_VERSION "${ETH_VERSION}") |
||||
|
set(MACOSX_BUNDLE_INFO_STRING "${PROJECT_NAME} ${PROJECT_VERSION}") |
||||
|
set(MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_NAME} ${PROJECT_VERSION}") |
||||
|
set(MACOSX_BUNDLE_LONG_VERSION_STRING "${PROJECT_NAME} ${PROJECT_VERSION}") |
||||
|
set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION}") |
||||
|
set(MACOSX_BUNDLE_COPYRIGHT "${PROJECT_COPYRIGHT_YEAR} ${PROJECT_VENDOR}") |
||||
|
set(MACOSX_BUNDLE_GUI_IDENTIFIER "${PROJECT_DOMAIN_SECOND}.${PROJECT_DOMAIN_FIRST}") |
||||
|
set(MACOSX_BUNDLE_BUNDLE_NAME ${EXECUTEABLE}) |
||||
|
include(BundleUtilities) |
||||
|
|
||||
|
add_executable(${EXECUTEABLE} MACOSX_BUNDLE Main.ui ${RESOURCE_ADDED} ${SRC_LIST}) |
||||
|
else () |
||||
|
set(EXECUTEABLE walleth) |
||||
|
add_executable(${EXECUTEABLE} Main.ui ${RESOURCE_ADDED} ${SRC_LIST}) |
||||
|
endif () |
||||
|
|
||||
|
qt5_use_modules(${EXECUTEABLE} Core Gui Widgets Network Quick Qml) |
||||
|
target_link_libraries(${EXECUTEABLE} ethereum secp256k1 ${CRYPTOPP_LIBRARIES}) |
||||
|
|
||||
|
if (APPLE) |
||||
|
if (${ADDFRAMEWORKS}) |
||||
|
set_target_properties(${EXECUTEABLE} PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/EthereumMacOSXBundleInfo.plist.in") |
||||
|
endif () |
||||
|
|
||||
|
SET_SOURCE_FILES_PROPERTIES(${EXECUTEABLE} PROPERTIES MACOSX_PACKAGE_LOCATION MacOS) |
||||
|
|
||||
|
# This is a workaround for when the build-type defaults to Debug, and when a multi-config generator like xcode is used, where the type |
||||
|
# will not be set but defaults to release. |
||||
|
set(generator_lowercase "${CMAKE_GENERATOR}") |
||||
|
string(TOLOWER "${CMAKE_GENERATOR}" generator_lowercase) |
||||
|
if (generator_lowercase STREQUAL "xcode") |
||||
|
# TODO: Not sure how to resolve this. Possibly \${TARGET_BUILD_DIR} |
||||
|
set(binary_build_dir "${CMAKE_CURRENT_BINARY_DIR}/Debug") |
||||
|
else () |
||||
|
set(binary_build_dir "${CMAKE_CURRENT_BINARY_DIR}") |
||||
|
endif () |
||||
|
|
||||
|
set(APPS ${binary_build_dir}/${EXECUTEABLE}.app) |
||||
|
|
||||
|
# This tool and the next will automatically looked at the linked libraries in order to determine what dependencies are required. Thus, target_link_libaries only needs to add ethereum and secp256k1 (above) |
||||
|
install(CODE " |
||||
|
include(BundleUtilities) |
||||
|
set(BU_CHMOD_BUNDLE_ITEMS 1) |
||||
|
fixup_bundle(\"${APPS}\" \"${BUNDLELIBS}\" \"../libethereum ../secp256k1\") |
||||
|
" COMPONENT RUNTIME ) |
||||
|
|
||||
|
if (${ADDFRAMEWORKS}) |
||||
|
add_custom_target(addframeworks ALL |
||||
|
COMMAND /usr/local/opt/qt5/bin/macdeployqt ${binary_build_dir}/${EXECUTEABLE}.app |
||||
|
WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} |
||||
|
DEPENDS ${PROJECT_NAME} |
||||
|
) |
||||
|
endif () |
||||
|
|
||||
|
elseif (${TARGET_PLATFORM} STREQUAL "w64") |
||||
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-keep-inline-dllexport -static-libgcc -static-libstdc++ -static") |
||||
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-s -Wl,-subsystem,windows -mthreads -L/usr/x86_64-w64-mingw32/plugins/platforms") |
||||
|
target_link_libraries(${EXECUTEABLE} gcc) |
||||
|
target_link_libraries(${EXECUTEABLE} mingw32 qtmain mswsock iphlpapi qwindows shlwapi Qt5PlatformSupport gdi32 comdlg32 oleaut32 imm32 winmm ole32 uuid ws2_32) |
||||
|
target_link_libraries(${EXECUTEABLE} boost_system-mt-s) |
||||
|
target_link_libraries(${EXECUTEABLE} boost_filesystem-mt-s) |
||||
|
target_link_libraries(${EXECUTEABLE} boost_thread_win32-mt-s) |
||||
|
target_link_libraries(${EXECUTEABLE} Qt5PlatformSupport) |
||||
|
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS) |
||||
|
elseif (UNIX) |
||||
|
else () |
||||
|
target_link_libraries(${EXECUTEABLE} boost_system) |
||||
|
target_link_libraries(${EXECUTEABLE} boost_filesystem) |
||||
|
find_package(Threads REQUIRED) |
||||
|
target_link_libraries(${EXECUTEABLE} ${CMAKE_THREAD_LIBS_INIT}) |
||||
|
install( TARGETS ${EXECUTEABLE} RUNTIME DESTINATION bin ) |
||||
|
endif () |
||||
|
|
||||
@ -0,0 +1,168 @@ |
|||||
|
<?xml version="1.0" encoding="UTF-8"?> |
||||
|
<ui version="4.0"> |
||||
|
<class>Main</class> |
||||
|
<widget class="QMainWindow" name="Main"> |
||||
|
<property name="geometry"> |
||||
|
<rect> |
||||
|
<x>0</x> |
||||
|
<y>0</y> |
||||
|
<width>562</width> |
||||
|
<height>488</height> |
||||
|
</rect> |
||||
|
</property> |
||||
|
<property name="windowTitle"> |
||||
|
<string>Walleth</string> |
||||
|
</property> |
||||
|
<property name="dockNestingEnabled"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="dockOptions"> |
||||
|
<set>QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks|QMainWindow::VerticalTabs</set> |
||||
|
</property> |
||||
|
<property name="sizeGripEnabled" stdset="0"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<widget class="QWidget" name="centralwidget"> |
||||
|
<layout class="QVBoxLayout" name="verticalLayout"> |
||||
|
<property name="leftMargin"> |
||||
|
<number>0</number> |
||||
|
</property> |
||||
|
<property name="topMargin"> |
||||
|
<number>0</number> |
||||
|
</property> |
||||
|
<property name="rightMargin"> |
||||
|
<number>0</number> |
||||
|
</property> |
||||
|
<property name="bottomMargin"> |
||||
|
<number>0</number> |
||||
|
</property> |
||||
|
<item> |
||||
|
<layout class="QHBoxLayout" name="fullDisplay"> |
||||
|
<item> |
||||
|
<widget class="QLabel" name="balance"> |
||||
|
<property name="text"> |
||||
|
<string>0 wei</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<widget class="QLabel" name="peerCount"> |
||||
|
<property name="text"> |
||||
|
<string>0 peers</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
<item> |
||||
|
<widget class="QLabel" name="blockCount"> |
||||
|
<property name="text"> |
||||
|
<string>1 block</string> |
||||
|
</property> |
||||
|
</widget> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</item> |
||||
|
</layout> |
||||
|
</widget> |
||||
|
<widget class="QMenuBar" name="menubar"> |
||||
|
<property name="geometry"> |
||||
|
<rect> |
||||
|
<x>0</x> |
||||
|
<y>0</y> |
||||
|
<width>562</width> |
||||
|
<height>20</height> |
||||
|
</rect> |
||||
|
</property> |
||||
|
<widget class="QMenu" name="menu_File"> |
||||
|
<property name="title"> |
||||
|
<string>&File</string> |
||||
|
</property> |
||||
|
<addaction name="quit"/> |
||||
|
</widget> |
||||
|
<widget class="QMenu" name="menu_Network"> |
||||
|
<property name="title"> |
||||
|
<string>&Network</string> |
||||
|
</property> |
||||
|
<addaction name="upnp"/> |
||||
|
<addaction name="net"/> |
||||
|
<addaction name="connect"/> |
||||
|
</widget> |
||||
|
<widget class="QMenu" name="menu_Tools"> |
||||
|
<property name="title"> |
||||
|
<string>T&ools</string> |
||||
|
</property> |
||||
|
<addaction name="mine"/> |
||||
|
<addaction name="create"/> |
||||
|
<addaction name="preview"/> |
||||
|
</widget> |
||||
|
<widget class="QMenu" name="menu_Help"> |
||||
|
<property name="title"> |
||||
|
<string>&Help</string> |
||||
|
</property> |
||||
|
<addaction name="about"/> |
||||
|
</widget> |
||||
|
<addaction name="menu_File"/> |
||||
|
<addaction name="menu_Network"/> |
||||
|
<addaction name="menu_Tools"/> |
||||
|
<addaction name="menu_Help"/> |
||||
|
</widget> |
||||
|
<widget class="QStatusBar" name="statusbar"/> |
||||
|
<action name="quit"> |
||||
|
<property name="text"> |
||||
|
<string>&Quit</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="upnp"> |
||||
|
<property name="checkable"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="checked"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="text"> |
||||
|
<string>Use &UPnP</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="connect"> |
||||
|
<property name="text"> |
||||
|
<string>&Connect to Peer...</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="net"> |
||||
|
<property name="checkable"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="text"> |
||||
|
<string>Enable &Network</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="mine"> |
||||
|
<property name="checkable"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="text"> |
||||
|
<string>&Mine</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="create"> |
||||
|
<property name="text"> |
||||
|
<string>&New Address</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="about"> |
||||
|
<property name="text"> |
||||
|
<string>&About...</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
<action name="preview"> |
||||
|
<property name="checkable"> |
||||
|
<bool>true</bool> |
||||
|
</property> |
||||
|
<property name="text"> |
||||
|
<string>&Preview</string> |
||||
|
</property> |
||||
|
</action> |
||||
|
</widget> |
||||
|
<layoutdefault spacing="6" margin="11"/> |
||||
|
<resources/> |
||||
|
<connections/> |
||||
|
</ui> |
||||
@ -0,0 +1,448 @@ |
|||||
|
#include <QtNetwork/QNetworkReply> |
||||
|
#include <QtQuick/QQuickView> |
||||
|
//#include <QtQml/QQmlContext>
|
||||
|
//#include <QtQml/QQmlEngine>
|
||||
|
#include <QtQml/QtQml> |
||||
|
#include <QtWidgets/QMessageBox> |
||||
|
#include <QtWidgets/QInputDialog> |
||||
|
#include <QtGui/QClipboard> |
||||
|
#include <QtCore/QtCore> |
||||
|
#include <libethereum/Dagger.h> |
||||
|
#include <libethereum/Client.h> |
||||
|
#include <libethereum/Instruction.h> |
||||
|
#include <libethereum/FileSystem.h> |
||||
|
#include <libethereum/PeerServer.h> |
||||
|
#include "BuildInfo.h" |
||||
|
#include "MainWin.h" |
||||
|
#include "ui_Main.h" |
||||
|
using namespace std; |
||||
|
|
||||
|
// types
|
||||
|
using eth::bytes; |
||||
|
using eth::bytesConstRef; |
||||
|
using eth::h160; |
||||
|
using eth::h256; |
||||
|
using eth::u160; |
||||
|
using eth::u256; |
||||
|
using eth::u256s; |
||||
|
using eth::Address; |
||||
|
using eth::BlockInfo; |
||||
|
using eth::Client; |
||||
|
using eth::Instruction; |
||||
|
using eth::KeyPair; |
||||
|
using eth::NodeMode; |
||||
|
using eth::PeerInfo; |
||||
|
using eth::RLP; |
||||
|
using eth::Secret; |
||||
|
using eth::Transaction; |
||||
|
|
||||
|
// functions
|
||||
|
using eth::toHex; |
||||
|
using eth::assemble; |
||||
|
using eth::compileLisp; |
||||
|
using eth::disassemble; |
||||
|
using eth::formatBalance; |
||||
|
using eth::fromHex; |
||||
|
using eth::right160; |
||||
|
using eth::simpleDebugOut; |
||||
|
using eth::toLog2; |
||||
|
using eth::toString; |
||||
|
using eth::units; |
||||
|
|
||||
|
// vars
|
||||
|
using eth::g_logPost; |
||||
|
using eth::g_logVerbosity; |
||||
|
using eth::c_instructionInfo; |
||||
|
|
||||
|
// Horrible global for the mainwindow. Needed for the QEthereums to find the Main window which acts as multiplexer for now.
|
||||
|
// Can get rid of this once we've sorted out ITC for signalling & multiplexed querying.
|
||||
|
Main* g_main = nullptr; |
||||
|
|
||||
|
QEthereum::QEthereum(QObject* _p): QObject(_p) |
||||
|
{ |
||||
|
connect(g_main, SIGNAL(changed()), SIGNAL(changed())); |
||||
|
} |
||||
|
|
||||
|
QEthereum::~QEthereum() |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
Client* QEthereum::client() const |
||||
|
{ |
||||
|
return g_main->client(); |
||||
|
} |
||||
|
|
||||
|
Address QEthereum::coinbase() const |
||||
|
{ |
||||
|
return client()->address(); |
||||
|
} |
||||
|
|
||||
|
void QEthereum::setCoinbase(Address _a) |
||||
|
{ |
||||
|
if (client()->address() != _a) |
||||
|
{ |
||||
|
client()->setAddress(_a); |
||||
|
changed(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
QAccount::QAccount(QObject*) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
QAccount::~QAccount() |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
void QAccount::setEthereum(QEthereum* _eth) |
||||
|
{ |
||||
|
if (m_eth == _eth) |
||||
|
return; |
||||
|
if (m_eth) |
||||
|
disconnect(m_eth, SIGNAL(changed()), this, SIGNAL(changed())); |
||||
|
m_eth = _eth; |
||||
|
if (m_eth) |
||||
|
connect(m_eth, SIGNAL(changed()), this, SIGNAL(changed())); |
||||
|
ethChanged(); |
||||
|
changed(); |
||||
|
} |
||||
|
|
||||
|
u256 QAccount::balance() const |
||||
|
{ |
||||
|
if (m_eth) |
||||
|
return m_eth->balanceAt(m_address); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
double QAccount::txCount() const |
||||
|
{ |
||||
|
if (m_eth) |
||||
|
return m_eth->txCountAt(m_address); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
bool QAccount::isContract() const |
||||
|
{ |
||||
|
if (m_eth) |
||||
|
return m_eth->isContractAt(m_address); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
u256 QEthereum::balanceAt(Address _a) const |
||||
|
{ |
||||
|
return client()->postState().balance(_a); |
||||
|
} |
||||
|
|
||||
|
bool QEthereum::isContractAt(Address _a) const |
||||
|
{ |
||||
|
return client()->postState().isContractAddress(_a); |
||||
|
} |
||||
|
|
||||
|
bool QEthereum::isMining() const |
||||
|
{ |
||||
|
return client()->isMining(); |
||||
|
} |
||||
|
|
||||
|
bool QEthereum::isListening() const |
||||
|
{ |
||||
|
return client()->haveNetwork(); |
||||
|
} |
||||
|
|
||||
|
void QEthereum::setMining(bool _l) |
||||
|
{ |
||||
|
if (_l) |
||||
|
client()->startMining(); |
||||
|
else |
||||
|
client()->stopMining(); |
||||
|
} |
||||
|
|
||||
|
void QEthereum::setListening(bool _l) |
||||
|
{ |
||||
|
if (_l) |
||||
|
client()->startNetwork(); |
||||
|
else |
||||
|
client()->stopNetwork(); |
||||
|
} |
||||
|
|
||||
|
double QEthereum::txCountAt(Address _a) const |
||||
|
{ |
||||
|
return (double)client()->postState().transactionsFrom(_a); |
||||
|
} |
||||
|
|
||||
|
unsigned QEthereum::peerCount() const |
||||
|
{ |
||||
|
return (unsigned)client()->peerCount(); |
||||
|
} |
||||
|
|
||||
|
void QEthereum::transact(Secret _secret, u256 _amount, u256 _gasPrice, u256 _gas, QByteArray _code, QByteArray _init) |
||||
|
{ |
||||
|
client()->transact(_secret, _amount, bytes(_code.data(), _code.data() + _code.size()), bytes(_init.data(), _init.data() + _init.size()), _gas, _gasPrice); |
||||
|
} |
||||
|
|
||||
|
void QEthereum::transact(Secret _secret, Address _dest, u256 _amount, u256 _gasPrice, u256 _gas, QByteArray _data) |
||||
|
{ |
||||
|
client()->transact(_secret, _amount, _dest, bytes(_data.data(), _data.data() + _data.size()), _gas, _gasPrice); |
||||
|
} |
||||
|
|
||||
|
Main::Main(QWidget *parent) : |
||||
|
QMainWindow(parent), |
||||
|
ui(new Ui::Main) |
||||
|
{ |
||||
|
setWindowFlags(Qt::Window); |
||||
|
ui->setupUi(this); |
||||
|
setWindowIcon(QIcon(":/Ethereum.png")); |
||||
|
|
||||
|
g_main = this; |
||||
|
|
||||
|
m_client.reset(new Client("Walleth", Address(), eth::getDataDir() + "/Walleth")); |
||||
|
|
||||
|
qRegisterMetaType<eth::u256>("eth::u256"); |
||||
|
qRegisterMetaType<eth::KeyPair>("eth::KeyPair"); |
||||
|
qRegisterMetaType<eth::Secret>("eth::Secret"); |
||||
|
qRegisterMetaType<eth::Address>("eth::Address"); |
||||
|
qRegisterMetaType<QAccount*>("QAccount*"); |
||||
|
qRegisterMetaType<QEthereum*>("QEthereum*"); |
||||
|
|
||||
|
qmlRegisterType<QEthereum>("org.ethereum", 1, 0, "Ethereum"); |
||||
|
qmlRegisterType<QAccount>("org.ethereum", 1, 0, "Account"); |
||||
|
qmlRegisterSingletonType<U256Helper>("org.ethereum", 1, 0, "Balance", QEthereum::constructU256Helper); |
||||
|
qmlRegisterSingletonType<KeyHelper>("org.ethereum", 1, 0, "Key", QEthereum::constructKeyHelper); |
||||
|
|
||||
|
/*
|
||||
|
ui->librariesView->setModel(m_libraryMan); |
||||
|
ui->graphsView->setModel(m_graphMan); |
||||
|
*/ |
||||
|
|
||||
|
m_view = new QQuickView(); |
||||
|
|
||||
|
// QQmlContext* context = m_view->rootContext();
|
||||
|
// context->setContextProperty("u256", new U256Helper(this));
|
||||
|
|
||||
|
m_view->setSource(QUrl("qrc:/Simple.qml")); |
||||
|
|
||||
|
QWidget* w = QWidget::createWindowContainer(m_view); |
||||
|
m_view->setResizeMode(QQuickView::SizeRootObjectToView); |
||||
|
ui->fullDisplay->insertWidget(0, w); |
||||
|
m_view->create(); |
||||
|
|
||||
|
// m_timelinesItem = m_view->rootObject()->findChild<TimelinesItem*>("timelines");
|
||||
|
|
||||
|
readSettings(); |
||||
|
refresh(); |
||||
|
|
||||
|
m_refreshNetwork = new QTimer(this); |
||||
|
connect(m_refreshNetwork, SIGNAL(timeout()), SLOT(refreshNetwork())); |
||||
|
m_refreshNetwork->start(1000); |
||||
|
|
||||
|
connect(this, SIGNAL(changed()), SLOT(refresh())); |
||||
|
|
||||
|
connect(&m_webCtrl, &QNetworkAccessManager::finished, [&](QNetworkReply* _r) |
||||
|
{ |
||||
|
m_servers = QString::fromUtf8(_r->readAll()).split("\n", QString::SkipEmptyParts); |
||||
|
if (m_servers.size()) |
||||
|
{ |
||||
|
ui->net->setChecked(true); |
||||
|
on_net_triggered(true); |
||||
|
} |
||||
|
}); |
||||
|
QNetworkRequest r(QUrl("http://www.ethereum.org/servers.poc" + QString(ETH_QUOTED(ETH_VERSION)).section('.', 1, 1) + ".txt")); |
||||
|
r.setHeader(QNetworkRequest::UserAgentHeader, "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1712.0 Safari/537.36"); |
||||
|
m_webCtrl.get(r); |
||||
|
srand(time(0)); |
||||
|
|
||||
|
startTimer(200); |
||||
|
|
||||
|
statusBar()->addPermanentWidget(ui->balance); |
||||
|
statusBar()->addPermanentWidget(ui->peerCount); |
||||
|
statusBar()->addPermanentWidget(ui->blockCount); |
||||
|
} |
||||
|
|
||||
|
Main::~Main() |
||||
|
{ |
||||
|
writeSettings(); |
||||
|
} |
||||
|
|
||||
|
void Main::timerEvent(QTimerEvent *) |
||||
|
{ |
||||
|
if (m_client->changed()) |
||||
|
changed(); |
||||
|
} |
||||
|
|
||||
|
void Main::on_about_triggered() |
||||
|
{ |
||||
|
QMessageBox::about(this, "About Walleth PoC-" + QString(ETH_QUOTED(ETH_VERSION)).section('.', 1, 1), "Walleth/v" ETH_QUOTED(ETH_VERSION) "/" ETH_QUOTED(ETH_BUILD_TYPE) "/" ETH_QUOTED(ETH_BUILD_PLATFORM) " - " ETH_QUOTED(ETH_COMMIT_HASH) "\nBy Gav Wood, 2014.\nBased on a design by Vitalik Buterin.\n\nTeam Ethereum++ includes: Tim Hughes, Eric Lombrozo, Marko Simovic, Alex Leverington and several others."); |
||||
|
} |
||||
|
|
||||
|
void Main::writeSettings() |
||||
|
{ |
||||
|
QSettings s("ethereum", "walleth"); |
||||
|
QByteArray b; |
||||
|
b.resize(sizeof(Secret) * m_myKeys.size()); |
||||
|
auto p = b.data(); |
||||
|
for (auto i: m_myKeys) |
||||
|
{ |
||||
|
memcpy(p, &(i.secret()), sizeof(Secret)); |
||||
|
p += sizeof(Secret); |
||||
|
} |
||||
|
s.setValue("address", b); |
||||
|
|
||||
|
s.setValue("upnp", ui->upnp->isChecked()); |
||||
|
s.setValue("clientName", m_clientName); |
||||
|
s.setValue("idealPeers", m_idealPeers); |
||||
|
s.setValue("port", m_port); |
||||
|
|
||||
|
if (client()->peerServer()) |
||||
|
{ |
||||
|
bytes d = client()->peerServer()->savePeers(); |
||||
|
m_peers = QByteArray((char*)d.data(), (int)d.size()); |
||||
|
|
||||
|
} |
||||
|
s.setValue("peers", m_peers); |
||||
|
|
||||
|
s.setValue("geometry", saveGeometry()); |
||||
|
s.setValue("windowState", saveState()); |
||||
|
} |
||||
|
|
||||
|
void Main::readSettings() |
||||
|
{ |
||||
|
QSettings s("ethereum", "walleth"); |
||||
|
|
||||
|
restoreGeometry(s.value("geometry").toByteArray()); |
||||
|
restoreState(s.value("windowState").toByteArray()); |
||||
|
|
||||
|
QByteArray b = s.value("address").toByteArray(); |
||||
|
if (b.isEmpty()) |
||||
|
m_myKeys.append(KeyPair::create()); |
||||
|
else |
||||
|
{ |
||||
|
h256 k; |
||||
|
for (unsigned i = 0; i < b.size() / sizeof(Secret); ++i) |
||||
|
{ |
||||
|
memcpy(&k, b.data() + i * sizeof(Secret), sizeof(Secret)); |
||||
|
m_myKeys.append(KeyPair(k)); |
||||
|
} |
||||
|
} |
||||
|
//m_eth->setAddress(m_myKeys.last().address());
|
||||
|
m_peers = s.value("peers").toByteArray(); |
||||
|
ui->upnp->setChecked(s.value("upnp", true).toBool()); |
||||
|
m_clientName = s.value("clientName", "").toString(); |
||||
|
m_idealPeers = s.value("idealPeers", 5).toInt(); |
||||
|
m_port = s.value("port", 30303).toInt(); |
||||
|
} |
||||
|
|
||||
|
void Main::refreshNetwork() |
||||
|
{ |
||||
|
auto ps = client()->peers(); |
||||
|
ui->peerCount->setText(QString::fromStdString(toString(ps.size())) + " peer(s)"); |
||||
|
} |
||||
|
|
||||
|
eth::State const& Main::state() const |
||||
|
{ |
||||
|
return ui->preview->isChecked() ? client()->postState() : client()->state(); |
||||
|
} |
||||
|
|
||||
|
void Main::refresh() |
||||
|
{ |
||||
|
eth::ClientGuard l(client()); |
||||
|
auto const& st = state(); |
||||
|
|
||||
|
auto d = client()->blockChain().details(); |
||||
|
auto diff = BlockInfo(client()->blockChain().block()).difficulty; |
||||
|
ui->blockCount->setText(QString("#%1 @%3 T%2").arg(d.number).arg(toLog2(d.totalDifficulty)).arg(toLog2(diff))); |
||||
|
|
||||
|
m_keysChanged = false; |
||||
|
u256 totalBalance = 0; |
||||
|
for (auto i: m_myKeys) |
||||
|
{ |
||||
|
u256 b = st.balance(i.address()); |
||||
|
totalBalance += b; |
||||
|
} |
||||
|
ui->balance->setText(QString::fromStdString(formatBalance(totalBalance))); |
||||
|
} |
||||
|
|
||||
|
void Main::on_net_triggered(bool _auto) |
||||
|
{ |
||||
|
string n = "Walleth/v" ETH_QUOTED(ETH_VERSION); |
||||
|
if (m_clientName.size()) |
||||
|
n += "/" + m_clientName.toStdString(); |
||||
|
n += "/" ETH_QUOTED(ETH_BUILD_TYPE) "/" ETH_QUOTED(ETH_BUILD_PLATFORM); |
||||
|
client()->setClientVersion(n); |
||||
|
if (ui->net->isChecked()) |
||||
|
{ |
||||
|
if (_auto) |
||||
|
{ |
||||
|
QString s = m_servers[rand() % m_servers.size()]; |
||||
|
client()->startNetwork(m_port, s.section(':', 0, 0).toStdString(), s.section(':', 1).toInt(), NodeMode::Full, m_idealPeers, std::string(), ui->upnp->isChecked()); |
||||
|
} |
||||
|
else |
||||
|
client()->startNetwork(m_port, string(), 0, NodeMode::Full, m_idealPeers, std::string(), ui->upnp->isChecked()); |
||||
|
if (m_peers.size()) |
||||
|
client()->peerServer()->restorePeers(bytesConstRef((byte*)m_peers.data(), m_peers.size())); |
||||
|
} |
||||
|
else |
||||
|
client()->stopNetwork(); |
||||
|
} |
||||
|
|
||||
|
void Main::on_connect_triggered() |
||||
|
{ |
||||
|
if (!ui->net->isChecked()) |
||||
|
{ |
||||
|
ui->net->setChecked(true); |
||||
|
on_net_triggered(); |
||||
|
} |
||||
|
bool ok = false; |
||||
|
QString s = QInputDialog::getItem(this, "Connect to a Network Peer", "Enter a peer to which a connection may be made:", m_servers, m_servers.count() ? rand() % m_servers.count() : 0, true, &ok); |
||||
|
if (ok && s.contains(":")) |
||||
|
{ |
||||
|
string host = s.section(":", 0, 0).toStdString(); |
||||
|
unsigned short port = s.section(":", 1).toInt(); |
||||
|
client()->connect(host, port); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Main::on_mine_triggered() |
||||
|
{ |
||||
|
if (ui->mine->isChecked()) |
||||
|
{ |
||||
|
client()->setAddress(m_myKeys.last().address()); |
||||
|
client()->startMining(); |
||||
|
} |
||||
|
else |
||||
|
client()->stopMining(); |
||||
|
} |
||||
|
|
||||
|
void Main::on_create_triggered() |
||||
|
{ |
||||
|
m_myKeys.append(KeyPair::create()); |
||||
|
m_keysChanged = true; |
||||
|
} |
||||
|
|
||||
|
// extra bits needed to link on VS
|
||||
|
#ifdef _MSC_VER |
||||
|
|
||||
|
// include moc file, ofuscated to hide from automoc
|
||||
|
#include\ |
||||
|
"moc_MainWin.cpp" |
||||
|
|
||||
|
// specify library dependencies, it's easier to do here than in the project since we can control the "d" debug suffix
|
||||
|
#ifdef _DEBUG |
||||
|
#define QTLIB(x) x"d.lib" |
||||
|
#else |
||||
|
#define QTLIB(x) x".lib" |
||||
|
#endif |
||||
|
|
||||
|
#pragma comment(lib, QTLIB("Qt5PlatformSupport")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Core")) |
||||
|
#pragma comment(lib, QTLIB("Qt5GUI")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Widgets")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Network")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Quick")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Declarative")) |
||||
|
#pragma comment(lib, QTLIB("Qt5Qml")) |
||||
|
#pragma comment(lib, QTLIB("qwindows")) |
||||
|
#pragma comment(lib, "Imm32.lib") |
||||
|
#pragma comment(lib, "opengl32.lib") |
||||
|
#pragma comment(lib, "winmm.lib") |
||||
|
|
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,224 @@ |
|||||
|
#ifndef MAIN_H |
||||
|
#define MAIN_H |
||||
|
|
||||
|
#include <QtNetwork/QNetworkAccessManager> |
||||
|
#include <QtCore/QAbstractListModel> |
||||
|
#include <QtCore/QMutex> |
||||
|
#include <QtWidgets/QMainWindow> |
||||
|
#include <libethereum/CommonEth.h> |
||||
|
|
||||
|
namespace Ui { |
||||
|
class Main; |
||||
|
} |
||||
|
|
||||
|
namespace eth { |
||||
|
class Client; |
||||
|
class State; |
||||
|
} |
||||
|
|
||||
|
class QQuickView; |
||||
|
class QQmlEngine; |
||||
|
class QJSEngine; |
||||
|
|
||||
|
class QEthereum; |
||||
|
class QAccount; |
||||
|
|
||||
|
Q_DECLARE_METATYPE(eth::u256) |
||||
|
Q_DECLARE_METATYPE(eth::Address) |
||||
|
Q_DECLARE_METATYPE(eth::Secret) |
||||
|
Q_DECLARE_METATYPE(eth::KeyPair) |
||||
|
Q_DECLARE_METATYPE(QEthereum*) |
||||
|
Q_DECLARE_METATYPE(QAccount*) |
||||
|
|
||||
|
class U256Helper: public QObject |
||||
|
{ |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
U256Helper(QObject* _p = nullptr): QObject(_p) {} |
||||
|
|
||||
|
Q_INVOKABLE eth::u256 add(eth::u256 _a, eth::u256 _b) const { return _a + _b; } |
||||
|
Q_INVOKABLE eth::u256 sub(eth::u256 _a, eth::u256 _b) const { return _a - _b; } |
||||
|
Q_INVOKABLE eth::u256 mul(eth::u256 _a, int _b) const { return _a * _b; } |
||||
|
Q_INVOKABLE eth::u256 mul(int _a, eth::u256 _b) const { return _a * _b; } |
||||
|
Q_INVOKABLE eth::u256 div(eth::u256 _a, int _b) const { return _a / _b; } |
||||
|
|
||||
|
Q_INVOKABLE eth::u256 wei(double _s) const { return (eth::u256)_s; } |
||||
|
Q_INVOKABLE eth::u256 szabo(double _s) const { return (eth::u256)(_s * (double)eth::szabo); } |
||||
|
Q_INVOKABLE eth::u256 finney(double _s) const { return (eth::u256)(_s * (double)eth::finney); } |
||||
|
Q_INVOKABLE eth::u256 ether(double _s) const { return (eth::u256)(_s * (double)eth::ether); } |
||||
|
Q_INVOKABLE eth::u256 wei(unsigned _s) const { return (eth::u256)_s; } |
||||
|
Q_INVOKABLE eth::u256 szabo(unsigned _s) const { return (eth::u256)(_s * eth::szabo); } |
||||
|
Q_INVOKABLE eth::u256 finney(unsigned _s) const { return (eth::u256)(_s * eth::finney); } |
||||
|
Q_INVOKABLE eth::u256 ether(unsigned _s) const { return (eth::u256)(_s * eth::ether); } |
||||
|
Q_INVOKABLE double toWei(eth::u256 _t) const { return (double)_t; } |
||||
|
Q_INVOKABLE double toSzabo(eth::u256 _t) const { return toWei(_t) / (double)eth::szabo; } |
||||
|
Q_INVOKABLE double toFinney(eth::u256 _t) const { return toWei(_t) / (double)eth::finney; } |
||||
|
Q_INVOKABLE double toEther(eth::u256 _t) const { return toWei(_t) / (double)eth::ether; } |
||||
|
|
||||
|
Q_INVOKABLE double value(eth::u256 _t) const { return (double)_t; } |
||||
|
|
||||
|
Q_INVOKABLE QString stringOf(eth::u256 _t) const { return QString::fromStdString(eth::formatBalance(_t)); } |
||||
|
}; |
||||
|
|
||||
|
class KeyHelper: public QObject |
||||
|
{ |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
KeyHelper(QObject* _p = nullptr): QObject(_p) {} |
||||
|
|
||||
|
Q_INVOKABLE eth::KeyPair create() const { return eth::KeyPair::create(); } |
||||
|
Q_INVOKABLE eth::Address address(eth::KeyPair _p) const { return _p.address(); } |
||||
|
Q_INVOKABLE eth::Secret secret(eth::KeyPair _p) const { return _p.secret(); } |
||||
|
Q_INVOKABLE eth::KeyPair keypair(eth::Secret _k) const { return eth::KeyPair(_k); } |
||||
|
|
||||
|
Q_INVOKABLE bool isNull(eth::Address _a) const { return !_a; } |
||||
|
|
||||
|
Q_INVOKABLE eth::Address addressOf(QString _s) const { return eth::Address(_s.toStdString()); } |
||||
|
Q_INVOKABLE QString stringOf(eth::Address _a) const { return QString::fromStdString(eth::toHex(_a.asArray())); } |
||||
|
Q_INVOKABLE QString toAbridged(eth::Address _a) const { return QString::fromStdString(_a.abridged()); } |
||||
|
}; |
||||
|
|
||||
|
class QAccount: public QObject |
||||
|
{ |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
QAccount(QObject* _p = nullptr); |
||||
|
virtual ~QAccount(); |
||||
|
|
||||
|
Q_INVOKABLE QEthereum* ethereum() const { return m_eth; } |
||||
|
Q_INVOKABLE eth::u256 balance() const; |
||||
|
Q_INVOKABLE double txCount() const; |
||||
|
Q_INVOKABLE bool isContract() const; |
||||
|
|
||||
|
// TODO: past transactions models.
|
||||
|
|
||||
|
public slots: |
||||
|
void setEthereum(QEthereum* _eth); |
||||
|
|
||||
|
signals: |
||||
|
void changed(); |
||||
|
void ethChanged(); |
||||
|
|
||||
|
private: |
||||
|
QEthereum* m_eth = nullptr; |
||||
|
eth::Address m_address; |
||||
|
|
||||
|
Q_PROPERTY(eth::u256 balance READ balance NOTIFY changed STORED false) |
||||
|
Q_PROPERTY(double txCount READ txCount NOTIFY changed STORED false) |
||||
|
Q_PROPERTY(bool isContract READ isContract NOTIFY changed STORED false) |
||||
|
Q_PROPERTY(eth::Address address MEMBER m_address NOTIFY changed) |
||||
|
Q_PROPERTY(QEthereum* ethereum READ ethereum WRITE setEthereum NOTIFY ethChanged) |
||||
|
}; |
||||
|
|
||||
|
class QEthereum: public QObject |
||||
|
{ |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
QEthereum(QObject* _p = nullptr); |
||||
|
virtual ~QEthereum(); |
||||
|
|
||||
|
eth::Client* client() const; |
||||
|
|
||||
|
static QObject* constructU256Helper(QQmlEngine*, QJSEngine*) { return new U256Helper; } |
||||
|
static QObject* constructKeyHelper(QQmlEngine*, QJSEngine*) { return new KeyHelper; } |
||||
|
|
||||
|
Q_INVOKABLE eth::Address coinbase() const; |
||||
|
|
||||
|
Q_INVOKABLE bool isListening() const; |
||||
|
Q_INVOKABLE bool isMining() const; |
||||
|
|
||||
|
Q_INVOKABLE eth::u256 balanceAt(eth::Address _a) const; |
||||
|
Q_INVOKABLE double txCountAt(eth::Address _a) const; |
||||
|
Q_INVOKABLE bool isContractAt(eth::Address _a) const; |
||||
|
|
||||
|
Q_INVOKABLE unsigned peerCount() const; |
||||
|
|
||||
|
Q_INVOKABLE QEthereum* self() { return this; } |
||||
|
|
||||
|
public slots: |
||||
|
void transact(eth::Secret _secret, eth::Address _dest, eth::u256 _amount, eth::u256 _gasPrice, eth::u256 _gas, QByteArray _data); |
||||
|
void transact(eth::Secret _secret, eth::u256 _amount, eth::u256 _gasPrice, eth::u256 _gas, QByteArray _code, QByteArray _init); |
||||
|
void setCoinbase(eth::Address); |
||||
|
void setMining(bool _l); |
||||
|
|
||||
|
void setListening(bool _l); |
||||
|
|
||||
|
signals: |
||||
|
void changed(); |
||||
|
// void netChanged();
|
||||
|
// void miningChanged();
|
||||
|
|
||||
|
private: |
||||
|
Q_PROPERTY(eth::Address coinbase READ coinbase WRITE setCoinbase NOTIFY changed) |
||||
|
Q_PROPERTY(bool listening READ isListening WRITE setListening) |
||||
|
Q_PROPERTY(bool mining READ isMining WRITE setMining) |
||||
|
}; |
||||
|
|
||||
|
class Main : public QMainWindow |
||||
|
{ |
||||
|
Q_OBJECT |
||||
|
|
||||
|
public: |
||||
|
explicit Main(QWidget *parent = 0); |
||||
|
~Main(); |
||||
|
|
||||
|
eth::Client* client() const { return m_client.get(); } |
||||
|
|
||||
|
private slots: |
||||
|
void on_connect_triggered(); |
||||
|
void on_mine_triggered(); |
||||
|
void on_create_triggered(); |
||||
|
void on_net_triggered(bool _auto = false); |
||||
|
void on_about_triggered(); |
||||
|
void on_preview_triggered() { refresh(); } |
||||
|
void on_quit_triggered() { close(); } |
||||
|
|
||||
|
void refresh(); |
||||
|
void refreshNetwork(); |
||||
|
|
||||
|
signals: |
||||
|
void changed(); |
||||
|
|
||||
|
protected: |
||||
|
virtual void timerEvent(QTimerEvent *); |
||||
|
|
||||
|
private: |
||||
|
/* QString pretty(eth::Address _a) const;
|
||||
|
QString render(eth::Address _a) const; |
||||
|
eth::Address fromString(QString const& _a) const; |
||||
|
*/ |
||||
|
eth::State const& state() const; |
||||
|
|
||||
|
void updateFee(); |
||||
|
void readSettings(); |
||||
|
void writeSettings(); |
||||
|
|
||||
|
eth::u256 fee() const; |
||||
|
eth::u256 total() const; |
||||
|
eth::u256 value() const; |
||||
|
|
||||
|
std::unique_ptr<Ui::Main> ui; |
||||
|
|
||||
|
QByteArray m_peers; |
||||
|
QMutex m_guiLock; |
||||
|
QTimer* m_refresh; |
||||
|
QTimer* m_refreshNetwork; |
||||
|
QVector<eth::KeyPair> m_myKeys; |
||||
|
bool m_keysChanged = false; |
||||
|
int m_port; |
||||
|
int m_idealPeers; |
||||
|
QString m_clientName; |
||||
|
QStringList m_servers; |
||||
|
|
||||
|
QQuickView* m_view; |
||||
|
|
||||
|
QNetworkAccessManager m_webCtrl; |
||||
|
|
||||
|
std::unique_ptr<eth::Client> m_client; |
||||
|
}; |
||||
|
|
||||
|
#endif // MAIN_H
|
||||
@ -0,0 +1,5 @@ |
|||||
|
<RCC> |
||||
|
<qresource prefix="/"> |
||||
|
<file>Simple.qml</file> |
||||
|
</qresource> |
||||
|
</RCC> |
||||
@ -0,0 +1,38 @@ |
|||||
|
import QtQml 2.2 |
||||
|
import QtQuick 2.1 |
||||
|
import QtQuick.Controls 1.0 |
||||
|
import QtQuick.Layouts 1.0 |
||||
|
import Qt.labs.settings 1.0 |
||||
|
import org.ethereum 1.0 |
||||
|
|
||||
|
Item { |
||||
|
id: main |
||||
|
anchors.fill: parent |
||||
|
anchors.margins: 9 |
||||
|
|
||||
|
// Qt.application.name: "Walleth" |
||||
|
// Qt.application.organization: "Ethereum" |
||||
|
// Qt.application.domain: "org.ethereum" |
||||
|
|
||||
|
Ethereum { |
||||
|
id: eth |
||||
|
} |
||||
|
|
||||
|
Account { |
||||
|
id: myAccount |
||||
|
address: Key.addressOf("84fc4ba9373c30bfe32d8c5a502854e7f1175878") |
||||
|
ethereum: eth |
||||
|
// TODO: state: eth.latest // could be eth.pending |
||||
|
// will provide balance, txCount, isContract, incomingTransactions (list model), outgoingTransactions (list model). |
||||
|
// transaction lists' items will provide value, from, to, final balance. |
||||
|
} |
||||
|
|
||||
|
// KeyPair provides makeTransaction(recvAddress, value, data (array)) |
||||
|
|
||||
|
Text { |
||||
|
text: "Balance: " + Balance.stringOf(myAccount.balance) + " [" + myAccount.txCount + "]" + "\nAccount: " + Key.stringOf(myAccount.address) |
||||
|
Layout.minimumHeight: 30 |
||||
|
Layout.fillHeight: true |
||||
|
Layout.fillWidth: true |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,11 @@ |
|||||
|
#include "MainWin.h" |
||||
|
#include <QtWidgets/QApplication> |
||||
|
|
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
QApplication a(argc, argv); |
||||
|
Main w; |
||||
|
w.show(); |
||||
|
|
||||
|
return a.exec(); |
||||
|
} |
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue