yann300
10 years ago
189 changed files with 9002 additions and 4669 deletions
@ -0,0 +1,126 @@ |
|||
/*
|
|||
base64.cpp and base64.h |
|||
|
|||
Copyright (C) 2004-2008 René Nyffenegger |
|||
|
|||
This source code is provided 'as-is', without any express or implied |
|||
warranty. In no event will the author be held liable for any damages |
|||
arising from the use of this software. |
|||
|
|||
Permission is granted to anyone to use this software for any purpose, |
|||
including commercial applications, and to alter it and redistribute it |
|||
freely, subject to the following restrictions: |
|||
|
|||
1. The origin of this source code must not be misrepresented; you must not |
|||
claim that you wrote the original source code. If you use this source code |
|||
in a product, an acknowledgment in the product documentation would be |
|||
appreciated but is not required. |
|||
|
|||
2. Altered source versions must be plainly marked as such, and must not be |
|||
misrepresented as being the original source code. |
|||
|
|||
3. This notice may not be removed or altered from any source distribution. |
|||
|
|||
René Nyffenegger rene.nyffenegger@adp-gmbh.ch |
|||
*/ |
|||
/// Adapted from code found on http://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
|
|||
/// Originally by René Nyffenegger, modified by some other guy and then devified by Gav Wood.
|
|||
|
|||
#include "Base64.h" |
|||
#include <iostream> |
|||
using namespace std; |
|||
using namespace dev; |
|||
|
|||
static const std::string base64_chars = |
|||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
|||
"abcdefghijklmnopqrstuvwxyz" |
|||
"0123456789+/"; |
|||
|
|||
static inline bool is_base64(byte c) { |
|||
return (isalnum(c) || (c == '+') || (c == '/')); |
|||
} |
|||
|
|||
std::string dev::toBase64(bytesConstRef _in) { |
|||
std::string ret; |
|||
int i = 0; |
|||
int j = 0; |
|||
byte char_array_3[3]; |
|||
byte char_array_4[4]; |
|||
|
|||
auto buf = _in.data(); |
|||
auto bufLen = _in.size(); |
|||
|
|||
while (bufLen--) { |
|||
char_array_3[i++] = *(buf++); |
|||
if (i == 3) { |
|||
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; |
|||
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); |
|||
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); |
|||
char_array_4[3] = char_array_3[2] & 0x3f; |
|||
|
|||
for(i = 0; (i <4) ; i++) |
|||
ret += base64_chars[char_array_4[i]]; |
|||
i = 0; |
|||
} |
|||
} |
|||
|
|||
if (i) |
|||
{ |
|||
for(j = i; j < 3; j++) |
|||
char_array_3[j] = '\0'; |
|||
|
|||
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; |
|||
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); |
|||
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); |
|||
char_array_4[3] = char_array_3[2] & 0x3f; |
|||
|
|||
for (j = 0; (j < i + 1); j++) |
|||
ret += base64_chars[char_array_4[j]]; |
|||
|
|||
while((i++ < 3)) |
|||
ret += '='; |
|||
} |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
bytes dev::fromBase64(std::string const& encoded_string) { |
|||
int in_len = encoded_string.size(); |
|||
int i = 0; |
|||
int j = 0; |
|||
int in_ = 0; |
|||
byte char_array_4[4], char_array_3[3]; |
|||
bytes ret; |
|||
|
|||
while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) { |
|||
char_array_4[i++] = encoded_string[in_]; in_++; |
|||
if (i ==4) { |
|||
for (i = 0; i <4; i++) |
|||
char_array_4[i] = base64_chars.find(char_array_4[i]); |
|||
|
|||
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); |
|||
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); |
|||
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; |
|||
|
|||
for (i = 0; (i < 3); i++) |
|||
ret.push_back(char_array_3[i]); |
|||
i = 0; |
|||
} |
|||
} |
|||
|
|||
if (i) { |
|||
for (j = i; j <4; j++) |
|||
char_array_4[j] = 0; |
|||
|
|||
for (j = 0; j <4; j++) |
|||
char_array_4[j] = base64_chars.find(char_array_4[j]); |
|||
|
|||
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); |
|||
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); |
|||
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; |
|||
|
|||
for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]); |
|||
} |
|||
|
|||
return ret; |
|||
} |
@ -0,0 +1,41 @@ |
|||
/*
|
|||
base64.cpp and base64.h |
|||
|
|||
Copyright (C) 2004-2008 René Nyffenegger |
|||
|
|||
This source code is provided 'as-is', without any express or implied |
|||
warranty. In no event will the author be held liable for any damages |
|||
arising from the use of this software. |
|||
|
|||
Permission is granted to anyone to use this software for any purpose, |
|||
including commercial applications, and to alter it and redistribute it |
|||
freely, subject to the following restrictions: |
|||
|
|||
1. The origin of this source code must not be misrepresented; you must not |
|||
claim that you wrote the original source code. If you use this source code |
|||
in a product, an acknowledgment in the product documentation would be |
|||
appreciated but is not required. |
|||
|
|||
2. Altered source versions must be plainly marked as such, and must not be |
|||
misrepresented as being the original source code. |
|||
|
|||
3. This notice may not be removed or altered from any source distribution. |
|||
|
|||
René Nyffenegger rene.nyffenegger@adp-gmbh.ch |
|||
*/ |
|||
/// Adapted from code found on http://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
|
|||
/// Originally by René Nyffenegger.
|
|||
/// DEVified by Gav Wood.
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
#include <string> |
|||
#include <libdevcore/Common.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
std::string toBase64(bytesConstRef _in); |
|||
bytes fromBase64(std::string const& _in); |
|||
|
|||
} |
@ -0,0 +1,101 @@ |
|||
/*
|
|||
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 CommonJS.cpp
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "CommonJS.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
bytes jsToBytes(std::string const& _s) |
|||
{ |
|||
if (_s.substr(0, 2) == "0x") |
|||
// Hex
|
|||
return fromHex(_s.substr(2)); |
|||
else if (_s.find_first_not_of("0123456789") == std::string::npos) |
|||
// Decimal
|
|||
return toCompactBigEndian(bigint(_s)); |
|||
else |
|||
return bytes(); |
|||
} |
|||
|
|||
bytes padded(bytes _b, unsigned _l) |
|||
{ |
|||
while (_b.size() < _l) |
|||
_b.insert(_b.begin(), 0); |
|||
return asBytes(asString(_b).substr(_b.size() - std::max(_l, _l))); |
|||
} |
|||
|
|||
bytes paddedRight(bytes _b, unsigned _l) |
|||
{ |
|||
_b.resize(_l); |
|||
return _b; |
|||
} |
|||
|
|||
bytes unpadded(bytes _b) |
|||
{ |
|||
auto p = asString(_b).find_last_not_of((char)0); |
|||
_b.resize(p == std::string::npos ? 0 : (p + 1)); |
|||
return _b; |
|||
} |
|||
|
|||
bytes unpadLeft(bytes _b) |
|||
{ |
|||
unsigned int i = 0; |
|||
if (_b.size() == 0) |
|||
return _b; |
|||
|
|||
while (i < _b.size() && _b[i] == byte(0)) |
|||
i++; |
|||
|
|||
if (i != 0) |
|||
_b.erase(_b.begin(), _b.begin() + i); |
|||
return _b; |
|||
} |
|||
|
|||
std::string fromRaw(h256 _n, unsigned* _inc) |
|||
{ |
|||
if (_n) |
|||
{ |
|||
std::string s((char const*)_n.data(), 32); |
|||
auto l = s.find_first_of('\0'); |
|||
if (!l) |
|||
return ""; |
|||
if (l != std::string::npos) |
|||
{ |
|||
auto p = s.find_first_not_of('\0', l); |
|||
if (!(p == std::string::npos || (_inc && p == 31))) |
|||
return ""; |
|||
if (_inc) |
|||
*_inc = (byte)s[31]; |
|||
s.resize(l); |
|||
} |
|||
for (auto i: s) |
|||
if (i < 32) |
|||
return ""; |
|||
return s; |
|||
} |
|||
return ""; |
|||
} |
|||
|
|||
} |
|||
|
@ -0,0 +1,116 @@ |
|||
/*
|
|||
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 CommonJS.h
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include "FixedHash.h" |
|||
#include "CommonData.h" |
|||
#include "CommonIO.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
template <unsigned S> std::string toJS(FixedHash<S> const& _h) |
|||
{ |
|||
return "0x" + toHex(_h.ref()); |
|||
} |
|||
|
|||
template <unsigned N> std::string toJS(boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N, N, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>> const& _n) |
|||
{ |
|||
return "0x" + toHex(toCompactBigEndian(_n)); |
|||
} |
|||
|
|||
inline std::string toJS(dev::bytes const& _n) |
|||
{ |
|||
return "0x" + dev::toHex(_n); |
|||
} |
|||
|
|||
/// Convert string to byte array. Input parameters can be hex or dec. Returns empty array if invalid input e.g neither dec or hex.
|
|||
bytes jsToBytes(std::string const& _s); |
|||
/// Add '0' on the head of @a _b until @a _l.
|
|||
bytes padded(bytes _b, unsigned _l); |
|||
/// Add '0' on the queue of @a _b until @a _l.
|
|||
bytes paddedRight(bytes _b, unsigned _l); |
|||
/// Removing all trailing '0'. Returns empty array if input contains only '0' char.
|
|||
bytes unpadded(bytes _s); |
|||
/// Remove all 0 byte on the head of @a _s.
|
|||
bytes unpadLeft(bytes _s); |
|||
/// Convert h256 into user-readable string (by directly using std::string constructor).
|
|||
std::string fromRaw(h256 _n, unsigned* _inc = nullptr); |
|||
|
|||
template <unsigned N> FixedHash<N> jsToFixed(std::string const& _s) |
|||
{ |
|||
if (_s.substr(0, 2) == "0x") |
|||
// Hex
|
|||
return FixedHash<N>(_s.substr(2 + std::max<unsigned>(N * 2, _s.size() - 2) - N * 2)); |
|||
else if (_s.find_first_not_of("0123456789") == std::string::npos) |
|||
// Decimal
|
|||
return (typename FixedHash<N>::Arith)(_s); |
|||
else |
|||
// Binary
|
|||
return FixedHash<N>(); // FAIL
|
|||
} |
|||
|
|||
inline std::string jsToFixed(double _s) |
|||
{ |
|||
return toJS(dev::u256(_s * (double)(dev::u256(1) << 128))); |
|||
} |
|||
|
|||
template <unsigned N> boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>> jsToInt(std::string const& _s) |
|||
{ |
|||
if (_s.substr(0, 2) == "0x") |
|||
// Hex
|
|||
return fromBigEndian<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>>(fromHex(_s.substr(2))); |
|||
else if (_s.find_first_not_of("0123456789") == std::string::npos) |
|||
// Decimal
|
|||
return boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>(_s); |
|||
else |
|||
// Binary
|
|||
return 0; // FAIL
|
|||
} |
|||
|
|||
inline u256 jsToU256(std::string const& _s) { return jsToInt<32>(_s); } |
|||
|
|||
inline std::string jsToDecimal(std::string const& _s) |
|||
{ |
|||
return dev::toString(jsToU256(_s)); |
|||
} |
|||
|
|||
inline std::string jsFromBinary(dev::bytes _s, unsigned _padding = 32) |
|||
{ |
|||
_s.resize(std::max<unsigned>(_s.size(), _padding)); |
|||
return "0x" + dev::toHex(_s); |
|||
} |
|||
|
|||
inline std::string jsFromBinary(std::string const& _s, unsigned _padding = 32) |
|||
{ |
|||
return jsFromBinary(asBytes(_s), _padding); |
|||
} |
|||
|
|||
inline double jsFromFixed(std::string const& _s) |
|||
{ |
|||
return (double)jsToU256(_s) / (double)(dev::u256(1) << 128); |
|||
} |
|||
|
|||
} |
@ -0,0 +1,39 @@ |
|||
set(LIBRARY ethash) |
|||
|
|||
if (CPPETHEREUM) |
|||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") |
|||
#else () |
|||
endif () |
|||
|
|||
set(CMAKE_BUILD_TYPE Release) |
|||
|
|||
if (NOT MSVC) |
|||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") |
|||
endif() |
|||
|
|||
set(FILES util.c |
|||
util.h |
|||
internal.c |
|||
ethash.h |
|||
endian.h |
|||
compiler.h |
|||
fnv.h |
|||
data_sizes.h) |
|||
|
|||
if (NOT CRYPTOPP_FOUND) |
|||
find_package(CryptoPP 5.6.2) |
|||
endif() |
|||
|
|||
if (CRYPTOPP_FOUND) |
|||
add_definitions(-DWITH_CRYPTOPP) |
|||
include_directories( ${CRYPTOPP_INCLUDE_DIRS} ) |
|||
list(APPEND FILES sha3_cryptopp.cpp sha3_cryptopp.h) |
|||
else() |
|||
list(APPEND FILES sha3.c sha3.h) |
|||
endif() |
|||
|
|||
add_library(${LIBRARY} ${FILES}) |
|||
|
|||
if (CRYPTOPP_FOUND) |
|||
TARGET_LINK_LIBRARIES(${LIBRARY} ${CRYPTOPP_LIBRARIES}) |
|||
endif() |
@ -0,0 +1,33 @@ |
|||
/*
|
|||
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 compiler.h
|
|||
* @date 2014 |
|||
*/ |
|||
#pragma once |
|||
|
|||
// Visual Studio doesn't support the inline keyword in C mode
|
|||
#if defined(_MSC_VER) && !defined(__cplusplus) |
|||
#define inline __inline |
|||
#endif |
|||
|
|||
// pretend restrict is a standard keyword
|
|||
#if defined(_MSC_VER) |
|||
#define restrict __restrict |
|||
#else |
|||
#define restrict __restrict__ |
|||
#endif |
|||
|
@ -0,0 +1,247 @@ |
|||
/*
|
|||
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 FoundationUUU,either version 3 of the LicenseUUU,or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be usefulU, |
|||
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 notUUU,see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
|
|||
/** @file data_sizes.h
|
|||
* @author Matthew Wampler-Doty <negacthulhu@gmail.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
// TODO: Update this after ~3.5 years
|
|||
|
|||
#pragma once |
|||
|
|||
#include <stdint.h> |
|||
#include "compiler.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
#include <stdint.h> |
|||
|
|||
// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
|
|||
|
|||
// Generated with the following Mathematica Code:
|
|||
// GetDataSizes[n_] := Module[{
|
|||
// DAGSizeBytesInit = 2^30,
|
|||
// MixBytes = 128,
|
|||
// DAGGrowth = 113000000,
|
|||
// j = 0},
|
|||
// Reap[
|
|||
// While[j < n,
|
|||
// Module[{i =
|
|||
// Floor[(DAGSizeBytesInit + DAGGrowth * j) / MixBytes]},
|
|||
// While[! PrimeQ[i], i--];
|
|||
// Sow[i*MixBytes]; j++]]]][[2]][[1]]
|
|||
|
|||
static const size_t dag_sizes[] = { |
|||
1073739904U, 1186739584U, 1299741568U, 1412741248U, 1525741696U, |
|||
1638736768U, 1751741312U, 1864740736U, 1977740672U, 2090740864U, |
|||
2203740544U, 2316741248U, 2429739392U, 2542740352U, 2655741824U, |
|||
2768739712U, 2881740416U, 2994741632U, 3107740544U, 3220741504U, |
|||
3333738112U, 3446741632U, 3559741312U, 3672740224U, 3785740928U, |
|||
3898738304U, 4011741824U, 4124739712U, 4237735808U, 4350740864U, |
|||
4463741824U, 4576741504U, 4689741184U, 4802739328U, 4915741568U, |
|||
5028740224U, 5141740672U, 5254738304U, 5367741824U, 5480737664U, |
|||
5593738112U, 5706741632U, 5819740544U, 5932734592U, 6045739904U, |
|||
6158740096U, 6271740032U, 6384731776U, 6497732992U, 6610740352U, |
|||
6723741056U, 6836741504U, 6949740416U, 7062740096U, 7175741824U, |
|||
7288740224U, 7401741184U, 7514741632U, 7627741568U, 7740739712U, |
|||
7853739136U, 7966740352U, 8079741568U, 8192739712U, 8305738624U, |
|||
8418740864U, 8531740288U, 8644740736U, 8757735808U, 8870738816U, |
|||
8983739264U, 9096740992U, 9209740928U, 9322739584U, 9435741824U, |
|||
9548741504U, 9661739392U, 9774738304U, 9887741312U, 10000738688U, |
|||
10113739136U, 10226741632U, 10339739776U, 10452741248U, 10565740928U, |
|||
10678736512U, 10791734656U, 10904741248U, 11017738112U, 11130741632U, |
|||
11243741312U, 11356739456U, 11469740416U, 11582734976U, 11695739008U, |
|||
11808741248U, 11921734784U, 12034739072U, 12147741568U, 12260737408U, |
|||
12373741696U, 12486738304U, 12599740544U, 12712740224U, 12825741184U, |
|||
12938736256U, 13051741312U, 13164737408U, 13277738368U, 13390738048U, |
|||
13503741824U, 13616741504U, 13729737088U, 13842740096U, 13955741312U, |
|||
14068741504U, 14181740416U, 14294741632U, 14407739776U, 14520740224U, |
|||
14633740928U, 14746736512U, 14859741824U, 14972740736U, 15085740928U, |
|||
15198738304U, 15311732096U, 15424740736U, 15537739904U, 15650741632U, |
|||
15763741568U, 15876737152U, 15989741696U, 16102740608U, 16215741056U, |
|||
16328741248U, 16441740416U, 16554737792U, 16667740288U, 16780740992U, |
|||
16893738112U, 17006741632U, 17119739008U, 17232735616U, 17345739392U, |
|||
17458740352U, 17571736192U, 17684739712U, 17797739392U, 17910740096U, |
|||
18023741312U, 18136740736U, 18249738112U, 18362738816U, 18475735424U, |
|||
18588740224U, 18701738368U, 18814736768U, 18927737216U, 19040739968U, |
|||
19153739648U, 19266736768U, 19379737984U, 19492739456U, 19605738368U, |
|||
19718740352U, 19831741312U, 19944736384U, 20057741696U, 20170741376U, |
|||
20283741824U, 20396737408U, 20509741696U, 20622741376U, 20735739008U, |
|||
20848741504U, 20961740672U, 21074739328U, 21187740032U, 21300739456U, |
|||
21413741696U, 21526740608U, 21639741824U, 21752737408U, 21865741696U, |
|||
21978741376U, 22091741824U, 22204738432U, 22317740672U, 22430740096U, |
|||
22543736704U, 22656741248U, 22769739904U, 22882739584U, 22995740288U, |
|||
23108740736U, 23221740928U, 23334741376U, 23447737216U, 23560740992U, |
|||
23673741184U, 23786740864U, 23899737728U, 24012741248U, 24125734784U, |
|||
24238736512U, 24351741824U, 24464740736U, 24577737088U, 24690741632U, |
|||
24803739776U, 24916740736U, 25029740416U, 25142740864U, 25255741568U, |
|||
25368741248U, 25481740672U, 25594741376U, 25707741568U, 25820741504U, |
|||
25933730432U, 26046739072U, 26159741824U, 26272741504U, 26385740672U, |
|||
26498740096U, 26611741568U, 26724740992U, 26837739904U, 26950735232U, |
|||
27063738496U, 27176741248U, 27289741184U, 27402740864U, 27515740544U, |
|||
27628737152U, 27741740672U, 27854741632U, 27967740544U, 28080739712U, |
|||
28193738368U, 28306741376U, 28419737728U, 28532739968U, 28645739648U, |
|||
28758740096U, 28871741312U, 28984739456U, 29097740416U, 29210740864U, |
|||
29323741312U, 29436740224U, 29549741696U, 29662738304U, 29775741568U, |
|||
29888741504U, 30001740928U, 30114737024U, 30227735168U, 30340737664U, |
|||
30453738368U, 30566737024U, 30679733632U, 30792740224U, 30905740928U, |
|||
31018740352U, 31131740032U, 31244738944U, 31357737344U, 31470741376U, |
|||
31583740544U, 31696740224U, 31809738112U, 31922739328U, 32035737472U, |
|||
32148740992U, 32261741696U, 32374740352U, 32487741824U, 32600740736U, |
|||
32713739648U, 32826740608U, 32939729792U, 33052740992U, 33165740672U, |
|||
33278739584U, 33391741312U, 33504739712U, 33617740928U, 33730740608U, |
|||
33843738496U, 33956739968U, 34069741696U, 34182739328U, 34295741824U, |
|||
34408739968U, 34521740672U, 34634736512U, 34747741568U, 34860741248U, |
|||
34973739392U, 35086738304U, 35199741056U, 35312736896U, 35425741184U, |
|||
35538741376U, 35651740288U, 35764737152U, 35877741184U, 35990739584U, |
|||
36103740544U, 36216740992U, 36329739392U, 36442737536U, 36555741568U, |
|||
36668740736U, 36781741184U, 36894737024U, 37007741312U, 37120739456U, |
|||
37233741184U, 37346736256U, 37459736192U, 37572734336U, 37685739904U, |
|||
37798740352U, 37911737728U, 38024741504U, 38137739648U, 38250740608U, |
|||
38363741824U, 38476740992U, 38589741184U, 38702740096U, 38815741312U, |
|||
38928741248U, 39041738368U, 39154739584U, 39267741824U, 39380739712U, |
|||
39493735808U, 39606741632U, 39719741312U, 39832741504U, 39945739648U, |
|||
40058740352U, 40171740032U, 40284740992U, 40397740672U, 40510740352U, |
|||
40623740288U, 40736738176U, 40849737856U, 40962741376U, 41075739776U, |
|||
41188737664U, 41301735808U, 41414738048U, 41527741312U, 41640740992U, |
|||
41753739904U, 41866739072U, 41979738496U, 42092740736U, 42205739648U, |
|||
42318740608U, 42431741312U, 42544738688U, 42657741184U, 42770738048U, |
|||
42883741568U, 42996741248U, 43109740928U, 43222736512U, 43335741056U, |
|||
43448730496U, 43561740416U, 43674741632U, 43787740544U, 43900741504U, |
|||
44013739648U, 44126740864U, 44239740544U, 44352741248U, 44465738368U, |
|||
44578735232U, 44691739264U, 44804741504U, 44917741696U, 45030741376U, |
|||
45143741824U, 45256740992U, 45369739136U, 45482740096U, 45595739776U, |
|||
45708739712U, 45821740672U, 45934741376U, 46047741056U, 46160741248U, |
|||
46273737088U, 46386740864U, 46499739008U, 46612739968U, 46725735296U, |
|||
46838740864U, 46951741568U, 47064737152U, 47177741696U, 47290741376U, |
|||
47403738752U, 47516741248U, 47629739648U, 47742741632U, 47855737984U, |
|||
47968740224U, 48081738368U, 48194741632U, 48307739264U, 48420739712U, |
|||
48533739136U, 48646738304U, 48759741824U, 48872741504U, 48985739392U, |
|||
49098741376U, 49211741056U, 49324740992U, 49437738368U, 49550740864U, |
|||
49663735424U, 49776737408U, 49889740672U, 50002738816U, 50115738752U, |
|||
50228739712U, 50341741696U, 50454736768U, 50567738752U, 50680739968U, |
|||
50793736832U, 50906734976U, 51019741568U, 51132739456U, 51245741696U, |
|||
51358741376U, 51471741056U, 51584738944U, 51697734272U, 51810739072U, |
|||
51923736448U, 52036740736U, 52149741184U, 52262737024U, 52375738496U, |
|||
52488740992U, 52601739136U, 52714740352U, 52827736448U, 52940738176U, |
|||
53053741696U, 53166740864U, 53279741824U, 53392741504U, 53505739136U, |
|||
53618739584U, 53731741312U, 53844741248U, 53957741696U, 54070741376U, |
|||
54183740288U, 54296741504U, 54409741696U, 54522739072U, 54635737472U, |
|||
54748741504U, 54861736064U, 54974740096U, 55087741568U, 55200733568U, |
|||
55313741696U, 55426734464U, 55539741056U, 55652741504U, 55765741184U, |
|||
55878741376U, 55991730304U, 56104740992U, 56217740672U, 56330731648U, |
|||
56443737472U, 56556724352U, 56669740672U, 56782739072U, 56895740032U, |
|||
57008741248U, 57121741696U, 57234740096U, 57347741312U, 57460741504U |
|||
}; |
|||
|
|||
// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
|
|||
|
|||
// Generated with the following Mathematica Code:
|
|||
// GetCacheSizes[n_] := Module[{
|
|||
// DAGSizeBytesInit = 2^30,
|
|||
// MixBytes = 128,
|
|||
// DAGGrowth = 113000000,
|
|||
// HashBytes = 64,
|
|||
// DAGParents = 1024,
|
|||
// j = 0},
|
|||
// Reap[
|
|||
// While[j < n,
|
|||
// Module[{i = Floor[(DAGSizeBytesInit + DAGGrowth * j) / (DAGParents * HashBytes)]},
|
|||
// While[! PrimeQ[i], i--];
|
|||
// Sow[i*HashBytes]; j++]]]][[2]][[1]]
|
|||
|
|||
const size_t cache_sizes[] = { |
|||
1048384U, 1158208U, 1268416U, 1377856U, 1489856U, 1599296U, 1710656U, |
|||
1820608U, 1930816U, 2041024U, 2151872U, 2261696U, 2371904U, 2482624U, |
|||
2593216U, 2703296U, 2814016U, 2924224U, 3034816U, 3144896U, 3255488U, |
|||
3365312U, 3475904U, 3586624U, 3696064U, 3806272U, 3917504U, 4027456U, |
|||
4138304U, 4248512U, 4359104U, 4469312U, 4579264U, 4689728U, 4797376U, |
|||
4909888U, 5020096U, 5131328U, 5241664U, 5351744U, 5461312U, 5572544U, |
|||
5683264U, 5793472U, 5903552U, 6014144U, 6121664U, 6235072U, 6344896U, |
|||
6454592U, 6565952U, 6675904U, 6786112U, 6896704U, 7006784U, 7117888U, |
|||
7228096U, 7338304U, 7448768U, 7557952U, 7669184U, 7779776U, 7889216U, |
|||
8000192U, 8110912U, 8220736U, 8331712U, 8441536U, 8552384U, 8662592U, |
|||
8772928U, 8883136U, 8993728U, 9103168U, 9214528U, 9323968U, 9434816U, |
|||
9545152U, 9655616U, 9766336U, 9876544U, 9986624U, 10097344U, 10207424U, |
|||
10316864U, 10427968U, 10538432U, 10649152U, 10758976U, 10869568U, 10979776U, |
|||
11089472U, 11200832U, 11309632U, 11420608U, 11531584U, 11641792U, 11751104U, |
|||
11862976U, 11973184U, 12083264U, 12193856U, 12304064U, 12414656U, 12524608U, |
|||
12635072U, 12745792U, 12855616U, 12965824U, 13076416U, 13187008U, 13297216U, |
|||
13407808U, 13518016U, 13627072U, 13738688U, 13848256U, 13959488U, 14069696U, |
|||
14180288U, 14290624U, 14399552U, 14511424U, 14621504U, 14732096U, 14841664U, |
|||
14951744U, 15062336U, 15172672U, 15283264U, 15393088U, 15504448U, 15614272U, |
|||
15723712U, 15834944U, 15945152U, 16055744U, 16165696U, 16277056U, 16387136U, |
|||
16494784U, 16607936U, 16718272U, 16828736U, 16938176U, 17048384U, 17159872U, |
|||
17266624U, 17380544U, 17490496U, 17600192U, 17711296U, 17821376U, 17931968U, |
|||
18041152U, 18152896U, 18261952U, 18373568U, 18483392U, 18594112U, 18703936U, |
|||
18814912U, 18924992U, 19034944U, 19145408U, 19256128U, 19366208U, 19477184U, |
|||
19587136U, 19696576U, 19808192U, 19916992U, 20028352U, 20137664U, 20249024U, |
|||
20358848U, 20470336U, 20580544U, 20689472U, 20801344U, 20911424U, 21020096U, |
|||
21130688U, 21242176U, 21352384U, 21462208U, 21573824U, 21683392U, 21794624U, |
|||
21904448U, 22013632U, 22125248U, 22235968U, 22344512U, 22456768U, 22566848U, |
|||
22677056U, 22786496U, 22897984U, 23008064U, 23118272U, 23228992U, 23338816U, |
|||
23449408U, 23560256U, 23670464U, 23780672U, 23891264U, 24001216U, 24110656U, |
|||
24221888U, 24332608U, 24442688U, 24552512U, 24662464U, 24773696U, 24884032U, |
|||
24994496U, 25105216U, 25215296U, 25324864U, 25435712U, 25546432U, 25655744U, |
|||
25767232U, 25876672U, 25986368U, 26098112U, 26207936U, 26318912U, 26428736U, |
|||
26539712U, 26650048U, 26760256U, 26869184U, 26979776U, 27091136U, 27201728U, |
|||
27311552U, 27422272U, 27532352U, 27642304U, 27752896U, 27863744U, 27973952U, |
|||
28082752U, 28194752U, 28305344U, 28415168U, 28524992U, 28636352U, 28746304U, |
|||
28857152U, 28967104U, 29077184U, 29187904U, 29298496U, 29408576U, 29518912U, |
|||
29628992U, 29739968U, 29850176U, 29960512U, 30070336U, 30180544U, 30290752U, |
|||
30398912U, 30512192U, 30622784U, 30732992U, 30842176U, 30953536U, 31063744U, |
|||
31174336U, 31284544U, 31395136U, 31504448U, 31615552U, 31725632U, 31835072U, |
|||
31946176U, 32057024U, 32167232U, 32277568U, 32387008U, 32497984U, 32608832U, |
|||
32719168U, 32829376U, 32939584U, 33050048U, 33160768U, 33271232U, 33381184U, |
|||
33491648U, 33601856U, 33712576U, 33822016U, 33932992U, 34042816U, 34153024U, |
|||
34263104U, 34373824U, 34485056U, 34594624U, 34704832U, 34816064U, 34926272U, |
|||
35036224U, 35146816U, 35255104U, 35367104U, 35478208U, 35588416U, 35698496U, |
|||
35808832U, 35918656U, 36029888U, 36139456U, 36250688U, 36360512U, 36471104U, |
|||
36581696U, 36691136U, 36802112U, 36912448U, 37022912U, 37132864U, 37242944U, |
|||
37354048U, 37464512U, 37574848U, 37684928U, 37794752U, 37904704U, 38015552U, |
|||
38125888U, 38236864U, 38345792U, 38457152U, 38567744U, 38678336U, 38787776U, |
|||
38897216U, 39009088U, 39117632U, 39230144U, 39340352U, 39450304U, 39560384U, |
|||
39671488U, 39781312U, 39891392U, 40002112U, 40112704U, 40223168U, 40332608U, |
|||
40443968U, 40553792U, 40664768U, 40774208U, 40884416U, 40993984U, 41105984U, |
|||
41215424U, 41326528U, 41436992U, 41546048U, 41655872U, 41768128U, 41878336U, |
|||
41988928U, 42098752U, 42209344U, 42319168U, 42429248U, 42540352U, 42649792U, |
|||
42761024U, 42871616U, 42981824U, 43092032U, 43201856U, 43312832U, 43423552U, |
|||
43533632U, 43643584U, 43753792U, 43864384U, 43974976U, 44084032U, 44195392U, |
|||
44306368U, 44415296U, 44526016U, 44637248U, 44746816U, 44858048U, 44967872U, |
|||
45078848U, 45188288U, 45299264U, 45409216U, 45518272U, 45630272U, 45740224U, |
|||
45850432U, 45960896U, 46069696U, 46182208U, 46292416U, 46402624U, 46512064U, |
|||
46623296U, 46733888U, 46843712U, 46953664U, 47065024U, 47175104U, 47285696U, |
|||
47395904U, 47506496U, 47615296U, 47726912U, 47837632U, 47947712U, 48055232U, |
|||
48168128U, 48277952U, 48387392U, 48499648U, 48609472U, 48720064U, 48830272U, |
|||
48940096U, 49050944U, 49160896U, 49271744U, 49381568U, 49492288U, 49602752U, |
|||
49712576U, 49822016U, 49934272U, 50042816U, 50154304U, 50264128U, 50374336U, |
|||
50484416U, 50596288U, 50706752U, 50816704U, 50927168U, 51035456U, 51146944U, |
|||
51258176U, 51366976U, 51477824U, 51589568U, 51699776U, 51809728U, 51920576U, |
|||
52030016U, 52140736U, 52251328U, 52361152U, 52470592U, 52582592U, 52691776U, |
|||
52803136U, 52912576U, 53020736U, 53132224U, 53242688U, 53354816U, 53465536U, |
|||
53575232U, 53685568U, 53796544U, 53906752U, 54016832U, 54126656U, 54236992U, |
|||
54347456U, 54457408U, 54569024U, 54679232U, 54789184U, 54899776U, 55008832U, |
|||
55119296U, 55231168U, 55341248U, 55451584U, 55562048U, 55672256U, 55782208U, |
|||
55893184U, 56002112U, 56113216U |
|||
}; |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,74 @@ |
|||
#pragma once |
|||
|
|||
#include <stdint.h> |
|||
#include "compiler.h" |
|||
|
|||
static const uint8_t BitReverseTable256[] = |
|||
{ |
|||
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, |
|||
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, |
|||
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, |
|||
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, |
|||
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, |
|||
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, |
|||
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, |
|||
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, |
|||
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, |
|||
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, |
|||
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, |
|||
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, |
|||
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, |
|||
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, |
|||
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, |
|||
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF |
|||
}; |
|||
|
|||
static inline uint32_t bitfn_swap32(uint32_t a) { |
|||
return (BitReverseTable256[a & 0xff] << 24) | |
|||
(BitReverseTable256[(a >> 8) & 0xff] << 16) | |
|||
(BitReverseTable256[(a >> 16) & 0xff] << 8) | |
|||
(BitReverseTable256[(a >> 24) & 0xff]); |
|||
} |
|||
|
|||
static inline uint64_t bitfn_swap64(uint64_t a) { |
|||
return ((uint64_t) bitfn_swap32((uint32_t) (a >> 32))) | |
|||
(((uint64_t) bitfn_swap32((uint32_t) a)) << 32); |
|||
} |
|||
|
|||
#if defined(__MINGW32__) || defined(_WIN32) |
|||
# define LITTLE_ENDIAN 1234 |
|||
# define BYTE_ORDER LITTLE_ENDIAN |
|||
#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) |
|||
# include <sys/endian.h> |
|||
#elif defined(__OpenBSD__) || defined(__SVR4) |
|||
# include <sys/types.h> |
|||
#elif defined(__APPLE__) |
|||
# include <machine/endian.h> |
|||
#elif defined( BSD ) && (BSD >= 199103) |
|||
# include <machine/endian.h> |
|||
#elif defined( __QNXNTO__ ) && defined( __LITTLEENDIAN__ ) |
|||
# define LITTLE_ENDIAN 1234 |
|||
# define BYTE_ORDER LITTLE_ENDIAN |
|||
#elif defined( __QNXNTO__ ) && defined( __BIGENDIAN__ ) |
|||
# define BIG_ENDIAN 1234 |
|||
# define BYTE_ORDER BIG_ENDIAN |
|||
#else |
|||
|
|||
# include <endian.h> |
|||
|
|||
#endif |
|||
|
|||
|
|||
#if LITTLE_ENDIAN == BYTE_ORDER |
|||
|
|||
#define fix_endian32(x) (x) |
|||
#define fix_endian64(x) (x) |
|||
|
|||
#elif BIG_ENDIAN == BYTE_ORDER |
|||
|
|||
#define fix_endian32(x) bitfn_swap32(x) |
|||
#define fix_endian64(x) bitfn_swap64(x) |
|||
|
|||
#else |
|||
# error "endian not supported" |
|||
#endif // BYTE_ORDER
|
@ -0,0 +1,93 @@ |
|||
/*
|
|||
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 ethash.h
|
|||
* @date 2015 |
|||
*/ |
|||
#pragma once |
|||
|
|||
#include <stdint.h> |
|||
#include <stdbool.h> |
|||
#include <string.h> |
|||
#include <stddef.h> |
|||
#include "compiler.h" |
|||
|
|||
#define REVISION 19 |
|||
#define DAGSIZE_BYTES_INIT 1073741824U // 2**30
|
|||
#define DAG_GROWTH 113000000U |
|||
#define EPOCH_LENGTH 30000U |
|||
#define MIX_BYTES 128 |
|||
#define DAG_PARENTS 256 |
|||
#define CACHE_ROUNDS 3 |
|||
#define ACCESSES 64 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct ethash_params { |
|||
size_t full_size; // Size of full data set (in bytes, multiple of mix size (128)).
|
|||
size_t cache_size; // Size of compute cache (in bytes, multiple of node size (64)).
|
|||
} ethash_params; |
|||
|
|||
typedef struct ethash_return_value { |
|||
uint8_t result[32]; |
|||
uint8_t mix_hash[32]; |
|||
} ethash_return_value; |
|||
|
|||
size_t ethash_get_datasize(const uint32_t block_number); |
|||
size_t ethash_get_cachesize(const uint32_t block_number); |
|||
|
|||
// initialize the parameters
|
|||
static inline void ethash_params_init(ethash_params *params, const uint32_t block_number) { |
|||
params->full_size = ethash_get_datasize(block_number); |
|||
params->cache_size = ethash_get_cachesize(block_number); |
|||
} |
|||
|
|||
typedef struct ethash_cache { |
|||
void *mem; |
|||
} ethash_cache; |
|||
|
|||
void ethash_mkcache(ethash_cache *cache, ethash_params const *params, const uint8_t seed[32]); |
|||
void ethash_compute_full_data(void *mem, ethash_params const *params, ethash_cache const *cache); |
|||
void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce); |
|||
void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce); |
|||
|
|||
static inline void ethash_prep_light(void *cache, ethash_params const *params, const uint8_t seed[32]) { ethash_cache c; c.mem = cache; ethash_mkcache(&c, params, seed); } |
|||
static inline void ethash_compute_light(ethash_return_value *ret, void const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) { ethash_cache c; c.mem = (void*)cache; ethash_light(ret, &c, params, header_hash, nonce); } |
|||
static inline void ethash_prep_full(void *full, ethash_params const *params, void const *cache) { ethash_cache c; c.mem = (void*)cache; ethash_compute_full_data(full, params, &c); } |
|||
static inline void ethash_compute_full(ethash_return_value *ret, void const *full, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) { ethash_full(ret, full, params, header_hash, nonce); } |
|||
|
|||
static inline int ethash_check_difficulty( |
|||
const uint8_t hash[32], |
|||
const uint8_t difficulty[32]) { |
|||
// Difficulty is big endian
|
|||
for (int i = 0; i < 32; i++) { |
|||
if (hash[i] == difficulty[i]) continue; |
|||
return hash[i] < difficulty[i]; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
int ethash_quick_check_difficulty( |
|||
const uint8_t header_hash[32], |
|||
const uint64_t nonce, |
|||
const uint8_t mix_hash[32], |
|||
const uint8_t difficulty[32]); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,38 @@ |
|||
/*
|
|||
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 fnv.h
|
|||
* @author Matthew Wampler-Doty <negacthulhu@gmail.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#pragma once |
|||
#include <stdint.h> |
|||
#include "compiler.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
#define FNV_PRIME 0x01000193 |
|||
|
|||
static inline uint32_t fnv_hash(const uint32_t x, const uint32_t y) { |
|||
return x*FNV_PRIME ^ y; |
|||
} |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,298 @@ |
|||
/*
|
|||
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 dash.cpp
|
|||
* @author Tim Hughes <tim@twistedfury.com> |
|||
* @author Matthew Wampler-Doty |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#include <assert.h> |
|||
#include <inttypes.h> |
|||
#include <stddef.h> |
|||
#include "ethash.h" |
|||
#include "fnv.h" |
|||
#include "endian.h" |
|||
#include "internal.h" |
|||
#include "data_sizes.h" |
|||
|
|||
#ifdef WITH_CRYPTOPP |
|||
|
|||
#include "sha3_cryptopp.h" |
|||
|
|||
#else |
|||
#include "sha3.h" |
|||
#endif // WITH_CRYPTOPP
|
|||
|
|||
size_t ethash_get_datasize(const uint32_t block_number) { |
|||
assert(block_number / EPOCH_LENGTH < 500); |
|||
return dag_sizes[block_number / EPOCH_LENGTH]; |
|||
} |
|||
|
|||
size_t ethash_get_cachesize(const uint32_t block_number) { |
|||
assert(block_number / EPOCH_LENGTH < 500); |
|||
return cache_sizes[block_number / EPOCH_LENGTH]; |
|||
} |
|||
|
|||
// Follows Sergio's "STRICT MEMORY HARD HASHING FUNCTIONS" (2014)
|
|||
// https://bitslog.files.wordpress.com/2013/12/memohash-v0-3.pdf
|
|||
// SeqMemoHash(s, R, N)
|
|||
void static ethash_compute_cache_nodes( |
|||
node *const nodes, |
|||
ethash_params const *params, |
|||
const uint8_t seed[32]) { |
|||
assert((params->cache_size % sizeof(node)) == 0); |
|||
uint32_t const num_nodes = (uint32_t)(params->cache_size / sizeof(node)); |
|||
|
|||
SHA3_512(nodes[0].bytes, seed, 32); |
|||
|
|||
for (unsigned i = 1; i != num_nodes; ++i) { |
|||
SHA3_512(nodes[i].bytes, nodes[i - 1].bytes, 64); |
|||
} |
|||
|
|||
for (unsigned j = 0; j != CACHE_ROUNDS; j++) { |
|||
for (unsigned i = 0; i != num_nodes; i++) { |
|||
uint32_t const idx = nodes[i].words[0] % num_nodes; |
|||
node data; |
|||
data = nodes[(num_nodes - 1 + i) % num_nodes]; |
|||
for (unsigned w = 0; w != NODE_WORDS; ++w) |
|||
{ |
|||
data.words[w] ^= nodes[idx].words[w]; |
|||
} |
|||
SHA3_512(nodes[i].bytes, data.bytes, sizeof(data)); |
|||
} |
|||
} |
|||
|
|||
// now perform endian conversion
|
|||
#if BYTE_ORDER != LITTLE_ENDIAN |
|||
for (unsigned w = 0; w != (num_nodes*NODE_WORDS); ++w) |
|||
{ |
|||
nodes->words[w] = fix_endian32(nodes->words[w]); |
|||
} |
|||
#endif |
|||
} |
|||
|
|||
void ethash_mkcache( |
|||
ethash_cache *cache, |
|||
ethash_params const *params, |
|||
const uint8_t seed[32]) { |
|||
node *nodes = (node *) cache->mem; |
|||
ethash_compute_cache_nodes(nodes, params, seed); |
|||
} |
|||
|
|||
void ethash_calculate_dag_item( |
|||
node *const ret, |
|||
const unsigned node_index, |
|||
const struct ethash_params *params, |
|||
const struct ethash_cache *cache) { |
|||
|
|||
uint32_t num_parent_nodes = (uint32_t)(params->cache_size / sizeof(node)); |
|||
node const *cache_nodes = (node const *) cache->mem; |
|||
node const *init = &cache_nodes[node_index % num_parent_nodes]; |
|||
|
|||
memcpy(ret, init, sizeof(node)); |
|||
ret->words[0] ^= node_index; |
|||
SHA3_512(ret->bytes, ret->bytes, sizeof(node)); |
|||
|
|||
#if defined(_M_X64) && ENABLE_SSE |
|||
__m128i const fnv_prime = _mm_set1_epi32(FNV_PRIME); |
|||
__m128i xmm0 = ret->xmm[0]; |
|||
__m128i xmm1 = ret->xmm[1]; |
|||
__m128i xmm2 = ret->xmm[2]; |
|||
__m128i xmm3 = ret->xmm[3]; |
|||
#endif |
|||
|
|||
for (unsigned i = 0; i != DAG_PARENTS; ++i) |
|||
{ |
|||
uint32_t parent_index = ((node_index ^ i)*FNV_PRIME ^ ret->words[i % NODE_WORDS]) % num_parent_nodes; |
|||
node const *parent = &cache_nodes[parent_index]; |
|||
|
|||
#if defined(_M_X64) && ENABLE_SSE |
|||
{ |
|||
xmm0 = _mm_mullo_epi32(xmm0, fnv_prime); |
|||
xmm1 = _mm_mullo_epi32(xmm1, fnv_prime); |
|||
xmm2 = _mm_mullo_epi32(xmm2, fnv_prime); |
|||
xmm3 = _mm_mullo_epi32(xmm3, fnv_prime); |
|||
xmm0 = _mm_xor_si128(xmm0, parent->xmm[0]); |
|||
xmm1 = _mm_xor_si128(xmm1, parent->xmm[1]); |
|||
xmm2 = _mm_xor_si128(xmm2, parent->xmm[2]); |
|||
xmm3 = _mm_xor_si128(xmm3, parent->xmm[3]); |
|||
|
|||
// have to write to ret as values are used to compute index
|
|||
ret->xmm[0] = xmm0; |
|||
ret->xmm[1] = xmm1; |
|||
ret->xmm[2] = xmm2; |
|||
ret->xmm[3] = xmm3; |
|||
} |
|||
#else |
|||
{ |
|||
for (unsigned w = 0; w != NODE_WORDS; ++w) { |
|||
ret->words[w] = fnv_hash(ret->words[w], parent->words[w]); |
|||
} |
|||
} |
|||
#endif |
|||
} |
|||
|
|||
SHA3_512(ret->bytes, ret->bytes, sizeof(node)); |
|||
} |
|||
|
|||
void ethash_compute_full_data( |
|||
void *mem, |
|||
ethash_params const *params, |
|||
ethash_cache const *cache) { |
|||
assert((params->full_size % (sizeof(uint32_t) * MIX_WORDS)) == 0); |
|||
assert((params->full_size % sizeof(node)) == 0); |
|||
node *full_nodes = mem; |
|||
|
|||
// now compute full nodes
|
|||
for (unsigned n = 0; n != (params->full_size / sizeof(node)); ++n) { |
|||
ethash_calculate_dag_item(&(full_nodes[n]), n, params, cache); |
|||
} |
|||
} |
|||
|
|||
static void ethash_hash( |
|||
ethash_return_value * ret, |
|||
node const *full_nodes, |
|||
ethash_cache const *cache, |
|||
ethash_params const *params, |
|||
const uint8_t header_hash[32], |
|||
const uint64_t nonce) { |
|||
|
|||
assert((params->full_size % MIX_WORDS) == 0); |
|||
|
|||
// pack hash and nonce together into first 40 bytes of s_mix
|
|||
assert(sizeof(node)*8 == 512); |
|||
node s_mix[MIX_NODES + 1]; |
|||
memcpy(s_mix[0].bytes, header_hash, 32); |
|||
|
|||
#if BYTE_ORDER != LITTLE_ENDIAN |
|||
s_mix[0].double_words[4] = fix_endian64(nonce); |
|||
#else |
|||
s_mix[0].double_words[4] = nonce; |
|||
#endif |
|||
|
|||
// compute sha3-512 hash and replicate across mix
|
|||
SHA3_512(s_mix->bytes, s_mix->bytes, 40); |
|||
|
|||
#if BYTE_ORDER != LITTLE_ENDIAN |
|||
for (unsigned w = 0; w != 16; ++w) { |
|||
s_mix[0].words[w] = fix_endian32(s_mix[0].words[w]); |
|||
} |
|||
#endif |
|||
|
|||
node* const mix = s_mix + 1; |
|||
for (unsigned w = 0; w != MIX_WORDS; ++w) { |
|||
mix->words[w] = s_mix[0].words[w % NODE_WORDS]; |
|||
} |
|||
|
|||
unsigned const |
|||
page_size = sizeof(uint32_t) * MIX_WORDS, |
|||
num_full_pages = (unsigned)(params->full_size / page_size); |
|||
|
|||
|
|||
for (unsigned i = 0; i != ACCESSES; ++i) |
|||
{ |
|||
uint32_t const index = ((s_mix->words[0] ^ i)*FNV_PRIME ^ mix->words[i % MIX_WORDS]) % num_full_pages; |
|||
|
|||
for (unsigned n = 0; n != MIX_NODES; ++n) |
|||
{ |
|||
const node * dag_node = &full_nodes[MIX_NODES * index + n]; |
|||
|
|||
if (!full_nodes) { |
|||
node tmp_node; |
|||
ethash_calculate_dag_item(&tmp_node, index * MIX_NODES + n, params, cache); |
|||
dag_node = &tmp_node; |
|||
} |
|||
|
|||
#if defined(_M_X64) && ENABLE_SSE |
|||
{ |
|||
__m128i fnv_prime = _mm_set1_epi32(FNV_PRIME); |
|||
__m128i xmm0 = _mm_mullo_epi32(fnv_prime, mix[n].xmm[0]); |
|||
__m128i xmm1 = _mm_mullo_epi32(fnv_prime, mix[n].xmm[1]); |
|||
__m128i xmm2 = _mm_mullo_epi32(fnv_prime, mix[n].xmm[2]); |
|||
__m128i xmm3 = _mm_mullo_epi32(fnv_prime, mix[n].xmm[3]); |
|||
mix[n].xmm[0] = _mm_xor_si128(xmm0, dag_node->xmm[0]); |
|||
mix[n].xmm[1] = _mm_xor_si128(xmm1, dag_node->xmm[1]); |
|||
mix[n].xmm[2] = _mm_xor_si128(xmm2, dag_node->xmm[2]); |
|||
mix[n].xmm[3] = _mm_xor_si128(xmm3, dag_node->xmm[3]); |
|||
} |
|||
#else |
|||
{ |
|||
for (unsigned w = 0; w != NODE_WORDS; ++w) { |
|||
mix[n].words[w] = fnv_hash(mix[n].words[w], dag_node->words[w]); |
|||
} |
|||
} |
|||
#endif |
|||
} |
|||
|
|||
} |
|||
|
|||
// compress mix
|
|||
for (unsigned w = 0; w != MIX_WORDS; w += 4) |
|||
{ |
|||
uint32_t reduction = mix->words[w+0]; |
|||
reduction = reduction*FNV_PRIME ^ mix->words[w+1]; |
|||
reduction = reduction*FNV_PRIME ^ mix->words[w+2]; |
|||
reduction = reduction*FNV_PRIME ^ mix->words[w+3]; |
|||
mix->words[w/4] = reduction; |
|||
} |
|||
|
|||
#if BYTE_ORDER != LITTLE_ENDIAN |
|||
for (unsigned w = 0; w != MIX_WORDS/4; ++w) { |
|||
mix->words[w] = fix_endian32(mix->words[w]); |
|||
} |
|||
#endif |
|||
|
|||
memcpy(ret->mix_hash, mix->bytes, 32); |
|||
// final Keccak hash
|
|||
SHA3_256(ret->result, s_mix->bytes, 64+32); // Keccak-256(s + compressed_mix)
|
|||
} |
|||
|
|||
void ethash_quick_hash( |
|||
uint8_t return_hash[32], |
|||
const uint8_t header_hash[32], |
|||
const uint64_t nonce, |
|||
const uint8_t mix_hash[32]) { |
|||
|
|||
uint8_t buf[64+32]; |
|||
memcpy(buf, header_hash, 32); |
|||
#if BYTE_ORDER != LITTLE_ENDIAN |
|||
nonce = fix_endian64(nonce); |
|||
#endif |
|||
memcpy(&(buf[32]), &nonce, 8); |
|||
SHA3_512(buf, buf, 40); |
|||
memcpy(&(buf[64]), mix_hash, 32); |
|||
SHA3_256(return_hash, buf, 64+32); |
|||
} |
|||
|
|||
int ethash_quick_check_difficulty( |
|||
const uint8_t header_hash[32], |
|||
const uint64_t nonce, |
|||
const uint8_t mix_hash[32], |
|||
const uint8_t difficulty[32]) { |
|||
|
|||
uint8_t return_hash[32]; |
|||
ethash_quick_hash(return_hash, header_hash, nonce, mix_hash); |
|||
return ethash_check_difficulty(return_hash, difficulty); |
|||
} |
|||
|
|||
void ethash_full(ethash_return_value * ret, void const *full_mem, ethash_params const *params, const uint8_t previous_hash[32], const uint64_t nonce) { |
|||
ethash_hash(ret, (node const *) full_mem, NULL, params, previous_hash, nonce); |
|||
} |
|||
|
|||
void ethash_light(ethash_return_value * ret, ethash_cache const *cache, ethash_params const *params, const uint8_t previous_hash[32], const uint64_t nonce) { |
|||
ethash_hash(ret, NULL, cache, params, previous_hash, nonce); |
|||
} |
@ -0,0 +1,48 @@ |
|||
#pragma once |
|||
#include "compiler.h" |
|||
#include "endian.h" |
|||
#include "ethash.h" |
|||
|
|||
#define ENABLE_SSE 1 |
|||
|
|||
#if defined(_M_X64) && ENABLE_SSE |
|||
#include <smmintrin.h> |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
// compile time settings
|
|||
#define NODE_WORDS (64/4) |
|||
#define MIX_WORDS (MIX_BYTES/4) |
|||
#define MIX_NODES (MIX_WORDS / NODE_WORDS) |
|||
#include <stdint.h> |
|||
|
|||
typedef union node { |
|||
uint8_t bytes[NODE_WORDS * 4]; |
|||
uint32_t words[NODE_WORDS]; |
|||
uint64_t double_words[NODE_WORDS / 2]; |
|||
|
|||
#if defined(_M_X64) && ENABLE_SSE |
|||
__m128i xmm[NODE_WORDS/4]; |
|||
#endif |
|||
|
|||
} node; |
|||
|
|||
void ethash_calculate_dag_item( |
|||
node *const ret, |
|||
const unsigned node_index, |
|||
ethash_params const *params, |
|||
ethash_cache const *cache |
|||
); |
|||
|
|||
void ethash_quick_hash( |
|||
uint8_t return_hash[32], |
|||
const uint8_t header_hash[32], |
|||
const uint64_t nonce, |
|||
const uint8_t mix_hash[32]); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,151 @@ |
|||
/** libkeccak-tiny
|
|||
* |
|||
* A single-file implementation of SHA-3 and SHAKE. |
|||
* |
|||
* Implementor: David Leon Gil |
|||
* License: CC0, attribution kindly requested. Blame taken too, |
|||
* but not liability. |
|||
*/ |
|||
#include "sha3.h" |
|||
|
|||
#include <stdint.h> |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
/******** The Keccak-f[1600] permutation ********/ |
|||
|
|||
/*** Constants. ***/ |
|||
static const uint8_t rho[24] = \ |
|||
{ 1, 3, 6, 10, 15, 21, |
|||
28, 36, 45, 55, 2, 14, |
|||
27, 41, 56, 8, 25, 43, |
|||
62, 18, 39, 61, 20, 44}; |
|||
static const uint8_t pi[24] = \ |
|||
{10, 7, 11, 17, 18, 3, |
|||
5, 16, 8, 21, 24, 4, |
|||
15, 23, 19, 13, 12, 2, |
|||
20, 14, 22, 9, 6, 1}; |
|||
static const uint64_t RC[24] = \ |
|||
{1ULL, 0x8082ULL, 0x800000000000808aULL, 0x8000000080008000ULL, |
|||
0x808bULL, 0x80000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL, |
|||
0x8aULL, 0x88ULL, 0x80008009ULL, 0x8000000aULL, |
|||
0x8000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL, 0x8000000000008003ULL, |
|||
0x8000000000008002ULL, 0x8000000000000080ULL, 0x800aULL, 0x800000008000000aULL, |
|||
0x8000000080008081ULL, 0x8000000000008080ULL, 0x80000001ULL, 0x8000000080008008ULL}; |
|||
|
|||
/*** Helper macros to unroll the permutation. ***/ |
|||
#define rol(x, s) (((x) << s) | ((x) >> (64 - s))) |
|||
#define REPEAT6(e) e e e e e e |
|||
#define REPEAT24(e) REPEAT6(e e e e) |
|||
#define REPEAT5(e) e e e e e |
|||
#define FOR5(v, s, e) \ |
|||
v = 0; \ |
|||
REPEAT5(e; v += s;) |
|||
|
|||
/*** Keccak-f[1600] ***/ |
|||
static inline void keccakf(void* state) { |
|||
uint64_t* a = (uint64_t*)state; |
|||
uint64_t b[5] = {0}; |
|||
uint64_t t = 0; |
|||
uint8_t x, y; |
|||
|
|||
for (int i = 0; i < 24; i++) { |
|||
// Theta
|
|||
FOR5(x, 1, |
|||
b[x] = 0; |
|||
FOR5(y, 5, |
|||
b[x] ^= a[x + y]; )) |
|||
FOR5(x, 1, |
|||
FOR5(y, 5, |
|||
a[y + x] ^= b[(x + 4) % 5] ^ rol(b[(x + 1) % 5], 1); )) |
|||
// Rho and pi
|
|||
t = a[1]; |
|||
x = 0; |
|||
REPEAT24(b[0] = a[pi[x]]; |
|||
a[pi[x]] = rol(t, rho[x]); |
|||
t = b[0]; |
|||
x++; ) |
|||
// Chi
|
|||
FOR5(y, |
|||
5, |
|||
FOR5(x, 1, |
|||
b[x] = a[y + x];) |
|||
FOR5(x, 1, |
|||
a[y + x] = b[x] ^ ((~b[(x + 1) % 5]) & b[(x + 2) % 5]); )) |
|||
// Iota
|
|||
a[0] ^= RC[i]; |
|||
} |
|||
} |
|||
|
|||
/******** The FIPS202-defined functions. ********/ |
|||
|
|||
/*** Some helper macros. ***/ |
|||
|
|||
#define _(S) do { S } while (0) |
|||
#define FOR(i, ST, L, S) \ |
|||
_(for (size_t i = 0; i < L; i += ST) { S; }) |
|||
#define mkapply_ds(NAME, S) \ |
|||
static inline void NAME(uint8_t* dst, \ |
|||
const uint8_t* src, \ |
|||
size_t len) { \ |
|||
FOR(i, 1, len, S); \ |
|||
} |
|||
#define mkapply_sd(NAME, S) \ |
|||
static inline void NAME(const uint8_t* src, \ |
|||
uint8_t* dst, \ |
|||
size_t len) { \ |
|||
FOR(i, 1, len, S); \ |
|||
} |
|||
|
|||
mkapply_ds(xorin, dst[i] ^= src[i]) // xorin
|
|||
mkapply_sd(setout, dst[i] = src[i]) // setout
|
|||
|
|||
#define P keccakf |
|||
#define Plen 200 |
|||
|
|||
// Fold P*F over the full blocks of an input.
|
|||
#define foldP(I, L, F) \ |
|||
while (L >= rate) { \ |
|||
F(a, I, rate); \ |
|||
P(a); \ |
|||
I += rate; \ |
|||
L -= rate; \ |
|||
} |
|||
|
|||
/** The sponge-based hash construction. **/ |
|||
static inline int hash(uint8_t* out, size_t outlen, |
|||
const uint8_t* in, size_t inlen, |
|||
size_t rate, uint8_t delim) { |
|||
if ((out == NULL) || ((in == NULL) && inlen != 0) || (rate >= Plen)) { |
|||
return -1; |
|||
} |
|||
uint8_t a[Plen] = {0}; |
|||
// Absorb input.
|
|||
foldP(in, inlen, xorin); |
|||
// Xor in the DS and pad frame.
|
|||
a[inlen] ^= delim; |
|||
a[rate - 1] ^= 0x80; |
|||
// Xor in the last block.
|
|||
xorin(a, in, inlen); |
|||
// Apply P
|
|||
P(a); |
|||
// Squeeze output.
|
|||
foldP(out, outlen, setout); |
|||
setout(a, out, outlen); |
|||
memset(a, 0, 200); |
|||
return 0; |
|||
} |
|||
|
|||
#define defsha3(bits) \ |
|||
int sha3_##bits(uint8_t* out, size_t outlen, \ |
|||
const uint8_t* in, size_t inlen) { \ |
|||
if (outlen > (bits/8)) { \ |
|||
return -1; \ |
|||
} \ |
|||
return hash(out, outlen, in, inlen, 200 - (bits / 4), 0x01); \ |
|||
} |
|||
|
|||
/*** FIPS202 SHA3 FOFs ***/ |
|||
defsha3(256) |
|||
defsha3(512) |
@ -0,0 +1,27 @@ |
|||
#pragma once |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
#include "compiler.h" |
|||
#include <stdint.h> |
|||
#include <stdlib.h> |
|||
|
|||
#define decsha3(bits) \ |
|||
int sha3_##bits(uint8_t*, size_t, const uint8_t*, size_t); |
|||
|
|||
decsha3(256) |
|||
decsha3(512) |
|||
|
|||
static inline void SHA3_256(uint8_t * const ret, uint8_t const *data, const size_t size) { |
|||
sha3_256(ret, 32, data, size); |
|||
} |
|||
|
|||
static inline void SHA3_512(uint8_t * const ret, uint8_t const *data, const size_t size) { |
|||
sha3_512(ret, 64, data, size); |
|||
} |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,34 @@ |
|||
/*
|
|||
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 sha3.cpp
|
|||
* @author Tim Hughes <tim@twistedfury.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#include <stdint.h> |
|||
#include <cryptopp/sha3.h> |
|||
|
|||
extern "C" { |
|||
void SHA3_256(uint8_t *const ret, const uint8_t *data, size_t size) { |
|||
CryptoPP::SHA3_256().CalculateDigest(ret, data, size); |
|||
} |
|||
|
|||
void SHA3_512(uint8_t *const ret, const uint8_t *data, size_t size) { |
|||
CryptoPP::SHA3_512().CalculateDigest(ret, data, size); |
|||
} |
|||
} |
@ -0,0 +1,15 @@ |
|||
#pragma once |
|||
|
|||
#include "compiler.h" |
|||
#include <stdint.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
void SHA3_256(uint8_t *const ret, const uint8_t *data, size_t size); |
|||
void SHA3_512(uint8_t *const ret, const uint8_t *data, size_t size); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,41 @@ |
|||
/*
|
|||
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 util.c
|
|||
* @author Tim Hughes <tim@twistedfury.com> |
|||
* @date 2015 |
|||
*/ |
|||
#include <stdarg.h> |
|||
#include <stdio.h> |
|||
#include "util.h" |
|||
|
|||
#ifdef _MSC_VER |
|||
|
|||
// foward declare without all of Windows.h
|
|||
__declspec(dllimport) void __stdcall OutputDebugStringA(const char* lpOutputString); |
|||
|
|||
void debugf(const char *str, ...) |
|||
{ |
|||
va_list args; |
|||
va_start(args, str); |
|||
|
|||
char buf[1<<16]; |
|||
_vsnprintf_s(buf, sizeof(buf), sizeof(buf), str, args); |
|||
buf[sizeof(buf)-1] = '\0'; |
|||
OutputDebugStringA(buf); |
|||
} |
|||
|
|||
#endif |
@ -0,0 +1,47 @@ |
|||
/*
|
|||
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 util.h
|
|||
* @author Tim Hughes <tim@twistedfury.com> |
|||
* @date 2015 |
|||
*/ |
|||
#pragma once |
|||
#include <stdint.h> |
|||
#include "compiler.h" |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
#ifdef _MSC_VER |
|||
void debugf(const char *str, ...); |
|||
#else |
|||
#define debugf printf |
|||
#endif |
|||
|
|||
static inline uint32_t min_u32(uint32_t a, uint32_t b) |
|||
{ |
|||
return a < b ? a : b; |
|||
} |
|||
|
|||
static inline uint32_t clamp_u32(uint32_t x, uint32_t min_, uint32_t max_) |
|||
{ |
|||
return x < min_ ? min_ : (x > max_ ? max_ : x); |
|||
} |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
@ -0,0 +1,115 @@ |
|||
/*
|
|||
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 Ethasher.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include <boost/detail/endian.hpp> |
|||
#include <boost/filesystem.hpp> |
|||
#include <chrono> |
|||
#include <array> |
|||
#include <random> |
|||
#include <thread> |
|||
#include <libdevcore/Guards.h> |
|||
#include <libdevcore/Log.h> |
|||
#include <libdevcrypto/CryptoPP.h> |
|||
#include <libdevcrypto/FileSystem.h> |
|||
#include <libdevcore/Common.h> |
|||
#include <libethash/ethash.h> |
|||
#include "BlockInfo.h" |
|||
#include "Ethasher.h" |
|||
using namespace std; |
|||
using namespace chrono; |
|||
using namespace dev; |
|||
using namespace eth; |
|||
|
|||
Ethasher* dev::eth::Ethasher::s_this = nullptr; |
|||
|
|||
bytes const& Ethasher::cache(BlockInfo const& _header) |
|||
{ |
|||
RecursiveGuard l(x_this); |
|||
if (!m_caches.count(_header.seedHash)) |
|||
{ |
|||
try { |
|||
boost::filesystem::create_directories(getDataDir() + "/ethashcache"); |
|||
} catch (...) {} |
|||
std::string memoFile = getDataDir() + "/ethashcache/" + toHex(_header.seedHash.ref().cropped(0, 4)) + ".cache"; |
|||
m_caches[_header.seedHash] = contents(memoFile); |
|||
if (m_caches[_header.seedHash].empty()) |
|||
{ |
|||
ethash_params p = params((unsigned)_header.number); |
|||
m_caches[_header.seedHash].resize(p.cache_size); |
|||
ethash_prep_light(m_caches[_header.seedHash].data(), &p, _header.seedHash.data()); |
|||
writeFile(memoFile, m_caches[_header.seedHash]); |
|||
} |
|||
} |
|||
return m_caches[_header.seedHash]; |
|||
} |
|||
|
|||
bytesConstRef Ethasher::full(BlockInfo const& _header) |
|||
{ |
|||
RecursiveGuard l(x_this); |
|||
if (!m_fulls.count(_header.seedHash)) |
|||
{ |
|||
if (!m_fulls.empty()) |
|||
{ |
|||
delete [] m_fulls.begin()->second.data(); |
|||
m_fulls.erase(m_fulls.begin()); |
|||
} |
|||
std::string memoFile = getDataDir() + "/ethashcache/" + toHex(_header.seedHash.ref().cropped(0, 4)) + ".full"; |
|||
m_fulls[_header.seedHash] = contentsNew(memoFile); |
|||
if (!m_fulls[_header.seedHash]) |
|||
{ |
|||
ethash_params p = params((unsigned)_header.number); |
|||
m_fulls[_header.seedHash] = bytesRef(new byte[p.full_size], p.full_size); |
|||
auto c = cache(_header); |
|||
ethash_prep_full(m_fulls[_header.seedHash].data(), &p, c.data()); |
|||
writeFile(memoFile, m_fulls[_header.seedHash]); |
|||
} |
|||
} |
|||
return m_fulls[_header.seedHash]; |
|||
} |
|||
|
|||
ethash_params Ethasher::params(BlockInfo const& _header) |
|||
{ |
|||
return params((unsigned)_header.number); |
|||
} |
|||
|
|||
ethash_params Ethasher::params(unsigned _n) |
|||
{ |
|||
ethash_params p; |
|||
p.cache_size = ethash_get_cachesize(_n); |
|||
p.full_size = ethash_get_datasize(_n); |
|||
return p; |
|||
} |
|||
|
|||
bool Ethasher::verify(BlockInfo const& _header) |
|||
{ |
|||
bigint boundary = (bigint(1) << 256) / _header.difficulty; |
|||
auto e = eval(_header, _header.nonce); |
|||
return (u256)e.value <= boundary && e.mixHash == _header.mixHash; |
|||
} |
|||
|
|||
Ethasher::Result Ethasher::eval(BlockInfo const& _header, Nonce const& _nonce) |
|||
{ |
|||
auto p = Ethasher::params(_header); |
|||
ethash_return_value r; |
|||
ethash_compute_light(&r, Ethasher::get()->cache(_header).data(), &p, _header.headerHash(WithoutNonce).data(), (uint64_t)(u64)_nonce); |
|||
return Result{h256(r.result, h256::ConstructFromPointer), h256(r.mix_hash, h256::ConstructFromPointer)}; |
|||
} |
|||
|
@ -0,0 +1,97 @@ |
|||
/*
|
|||
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 Ethasher.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* ProofOfWork algorithm. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <chrono> |
|||
#include <thread> |
|||
#include <cstdint> |
|||
#include <libdevcore/Guards.h> |
|||
#include <libdevcrypto/SHA3.h> |
|||
#include <libethash/ethash.h> // TODO: REMOVE once everything merged into this class and an opaque API can be provided. |
|||
#include "Common.h" |
|||
#include "BlockInfo.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
class Ethasher |
|||
{ |
|||
public: |
|||
Ethasher() {} |
|||
|
|||
static Ethasher* get() { if (!s_this) s_this = new Ethasher(); return s_this; } |
|||
|
|||
bytes const& cache(BlockInfo const& _header); |
|||
bytesConstRef full(BlockInfo const& _header); |
|||
static ethash_params params(BlockInfo const& _header); |
|||
static ethash_params params(unsigned _n); |
|||
|
|||
struct Result |
|||
{ |
|||
h256 value; |
|||
h256 mixHash; |
|||
}; |
|||
|
|||
static Result eval(BlockInfo const& _header) { return eval(_header, _header.nonce); } |
|||
static Result eval(BlockInfo const& _header, Nonce const& _nonce); |
|||
static bool verify(BlockInfo const& _header); |
|||
|
|||
class Miner |
|||
{ |
|||
public: |
|||
Miner(BlockInfo const& _header): |
|||
m_headerHash(_header.headerHash(WithoutNonce)), |
|||
m_params(Ethasher::params(_header)), |
|||
m_datasetPointer(Ethasher::get()->full(_header).data()) |
|||
{} |
|||
|
|||
inline h256 mine(uint64_t _nonce) |
|||
{ |
|||
ethash_compute_full(&m_ethashReturn, m_datasetPointer, &m_params, m_headerHash.data(), _nonce); |
|||
return h256(m_ethashReturn.result, h256::ConstructFromPointer); |
|||
} |
|||
|
|||
inline h256 lastMixHash() const |
|||
{ |
|||
return h256(m_ethashReturn.mix_hash, h256::ConstructFromPointer); |
|||
} |
|||
|
|||
private: |
|||
ethash_return_value m_ethashReturn; |
|||
h256 m_headerHash; |
|||
ethash_params m_params; |
|||
void const* m_datasetPointer; |
|||
}; |
|||
|
|||
private: |
|||
static Ethasher* s_this; |
|||
RecursiveMutex x_this; |
|||
std::map<h256, bytes> m_caches; |
|||
std::map<h256, bytesRef> m_fulls; |
|||
}; |
|||
|
|||
} |
|||
} |
@ -1,46 +0,0 @@ |
|||
/*
|
|||
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 Exceptions.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Exceptions.h" |
|||
#include <boost/thread.hpp> |
|||
#include <libdevcore/CommonIO.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
#if ALL_COMPILERS_ARE_CPP11 |
|||
#define ETH_RETURN_STRING(S) thread_local static string s_what; s_what = S; return s_what.c_str(); |
|||
#elsif USE_BOOST_TLS |
|||
static boost::thread_specific_ptr<string> g_exceptionMessage; |
|||
#define ETH_RETURN_STRING(S) if (!g_exceptionMessage.get()); g_exceptionMessage.reset(new string); *g_exceptionMessage.get() = S; return g_exceptionMessage.get()->c_str(); |
|||
#else |
|||
#define ETH_RETURN_STRING(S) m_message = S; return m_message.c_str(); |
|||
#endif |
|||
|
|||
const char* InvalidBlockFormat::what() const noexcept { ETH_RETURN_STRING("Invalid block format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"); } |
|||
const char* UncleInChain::what() const noexcept { ETH_RETURN_STRING("Uncle in block already mentioned: Uncles " + toString(m_uncles) + " (" + m_block.abridged() + ")"); } |
|||
const char* InvalidTransactionsHash::what() const noexcept { ETH_RETURN_STRING("Invalid transactions hash: header says: " + toHex(m_head.ref()) + " block is:" + toHex(m_real.ref())); } |
|||
const char* InvalidGasLimit::what() const noexcept { ETH_RETURN_STRING("Invalid gas limit (provided: " + toString(provided) + " valid:" + toString(valid) + ")"); } |
|||
const char* InvalidMinGasPrice::what() const noexcept { ETH_RETURN_STRING("Invalid minimum gas price (provided: " + toString(provided) + " limit:" + toString(limit) + ")"); } |
|||
const char* InvalidNonce::what() const noexcept { ETH_RETURN_STRING("Invalid nonce (r: " + toString(required) + " c:" + toString(candidate) + ")"); } |
|||
const char* InvalidBlockNonce::what() const noexcept { ETH_RETURN_STRING("Invalid nonce (h: " + toString(h) + " n:" + toString(n) + " d:" + toString(d) + ")"); } |
|||
|
@ -0,0 +1,78 @@ |
|||
/*
|
|||
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 FeeStructure.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Params.h" |
|||
|
|||
using namespace std; |
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
//--- BEGIN: AUTOGENERATED FROM /feeStructure.json
|
|||
u256 const c_genesisDifficulty = 131072; |
|||
u256 const c_maximumExtraDataSize = 1024; |
|||
u256 const c_epochDuration = 3000; |
|||
u256 const c_genesisGasLimit = 1000000; |
|||
u256 const c_minGasLimit = 125000; |
|||
u256 const c_gasLimitBoundDivisor = 1024; |
|||
u256 const c_minimumDifficulty = 131072; |
|||
u256 const c_difficultyBoundDivisor = 2048; |
|||
u256 const c_durationLimit = 8; |
|||
u256 const c_tierStepGas[] = {0, 2, 3, 5, 8, 10, 20, 0}; |
|||
u256 const c_expGas = 10; |
|||
u256 const c_expByteGas = 10; |
|||
u256 const c_sha3Gas = 30; |
|||
u256 const c_sha3WordGas = 6; |
|||
u256 const c_sloadGas = 50; |
|||
u256 const c_sstoreSetGas = 20000; |
|||
u256 const c_sstoreResetGas = 5000; |
|||
u256 const c_sstoreClearGas = 5000; |
|||
u256 const c_sstoreRefundGas = 15000; |
|||
u256 const c_jumpdestGas = 1; |
|||
u256 const c_logGas = 375; |
|||
u256 const c_logDataGas = 8; |
|||
u256 const c_logTopicGas = 375; |
|||
u256 const c_createGas = 32000; |
|||
u256 const c_callGas = 40; |
|||
u256 const c_callStipend = 2300; |
|||
u256 const c_callValueTransferGas = 9000; |
|||
u256 const c_callNewAccountGas = 25000; |
|||
u256 const c_suicideRefundGas = 24000; |
|||
u256 const c_memoryGas = 3; |
|||
u256 const c_quadCoeffDiv = 512; |
|||
u256 const c_createDataGas = 200; |
|||
u256 const c_txGas = 21000; |
|||
u256 const c_txDataZeroGas = 4; |
|||
u256 const c_txDataNonZeroGas = 68; |
|||
u256 const c_copyGas = 3; |
|||
u256 const c_ecrecoverGas = 3000; |
|||
u256 const c_sha256Gas = 60; |
|||
u256 const c_sha256WordGas = 12; |
|||
u256 const c_ripemd160Gas = 600; |
|||
u256 const c_ripemd160WordGas = 120; |
|||
u256 const c_identityGas = 15; |
|||
u256 const c_identityWordGas = 3; |
|||
//--- END: AUTOGENERATED FROM /feeStructure.json
|
|||
|
|||
} |
|||
} |
|||
|
@ -0,0 +1,78 @@ |
|||
/*
|
|||
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 FeeStructure.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
//--- BEGIN: AUTOGENERATED FROM /feeStructure.json
|
|||
extern u256 const c_genesisDifficulty; |
|||
extern u256 const c_maximumExtraDataSize; |
|||
extern u256 const c_epochDuration; |
|||
extern u256 const c_genesisGasLimit; |
|||
extern u256 const c_minGasLimit; |
|||
extern u256 const c_gasLimitBoundDivisor; |
|||
extern u256 const c_minimumDifficulty; |
|||
extern u256 const c_difficultyBoundDivisor; |
|||
extern u256 const c_durationLimit; |
|||
|
|||
extern u256 const c_tierStepGas[8]; ///< Once per operation, for a selection of them.
|
|||
extern u256 const c_expGas; ///< Once per EXP instuction.
|
|||
extern u256 const c_expByteGas; ///< Times ceil(log256(exponent)) for the EXP instruction.
|
|||
extern u256 const c_sha3Gas; ///< Once per SHA3 operation.
|
|||
extern u256 const c_sha3WordGas; ///< Once per word of the SHA3 operation's data.
|
|||
extern u256 const c_copyGas; ///< Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
|
|||
extern u256 const c_sloadGas; ///< Once per SLOAD operation.
|
|||
extern u256 const c_sstoreSetGas; ///< Once per SSTORE operation if the zeroness changes from zero.
|
|||
extern u256 const c_sstoreResetGas; ///< Once per SSTORE operation if the zeroness doesn't change.
|
|||
extern u256 const c_sstoreClearGas; ///< Once per SSTORE operation if the zeroness changes to zero.
|
|||
extern u256 const c_sstoreRefundGas; ///< Refunded gas, once per SSTORE operation if the zeroness changes to zero.
|
|||
extern u256 const c_jumpdestGas; ///< Once per JUMPDEST operation.
|
|||
extern u256 const c_logGas; ///< Per LOG* operation.
|
|||
extern u256 const c_logDataGas; ///< Per byte in a LOG* operation's data.
|
|||
extern u256 const c_logTopicGas; ///< Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
|
|||
extern u256 const c_createGas; ///< Once per CREATE operation & contract-creation transaction.
|
|||
extern u256 const c_createDataGas; |
|||
extern u256 const c_callGas; ///< Once per CALL operation & message call transaction.
|
|||
extern u256 const c_callStipend; ///< Free gas given at beginning of call.
|
|||
extern u256 const c_callNewAccountGas; ///< Paid for CALL when the destination address didn't exist prior.
|
|||
extern u256 const c_callValueTransferGas; ///< Paid for CALL when the value transfor is non-zero.
|
|||
extern u256 const c_suicideRefundGas; ///< Refunded following a suicide operation.
|
|||
extern u256 const c_memoryGas; ///< Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
|
|||
extern u256 const c_quadCoeffDiv; ///< Divisor for the quadratic particle of the memory cost equation.
|
|||
extern u256 const c_txGas; ///< Per transaction. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_txDataZeroGas; ///< Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_txDataNonZeroGas; ///< Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_ecrecoverGas; |
|||
extern u256 const c_sha256Gas; |
|||
extern u256 const c_sha256WordGas; |
|||
extern u256 const c_ripemd160Gas; |
|||
extern u256 const c_ripemd160WordGas; |
|||
extern u256 const c_identityGas; |
|||
extern u256 const c_identityWordGas; |
|||
|
|||
} |
|||
} |
@ -1,5 +1,4 @@ |
|||
#pragma once |
|||
|
|||
#include "ExtVMFace.h" |
|||
#include "FeeStructure.h" |
|||
#include "VM.h" |
|||
|
@ -1,48 +0,0 @@ |
|||
/*
|
|||
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 FeeStructure.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "FeeStructure.h" |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
u256 const dev::eth::c_stepGas = 1; |
|||
u256 const dev::eth::c_balanceGas = 20; |
|||
u256 const dev::eth::c_sha3Gas = 10; |
|||
u256 const dev::eth::c_sha3WordGas = 10; |
|||
u256 const dev::eth::c_sloadGas = 20; |
|||
u256 const dev::eth::c_sstoreSetGas = 300; |
|||
u256 const dev::eth::c_sstoreResetGas = 100; |
|||
u256 const dev::eth::c_sstoreRefundGas = 100; |
|||
u256 const dev::eth::c_createGas = 100; |
|||
u256 const dev::eth::c_createDataGas = 5; |
|||
u256 const dev::eth::c_callGas = 20; |
|||
u256 const dev::eth::c_expGas = 1; |
|||
u256 const dev::eth::c_expByteGas = 1; |
|||
u256 const dev::eth::c_memoryGas = 1; |
|||
u256 const dev::eth::c_txDataZeroGas = 1; |
|||
u256 const dev::eth::c_txDataNonZeroGas = 5; |
|||
u256 const dev::eth::c_txGas = 500; |
|||
u256 const dev::eth::c_logGas = 32; |
|||
u256 const dev::eth::c_logDataGas = 1; |
|||
u256 const dev::eth::c_logTopicGas = 32; |
|||
u256 const dev::eth::c_copyGas = 1; |
@ -1,54 +0,0 @@ |
|||
/*
|
|||
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 FeeStructure.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
extern u256 const c_stepGas; ///< Once per operation, except for SSTORE, SLOAD, BALANCE, SHA3, CREATE, CALL.
|
|||
extern u256 const c_balanceGas; ///< Once per BALANCE operation.
|
|||
extern u256 const c_sha3Gas; ///< Once per SHA3 operation.
|
|||
extern u256 const c_sha3WordGas; |
|||
extern u256 const c_sloadGas; ///< Once per SLOAD operation.
|
|||
extern u256 const c_sstoreSetGas; ///< Once per SSTORE operation if the zeroness changes from zero.
|
|||
extern u256 const c_sstoreResetGas; ///< Once per SSTORE operation if the zeroness doesn't change.
|
|||
extern u256 const c_sstoreRefundGas; ///< Refunded gas, once per SSTORE operation if the zeroness changes to zero.
|
|||
extern u256 const c_createGas; ///< Once per CREATE operation & contract-creation transaction.
|
|||
extern u256 const c_createDataGas; |
|||
extern u256 const c_callGas; ///< Once per CALL operation & message call transaction.
|
|||
extern u256 const c_expGas; ///< Once per EXP instuction.
|
|||
extern u256 const c_expByteGas; ///< Times ceil(log256(exponent)) for the EXP instruction.
|
|||
extern u256 const c_memoryGas; ///< Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
|
|||
extern u256 const c_txDataZeroGas; ///< Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_txDataNonZeroGas; ///< Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_txGas; ///< Per transaction. NOTE: Not payable on data of calls between transactions.
|
|||
extern u256 const c_logGas; ///< Per LOG* operation.
|
|||
extern u256 const c_logDataGas; ///< Per byte in a LOG* operation's data.
|
|||
extern u256 const c_logTopicGas; ///< Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
|
|||
extern u256 const c_copyGas; ///< Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.
|
|||
|
|||
} |
|||
} |
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue