Add BIP44 Key Generation with HD Mint path

src/Makefile.am

@@ -162,6 +162,8 @@ BITCOIN_CORE_H = \
   policy/rbf.h \
   fixed.h \
   pow.h \
+  hdmint/hdmint.h \
+  primitives/zerocoin.h \
   protocol.h \
   random.h \
   reverselock.h \
@@ -207,6 +209,9 @@ BITCOIN_CORE_H = \
   zmq/zmqconfig.h\
   zmq/zmqnotificationinterface.h \
   zmq/zmqpublishnotifier.h \
+  hdmint/mintpool.h \
+  hdmint/tracker.h \
+  hdmint/wallet.h \
   zerocoin.h \
   zerocoin_v3.h \
   hash_functions.h \
@@ -284,12 +289,15 @@ libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
   activeznode.cpp \
   darksend.cpp \
+  hdmint/hdmint.cpp \
   znode.cpp \
   instantx.cpp \
   znode-payments.cpp \
   znode-sync.cpp \
   znodeconfig.cpp \
   znodeman.cpp \
+  hdmint/mintpool.cpp \
+  hdmint/wallet.cpp \
   zerocoin_v3.cpp \
   wallet/crypter.cpp \
   wallet/db.cpp \
@@ -301,6 +309,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/wallet.cpp \
   wallet/walletdb.cpp \
   wallet/authhelper.cpp \
+  hdmint/tracker.cpp \
   policy/rbf.cpp \
   $(BITCOIN_CORE_H)
 
@@ -400,6 +409,7 @@ libbitcoin_common_a_SOURCES = \
   compressor.cpp \
   core_read.cpp \
   core_write.cpp \
+  hdmint/hdmint.cpp \
   key.cpp \
   keystore.cpp \
   netbase.cpp \

src/Makefile.test.include

@@ -76,6 +76,7 @@ BITCOIN_TESTS =\
   test/DoS_tests.cpp \
   test/getarg_tests.cpp \
   test/hash_tests.cpp \
+  test/hdmint_tests.cpp \
   test/key_tests.cpp \
   test/limitedmap_tests.cpp \
   test/dbwrapper_tests.cpp \

src/arith_uint256.cpp

@@ -147,13 +147,14 @@ double base_uint<BITS>::getdouble() const
 template <unsigned int BITS>
 std::string base_uint<BITS>::GetHex() const
 {
-    return ArithToUint256(*this).GetHex();
+    return ArithToUint(*this).GetHex();
 }
 
 template <unsigned int BITS>
 void base_uint<BITS>::SetHex(const char* psz)
 {
-    *this = UintToArith256(uint256S(psz));
+    base_blob<BITS> a;
+    *this = UintToArith(a.uintS(psz));
 }
 
 template <unsigned int BITS>
@@ -183,6 +184,24 @@ unsigned int base_uint<BITS>::bits() const
     return 0;
 }
 
+template <unsigned int BITS>
+base_uint<BITS> base_uint<BITS>::UintToArith(const base_blob<BITS>& a) const
+{
+    base_uint<BITS> b;
+    for(int x=0; x<b.WIDTH; ++x)
+        b.pn[x] = ReadLE32(a.begin() + x*4);
+    return b;
+}
+
+ template <unsigned int BITS>
+base_blob<BITS> base_uint<BITS>::ArithToUint(const base_uint<BITS>& a) const
+{
+    base_blob<BITS> b;
+    for(int x=0; x<a.WIDTH; ++x)
+        WriteLE32(b.begin() + x*4, a.pn[x]);
+    return b;
+}
+
 // Explicit instantiations for base_uint<256>
 template base_uint<256>::base_uint(const std::string&);
 template base_uint<256>& base_uint<256>::operator<<=(unsigned int);
@@ -198,6 +217,8 @@ template std::string base_uint<256>::ToString() const;
 template void base_uint<256>::SetHex(const char*);
 template void base_uint<256>::SetHex(const std::string&);
 template unsigned int base_uint<256>::bits() const;
+template base_uint<256> base_uint<256>::UintToArith(const base_blob<256>& a) const;
+template base_blob<256> base_uint<256>::ArithToUint(const base_uint<256>& a) const;
 
 // This implementation directly uses shifts instead of going
 // through an intermediate MPI representation.
@@ -258,3 +279,36 @@ arith_uint256 UintToArith256(const uint256 &a)
         b.pn[x] = ReadLE32(a.begin() + x*4);
     return b;
 }
