Paweł Bylica
10 years ago
173 changed files with 7888 additions and 4021 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; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -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.
|
|||
|
|||
} |
|||
} |
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue