Switch miner to P2PKH, add -mineraddress option

configure.ac

@@ -82,6 +82,12 @@ AC_ARG_ENABLE([wallet],
   [enable_wallet=$enableval],
   [enable_wallet=yes])
 
+AC_ARG_ENABLE([mining],
+  [AS_HELP_STRING([--enable-mining],
+  [enable mining (default is yes)])],
+  [enable_mining=$enableval],
+  [enable_mining=yes])
+
 AC_ARG_WITH([miniupnpc],
   [AS_HELP_STRING([--with-miniupnpc],
   [enable UPNP (default is yes if libminiupnpc is found)])],
@@ -790,6 +796,16 @@ else
   AC_MSG_RESULT(no)
 fi
 
+dnl enable mining
+AC_MSG_CHECKING([if mining should be enabled])
+if test x$enable_mining != xno; then
+  AC_MSG_RESULT(yes)
+  AC_DEFINE(ENABLE_MINING, 1, [Define to 1 to enable mining functions])
+
+else
+  AC_MSG_RESULT(no)
+fi
+
 dnl enable upnp support
 AC_MSG_CHECKING([whether to build with support for UPnP])
 if test x$have_miniupnpc = xno; then
@@ -881,6 +897,7 @@ AM_CONDITIONAL([TARGET_DARWIN], [test x$TARGET_OS = xdarwin])
 AM_CONDITIONAL([BUILD_DARWIN], [test x$BUILD_OS = xdarwin])
 AM_CONDITIONAL([TARGET_WINDOWS], [test x$TARGET_OS = xwindows])
 AM_CONDITIONAL([ENABLE_WALLET],[test x$enable_wallet = xyes])
+AM_CONDITIONAL([ENABLE_MINING],[test x$enable_mining = xyes])
 AM_CONDITIONAL([ENABLE_TESTS],[test x$BUILD_TEST = xyes])
 AM_CONDITIONAL([ENABLE_QT],[test x$bitcoin_enable_qt = xyes])
 AM_CONDITIONAL([ENABLE_QT_TESTS],[test x$BUILD_TEST_QT = xyes])

src/Makefile.am

@@ -248,13 +248,8 @@ libbitcoin_wallet_a_SOURCES = \
   $(BITCOIN_CORE_H) \
   $(LIBZCASH_H)
 
-EQUIHASH_TROMP_SOURCES = \
-  pow/tromp/equi_miner.h \
-  pow/tromp/equi.h \
-  pow/tromp/osx_barrier.h
-
 # crypto primitives library
-crypto_libbitcoin_crypto_a_CPPFLAGS = $(BITCOIN_CONFIG_INCLUDES) -DEQUIHASH_TROMP_ATOMIC
+crypto_libbitcoin_crypto_a_CPPFLAGS = $(BITCOIN_CONFIG_INCLUDES)
 crypto_libbitcoin_crypto_a_SOURCES = \
   crypto/common.h \
   crypto/equihash.cpp \
@@ -271,8 +266,19 @@ crypto_libbitcoin_crypto_a_SOURCES = \
   crypto/sha256.cpp \
   crypto/sha256.h \
   crypto/sha512.cpp \
-  crypto/sha512.h \
+  crypto/sha512.h
+
+if ENABLE_MINING
+EQUIHASH_TROMP_SOURCES = \
+  pow/tromp/equi_miner.h \
+  pow/tromp/equi.h \
+  pow/tromp/osx_barrier.h
+
+crypto_libbitcoin_crypto_a_CPPFLAGS += \
+  -DEQUIHASH_TROMP_ATOMIC
+crypto_libbitcoin_crypto_a_SOURCES += \
   ${EQUIHASH_TROMP_SOURCES}
+endif
 
 # univalue JSON library
 univalue_libbitcoin_univalue_a_SOURCES = \

src/Makefile.gtest.include

@@ -26,6 +26,7 @@ zcash_gtest_SOURCES += \
 	gtest/test_noteencryption.cpp \
 	gtest/test_merkletree.cpp \
 	gtest/test_metrics.cpp \
+	gtest/test_miner.cpp \
 	gtest/test_pow.cpp \
 	gtest/test_random.cpp \
 	gtest/test_rpc.cpp \

src/crypto/equihash.cpp

@@ -12,6 +12,10 @@
 // NDSS ’16, 21-24 February 2016, San Diego, CA, USA
 // https://www.internetsociety.org/sites/default/files/blogs-media/equihash-asymmetric-proof-of-work-based-generalized-birthday-problem.pdf
 
+#if defined(HAVE_CONFIG_H)
+#include "config/bitcoin-config.h"
+#endif
+
 #include "crypto/equihash.h"
 #include "util.h"
 
@@ -319,6 +323,7 @@ std::shared_ptr<eh_trunc> TruncatedStepRow<WIDTH>::GetTruncatedIndices(size_t le
     return p;
 }
 
+#ifdef ENABLE_MINING
 template<unsigned int N, unsigned int K>
 bool Equihash<N,K>::BasicSolve(const eh_HashState& base_state,
                                const std::function<bool(std::vector<unsigned char>)> validBlock,
@@ -711,6 +716,7 @@ bool Equihash<N,K>::OptimisedSolve(const eh_HashState& base_state,
 
     return false;
 }
+#endif // ENABLE_MINING
 
 template<unsigned int N, unsigned int K>
 bool Equihash<N,K>::IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln)
@@ -762,40 +768,48 @@ bool Equihash<N,K>::IsValidSolution(const eh_HashState& base_state, std::vector<
 
 // Explicit instantiations for Equihash<96,3>
 template int Equihash<96,3>::InitialiseState(eh_HashState& base_state);
+#ifdef ENABLE_MINING
 template bool Equihash<96,3>::BasicSolve(const eh_HashState& base_state,
                                          const std::function<bool(std::vector<unsigned char>)> validBlock,
                                          const std::function<bool(EhSolverCancelCheck)> cancelled);
 template bool Equihash<96,3>::OptimisedSolve(const eh_HashState& base_state,
                                              const std::function<bool(std::vector<unsigned char>)> validBlock,
                                              const std::function<bool(EhSolverCancelCheck)> cancelled);
+#endif
 template bool Equihash<96,3>::IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln);
 
 // Explicit instantiations for Equihash<200,9>
 template int Equihash<200,9>::InitialiseState(eh_HashState& base_state);
+#ifdef ENABLE_MINING
 template bool Equihash<200,9>::BasicSolve(const eh_HashState& base_state,
                                           const std::function<bool(std::vector<unsigned char>)> validBlock,
                                           const std::function<bool(EhSolverCancelCheck)> cancelled);
 template bool Equihash<200,9>::OptimisedSolve(const eh_HashState& base_state,
                                               const std::function<bool(std::vector<unsigned char>)> validBlock,
                                               const std::function<bool(EhSolverCancelCheck)> cancelled);
+#endif
 template bool Equihash<200,9>::IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln);
 
 // Explicit instantiations for Equihash<96,5>
 template int Equihash<96,5>::InitialiseState(eh_HashState& base_state);
+#ifdef ENABLE_MINING
 template bool Equihash<96,5>::BasicSolve(const eh_HashState& base_state,
                                          const std::function<bool(std::vector<unsigned char>)> validBlock,
                                          const std::function<bool(EhSolverCancelCheck)> cancelled);
 template bool Equihash<96,5>::OptimisedSolve(const eh_HashState& base_state,
                                              const std::function<bool(std::vector<unsigned char>)> validBlock,
                                              const std::function<bool(EhSolverCancelCheck)> cancelled);
+#endif
 template bool Equihash<96,5>::IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln);
 
 // Explicit instantiations for Equihash<48,5>
 template int Equihash<48,5>::InitialiseState(eh_HashState& base_state);
+#ifdef ENABLE_MINING
 template bool Equihash<48,5>::BasicSolve(const eh_HashState& base_state,
                                          const std::function<bool(std::vector<unsigned char>)> validBlock,
                                          const std::function<bool(EhSolverCancelCheck)> cancelled);
 template bool Equihash<48,5>::OptimisedSolve(const eh_HashState& base_state,
                                              const std::function<bool(std::vector<unsigned char>)> validBlock,
                                              const std::function<bool(EhSolverCancelCheck)> cancelled);
+#endif
 template bool Equihash<48,5>::IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln);

src/crypto/equihash.h

@@ -182,12 +182,14 @@ class Equihash
     Equihash() { }
 
     int InitialiseState(eh_HashState& base_state);
+#ifdef ENABLE_MINING
     bool BasicSolve(const eh_HashState& base_state,
                     const std::function<bool(std::vector<unsigned char>)> validBlock,
                     const std::function<bool(EhSolverCancelCheck)> cancelled);
     bool OptimisedSolve(const eh_HashState& base_state,
                         const std::function<bool(std::vector<unsigned char>)> validBlock,
                         const std::function<bool(EhSolverCancelCheck)> cancelled);
+#endif
     bool IsValidSolution(const eh_HashState& base_state, std::vector<unsigned char> soln);
 };
 
@@ -211,6 +213,7 @@ static Equihash<48,5> Eh48_5;
         throw std::invalid_argument("Unsupported Equihash parameters"); \
     }
 
+#ifdef ENABLE_MINING
 inline bool EhBasicSolve(unsigned int n, unsigned int k, const eh_HashState& base_state,
                     const std::function<bool(std::vector<unsigned char>)> validBlock,
                     const std::function<bool(EhSolverCancelCheck)> cancelled)
@@ -258,6 +261,7 @@ inline bool EhOptimisedSolveUncancellable(unsigned int n, unsigned int k, const
     return EhOptimisedSolve(n, k, base_state, validBlock,
                             [](EhSolverCancelCheck pos) { return false; });
 }
+#endif // ENABLE_MINING
 
 #define EhIsValidSolution(n, k, base_state, soln, ret)   \
     if (n == 96 && k == 3) {                             \

src/gtest/test_equihash.cpp

@@ -1,3 +1,7 @@
+#if defined(HAVE_CONFIG_H)
+#include "config/bitcoin-config.h"
+#endif
+
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -76,6 +80,7 @@ TEST(equihash_tests, is_probably_duplicate) {
     ASSERT_TRUE(IsProbablyDuplicate<4>(p3, 4));
 }
 
+#ifdef ENABLE_MINING
 TEST(equihash_tests, check_basic_solver_cancelled) {
     Equihash<48,5> Eh48_5;
     crypto_generichash_blake2b_state state;
@@ -283,3 +288,4 @@ TEST(equihash_tests, check_optimised_solver_cancelled) {
         }), EhSolverCancelledException);
     }
 }
+#endif // ENABLE_MINING

src/gtest/test_miner.cpp

@@ -0,0 +1,103 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "chainparams.h"
+#include "key.h"
+#include "miner.h"
+#include "util.h"
+#ifdef ENABLE_WALLET
+#include "wallet/wallet.h"
+#endif
+
+#include <boost/optional.hpp>
+
+using ::testing::Return;
+
+#ifdef ENABLE_WALLET
+class MockReserveKey : public CReserveKey {
+public:
+    MockReserveKey() : CReserveKey(nullptr) { }
+
+    MOCK_METHOD1(GetReservedKey, bool(CPubKey &pubkey));
+};
+#endif
+
+TEST(Miner, GetMinerScriptPubKey) {
+    SelectParams(CBaseChainParams::MAIN);
+
+    boost::optional<CScript> scriptPubKey;
+#ifdef ENABLE_WALLET
+    MockReserveKey reservekey;
+    EXPECT_CALL(reservekey, GetReservedKey(::testing::_))
+        .WillRepeatedly(Return(false));
+#endif
+
+    // No miner address set
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_FALSE((bool) scriptPubKey);
+
+    mapArgs["-mineraddress"] = "notAnAddress";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_FALSE((bool) scriptPubKey);
+
+    // Partial address
+    mapArgs["-mineraddress"] = "t1T8yaLVhNqxA5KJcmiqq";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_FALSE((bool) scriptPubKey);
+
+    // Typo in address
+    mapArgs["-mineraddress"] = "t1TByaLVhNqxA5KJcmiqqFN88e8DNp2PBfF";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_FALSE((bool) scriptPubKey);
+
+    // Set up expected scriptPubKey for t1T8yaLVhNqxA5KJcmiqqFN88e8DNp2PBfF
+    CKeyID keyID;
+    keyID.SetHex("eb88f1c65b39a823479ac9c7db2f4a865960a165");
+    CScript expectedScriptPubKey = CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+    // Valid address
+    mapArgs["-mineraddress"] = "t1T8yaLVhNqxA5KJcmiqqFN88e8DNp2PBfF";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_TRUE((bool) scriptPubKey);
+    EXPECT_EQ(expectedScriptPubKey, *scriptPubKey);
+
+    // Valid address with leading whitespace
+    mapArgs["-mineraddress"] = "  t1T8yaLVhNqxA5KJcmiqqFN88e8DNp2PBfF";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_TRUE((bool) scriptPubKey);
+    EXPECT_EQ(expectedScriptPubKey, *scriptPubKey);
+
+    // Valid address with trailing whitespace
+    mapArgs["-mineraddress"] = "t1T8yaLVhNqxA5KJcmiqqFN88e8DNp2PBfF  ";
+#ifdef ENABLE_WALLET
+    scriptPubKey = GetMinerScriptPubKey(reservekey);
+#else
+    scriptPubKey = GetMinerScriptPubKey();
+#endif
+    EXPECT_TRUE((bool) scriptPubKey);
+    EXPECT_EQ(expectedScriptPubKey, *scriptPubKey);
+}