+
+// Explicit instantiations for base_uint<512>
+template base_uint<512>::base_uint(const std::string&);
+template base_uint<512>& base_uint<512>::operator<<=(unsigned int);
+template base_uint<512>& base_uint<512>::operator>>=(unsigned int);
+template base_uint<512>& base_uint<512>::operator*=(uint32_t b32);
+template base_uint<512>& base_uint<512>::operator*=(const base_uint<512>& b);
+template base_uint<512>& base_uint<512>::operator/=(const base_uint<512>& b);
+template int base_uint<512>::CompareTo(const base_uint<512>&) const;
+template bool base_uint<512>::EqualTo(uint64_t) const;
+template double base_uint<512>::getdouble() const;
+template std::string base_uint<512>::GetHex() const;
+template std::string base_uint<512>::ToString() const;
+template void base_uint<512>::SetHex(const char*);
+template void base_uint<512>::SetHex(const std::string&);
+template unsigned int base_uint<512>::bits() const;
+template base_uint<512> base_uint<512>::UintToArith(const base_blob<512>& a) const;
+template base_blob<512> base_uint<512>::ArithToUint(const base_uint<512>& a) const;
+
+ uint512 ArithToUint512(const arith_uint512 &a)
+{
+    uint512 b;
+    for(int x=0; x<a.WIDTH; ++x)
+        WriteLE32(b.begin() + x*4, a.pn[x]);
+    return b;
+}
+arith_uint512 UintToArith512(const uint512 &a)
+{
+    arith_uint512 b;
+    for(int x=0; x<b.WIDTH; ++x)
+        b.pn[x] = ReadLE32(a.begin() + x*4);
+    return b;
+}

src/arith_uint256.h

@@ -12,6 +12,7 @@
 #include <stdint.h>
 #include <string>
 #include <vector>
+#include <uint256.h>
 
 class uint256;
 
@@ -236,6 +237,9 @@ class base_uint
         return sizeof(pn);
     }
 
+    base_uint<BITS> UintToArith(const base_blob<BITS>& a) const;
+    base_blob<BITS> ArithToUint(const base_uint<BITS>& a) const;
+
     /**
      * Returns the position of the highest bit set plus one, or zero if the
      * value is zero.
@@ -295,7 +299,21 @@ class arith_uint256 : public base_uint<256> {
     friend arith_uint256 UintToArith256(const uint256 &);
 };
 
+/** 512-bit unsigned big integer. */
+class arith_uint512 : public base_uint<512> {
+public:
+    arith_uint512() {}
+    arith_uint512(const base_uint<512>& b) : base_uint<512>(b) {}
+    arith_uint512(uint64_t b) : base_uint<512>(b) {}
+    explicit arith_uint512(const std::string& str) : base_uint<512>(str) {}
+    friend uint512 ArithToUint512(const arith_uint512 &);
+    friend arith_uint512 UintToArith512(const uint512 &);
+};
+
 uint256 ArithToUint256(const arith_uint256 &);
 arith_uint256 UintToArith256(const uint256 &);
 
+uint512 ArithToUint512(const arith_uint512 &);
+arith_uint512 UintToArith512(const uint512 &);
+
 #endif // BITCOIN_ARITH_UINT256_H

src/hash.h

@@ -8,6 +8,7 @@
 
 #include "crypto/ripemd160.h"
 #include "crypto/sha256.h"
+#include "crypto/sha512.h"
 #include "prevector.h"
 #include "serialize.h"
 #include "uint256.h"
@@ -66,6 +67,53 @@ class CHash160 {
     }
 };
 
+class CHash512
+{
+private:
+    CSHA512 sha;
+
+ public:
+    static const size_t OUTPUT_SIZE = CSHA512::OUTPUT_SIZE;
+
+     void Finalize(unsigned char hash[OUTPUT_SIZE])
+    {
+        unsigned char buf[CSHA512::OUTPUT_SIZE];
+        sha.Finalize(buf);
+        sha.Reset().Write(buf, CSHA512::OUTPUT_SIZE).Finalize(hash);
+    }
+
+     CHash512& Write(const unsigned char* data, size_t len)
+    {
+        sha.Write(data, len);
+        return *this;
+    }
+
+     CHash512& Reset()
+    {
+        sha.Reset();
+        return *this;
+    }
+};
+
+
+ /** Compute the 512-bit hash of an object. */
+template <typename T1>
+inline uint512 Hash512(const T1 pbegin, const T1 pend)
+{
+    static const unsigned char pblank[1] = {};
+    uint512 result;
+    CHash512().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
+    return result;
+}
+template <typename T1, typename T2>
+inline uint512 Hash512(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end)
+{
+    static const unsigned char pblank[1] = {};
+    uint512 result;
+    CHash512().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Finalize((unsigned char*)&result);
+    return result;
+}
+
 /** Compute the 256-bit hash of an object. */
 template<typename T1>
 inline uint256 Hash(const T1 pbegin, const T1 pend)

src/hdmint/hdmint.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2019 The Zcoin Core Developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <tinyformat.h>
+#include "hdmint.h"
+
+CHDMint::CHDMint()
+{
+    SetNull();
+}
+
+CHDMint::CHDMint(const uint32_t& nCount, const CKeyID& seedId, const uint256& hashSerial, const GroupElement& pubCoinValue)
+{
+    SetNull();
+    this->nCount = nCount;
+    this->seedId = seedId;
+    this->hashSerial = hashSerial;
+    this->pubCoinValue = pubCoinValue;
+}
+
+void CHDMint::SetNull()
+{
+    nCount = 0;
+    seedId.SetNull();
+    hashSerial.SetNull();
+    txid.SetNull();
+    nHeight = -1;
+    nId = -1;
+    DenominationToInteger(sigma::CoinDenomination::SIGMA_ERROR, denom);
+    isUsed = false;
+}
+
+std::string CHDMint::ToString() const
+{
+    return strprintf(" HDMint:\n   count=%d\n   seedId=%s\n   hashSerial=%s\n   hashPubCoinValue=%s\n   txid=%s\n   height=%d\n   id=%d\n   denom=%d\n   isUsed=%d\n",
+    nCount, seedId.ToString(), hashSerial.GetHex(), GetPubCoinHash().GetHex(), txid.GetHex(), nHeight, nId, denom, isUsed);
+}

src/hdmint/hdmint.h

@@ -0,0 +1,78 @@
+// Copyright (c) 2019 The Zcoin Core Developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef ZCOIN_HDMINT_H
+#define ZCOIN_HDMINT_H
+
+#include "primitives/zerocoin.h"
+#include "zerocoin_v3.h"
+
+//struct that is safe to store essential mint data, without holding any information that allows for actual spending (serial, randomness, private key)
+class CHDMint
+{
+private:
+    uint32_t nCount;
+    CKeyID seedId;
+    uint256 hashSerial;
+    GroupElement pubCoinValue;
+    uint256 txid;
+    int nHeight;
+    int nId;
+    int64_t denom;
+    bool isUsed;
+
+public:
+    CHDMint();
+    CHDMint(const uint32_t& nCount, const CKeyID& seedId, const uint256& hashSerial, const GroupElement& pubCoinValue);
+
+    sigma::CoinDenomination GetDenomination() const {
+        sigma::CoinDenomination value;
+        IntegerToDenomination(denom, value);
+        return value;
+    }
+    int64_t GetDenominationValue() const {
+        return denom;
+    }
+    uint32_t GetCount() const { return nCount; }
+    int GetHeight() const { return nHeight; }
+    int GetId() const { return nId; }
+    CKeyID GetSeedId() const { return seedId; }
+    uint256 GetSerialHash() const { return hashSerial; }
+    GroupElement GetPubcoinValue() const { return pubCoinValue; }
+    uint256 GetPubCoinHash() const { return sigma::GetPubCoinValueHash(pubCoinValue); }
+    uint256 GetTxHash() const { return txid; }
+    bool IsUsed() const { return isUsed; }
+    void SetDenomination(const sigma::CoinDenomination value) {
+        int64_t denom;
+        DenominationToInteger(value, denom);
+        this->denom = denom;
+    };
+    void SetDenominationValue(const int64_t& denom) { this->denom = denom; }
+    void SetHeight(const int& nHeight) { this->nHeight = nHeight; }
+    void SetId(const int& nId) { this->nId = nId; }
+    void SetNull();
+    void SetTxHash(const uint256& txid) { this->txid = txid; }
+    void SetUsed(const bool isUsed) { this->isUsed = isUsed; }
+    void SetPubcoinValue(const GroupElement pubCoinValue) { this->pubCoinValue = pubCoinValue; }
+    std::string ToString() const;
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
+    {
+        READWRITE(nCount);
+        READWRITE(seedId);
+        READWRITE(hashSerial);
+        READWRITE(pubCoinValue);
+        READWRITE(txid);
+        READWRITE(nHeight);
+        READWRITE(nId);
+        READWRITE(denom);
+        READWRITE(isUsed);
+    };
+};
+
+#endif //ZCOIN_HDMINT_H
+